Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Performance, Profiling und Verteilung

Ziel: logsum aus Tag 2 auf einem Log mit einer Million Zeilen rund 10× schneller machen – gemessen, nicht geraten – und das Ergebnis als Wheel, uv tool, zipapp und mit CI ausliefern · Dauer: ca. 150 min · Voraussetzung: Tag 5

Briefing

  • Erst messen, dann ändern: hyperfine für das ganze Tool, cProfile für Funktionen, line_profiler für Zeilen, timeit für Schnipsel.
  • Der Gewinn steckt fast immer an einer einzigen Stelle. Die findest du nur mit einem Profil.
  • Jede Optimierung braucht einen Gleichheitsbeweis: gleiche Ausgabe, gleiche Tests.
  • Generatoren sparen Speicher, Prozesse nutzen alle Kerne, polars rechnet spaltenweise in Rust.
  • Ausliefern: uv build (Wheel), uv tool install, python -m zipapp, GitHub Actions.
lab/big.log (1 Mio. Zeilen, 92 MB)
  ├─ messen      hyperfine ──► 5,3 s, 350 MiB
  ├─ finden      cProfile ──► strptime · line_profiler ──► Zeile 31
  ├─ verbessern  parse_stamp · str.split · Generator · Prozesse
  └─ beweisen    diff gegen Referenz · pytest · mypy ──► 0,56 s

Drill 1: Die Messlatte

Wie an Tag 5 kopierst du das Projekt, damit Tag 2 als Referenz unangetastet bleibt:

cd ~/py-lab
rsync -a --exclude .venv --exclude .git --exclude __pycache__ \
  --exclude '.*_cache' tag02-logsum/ tag14-logsum-fast/
cd tag14-logsum-fast && git init -q
uv add -q --dev mypy
cat >> pyproject.toml <<'EOF'

[tool.mypy]
strict = true
files = ["src"]
EOF
uv run scripts/genlog.py 1000000 > lab/big.log
head -n 200000 lab/big.log > lab/200k.log
ls -lh lab/big.log | awk '{print $5}'
shasum lab/big.log
uv run logsum lab/big.log | tee lab/referenz.txt

Erwartet:

92M
5ff495ee6c9a69e2da0add82afe809191dd57ae6  lab/big.log
logsum: 2000 Zeilen übersprungen (Format)
Anfragen: 998000  Fehlerquote 5xx: 8.2%
Zeitraum: 08:00:00 - 16:10:35 UTC
Statuscodes:
  200  882446
  404   34031
  500   43765
  503   37758
Top 3 Fehlerpfade:
   49801  /api/payments
    7960  /api/orders
    7934  /login

lab/referenz.txt ist ab jetzt der Gleichheitsbeweis: Jede schnellere Version muss exakt diese Ausgabe liefern. Gezählt wird mit hyperfine (brew install hyperfine):

hyperfine -w 1 -r 3 'uv run logsum lab/big.log'

Erwartet (Werte schwanken mit Rechner und Last):

Benchmark 1: uv run logsum lab/big.log (3 runs)
                mean     ±       σ          min     …     max
  Wall Time    5.288 s   ±   0.059 s      5.223 s   …   5.337 s
  Memory       350.1 MiB ±     0.1 MiB    350.0 MiB …   350.1 MiB

Warum hyperfine statt time? Es wärmt auf (-w), wiederholt (-r), zeigt die Streuung und – ab Version 2 – den Speicher. Eine Messung ohne Streuung ist eine Anekdote.

Tipp: Auf einem ausgelasteten Laptop schwanken die Zeiten um 20 % und mehr. Vergleiche nur Läufe, die direkt nacheinander entstanden sind, und schau auf min.

Fortschritt speichern? Kostenlos registrieren

Drill 2: cProfile – welche Funktion?

Profiliert wird auf 200 000 Zeilen; das reicht und spart Wartezeit.

uv run python -m cProfile -o lab/prof.out -m logsum lab/200k.log > /dev/null 2>&1
uv run python - <<'EOF'
import pstats

stats = pstats.Stats("lab/prof.out")
stats.strip_dirs().sort_stats("tottime").print_stats(6)
EOF

Erwartet (gekürzt):

         7217071 function calls (7216338 primitive calls) in 4.432 seconds

   Ordered by: internal time
   List reduced from 668 to 6 due to restriction <6>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
   199600    1.726    0.000    2.970    0.000 _strptime.py:516(_strptime)
   200000    0.373    0.000    4.314    0.000 parse.py:24(parse_line)
   399607    0.335    0.000    0.335    0.000 {method 'match' of 're.Pattern'…}
   199600    0.168    0.000    0.168    0.000 _strptime.py:793(_parse_tz)
   199600    0.148    0.000    3.540    0.000 {built-in method strptime}
  • tottime ist die Zeit in der Funktion, cumtime inklusive aller Aufrufe darunter. Sortiere nach tottime, um den Täter zu finden, nach cumtime, um den Pfad dorthin zu sehen.
  • strptime braucht 3,5 von 4,4 Sekunden – 80 %. Die Regex (match) ist mit 0,3 s harmlos.
  • Unter cProfile läuft alles 2–3× langsamer. Die absoluten Zahlen sind egal, die Anteile zählen.

Tipp: Für laufende Prozesse (z. B. einen hängenden Dienst) gibt es den Sampling-Profiler py-spy: uvx py-spy top --pid <PID> oder py-spy record -o profil.svg für einen Flamegraph. Unter macOS braucht er sudo.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Zeilen und Schnipsel messen

cProfile kennt nur Funktionen. Welche Zeile in parse_line teuer ist, zeigt line_profiler – nur für diesen Lauf per --with geladen, nicht als Abhängigkeit:

cat > scripts/lineprof.py <<'EOF'
"""Zeilengenaues Profil von parse_line (läuft mit --with line_profiler)."""

import sys
from pathlib import Path

from line_profiler import LineProfiler

from logsum.parse import parse_line

lines = Path(sys.argv[1]).read_text(encoding="utf-8").splitlines()
lp = LineProfiler(parse_line)
lp.runcall(lambda: [parse_line(line) for line in lines])
lp.print_stats(output_unit=1e-3)
EOF
uv run --with line_profiler python scripts/lineprof.py lab/200k.log

Erwartet (gekürzt):

Function: parse_line at line 24

