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í.
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áchStavový kód je trojciferné číslo. První číslice řekne, jak to dopadlo:
| Skupina | Význam | Příklad |
|---|---|---|
2xx | v pořádku | 200 hotovo |
3xx | jdi jinam | 301 stránka se přestěhovala |
4xx | chyba na straně návštěvníka | 404 nenalezeno, 401 špatné přihlášení |
5xx | chyba na straně serveru | 500 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:])
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}")
ip 198.51.100.7 cas 14/Nov/2026:14:21:08 +0100 metoda POST cesta /pokladna
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, statusabajtybudouint,dobabudefloat,- některé servery místo nuly bajtů píšou
-. V tom případě budebajtyrovno0.
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))
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.
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 logu se 100 000 řádky je 37 vadných. Co s nimi?
Pár vadných řádků je běžný šum. Musíš je ale vidět, protože prudký nárůst znamená změnu formátu nebo chybu parseru, a pak by byly i ostatní výsledky k ničemu.
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].
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))
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"))
False True 2026-11-14 13:20
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))
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")
vyrovnaná průměr 0.89 s p95 0.89 s zrádná průměr 0.89 s p95 8.00 s
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))
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.
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))
Stránka má průměrnou dobu 0,3 s, ale p95 je 6 s. Co z toho plyne?
p95 říká, že 5 % požadavků je na této hodnotě nebo nad ní. Na webu s tisíci návštěv je to spousta naštvaných lidí, i když průměr vypadá skvěle.
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}")
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í
5xxpřipadá na/pokladnaa 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.66má 75 neúspěšných přihlášení. Jsou to všechny odpovědi4xxv 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.
Proč v reportu nestačí údaj „chybovost 0,6 %“?
Souhrn za hodinu a za celý web rozmělní krátký výpadek jedné funkce. Proto se data dělí podle času a podle cesty.
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))
{'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
repouží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()neborepr(). - 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").