0 dní v řadě · 0 bodů

Soubory, chyby a knihovny · 35 min

Mise: rozbor serverových logů

Z hrubého access logu e-shopu zjistíš, kdy přestala fungovat pokladna, co bylo nejpomalejší a kdo zkoušel hesla.

Hloubka
Úkoly
Lidsky řečeno

Log je kniha návštěv s velmi pečlivým vrátným. U každého příchozího si zapíše, kdo to byl, kdy přišel, co chtěl a jak to dopadlo. Jeden zápis nic neřekne. Když jich ale projdeš tisíce a začneš je třídit, poznáš, že ve 14:20 se u pokladny něco zaseklo.

Co je v jednom řádku

Server zapisuje na každý požadavek jeden řádek. Tenhle formát vychází z běžného formátu webových serverů, na konec jsme si přidali dobu vyřízení.

text
198.51.100.7                      kdo: IP adresa návštěvníka
- -                               identita a přihlášení, obvykle prázdné
[14/Nov/2026:14:21:08 +0100]      kdy, včetně posunu proti UTC
"POST /pokladna HTTP/1.1"         co chtěl: metoda, cesta, protokol
504                               jak to dopadlo: stavový kód
312                               kolik bajtů server poslal
"https://obchod.example/kosik"    odkud přišel
"Mozilla/5.0 (Windows NT 10.0)"   čím přišel: prohlížeč
30.001                            jak dlouho to trvalo, v sekundách

Stavový kód je trojciferné číslo. První číslice řekne, jak to dopadlo:

SkupinaVýznamPříklad
2xxv pořádku200 hotovo
3xxjdi jinam301 stránka se přestěhovala
4xxchyba na straně návštěvníka404 nenalezeno, 401 špatné přihlášení
5xxchyba na straně serveru500 vnitřní chyba, 504 nedočkal se odpovědi

První nápad bývá rozdělit řádek podle mezer. Jenže mezery jsou i uvnitř polí.

radek = '198.51.100.7 - - [14/Nov/2026:14:21:08 +0100] "POST /pokladna HTTP/1.1" 504 312 "-" "Mozilla/5.0 (Windows NT 10.0)" 30.001'

casti = radek.split()
print(len(casti), "kousků místo 10 polí")
print(casti[3], "|", casti[4])
print(casti[-3:])
Výstup
16 kousků místo 10 polí
[14/Nov/2026:14:21:08 | +0100]
['NT', '10.0)"', '30.001']

Čas se rozpadl na dva kousky a prohlížeč na několik. Pole jde poznat podle tvaru, a to je práce pro regulární výraz. Pojmenované skupiny (?P<jmeno>...) dají rovnou slovník a re.VERBOSE dovolí psát vzor přehledně na víc řádků. Mezery ve vzoru se pak ignorují, proto mezeru v textu zapisujeme jako \s.

import re

RADEK = '198.51.100.7 - - [14/Nov/2026:14:21:08 +0100] "POST /pokladna HTTP/1.1" 504 312 "-" "Mozilla/5.0 (Windows NT 10.0)" 30.001'

ZACATEK = re.compile(r"""
    (?P<ip>\S+) \s \S+ \s \S+ \s     # IP adresa a dvě pomlčky
    \[(?P<cas>[^\]]+)\] \s           # čas v hranatých závorkách
    "(?P<metoda>[A-Z]+) \s (?P<cesta>\S+) \s HTTP/[\d.]+"
""", re.VERBOSE)

shoda = ZACATEK.match(RADEK)
for klic, hodnota in shoda.groupdict().items():
    print(f"{klic:7} {hodnota}")
Výstup
ip      198.51.100.7
cas     14/Nov/2026:14:21:08 +0100
metoda  POST
cesta   /pokladna
Úkol

Krok 1: rozeber řádek