Line #      Hits         Time  Per Hit   % Time  Line Contents
==============================================================
    26    200000        155.2      0.0      1.8      m = LINE_RE.match(line)
    27    200000         40.6      0.0      0.5      if m is None:
    28       400          0.1      0.0      0.0          return None
    29    399200        529.6      0.0      6.1      return LogEntry(
    30    199600         48.8      0.0      0.6          ip=m["ip"],
    31    199600       7639.0      0.0     88.4          time=datetime.strptime(...
    34    199600         62.9      0.0      0.7          status=int(m["status"]),

88 % in einer Zeile. Was die Alternative kostet, misst timeit direkt auf der Kommandozeile:

uv run python -m timeit -s 'from datetime import datetime' \
  'datetime.strptime("10/Oct/2026:08:00:00 +0000", "%d/%b/%Y:%H:%M:%S %z")'
uv run python -m timeit -s 'from datetime import datetime' \
  'datetime(2026, 10, 10, 8, 0, 0)'

Erwartet (gekürzt, schwankt):

100000 loops, best of 5: 4.9 usec per loop
5000000 loops, best of 5: 85.9 nsec per loop

Warum ist strptime so langsam? Es ist in Python geschrieben, interpretiert bei jedem Aufruf den Formatstring, prüft die Locale und baut die Zeitzone neu. Das Log hat aber immer dasselbe Format – die Positionen sind fest.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Zeitstempel selbst parsen – und functools.cache

Ergänze in src/logsum/parse.py die Importe und darunter drei Bausteine:

import calendar
from datetime import datetime, timedelta, timezone
from functools import cache

MONTHS = {name: i for i, name in enumerate(calendar.month_abbr) if name}


@cache
def tz(offset: str) -> timezone:
    """'+0200' -> timezone(+2h). Es gibt nur wenige Offsets: cache ohne Limit."""
    sign = -1 if offset[0] == "-" else 1
    hours, minutes = int(offset[1:3]), int(offset[3:5])
    return timezone(sign * timedelta(hours=hours, minutes=minutes))


def parse_stamp(s: str) -> datetime:
    """'10/Oct/2026:08:00:00 +0000' über feste Positionen statt strptime."""
    return datetime(
        int(s[7:11]),
        MONTHS[s[3:6]],
        int(s[0:2]),
        int(s[12:14]),
        int(s[15:17]),
        int(s[18:20]),
        tzinfo=tz(s[21:26]),
    )
sed -i '' 's/datetime.strptime(m\["time"\], TIME_FORMAT)/parse_stamp(m["time"])/' \
  src/logsum/parse.py
uv run python -m timeit -s 'from logsum.parse import parse_stamp' \
  'parse_stamp("10/Oct/2026:08:00:00 +0000")'
uv run logsum lab/big.log 2>/dev/null | diff - lab/referenz.txt && echo identisch

Erwartet:

500000 loops, best of 5: 670 nsec per loop
identisch
  • calendar.month_abbr ist ['', 'Jan', 'Feb', …]; die Comprehension baut daraus {'Jan': 1, …}.
  • @cache merkt sich jedes Ergebnis pro Argument. Für tz() ideal: Ein Log hat einen, höchstens zwei Offsets.
  • 670 ns statt 4,9 µs: 7× schneller für die teuerste Zeile – bei gleichem Ergebnis, wie diff beweist.

Lohnt sich @cache auch für parse_stamp? Nicht raten, messen:

uv run python - <<'EOF'
import time
from functools import cache, lru_cache
from pathlib import Path

from logsum.parse import LINE_RE, parse_stamp

lines = Path("lab/big.log").read_text(encoding="utf-8")
stamps = [m["time"] for line in lines.splitlines() if (m := LINE_RE.match(line))]
for label, fn in [
    ("ohne Cache", parse_stamp),
    ("lru_cache", lru_cache(maxsize=4096)(parse_stamp)),
    ("cache", cache(parse_stamp)),
]:
    start = time.perf_counter()
    for s in stamps:
        fn(s)
    print(f"{label:<11} {time.perf_counter() - start:.2f}s", end="  ")
    print(fn.cache_info() if hasattr(fn, "cache_info") else "")
EOF

Erwartet (umbrochen, Zeiten schwanken):

ohne Cache  0.51s
lru_cache   0.51s  CacheInfo(hits=249918, misses=748082, maxsize=4096,
  currsize=4096)
cache       0.63s  CacheInfo(hits=249918, misses=748082, maxsize=None,
  currsize=748082)

Nur 25 % Treffer: Das Lab-Log hat fast jede Sekunde nur eine Zeile. Der Cache kostet Hashing und Verwaltung, und @cache hält am Ende 748 082 datetime-Objekte im Speicher – ein Leck mit Ansage. Darum bleibt parse_stamp ohne Cache.

Tipp: Ein Webserver mit hunderten Requests pro Sekunde hat fast nur Treffer; dann gewinnt lru_cache(maxsize=…). cache_info() sagt dir, welcher Fall vorliegt. @cache ohne Limit nur für Argumente mit kleinem, festem Wertebereich.

hyperfine -w 1 -r 3 'uv run logsum lab/big.log'

Erwartet (gekürzt):

  Wall Time    2.028 s   ±   0.038 s      1.990 s   …   2.065 s
  Memory       349.0 MiB ±     0.1 MiB    348.9 MiB …   349.1 MiB

2,6× schneller. Der Speicher ist unverändert – darum kümmert sich Drill 6.

Fortschritt speichern? Kostenlos registrieren

Drill 5: str-Methoden statt Regex – mit Rückfallebene

Die Regex ist nicht teuer, aber str.split ist billiger:

L='10.0.1.59 - - [10/Oct/2026:08:00:00 +0000] "GET /api HTTP/1.1" 200 13 "-" "x"'
uv run python -m timeit -s "from logsum.parse import LINE_RE; l='$L'" \
  'LINE_RE.match(l)'
uv run python -m timeit -s "l='$L'" 'l.split(" ", 10)'

Erwartet (gekürzt):

1000000 loops, best of 5: 251 nsec per loop
2000000 loops, best of 5: 132 nsec per loop

Der Trick: split für den Normalfall, die bewährte Regex als Rückfallebene für alles Ungewöhnliche. So bleibt das Verhalten identisch. parse.py komplett:

cat > src/logsum/parse.py <<'EOF'
"""Logzeilen im nginx-combined-Format in LogEntry-Objekte verwandeln."""

import calendar
import re
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from functools import cache

LINE_RE = re.compile(
    r"(?P<ip>\S+) \S+ \S+ \[(?P<time>[^\]]+)\] "
    r'"(?P<method>\S+) (?P<path>\S+) \S+" (?P<status>\d{3}) (?P<size>\d+)'
)
TIME_FORMAT = "%d/%b/%Y:%H:%M:%S %z"
MONTHS = {name: i for i, name in enumerate(calendar.month_abbr) if name}


@dataclass(frozen=True, slots=True)
class LogEntry:
    ip: str
    time: datetime
    method: str
    path: str
    status: int
    size: int


def parse_line_re(line: str) -> LogEntry | None:
    """Referenz aus Tag 2: Regex + strptime. Gründlich, aber langsam."""
    m = LINE_RE.match(line)
    if m is None:
        return None
    return LogEntry(
        ip=m["ip"],
        time=datetime.strptime(m["time"], TIME_FORMAT),
        method=m["method"],
        path=m["path"],
        status=int(m["status"]),
        size=int(m["size"]),
    )


@cache
def tz(offset: str) -> timezone:
    """'+0200' -> timezone(+2h). Es gibt nur wenige Offsets: cache ohne Limit."""
    sign = -1 if offset[0] == "-" else 1
    hours, minutes = int(offset[1:3]), int(offset[3:5])
    return timezone(sign * timedelta(hours=hours, minutes=minutes))


def parse_stamp(s: str) -> datetime:
    """'10/Oct/2026:08:00:00 +0000' über feste Positionen statt strptime."""
    return datetime(
        int(s[7:11]),
        MONTHS[s[3:6]],
        int(s[0:2]),
        int(s[12:14]),
        int(s[15:17]),
        int(s[18:20]),
        tzinfo=tz(s[21:26]),
    )


def parse_line(line: str) -> LogEntry | None:
    """Schneller Weg mit str.split; alles Ungewöhnliche prüft die Regex."""
    p = line.split(" ", 10)
    if (
        len(p) >= 10
        and len(p[3]) == 21
        and p[3][:1] == "["
        and p[5][:1] == '"'
        and p[7][-1:] == '"'
        and len(p[8]) == 3
        and p[8].isdigit()
        and p[9].isdigit()
    ):
        try:
            t = parse_stamp(f"{p[3][1:]} {p[4][:-1]}")
        except KeyError, ValueError:
            return parse_line_re(line)
        return LogEntry(p[0], t, p[5][1:], p[6], int(p[8]), int(p[9]))
    return parse_line_re(line)
EOF
  • Die alte Funktion heißt jetzt parse_line_re und bleibt die Referenz: langsam, aber gründlich. Jede Zeile, die nicht exakt ins Raster passt, landet dort.
  • split(" ", 10) teilt höchstens zehnmal – der User-Agent am Ende bleibt ein Stück, egal wie viele Leerzeichen er hat.
  • except KeyError, ValueError: ohne Klammern ist neu in Python 3.14 (PEP 758); ruff formatiert so, sobald requires-python = ">=3.14" gilt. Mit as err bleiben die Klammern Pflicht.

Der Gleichheitsbeweis als Test – schnell und Referenz müssen sich bei jeder Zeile einig sein, auch bei kaputten:

cat > tests/test_parse_fast.py <<'EOF'
from datetime import UTC, datetime, timedelta

import pytest

from logsum.parse import parse_line, parse_line_re, parse_stamp

OK = (
    '10.0.3.10 - - [10/Oct/2026:08:00:00 +0000] "GET /health HTTP/1.1" '
    '503 444 "-" "curl/8.7.1"'
)


@pytest.mark.parametrize(
    "line",
    [
        OK,
        OK + "\n",
        OK.replace("+0000", "+0200"),
        OK.replace("+0000", "-0130"),
        OK.replace(' "-" "curl/8.7.1"', ""),  # ohne Referer und Agent
        OK.replace("GET", "POST"),
        OK.replace(" 503 ", " 5030 "),
        OK.replace("Oct", "Okt"),  # unbekannter Monat
        "kaputte Zeile ohne Format",
        "",
    ],
)
def test_schnell_gleich_referenz(line):
    try:
        expected = parse_line_re(line)
    except ValueError:  # strptime scheitert -> der schnelle Weg auch
        with pytest.raises(ValueError):
            parse_line(line)
        return
    assert parse_line(line) == expected


def test_parse_stamp_mit_offset():
    t = parse_stamp("10/Oct/2026:08:00:00 -0130")
    assert t.utcoffset() == -timedelta(hours=1, minutes=30)
    assert parse_stamp("01/Jan/2027:00:00:00 +0000") == datetime(2027, 1, 1, tzinfo=UTC)
EOF
uv run pytest -q
uv run logsum lab/big.log 2>/dev/null | diff - lab/referenz.txt && echo identisch
hyperfine -w 1 -r 3 'uv run logsum lab/big.log'

Erwartet (gekürzt):

.................                                                        [100%]
17 passed in 0.03s
identisch
  Wall Time    1.857 s   ±   0.050 s      1.810 s   …   1.910 s
  Memory       349.3 MiB ±     0.5 MiB    349.0 MiB …   349.9 MiB

Nur noch 10 % – die großen Brocken im Parser sind weg. Die Testfälle mit Okt und 5030 sind die wichtigsten: Sie beweisen, dass der schnelle Weg Fehler nicht verschluckt, sondern an die Referenz weiterreicht.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Generatoren statt Listen – Speicher mit tracemalloc

load() aus Tag 2 baut eine Liste mit einer Million LogEntry-Objekten, nur um sie einmal zu durchlaufen. Ein Generator liefert stattdessen Eintrag für Eintrag. Dafür zählt summarize die kaputten Zeilen gleich mit (None = übersprungen) und kann Teilergebnisse zusammenführen (merge, brauchst du in Drill 7):

cat > src/logsum/stats.py <<'EOF'
"""Kennzahlen aus LogEntry-Strömen berechnen."""

from collections import Counter
from collections.abc import Iterable
from dataclasses import dataclass, field
from datetime import datetime

from logsum.parse import LogEntry


@dataclass
class Summary:
    total: int = 0
    skipped: int = 0
    statuses: Counter[int] = field(default_factory=Counter)
    errors: Counter[str] = field(default_factory=Counter)
    first: datetime | None = None
    last: datetime | None = None

    @property
    def error_rate(self) -> float:
        failed = sum(n for code, n in self.statuses.items() if code >= 500)
        return failed / self.total if self.total else 0.0


def in_window(
    entry: LogEntry, since: datetime | None = None, until: datetime | None = None
) -> bool:
    """True, wenn der Eintrag im halboffenen Zeitfenster [since, until) liegt."""
    if since is not None and entry.time < since:
        return False
    return until is None or entry.time < until


def summarize(
    entries: Iterable[LogEntry | None],
    *,
    since: datetime | None = None,
    until: datetime | None = None,
    min_status: int = 500,
) -> Summary:
    """Zählt Statuscodes und Fehlerpfade; None zählt als übersprungene Zeile."""
    s = Summary()
    window = since is not None or until is not None
    for e in entries:
        if e is None:
            s.skipped += 1
            continue
        if window and not in_window(e, since, until):
            continue
        s.total += 1
        s.statuses[e.status] += 1
        if e.status >= min_status:
            s.errors[e.path] += 1
        if s.first is None or e.time < s.first:
            s.first = e.time
        if s.last is None or e.time > s.last:
            s.last = e.time
    return s


def merge(parts: Iterable[Summary]) -> Summary:
    """Teilergebnisse (z. B. aus Prozessen) zu einer Summary addieren."""
    s = Summary()
    for p in parts:
        s.total += p.total
        s.skipped += p.skipped
        s.statuses.update(p.statuses)
        s.errors.update(p.errors)
        times = [t for t in (s.first, s.last, p.first, p.last) if t is not None]
        if times:
            s.first, s.last = min(times), max(times)
    return s
EOF

In src/logsum/cli.py ersetzt read_entries die Funktion load (oben from collections.abc import Iterator ergänzen):

def read_entries(path: Path) -> Iterator[LogEntry | None]:
    """Zeile für Zeile parsen – ein Generator, nie die ganze Datei im Speicher."""
    with path.open(encoding="utf-8") as f:
        for line in f:
            yield parse_line(line)

Und in main() wird aus dem try-Block samt Ausgabe:

    try:
        s = summarize(
            read_entries(args.logfile),
            since=args.since,
            until=args.until,
            min_status=args.min_status,
        )
    except OSError as err:
        print(f"logsum: {err}", file=sys.stderr)
        return 1
    print(render(s, args.top))
    if s.skipped:
        print(f"logsum: {s.skipped} Zeilen übersprungen (Format)", file=sys.stderr)
    return 0
  • yield macht aus der Funktion einen Generator. Der Code läuft erst los, wenn summarize den ersten Eintrag holt – deshalb muss summarize im try stehen: Ein OSError für eine fehlende Datei kommt erst dort.
  • Die Datei bleibt offen, bis der Generator erschöpft ist; with schließt sie danach.
  • In summarize vergleicht e.time < s.first direkt, statt pro Zeile min() aufzurufen, und in_window läuft nur, wenn überhaupt ein Fenster gesetzt ist.

Wie viel Speicher spart das? tracemalloc aus der Standardbibliothek zählt jede Allokation – mit Zeilennummer:

cat > scripts/mem.py <<'EOF'
"""Speicherspitze: erst alles in eine Liste, dann als Generator."""

import sys
import tracemalloc
from pathlib import Path

from logsum.cli import read_entries
from logsum.stats import summarize

path = Path(sys.argv[1])
tracemalloc.start()

entries = list(read_entries(path))
summarize(entries)
print(f"Liste:     {tracemalloc.get_traced_memory()[1] / 2**20:5.1f} MiB Spitze")
for stat in tracemalloc.take_snapshot().statistics("lineno")[:3]:
    frame = stat.traceback[0]
    print(f"  {Path(frame.filename).name}:{frame.lineno}  {stat.size / 2**20:.1f} MiB")
del entries

tracemalloc.reset_peak()
summarize(read_entries(path))
print(f"Generator: {tracemalloc.get_traced_memory()[1] / 2**20:5.1f} MiB Spitze")
EOF
uv run python scripts/mem.py lab/200k.log

Erwartet:

Liste:      59.5 MiB Spitze
  parse.py:80  29.5 MiB
  parse.py:65  19.2 MiB
  parse.py:52  9.1 MiB
Generator:   0.1 MiB Spitze

Zeile 80 erzeugt die LogEntry-Objekte, Zeile 65 die Teilstrings von split, Zeile 52 die datetime-Werte. Als Liste leben alle 200 000 gleichzeitig, als Generator immer nur einer.

uv run pytest -q | tail -1
uv run logsum lab/big.log 2>/dev/null | diff - lab/referenz.txt && echo identisch
hyperfine -w 1 -r 3 'uv run logsum lab/big.log'

Erwartet (gekürzt):

17 passed in 0.03s
identisch
  Wall Time    1.618 s   ±   0.018 s      1.600 s   …   1.636 s
  Memory        24.5 MiB ±     0.1 MiB     24.3 MiB …    24.6 MiB

350 MiB auf 25 MiB – und nebenbei schneller, weil der Garbage Collector nicht mehr eine Million Objekte durchsuchen muss. Die 25 MiB sind konstant, egal ob das Log 1 GB oder 100 GB groß ist.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Alle Kerne – Prozesse statt Threads

Parsen ist CPU-Arbeit; Threads helfen wegen des GIL nicht (Tag 7). Also Prozesse. Das Problem: Was schickt man ihnen? Eine Million Strings zu pickeln kostet mehr, als es bringt. Besser: Jeder Prozess bekommt nur einen Byte-Bereich der Datei, liest ihn selbst und liefert eine kleine Summary zurück.

big.log  |----- Bereich 1 -----|----- Bereich 2 -----|-- ... --|
          Schnitt immer direkt hinter einem \n
           │                     │
           ▼                     ▼
       Prozess 1             Prozess 2      ...   ──► merge() ──► Summary
cat > src/logsum/parallel.py <<'EOF'
"""Große Logs in Byte-Bereiche teilen und in mehreren Prozessen auswerten."""

from concurrent.futures import ProcessPoolExecutor
from datetime import datetime
from itertools import pairwise
from pathlib import Path

from logsum.parse import parse_line
from logsum.stats import Summary, merge, summarize


def ranges(path: Path, parts: int) -> list[tuple[int, int]]:
    """Etwa gleich große Bereiche (start, end), Schnitte immer nach einem \\n."""
    size = path.stat().st_size
    cuts = [0]
    with path.open("rb") as f:
        for i in range(1, parts):
            f.seek(size * i // parts)
            f.readline()  # bis hinter das nächste Zeilenende springen
            cuts.append(f.tell())
    cuts.append(size)
    return [(a, b) for a, b in pairwise(cuts) if a < b]


def summarize_range(
    path: Path,
    start: int,
    end: int,
    since: datetime | None,
    until: datetime | None,
    min_status: int,
) -> Summary:
    """Läuft im Worker-Prozess: einen Bereich lesen, parsen, zählen."""
    with path.open("rb") as f:
        f.seek(start)
        text = f.read(end - start).decode("utf-8")
    entries = (parse_line(line) for line in text.splitlines())
    return summarize(entries, since=since, until=until, min_status=min_status)


def summarize_parallel(
    path: Path,
    workers: int,
    *,
    since: datetime | None = None,
    until: datetime | None = None,
    min_status: int = 500,
) -> Summary:
    with ProcessPoolExecutor(max_workers=workers) as pool:
        futures = [
            pool.submit(summarize_range, path, a, b, since, until, min_status)
            for a, b in ranges(path, workers)
        ]
        return merge(f.result() for f in futures)
EOF
  • f.seek() springt an eine grobe Position, readline() liest bis hinter das nächste \n. So beginnt jeder Bereich mit einer ganzen Zeile, und jedes Byte gehört genau einem Bereich.
  • Die Datei wird binär gelesen: Byte-Positionen sind eindeutig, Zeichen-Positionen bei UTF-8 nicht. Dekodiert wird erst im Worker.
  • pool.submit übergibt nur Pfad, zwei Zahlen und die Filter – ein paar hundert Bytes pro Prozess. Zurück kommen zwei Counter und zwei Zeitstempel.

Das CLI bekommt --workers (0 = alle Kerne) und gleich noch --version für Drill 9. cli.py komplett:

cat > src/logsum/cli.py <<'EOF'
"""logsum – Accesslogs auswerten: Statuscodes, Top-Fehler, Zeitfenster."""

import argparse
import os
import sys
from collections.abc import Iterator
from datetime import UTC, datetime
from importlib.metadata import PackageNotFoundError, version
from pathlib import Path

from logsum.parallel import summarize_parallel
from logsum.parse import LogEntry, parse_line
from logsum.stats import Summary, summarize


def get_version() -> str:
    try:
        return version("logsum")
    except PackageNotFoundError:  # z. B. im zipapp ohne Paket-Metadaten
        return "unbekannt"


def parse_time(value: str) -> datetime:
    """ISO-Zeit wie 2026-10-10T08:30; ohne Zeitzone gilt UTC."""
    dt = datetime.fromisoformat(value)
    return dt if dt.tzinfo else dt.replace(tzinfo=UTC)


def read_entries(path: Path) -> Iterator[LogEntry | None]:
    """Zeile für Zeile parsen – ein Generator, nie die ganze Datei im Speicher."""
    with path.open(encoding="utf-8") as f:
        for line in f:
            yield parse_line(line)


def render(s: Summary, top: int) -> str:
    out = [f"Anfragen: {s.total}  Fehlerquote 5xx: {s.error_rate:.1%}"]
    if s.first and s.last:
        out.append(f"Zeitraum: {s.first:%H:%M:%S} - {s.last:%H:%M:%S} UTC")
    out.append("Statuscodes:")
    out += [f"  {code}  {n:>6}" for code, n in sorted(s.statuses.items())]
    out.append(f"Top {top} Fehlerpfade:")
    out += [f"  {n:>6}  {path}" for path, n in s.errors.most_common(top)]
    return "\n".join(out)


def main(argv: list[str] | None = None) -> int:
    p = argparse.ArgumentParser(prog="logsum", description=__doc__)
    p.add_argument("logfile", type=Path, help="Accesslog im combined-Format")
    p.add_argument("--top", type=int, default=3, help="Anzahl Fehlerpfade")
    p.add_argument("--since", type=parse_time, help="ab Zeitpunkt (inklusive)")
    p.add_argument("--until", type=parse_time, help="bis Zeitpunkt (exklusive)")
    p.add_argument("--min-status", type=int, default=500, help="Fehler ab Code")
    p.add_argument(
        "-w", "--workers", type=int, default=1, help="Prozesse (0 = alle Kerne)"
    )
    p.add_argument("--version", action="version", version=f"%(prog)s {get_version()}")
    args = p.parse_args(argv)
    workers = args.workers or os.process_cpu_count() or 1
    window = {"since": args.since, "until": args.until, "min_status": args.min_status}

    try:
        if workers == 1:
            s = summarize(read_entries(args.logfile), **window)
        else:
            s = summarize_parallel(args.logfile, workers, **window)
    except OSError as err:
        print(f"logsum: {err}", file=sys.stderr)
        return 1
    print(render(s, args.top))
    if s.skipped:
        print(f"logsum: {s.skipped} Zeilen übersprungen (Format)", file=sys.stderr)
    return 0
EOF
uv run python -c 'import os; print(os.process_cpu_count())'
uv run logsum lab/big.log -w 0 2>/dev/null | diff - lab/referenz.txt && echo identisch
uv run logsum lab/big.log -w 3 2>/dev/null | diff - lab/referenz.txt && echo identisch

Erwartet:

10
identisch
identisch
  • os.process_cpu_count() (neu in 3.13) zählt die Kerne, die dieser Prozess nutzen darf – in Containern mit CPU-Limit ehrlicher als os.cpu_count().
  • **window entpackt das Dict in Keyword-Argumente; beide Wege bekommen garantiert dieselben Filter.

Tests für Schnitte, Zusammenführung und den Gleichstand seriell/parallel:

cat > tests/test_parallel.py <<'EOF'
from datetime import UTC, datetime

import pytest

from logsum.cli import main, read_entries
from logsum.parallel import ranges, summarize_parallel
from logsum.parse import parse_line
from logsum.stats import merge, summarize

OK = (
    '10.0.3.10 - - [10/Oct/2026:08:00:00 +0000] "GET /health HTTP/1.1" '
    '503 444 "-" "curl/8.7.1"'
)


def test_merge_addiert_teile():
    e = [parse_line(OK), None, parse_line(OK.replace(" 503 ", " 200 "))]
    whole = summarize(e)
    assert merge([summarize(e[:1]), summarize(e[1:])]) == whole
    assert (whole.total, whole.skipped, whole.errors["/health"]) == (2, 1, 1)


def test_ranges_schneiden_an_zeilenenden(tmp_path):
    log = tmp_path / "a.log"
    log.write_text("".join(f"zeile {i}\n" for i in range(100)), encoding="utf-8")
    data = log.read_bytes()
    rs = ranges(log, 7)
    assert rs[0][0] == 0
    assert rs[-1][1] == len(data)
    assert all(data[b - 1 : b] == b"\n" for _, b in rs)
    assert b"".join(data[a:b] for a, b in rs) == data


def test_parallel_gleich_seriell(tmp_path):
    log = tmp_path / "a.log"
    lines = [OK.replace("08:00:00", f"08:{m:02d}:00") for m in range(60)]
    log.write_text("\n".join([*lines, "kaputt"]) + "\n", encoding="utf-8")
    since = datetime(2026, 10, 10, 8, 10, tzinfo=UTC)
    serial = summarize(read_entries(log), since=since)
    assert summarize_parallel(log, 3, since=since) == serial
    assert (serial.total, serial.skipped) == (50, 1)


def test_cli_workers_und_version(tmp_path, capsys):
    log = tmp_path / "a.log"
    log.write_text(OK + "\n", encoding="utf-8")
    assert main([str(log), "-w", "2"]) == 0
    assert "Anfragen: 1" in capsys.readouterr().out
    with pytest.raises(SystemExit):
        main(["--version"])
    assert capsys.readouterr().out.startswith("logsum ")
EOF
uv run pytest -q
uv run mypy

Erwartet:

.....................                                                    [100%]
21 passed in 0.19s
Success: no issues found in 6 source files

test_ranges_schneiden_an_zeilenenden prüft die Invariante, auf der alles ruht: Die Bereiche setzen sich lückenlos und überlappungsfrei zur Datei zusammen, und jeder endet mit \n.

hyperfine -w 1 -r 5 'uv run logsum lab/big.log -w 0'

Erwartet (10 Kerne, gekürzt):

  Wall Time    556.3 ms  ±    18.1 ms     534.6 ms  …   576.8 ms
  Memory        58.5 MiB ±     0.1 MiB     58.3 MiB …    58.5 MiB

5,3 s auf 0,56 s: das Ziel, knapp 10×. Dass 10 Prozesse nicht 10× bringen, liegt am Prozessstart (macOS nutzt spawn und importiert alles neu), an den langsameren Effizienzkernen und an Amdahl: Der serielle Rest (Start, Schnitte, merge) wird nicht schneller.

Achtung: Für kleine Dateien ist -w 0 langsamer als -w 1 – zehn Interpreter starten kostet mehr als 2000 Zeilen parsen. Darum bleibt --workers 1 der Default.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Zum Vergleich – polars

Wie schnell wäre es ganz ohne eigene Schleife? polars (Tag 8) kann Textdateien zeilenweise einlesen und die Regex in Rust auf allen Kernen anwenden. Als Skript, damit logsum selbst ohne Abhängigkeiten bleibt:

cat > scripts/polars_sum.py <<'EOF'
"""Dieselbe Auswertung mit polars – zum Vergleich, nicht Teil des Pakets."""

import sys

import polars as pl

PATTERN = (
    r"^\S+ \S+ \S+ \[(?P<time>[^\]]+)\] "
    r'"\S+ (?P<path>\S+) \S+" (?P<status>\d{3}) \d+'
)

df = (
    pl.scan_csv(  # jede Zeile als eine Spalte: Trenner, der nie vorkommt
        sys.argv[1],
        has_header=False,
        separator="\x1f",
        quote_char=None,
        new_columns=["line"],
    )
    .select(pl.col("line").str.extract_groups(PATTERN).alias("m"))
    .unnest("m")
    .drop_nulls()
    .with_columns(
        pl.col("status").cast(pl.Int32),
        pl.col("time").str.strptime(pl.Datetime, "%d/%b/%Y:%H:%M:%S %z"),
    )
    .collect()
)
errors = df.filter(pl.col("status") >= 500)
print(f"Anfragen: {df.height}  Fehlerquote 5xx: {errors.height / df.height:.1%}")
print(f"Zeitraum: {df['time'].min():%H:%M:%S} - {df['time'].max():%H:%M:%S} UTC")
print(dict(df.group_by("status").len().sort("status").iter_rows()))
print(errors.group_by("path").len().sort("len", descending=True).head(3).rows())
EOF
uv run --with polars scripts/polars_sum.py lab/big.log

Erwartet:

Anfragen: 998000  Fehlerquote 5xx: 8.2%
Zeitraum: 08:00:00 - 16:10:35 UTC
{200: 882446, 404: 34031, 500: 43765, 503: 37758}
[('/api/payments', 49801), ('/api/orders', 7960), ('/login', 7934)]
  • scan_csv mit einem Trennzeichen, das nie vorkommt (\x1f), liest jede Zeile als eine einzige Spalte.
  • str.extract_groups macht aus den benannten Gruppen eine Struct-Spalte, unnest daraus normale Spalten. Kaputte Zeilen werden null und fliegen mit drop_nulls raus.
  • uv run --with polars lädt polars nur für diesen Aufruf in eine Wegwerf-Umgebung – das Paket logsum bleibt bei null Abhängigkeiten.
Variante Zeit (1 Mio. Zeilen) Speicher
Tag 2 (Regex, strptime, Liste) 5,3 s 350 MiB
Tag 14 seriell 1,6 s 25 MiB
Tag 14, 10 Prozesse 0,56 s 58 MiB
polars 0,26 s 380 MiB

Warum dann nicht immer polars? 170 MB Abhängigkeit für ein kleines CLI, alles im Speicher statt gestreamt, und die Logik steckt in einer zweiten Sprache (Ausdrücke statt Python). Für Ad-hoc-Analysen großer Dateien ist polars unschlagbar; für ein schlankes Ops-Tool reicht die Python-Variante.

Fortschritt speichern? Kostenlos registrieren

Drill 9: Ausliefern – Wheel, uv tool, zipapp

Version und Paket kennst du aus Tag 5. Kurz: Beschreibung setzen, Version erhöhen, bauen.

sed -i '' 's/^description = .*/description = "Accesslogs auswerten – schnell"/' \
  pyproject.toml
uv version --bump minor
uv build
unzip -l dist/logsum-0.2.0-py3-none-any.whl | awk 'NR>3 {print $4}' | grep logsum/

Erwartet (gekürzt):

logsum 0.1.0 => 0.2.0
Successfully built dist/logsum-0.2.0.tar.gz
Successfully built dist/logsum-0.2.0-py3-none-any.whl
logsum/
logsum/__init__.py
logsum/__main__.py
logsum/cli.py
logsum/parallel.py
logsum/parse.py
logsum/stats.py

Installiert als Kommando für deinen User – eigenes venv, eigenes Python:

uv tool install dist/logsum-0.2.0-py3-none-any.whl
cd /tmp && logsum --version && logsum ~/py-lab/tag14-logsum-fast/lab/access.log \
  --top 1 -w 2; cd -

Erwartet (gekürzt):

Installed 1 executable: logsum
logsum 0.2.0
Anfragen: 1996  Fehlerquote 5xx: 8.4%
...
Top 1 Fehlerpfade:
     107  /api/payments

Ohne uv auf dem Zielrechner? python -m zipapp packt das Paket in eine ausführbare Datei. Damit der Exit-Code ankommt, bekommt das Archiv ein eigenes __main__.py:

rm -rf build && mkdir -p build/pyz
cp -R src/logsum build/pyz/ && rm -rf build/pyz/logsum/__pycache__
printf 'from logsum.cli import main\n\nraise SystemExit(main())\n' \
  > build/pyz/__main__.py
uv run python -m zipapp build/pyz -p '/usr/bin/env python3' -c -o dist/logsum.pyz
rm -rf build
ls -l dist/logsum.pyz | awk '{print $5, $9}'
./dist/logsum.pyz lab/access.log --top 1 -w 2 2>/dev/null | head -1
./dist/logsum.pyz --version
./dist/logsum.pyz nix.log; echo "exit=$?"

Erwartet:

4966 dist/logsum.pyz
Anfragen: 1996  Fehlerquote 5xx: 8.4%
logsum unbekannt
logsum: [Errno 2] No such file or directory: 'nix.log'
exit=1
  • -p schreibt die Shebang-Zeile, -c komprimiert. 5 KB, die mit jedem passenden Python laufen – auch mit Prozessen.
  • logsum unbekannt: Im zipapp fehlen die Paket-Metadaten, importlib.metadata.version() findet nichts. get_version() fängt genau das ab, statt abzustürzen.
  • Der naheliegende Weg python -m zipapp src -m 'logsum.cli:main' ruft main() auf, ignoriert aber den Rückgabewert – jeder Fehler endete mit Exit 0.

Achtung: /usr/bin/env python3 nimmt das erste python3 im PATH. Auf einem frischen Mac ist das Python 3.9 von Apple, und logsum stirbt mit ImportError: cannot import name 'UTC' from 'datetime'. Ein zipapp enthält keinen Interpreter – die Python-Version des Zielsystems gehört in die Doku.

Weg Ziel braucht Gut für
uv tool install <wheel> uv Entwickler, Admins
Wheel in internen Index pip oder uv Teams, CI
python -m zipapp Python ≥ 3.14 Jump-Hosts, Einmal-Kopie
Container-Image (Tag 9) Docker/Kubernetes Dienste, Cronjobs

Fortschritt speichern? Kostenlos registrieren

Drill 10: CI mit GitHub Actions

Was lokal per Hand läuft, prüft ab jetzt jeder Push: Lockfile, ruff, mypy, pytest, Build.

mkdir -p .github/workflows
cat > .github/workflows/ci.yml <<'EOF'
name: ci

on:
  push:
    branches: [main]
    tags: ["v*"]
  pull_request:

permissions:
  contents: read

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
      - uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884  # v10.3.0
        with:
          enable-cache: true
      - run: uv sync --locked
      - run: uv run ruff check
      - run: uv run ruff format --check
      - run: uv run mypy
      - run: uv run pytest -q
      - name: Tag passt zur Version
        if: startsWith(github.ref, 'refs/tags/v')
        run: test "v$(uv version --short)" = "$GITHUB_REF_NAME"
      - run: uv build
      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9  # v7.0.2
        with:
          name: dist
          path: dist/
EOF
uvx --from actionlint-py actionlint && echo "Workflow ok"

Erwartet:

Workflow ok
  • Actions sind auf einen Commit-SHA gepinnt, der Tag steht im Kommentar. Ein Tag wie v7 kann umgehängt werden – ein SHA nicht. Dependabot hält die SHAs aktuell.
  • permissions: contents: read: Der Job darf das Repo lesen, sonst nichts. Ohne die Zeile bekommt das GITHUB_TOKEN je nach Org-Einstellung Schreibrechte.
  • uv sync --locked scheitert, wenn uv.lock nicht zu pyproject.toml passt – kein stilles Nachauflösen in CI.
  • enable-cache cached den uv-Cache zwischen Läufen; Python 3.14 holt uv selbst anhand von .python-version.
  • Bei einem Tag v0.2.0 prüft ein Schritt, dass Tag und pyproject.toml übereinstimmen. Das fertige Wheel liegt danach als Artefakt dist am Lauf.

Dieselben Schritte lokal, bevor du pushst:

uv sync --locked && uv run ruff check && uv run ruff format --check \
  && uv run mypy && uv run pytest -q | tail -1
GITHUB_REF_NAME=v0.2.0 bash -c 'test "v$(uv version --short)" = "$GITHUB_REF_NAME"' \
  && echo "Tag passt"

Erwartet (gekürzt):

Resolved 14 packages in 17ms
Audited 13 packages in 4ms
All checks passed!
14 files already formatted
Success: no issues found in 6 source files
21 passed in 0.19s
Tag passt

Tipp: Mit Repo auf GitHub: git add -A && git commit -m "logsum 0.2.0" && git tag v0.2.0 && git push --follow-tags. Den Lauf verfolgst du mit gh run watch.

Fortschritt speichern? Kostenlos registrieren

Drill 11: Das Tool ist fertig

hyperfine -w 1 -r 5 \
  'uv run --project ../tag02-logsum logsum lab/big.log' \
  'uv run logsum lab/big.log -w 0' \
  'uv run --with polars scripts/polars_sum.py lab/big.log'

Erwartet (gekürzt, schwankt mit der Last):

Benchmark 1: uv run --project ../tag02-logsum logsum lab/big.log (5 runs)
  Wall Time    5.339 s   ±   0.069 s      5.284 s   …   5.438 s
  Memory       346.0 MiB ±     2.7 MiB    341.5 MiB …   348.1 MiB
Benchmark 2: uv run logsum lab/big.log -w 0 (5 runs)
  Wall Time    0.486 s   ±   0.032 s      0.458 s   …   0.525 s  (11.0x faster)
  Memory        58.3 MiB ±     0.1 MiB     58.2 MiB …    58.4 MiB  (5.9x less)
Benchmark 3: uv run --with polars scripts/polars_sum.py lab/big.log (5 runs)
  Wall Time    0.250 s   ±   0.010 s      0.240 s   …   0.266 s  (21.4x faster)
  Memory       372.2 MiB ±    13.5 MiB    352.1 MiB …   387.1 MiB

Ziel erreicht: 11× schneller, ein Sechstel des Speichers, null Abhängigkeiten. Laufen parallel andere Programme, fällt Benchmark 2 auf 7–8× – sie belegen genau die Kerne, die -w 0 braucht. Der Weg dorthin:

Schritt Werkzeug Gewinn
Hotspot finden cProfile, line_profiler 88 % in einer Zeile
strptime ersetzen timeit, @cache für tz() 2,6×
str.split + Regex-Rückfall Gleichheitstest +10 %
Generator statt Liste tracemalloc 350 → 25 MiB, +13 %
Byte-Bereiche, Prozesse ProcessPoolExecutor 2,9×

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/py-lab/tag14-logsum-fast
check "Lab-Log reproduzierbar" "shasum lab/big.log | grep -q ^5ff495ee6c9a"
check "seriell identisch" "uv run logsum lab/big.log | diff -q - lab/referenz.txt"
check "parallel identisch" \
  "uv run logsum lab/big.log -w 0 | diff -q - lab/referenz.txt"
check "kaputte Zeilen gezählt" \
  "uv run logsum lab/big.log -w 4 2>&1 >/dev/null | grep -q '2000 Zeilen'"
check "1 Mio. Zeilen unter 1,5 s" "hyperfine -N -r 3 --export-json /tmp/h.json \
  '.venv/bin/logsum lab/big.log -w 0' && jq -e \
  '.results[0].summary.time_wall.min < 1.5' /tmp/h.json"
check "keine Laufzeit-Abhängigkeiten" "grep -q '^dependencies = \[\]' pyproject.toml"
check "Tests grün" "uv run pytest -q"
check "ruff sauber" "uv run ruff check && uv run ruff format --check"
check "mypy --strict sauber" "uv run mypy"
check "Wheel 0.2.0 gebaut" "test -f dist/logsum-0.2.0-py3-none-any.whl"
check "zipapp liefert Exit 1" "./dist/logsum.pyz nix.log; test \$? -eq 1"
check "CI-Workflow gültig" "uvx --from actionlint-py actionlint"

Erwartet:

✔ Lab-Log reproduzierbar
✔ seriell identisch
✔ parallel identisch
✔ kaputte Zeilen gezählt
✔ 1 Mio. Zeilen unter 1,5 s
✔ keine Laufzeit-Abhängigkeiten
✔ Tests grün
✔ ruff sauber
✔ mypy --strict sauber
✔ Wheel 0.2.0 gebaut
✔ zipapp liefert Exit 1
✔ CI-Workflow gültig

-N startet das Programm ohne Shell und ohne uv run – so misst hyperfine nur logsum selbst. --export-json macht die Messung maschinenlesbar; derselbe Trick taugt als Performance-Gate in CI.

Challenge

-w 0 ist auf kleinen Dateien dreimal langsamer als -w 1 (Drill 7). Mach daraus einen echten Automatikmodus: -w 0 nutzt alle Kerne erst ab 20 MiB Dateigröße, sonst einen Prozess. Ein Test beweist beide Fälle – ohne eine 20-MiB-Datei zu schreiben.

Hinweis: path.stat().st_size kennt die Größe vor dem Lesen, und f.truncate(n) erzeugt eine Sparse-Datei, die groß ist, aber keinen Plattenplatz belegt.

Lösung

In src/logsum/cli.py vor parse_time einfügen:

AUTO_MIN_BYTES = 20 * 2**20


def pick_workers(requested: int, path: Path) -> int:
    """0 = automatisch: alle Kerne, aber nur für große Dateien."""
    if requested:
        return requested
    try:
        big = path.stat().st_size >= AUTO_MIN_BYTES
    except OSError:
        return 1  # Fehlermeldung kommt gleich beim Lesen
    return (os.process_cpu_count() or 1) if big else 1

In main() die Zeile workers = args.workers or ... ersetzen durch:

    workers = pick_workers(args.workers, args.logfile)

In tests/test_parallel.py den Import auf from logsum.cli import AUTO_MIN_BYTES, main, pick_workers, read_entries erweitern und anhängen:

def test_pick_workers(tmp_path):
    small, big = tmp_path / "s.log", tmp_path / "b.log"
    small.write_text("x\n", encoding="utf-8")
    with big.open("wb") as f:
        f.truncate(AUTO_MIN_BYTES)  # Sparse-Datei: groß, aber ohne Plattenplatz
    assert pick_workers(0, small) == 1
    assert pick_workers(0, big) > 1
    assert pick_workers(3, small) == 3
    assert pick_workers(0, tmp_path / "fehlt.log") == 1
uv run ruff format && uv run pytest -q | tail -1
uv run python -c 'from pathlib import Path; from logsum.cli import pick_workers
print(pick_workers(0, Path("lab/access.log")), pick_workers(0, Path("lab/big.log")))'

Erwartet:

14 files left unchanged
22 passed in 0.21s
1 10

Die Grenze von 20 MiB ist eine Messung, kein Naturgesetz: Mit hyperfine findest du den Punkt, an dem sich auf deinem Rechner die Prozesse lohnen.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Performance-Ziele als Zahlen festhalten („1 GB Log in < 10 s auf dem Runner”) und in CI messen – sonst schleichen sich Regressionen unbemerkt ein.
  • Vor dem Optimieren fragen, ob Python der richtige Ort ist: Loki, Elasticsearch oder ClickHouse beantworten dieselbe Frage über Terabytes, ohne dass jemand Dateien kopiert.
  • py-spy gegen Produktionsprozesse nur mit Freigabe: Es liest fremden Prozessspeicher (SYS_PTRACE im Container) und sieht damit auch Secrets.
  • Interne Verteilung über einen Paket-Index (Artifactory, Nexus, GitLab Package Registry) mit signierten Releases; zipapps nur für Fälle ohne Index, mit Prüfsumme neben der Datei.
  • GitHub Actions härten: Actions per SHA pinnen, permissions minimal, Releases per Trusted Publishing (OIDC) statt langlebiger API-Tokens.