Tag 14: Performance, Profiling und Verteilung
Ziel:
logsumaus 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,
timeitfü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.txtErwartet:
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)
EOFErwartet (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}
tottimeist die Zeit in der Funktion,cumtimeinklusive aller Aufrufe darunter. Sortiere nachtottime, um den Täter zu finden, nachcumtime, um den Pfad dorthin zu sehen.strptimebraucht 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>oderpy-spy record -o profil.svgfür einen Flamegraph. Unter macOS braucht ersudo.
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.logErwartet (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 identischErwartet:
500000 loops, best of 5: 670 nsec per loop
identisch
calendar.month_abbrist['', 'Jan', 'Feb', …]; die Comprehension baut daraus{'Jan': 1, …}.@cachemerkt sich jedes Ergebnis pro Argument. Fürtz()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
diffbeweist.
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 "")
EOFErwartet (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.@cacheohne 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_reund 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, sobaldrequires-python = ">=3.14"gilt. Mitas errbleiben 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
EOFIn 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 0yieldmacht aus der Funktion einen Generator. Der Code läuft erst los, wennsummarizeden ersten Eintrag holt – deshalb musssummarizeimtrystehen: EinOSErrorfür eine fehlende Datei kommt erst dort.- Die Datei bleibt offen, bis der Generator erschöpft ist;
withschließt sie danach. - In
summarizevergleichte.time < s.firstdirekt, statt pro Zeilemin()aufzurufen, undin_windowlä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.logErwartet:
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)
EOFf.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 zweiCounterund 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 identischErwartet:
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 alsos.cpu_count().**windowentpackt 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 mypyErwartet:
..................... [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 0langsamer als-w 1– zehn Interpreter starten kostet mehr als 2000 Zeilen parsen. Darum bleibt--workers 1der 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.logErwartet:
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_csvmit einem Trennzeichen, das nie vorkommt (\x1f), liest jede Zeile als eine einzige Spalte.str.extract_groupsmacht aus den benannten Gruppen eine Struct-Spalte,unnestdaraus normale Spalten. Kaputte Zeilen werdennullund fliegen mitdrop_nullsraus.uv run --with polarslädt polars nur für diesen Aufruf in eine Wegwerf-Umgebung – das Paketlogsumbleibt 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
-pschreibt die Shebang-Zeile,-ckomprimiert. 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'ruftmain()auf, ignoriert aber den Rückgabewert – jeder Fehler endete mit Exit 0.
Achtung:
/usr/bin/env python3nimmt das erstepython3imPATH. Auf einem frischen Mac ist das Python 3.9 von Apple, undlogsumstirbt mitImportError: 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
v7kann 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 dasGITHUB_TOKENje nach Org-Einstellung Schreibrechte.uv sync --lockedscheitert, wennuv.locknicht zupyproject.tomlpasst – kein stilles Nachauflösen in CI.enable-cachecached den uv-Cache zwischen Läufen; Python 3.14 holt uv selbst anhand von.python-version.- Bei einem Tag
v0.2.0prüft ein Schritt, dass Tag undpyproject.tomlübereinstimmen. Das fertige Wheel liegt danach als Artefaktdistam 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 mitgh 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 1In 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") == 1uv 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_PTRACEim 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,
permissionsminimal, Releases per Trusted Publishing (OIDC) statt langlebiger API-Tokens.