Doplň do vzoru skupiny status, bajty a doba. Mezi bajty a dobou leží dvě pole v uvozovkách, která nepotřebuješ. Potom napiš rozeber(radek):

  • když řádek vzoru neodpovídá, vrátí None,
  • jinak vrátí slovník s klíči ip, cas, metoda, cesta, status, bajty, doba,
  • status a bajty budou int, doba bude float,
  • některé servery místo nuly bajtů píšou -. V tom případě bude bajty rovno 0.
import re

UKAZKA = '198.51.100.7 - - [14/Nov/2026:14:21:08 +0100] "POST /pokladna HTTP/1.1" 504 312 "-" "Mozilla/5.0 (Windows NT 10.0)" 30.001'

VZOR = re.compile(r"""
    (?P<ip>\S+) \s \S+ \s \S+ \s
    \[(?P<cas>[^\]]+)\] \s
    "(?P<metoda>[A-Z]+) \s (?P<cesta>\S+) \s HTTP/[\d.]+" \s
""", re.VERBOSE)

def rozeber(radek):
    # doplň
    return None

print(rozeber(UKAZKA))
Výstup

Celý soubor a vadné řádky

Reálný log není čistý. Roboti posílají na web nesmysly, disk se zaplní uprostřed zápisu a občas se objeví bajty, které nejsou platné UTF-8. Analýza kvůli tomu nesmí spadnout, ale ani nesmí vadné řádky tiše zahodit. Počet vadných je sám o sobě informace: když jich je najednou polovina, změnil se formát a výsledkům nevěř.

Soubor se čte po řádcích přes for radek in f, takže se do paměti nenačítá celý najednou. U opravdu obřích logů bys navíc neukládal každý záznam do seznamu a počítal průběžně. Parametr errors="replace" nahradí neplatné bajty znakem � místo výjimky UnicodeDecodeError.

Úkol

Krok 2: načti log

Napiš nacti(cesta). Otevře soubor jako UTF-8 s errors="replace" a vrátí dvojici (zaznamy, vadne): seznam slovníků z funkce rozeber a počet řádků, které rozebrat nešly. Prázdné řádky přeskoč a nepočítej je.

import re
from pathlib import Path

VZOR = re.compile(r"""
    (?P<ip>\S+) \s \S+ \s \S+ \s
    \[(?P<cas>[^\]]+)\] \s
    "(?P<metoda>[A-Z]+) \s (?P<cesta>\S+) \s HTTP/[\d.]+" \s
    (?P<status>\d{3}) \s (?P<bajty>\d+|-) \s
    "[^"]*" \s "[^"]*" \s
    (?P<doba>[\d.]+)
""", re.VERBOSE)

def rozeber(radek):
    shoda = VZOR.fullmatch(radek.strip())
    if shoda is None:
        return None
    z = shoda.groupdict()
    z["status"] = int(z["status"])
    z["bajty"] = 0 if z["bajty"] == "-" else int(z["bajty"])
    z["doba"] = float(z["doba"])
    return z

Path("ukazka.log").write_bytes(
    b'198.51.100.1 - - [14/Nov/2026:14:00:00 +0100] "GET / HTTP/1.1" 200 90 "-" "Moz\xffilla" 0.010\n'
    b'nesmysl\n'
    b'\n'
)

def nacti(cesta):
    # doplň
    return [], 0

zaznamy, vadne = nacti("ukazka.log")
print(len(zaznamy), vadne)
Výstup
Kvíz

V logu se 100 000 řádky je 37 vadných. Co s nimi?

Co se dělo a kdy

Máš záznamy a můžeš se ptát. Od této chvíle pracuj s připravenými daty: funkce z jen zkracuje zápis a vyrobí stejný slovník jako rozeber. Cesty mohou obsahovat dotaz, například /produkty?strana=2. Pro statistiku je to pořád /produkty, proto odřízneš část za otazníkem pomocí cesta.split("?")[0].

Úkol

Krok 3: celkový přehled

Napiš dvě funkce.

tridy_stavu(zaznamy) vrátí slovník nebo Counter s počty podle skupin, například {"2xx": 3, "5xx": 2}.

nejcastejsi_cesty(zaznamy, n=3) vrátí seznam dvojic (cesta, počet) od nejčastější. Cesty počítej bez části za ?.

from collections import Counter

def z(cas, ip, metoda, cesta, status, doba):
    return {"ip": ip, "cas": f"14/Nov/2026:{cas} +0100", "metoda": metoda,
            "cesta": cesta, "status": status, "bajty": 512, "doba": doba}

ZAZNAMY = [
    z("14:19:58", "198.51.100.4", "GET", "/", 200, 0.041),
    z("14:20:03", "198.51.100.7", "GET", "/produkty?strana=2", 200, 0.090),
    z("14:20:11", "198.51.100.7", "GET", "/produkty", 200, 0.085),
    z("14:20:40", "198.51.100.9", "POST", "/pokladna", 504, 30.0),
    z("14:21:02", "198.51.100.4", "POST", "/pokladna", 504, 29.5),
    z("14:21:30", "203.0.113.66", "POST", "/prihlaseni", 401, 0.120),
    z("14:21:31", "203.0.113.66", "POST", "/prihlaseni", 401, 0.118),
    z("14:22:10", "198.51.100.9", "GET", "/chybi", 404, 0.012),
]

def tridy_stavu(zaznamy):
    # doplň
    return {}

def nejcastejsi_cesty(zaznamy, n=3):
    # doplň
    return []

print(tridy_stavu(ZAZNAMY))
print(nejcastejsi_cesty(ZAZNAMY))
Výstup

Teď čas. Časy v logu nesou posun proti UTC. UTC je světový referenční čas a +0100 znamená „o hodinu napřed“. Dva servery v různých pásmech zapíšou tentýž okamžik jinak, takže texty porovnat nejdou. Objekty datetime s posunem ano.

from datetime import datetime, timezone

FORMAT = "%d/%b/%Y:%H:%M:%S %z"
praha = "14/Nov/2026:14:20:40 +0100"
londyn = "14/Nov/2026:13:20:40 +0000"

print(praha == londyn)
a = datetime.strptime(praha, FORMAT)
b = datetime.strptime(londyn, FORMAT)
print(a == b)
print(a.astimezone(timezone.utc).strftime("%Y-%m-%d %H:%M"))
Výstup
False
True
2026-11-14 13:20
Úkol

Krok 4: kdy to začalo

Napiš minuta_utc(cas). Dostane čas ve tvaru z logu a vrátí text "RRRR-MM-DD HH:MM" v UTC.

Potom napiš chyby_po_minutach(zaznamy). Vrátí slovník nebo Counter, kde klíč je minuta a hodnota počet odpovědí se stavem 500 a výš.

from collections import Counter
from datetime import datetime, timezone

FORMAT = "%d/%b/%Y:%H:%M:%S %z"

def z(cas, ip, metoda, cesta, status, doba):
    return {"ip": ip, "cas": f"14/Nov/2026:{cas} +0100", "metoda": metoda,
            "cesta": cesta, "status": status, "bajty": 512, "doba": doba}

ZAZNAMY = [
    z("14:19:58", "198.51.100.4", "GET", "/", 200, 0.041),
    z("14:20:40", "198.51.100.9", "POST", "/pokladna", 504, 30.0),
    z("14:21:02", "198.51.100.4", "POST", "/pokladna", 504, 29.5),
    z("14:21:47", "198.51.100.7", "POST", "/pokladna", 504, 30.0),
]

def minuta_utc(cas):
    # doplň
    return ""

def chyby_po_minutach(zaznamy):
    # doplň
    return {}

print(minuta_utc("14/Nov/2026:14:20:40 +0100"))
print(chyby_po_minutach(ZAZNAMY))
Výstup

Kde to bolí a kdo klepe na dveře

Pomalost se špatně měří průměrem. Pár extrémně dlouhých požadavků se v něm rozpustí, nebo naopak jeden zkreslí celý obrázek. Lepší je percentil: 95. percentil (p95) je hodnota, pod kterou se vešlo 95 % požadavků. Říká, jak dlouho čekal skoro nejhůř dopadlý zákazník.

Spočítáš ho takto: seřaď hodnoty a vezmi tu na pořadí ceil(n * 95 / 100), počítáno od jedničky. Dvě stránky se stejným průměrem mohou být úplně jiný zážitek:

from math import ceil

def p95(hodnoty):
    serazene = sorted(hodnoty)
    return serazene[ceil(len(serazene) * 95 / 100) - 1]

vyrovnana = [0.89] * 100
zradna = [0.1] * 90 + [8.0] * 10

for jmeno, doby in [("vyrovnaná", vyrovnana), ("zrádná", zradna)]:
    prumer = sum(doby) / len(doby)
    print(f"{jmeno:10} průměr {prumer:.2f} s   p95 {p95(doby):.2f} s")
Výstup
vyrovnaná  průměr 0.89 s   p95 0.89 s
zrádná     průměr 0.89 s   p95 8.00 s
Úkol

Krok 5: nejpomalejší stránky

Napiš p95(hodnoty) podle postupu výše. Potom nejpomalejsi(zaznamy, min_pozadavku=2): seskup doby podle cesty bez části za ?, vynech cesty s menším počtem požadavků a vrať seznam dvojic (cesta, p95) od nejpomalejší.

from collections import defaultdict
from math import ceil

def z(cas, ip, metoda, cesta, status, doba):
    return {"ip": ip, "cas": f"14/Nov/2026:{cas} +0100", "metoda": metoda,
            "cesta": cesta, "status": status, "bajty": 512, "doba": doba}

ZAZNAMY = [
    z("14:19:58", "198.51.100.4", "GET", "/", 200, 0.041),
    z("14:20:03", "198.51.100.7", "GET", "/produkty?strana=2", 200, 0.090),
    z("14:20:11", "198.51.100.7", "GET", "/produkty", 200, 0.085),
    z("14:20:40", "198.51.100.9", "POST", "/pokladna", 504, 30.0),
    z("14:21:02", "198.51.100.4", "POST", "/pokladna", 504, 29.5),
]

def p95(hodnoty):
    # doplň
    return 0

def nejpomalejsi(zaznamy, min_pozadavku=2):
    # doplň
    return []

print(nejpomalejsi(ZAZNAMY))
Výstup

Zbývá kolegův dotaz. Jedno špatné heslo nic neznamená, to se stává každému. Stejná adresa s desítkami neúspěšných pokusů už ano.

Úkol

Krok 6: kdo zkouší hesla

Napiš podezrele_ip(zaznamy, limit=3). Neúspěšné přihlášení je záznam se stavem 401 na cestě /prihlaseni (bez části za ?). Vrať seznam dvojic (ip, počet) pro adresy s aspoň limit pokusy. Řaď od největšího počtu, při shodě podle IP adresy jako textu.

from collections import Counter

def z(cas, ip, metoda, cesta, status, doba):
    return {"ip": ip, "cas": f"14/Nov/2026:{cas} +0100", "metoda": metoda,
            "cesta": cesta, "status": status, "bajty": 512, "doba": doba}

ZAZNAMY = [
    z("14:40:01", "203.0.113.66", "POST", "/prihlaseni", 401, 0.120),
    z("14:40:03", "203.0.113.66", "POST", "/prihlaseni", 401, 0.118),
    z("14:40:05", "203.0.113.66", "POST", "/prihlaseni", 401, 0.121),
    z("14:41:12", "198.51.100.4", "POST", "/prihlaseni", 401, 0.117),
    z("14:41:20", "198.51.100.4", "POST", "/prihlaseni", 200, 0.130),
]

def podezrele_ip(zaznamy, limit=3):
    # doplň
    return []

print(podezrele_ip(ZAZNAMY))
Výstup
Kvíz

Stránka má průměrnou dobu 0,3 s, ale p95 je 6 s. Co z toho plyne?

Celé vyšetřování najednou

Všechny kroky teď spojíš do jednoho programu. Funkce vyrob_log nahrazuje skutečný server: vyrobí 3 000 požadavků z jedné hodiny a schová do nich dva incidenty. Zbytek je tvoje práce z předchozích kroků.

import json
import random
import re
from collections import Counter, defaultdict
from datetime import datetime, timedelta, timezone
from math import ceil
from pathlib import Path

FORMAT = "%d/%b/%Y:%H:%M:%S %z"
VZOR = re.compile(r"""
    (?P<ip>\S+) \s \S+ \s \S+ \s
    \[(?P<cas>[^\]]+)\] \s
    "(?P<metoda>[A-Z]+) \s (?P<cesta>\S+) \s HTTP/[\d.]+" \s
    (?P<status>\d{3}) \s (?P<bajty>\d+|-) \s
    "[^"]*" \s "[^"]*" \s
    (?P<doba>[\d.]+)
""", re.VERBOSE)


def vyrob_log(soubor, pocet=3000):
    los = random.Random(2026)
    cesty = ["/", "/produkty", "/produkty/hrnek", "/kosik", "/pokladna", "/static/app.js"]
    vahy = [20, 28, 14, 10, 8, 20]
    start = datetime(2026, 11, 14, 14, 0, tzinfo=timezone(timedelta(hours=1)))
    with open(soubor, "w", encoding="utf-8") as f:
        for i in range(pocet):
            kdy = start + timedelta(seconds=i * 3600 // pocet)
            ip = f"198.51.100.{los.randint(1, 80)}"
            metoda, cesta, status = "GET", los.choices(cesty, vahy)[0], 200
            doba = los.randint(20, 180) / 1000
            if cesta == "/produkty" and los.random() < 0.3:
                cesta += f"?strana={los.randint(2, 9)}"
            if cesta == "/pokladna":
                metoda, doba = "POST", los.randint(150, 600) / 1000
                if 20 <= kdy.minute < 26:          # incident 1: pokladna neodpovídá
                    status, doba = 504, los.randint(25000, 30000) / 1000
            if 40 <= kdy.minute < 46 and i % 4 == 0:   # incident 2: zkoušení hesel
                ip, metoda, cesta, status = "203.0.113.66", "POST", "/prihlaseni", 401
            cas = kdy.strftime(FORMAT)
            f.write(f'{ip} - - [{cas}] "{metoda} {cesta} HTTP/1.1" {status} '
                    f'{los.randint(300, 9000)} "-" "Mozilla/5.0" {doba:.3f}\n')
            if i % 700 == 0:                       # robot posílá nesmysly
                f.write(f'192.0.2.9 - - [{cas}] "\\x16\\x03\\x01" 400 0 "-" "-" 0.000\n')


def rozeber(radek):
    shoda = VZOR.fullmatch(radek.strip())
    if shoda is None:
        return None
    z = shoda.groupdict()
    z["status"] = int(z["status"])
    z["bajty"] = 0 if z["bajty"] == "-" else int(z["bajty"])
    z["doba"] = float(z["doba"])
    return z


def nacti(cesta):
    zaznamy, vadne = [], 0
    with open(cesta, encoding="utf-8", errors="replace") as f:
        for radek in f:
            if radek.strip():
                z = rozeber(radek)
                if z is None:
                    vadne += 1
                else:
                    zaznamy.append(z)
    return zaznamy, vadne


def cista(cesta):
    return cesta.split("?")[0]


def minuta_utc(cas):
    return datetime.strptime(cas, FORMAT).astimezone(timezone.utc).strftime("%H:%M")


def p95(hodnoty):
    serazene = sorted(hodnoty)
    return serazene[ceil(len(serazene) * 95 / 100) - 1]


def analyzuj(zaznamy, vadne):
    doby = defaultdict(list)
    for z in zaznamy:
        doby[cista(z["cesta"])].append(z["doba"])
    pomale = [(c, p95(d)) for c, d in doby.items() if len(d) >= 20]
    pokusy = Counter(z["ip"] for z in zaznamy
                     if z["status"] == 401 and cista(z["cesta"]) == "/prihlaseni")
    pokladna = [z for z in zaznamy if cista(z["cesta"]) == "/pokladna"]
    chyby = Counter(minuta_utc(z["cas"]) for z in zaznamy if z["status"] >= 500)
    return {
        "zaznamu": len(zaznamy),
        "vadnych_radku": vadne,
        "tridy_stavu": dict(sorted(Counter(f"{z['status'] // 100}xx" for z in zaznamy).items())),
        "nejcastejsi_cesty": Counter(cista(z["cesta"]) for z in zaznamy).most_common(3),
        "chyby_5xx_po_minutach_utc": dict(sorted(chyby.items())),
        "pokladna_pozadavku": len(pokladna),
        "pokladna_chyb": sum(z["status"] >= 500 for z in pokladna),
        "nejpomalejsi_p95_s": sorted(pomale, key=lambda x: x[1], reverse=True)[:2],
        "podezrele_ip": [(ip, n) for ip, n in pokusy.most_common() if n >= 20],
    }


vyrob_log("access.log")
report = analyzuj(*nacti("access.log"))
Path("report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")

for klic, hodnota in json.loads(Path("report.json").read_text(encoding="utf-8")).items():
    print(f"{klic}: {hodnota}")
Výstup
zaznamu: 3000
vadnych_radku: 5
tridy_stavu: {'2xx': 2906, '4xx': 75, '5xx': 19}
nejcastejsi_cesty: [['/produkty', 848], ['/static/app.js', 614], ['/', 605]]
chyby_5xx_po_minutach_utc: {'13:20': 3, '13:21': 7, '13:22': 2, '13:23': 1, '13:24': 4, '13:25': 2}
pokladna_pozadavku: 215
pokladna_chyb: 19
nejpomalejsi_p95_s: [['/pokladna', 27.048], ['/prihlaseni', 0.308]]
podezrele_ip: [['203.0.113.66', 75]]

Teď můžeš odpovědět oběma. Časy v reportu jsou v UTC, takže k nim přičti hodinu.

  • Zákaznice měla pravdu. Všech 19 odpovědí 5xx připadá na /pokladna a leží mezi 14:20 a 14:25 našeho času. Doba vyřízení se tam blížila půl minutě, p95 pokladny je přes 27 sekund, zatímco běžné stránky odpovídají ve zlomku sekundy.
  • Kolega měl také pravdu. Adresa 203.0.113.66 má 75 neúspěšných přihlášení. Jsou to všechny odpovědi 4xx v celém logu.
  • Vadných řádků je 5 z 3 005, takže výsledkům lze věřit.

Všimni si, co by udělal jediný souhrnný údaj: chyby tvoří jen asi 0,6 % všech požadavků a web by v něm vypadal zdravě. Na pokladně je to skoro 9 % a jde o jedinou stránku, kde se vydělávají peníze. Log navíc říká co a kdy, ne proč. Příčinu musíš hledat dál, třeba v logu aplikace nebo u poskytovatele plateb.

Kvíz

Proč v reportu nestačí údaj „chybovost 0,6 %“?

Počítání za celou hodinu nerozliší útok od člověka, který si týden nepamatuje heslo. Přesnější je klouzavé okno: kolik pokusů bylo za posledních 60 sekund. Fronta deque to zvládne v lineárním čase, protože každý záznam jednou přidáš a nejvýš jednou odebereš.

from collections import defaultdict, deque

def prvni_poplach(udalosti, limit=4, okno=60):
    fronty = defaultdict(deque)
    poplachy = {}
    for cas, ip in udalosti:
        fronta = fronty[ip]
        fronta.append(cas)
        while cas - fronta[0] >= okno:
            fronta.popleft()
        if len(fronta) >= limit:
            poplachy.setdefault(ip, cas)
    return poplachy

udalosti = [(0, "A"), (50, "A"), (100, "A"), (150, "A"),   # pomalu, nikdy 4 za minutu
            (200, "B"), (202, "B"), (204, "B"), (206, "B"), (208, "B")]
print(prvni_poplach(udalosti))
Výstup
{'B': 206}
Pod kapotou · co ti log neřekne přímo

Základ formátu je Combined Log Format, pole s dobou vyřízení je naše rozšíření (v nginxu $request_time). Čas v řádku neznamená všude totéž. Apache v %t zapisuje okamžik přijetí požadavku, nginx $time_local okamžik zápisu do logu, tedy konec vyřízení. Při 30sekundovém timeoutu je v nginxu začátek problému o půl minuty dřív, než ukazuje první 504, a soubor navíc není seřazený podle začátku požadavků.

Za reverzní proxy nebo CDN je v prvním poli adresa proxy. Skutečného klienta nese X-Forwarded-For, jenže jeho levou část si může vymyslet kdokoli, takže věřit lze jen záznamům od proxy, které sám provozuješ. Blokovat podle IP je navíc hrubé: za jednou adresou může být celá firma nebo mobilní operátor.

Doba vyřízení umí klamat oběma směry. Rychle vracené chyby p95 zlepší, proto sleduj latenci zvlášť pro úspěšné a neúspěšné odpovědi. Klient, který to vzdal, se v nginxu objeví jako nestandardní 499, takže skutečný problém vypadá jako chyba návštěvníka. Percentily se také nedají průměrovat: p95 za hodinu ani za cluster ze dílčích p95 nespočítáš. Při agregaci se ukládají histogramy nebo náčrty typu t-digest.

statistics.quantiles používá jinou definici než nearest-rank a ve výchozím stavu interpoluje. V Pythonu 3.12 navíc pro jediný údaj vyhodí StatisticsError, to se změnilo až ve 3.13.

Pod kapotou · log je nedůvěryhodný vstup

Cestu i user agent píše útočník. Z toho plyne několik konkrétních pravidel:

  • ReDoS. Modul re používá backtracking, takže vzor jako (a+)+$ může na připraveném textu běžet exponenciálně dlouho. Negované třídy typu [^"]* jsou bezpečné a přesné. Od Pythonu 3.11 jsou k dispozici i atomické skupiny (?>...) a posesivní kvantifikátory *+.
  • Uvozovky uvnitř polí. nginx je ve výchozím stavu zapisuje jako \x22, Apache jako \". Pro Apache proto potřebuješ "(?:[^"\\]|\\.)*", jinak takové řádky skončí mezi vadnými. To je přesně chvíle, kdy se vyplatí sledovat jejich počet.
  • Export do tabulky. Cesta začínající =, +, - nebo @ se po otevření CSV v Excelu může vyhodnotit jako vzorec (CSV injection).
  • Výpis do terminálu. Řídicí znaky ANSI umí přepsat obrazovku. Nedůvěryhodné hodnoty vypisuj přes ascii() nebo repr().
  • Osobní údaje. IP adresa a dotazy v URL mohou být osobní údaje a dotaz může obsahovat i přihlašovací token. Reporty proto čisti a omez dobu uchování.

Výkon: strptime je v takovém programu často nejdražší krok. Řádky ze stejné sekundy mají stejný text, takže pomůže functools.lru_cache kolem převodu. Pozor na %b: závisí na locale, a pokud aplikace zavolá locale.setlocale(locale.LC_TIME, "cs_CZ.UTF-8"), anglické Nov přestane fungovat. Rotované logy čte stejný cyklus přes gzip.open(cesta, "rt", encoding="utf-8", errors="replace").