0Pricing
DevOps Bootcamp · Lektion

Metriken und Histogramme aus Protokollströmen berechnen

Aggregieren Sie Anfrageraten, Perzentile und Top-N-Berichte direkt aus gestreamten Protokolldaten.

Metriken und Histogramme aus Protokollströmen berechnen ist eine kostenlose DevOps Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DevOps Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Warum Metriken aus Roh-Logs berechnen?

Produktivsysteme erzeugen Tausende von Logzeilen pro Sekunde. Statt Roh-Logs an teure Analyseplattformen zu senden, können Sie Anfrageraten, Perzentile und Top-N-Berichte direkt in der Shell berechnen — zu nahezu keinen Kosten.

  • Anfragerate: Wie viele Anfragen pro Sekunde/Minute verarbeitet Ihr Dienst?
  • Latenzperzentile: Wie hoch ist die Antwortzeit bei p50/p95/p99?
  • Top-N-Berichte: Welche Endpunkte, IPs oder Fehlercodes treten am häufigsten auf?

Shell-Tools wie awk, sort, uniq und bc bilden eine leistungsfähige, kombinierbare Pipeline, die diese Fragen anhand eines Live-Logstroms oder einer historischen Datei beantworten kann, ohne das Terminal zu verlassen.

Aufbau eines typischen Access-Logs

Die meisten Webserver schreiben Logs im Combined Log Format. Das Verständnis seiner Felder bildet die Grundlage jeder Metrik-Pipeline:

127.0.0.1 - frank [10/Oct/2024:13:55:36 -0700] "GET /api/users HTTP/1.1" 200 2326 0.042
  • Feld 1: Client-IP
  • Feld 4 (in eckigen Klammern): Zeitstempel
  • Feld 7 (in Anführungszeichen): HTTP-Methode + Pfad
  • Feld 9: Statuscode
  • Feld 10: Antwort-Bytes
  • Feld 11: Antwortzeit in Sekunden (benutzerdefiniertes Feld, nicht immer vorhanden)

Verwenden Sie awk, um über die Position auf Felder zuzugreifen ($1, $9 usw.). Felder innerhalb von Anführungszeichen zählen nur dann als ein Token, wenn Sie sorgfältig aufteilen — schließen Sie die Logzeile in awk -F'"' ein oder verwenden Sie mehrere Verarbeitungsschritte.

Anfragerate pro Minute zählen

Um Anfragen pro Minute zu berechnen, extrahieren Sie den Minutenanteil jedes Zeitstempels und zählen die Vorkommen. Das Muster [day/Mon/year:HH:MM liefert das Stunden-Minuten-Zeitfenster.

Die folgende Pipeline liest access.log und gibt eine Tabelle mit Minute → Anzahl der Anfragen aus:

#!/usr/bin/env bash
# Requests per minute from an nginx/apache access log
# Usage: bash req_per_min.sh access.log

LOG="${1:-access.log}"

awk '{
    # Extract [day/Mon/year:HH:MM from field 4
    match($0, /\[([^:]+:[0-9]+:[0-9]+)/, arr)
    minute = arr[1]
    if (minute != "") count[minute]++
} END {
    for (m in count) print count[m], m
}' "$LOG" | sort -k2

Anfragerate in einem Live-Datenstrom mit gleitendem Zeitfenster

Für eine Live-Verfolgung benötigen Sie ein gleitendes Zeitfenster. Der Trick besteht darin, tail -f an awk weiterzuleiten und den Zähler mithilfe der Systemuhr (systime()) alle N Sekunden zurückzusetzen.

Dieses Beispiel gibt alle 10 Sekunden eine Zeile mit der Rate aus:

#!/usr/bin/env bash
# Live request rate — prints lines/10s from a tailed log
# Usage: bash live_rate.sh /var/log/nginx/access.log

LOG="${1:-/var/log/nginx/access.log}"
WINDOW=10

tail -f "$LOG" | awk -v win="$WINDOW" '
BEGIN { start = systime(); count = 0 }
{
    count++
    now = systime()
    if (now - start >= win) {
        printf "[%s] %d req/%ds (%.1f req/s)\n",
               strftime("%H:%M:%S", now), count, win, count/win
        count = 0
        start = now
    }
}'

Latenzwerte für die Perzentilberechnung extrahieren

Für Perzentile müssen alle beobachteten Latenzwerte sortiert werden. Das Standardverfahren:

  1. Extrahieren Sie die Latenzspalte in eine einfache Liste von Zahlen.
  2. Sortieren Sie numerisch.
  3. Wählen Sie den Wert an der korrekten Position mithilfe der Zeilenanzahl aus.

Das folgende Skript extrahiert Feld 11 (Antwortzeit in Sekunden) und speichert es zur Perzentilberechnung im nächsten Schritt in einer temporären Datei:

#!/usr/bin/env bash
# Extract latency column from access log (field 11)
# Assumes last field on each line is response time in seconds

LOG="${1:-access.log}"
TMP=$(mktemp /tmp/latency_XXXXXX.txt)

awk '{ if ($NF ~ /^[0-9]+\.?[0-9]*$/) print $NF }' "$LOG" \
    | sort -n > "$TMP"

echo "Extracted $(wc -l < "$TMP") latency samples -> $TMP"
echo "$TMP"   # callers can read this file

p50, p95 und p99 mit awk berechnen

Sobald die Latenzwerte sortiert sind, ist die Auswahl eines Perzentils eine arithmetische Berechnung: Das p-te Perzentil steht in der Zeile ceil(p/100 * N). Mit reinem awk lässt sich dies in einem einzigen Durchlauf erledigen, nachdem die sortierte Datei in ein Array geladen wurde:

#!/usr/bin/env bash
# Compute p50 / p95 / p99 from a sorted latency file
# Usage: bash percentiles.sh latency_sorted.txt

# Demo: generate 1000 random latencies if no file given
if [[ $# -eq 0 ]]; then
    SORTED=$(mktemp)
    for i in $(seq 1 1000); do
        awk 'BEGIN { srand(); printf "%.4f\n", 0.001 + rand()*0.999 }'
    done | sort -n > "$SORTED"
else
    SORTED="$1"
fi

awk '
{ values[NR] = $1 }
END {
    n = NR
    if (n == 0) { print "No data"; exit }
    p50  = values[int(n * 0.50 + 0.9999)]
    p95  = values[int(n * 0.95 + 0.9999)]
    p99  = values[int(n * 0.99 + 0.9999)]
    printf "p50  = %.4fs\np95  = %.4fs\np99  = %.4fs\nN    = %d\n",
           p50, p95, p99, n
}' "$SORTED"

Einen Top-N-Bericht für Endpunkte erstellen

Ein Top-N-Bericht beantwortet die Frage: „Welche Pfade werden am häufigsten aufgerufen?“ Das klassische Shell-Idiom lautet:

  • awk, um das gewünschte Feld auszugeben (z. B. den URL-Pfad)
  • sort, um identische Werte zu gruppieren
  • uniq -c, um aufeinanderfolgende Duplikate zu zählen
  • sort -rn, um nach absteigender Anzahl zu sortieren
  • head -n N, um die obersten N Einträge auszuwählen
#!/usr/bin/env bash
# Top-10 most requested URL paths from access log
# Usage: bash top_endpoints.sh access.log [N]

LOG="${1:-access.log}"
N="${2:-10}"

echo "=== Top $N endpoints ==="
awk -F'"' '{ print $2 }' "$LOG" \
    | awk '{ print $2 }' \
    | sort \
    | uniq -c \
    | sort -rn \
    | head -n "$N" \
    | awk '{ printf "%6d  %s\n", $1, $2 }'

Top-N nach Statuscode: Fehler auf einen Blick erkennen

HTTP-Statuscodes geben Aufschluss über den Zustand Ihres Dienstes. Wenn Sie Logzeilen nach Statuscode gruppieren und zählen, erkennen Sie, ob Fehler selten oder systembedingt auftreten.

Das folgende Skript erstellt eine Aufschlüsselung über alle 2xx-/3xx-/4xx-/5xx-Kategorien:

#!/usr/bin/env bash
# Status code frequency breakdown
# Usage: bash status_breakdown.sh access.log

LOG="${1:-access.log}"

echo "=== HTTP Status Code Distribution ==="
awk '{ print $9 }' "$LOG" \
    | grep -E '^[0-9]{3}$' \
    | sort \
    | uniq -c \
    | sort -rn \
    | awk '{ printf "%6d  %s\n", $1, $2 }'

echo
echo "=== 5xx Error Spike Check ==="
awk '$9 ~ /^5/ { print $9, $7 }' "$LOG" \
    | sort | uniq -c | sort -rn | head -20

ASCII-Histogramme mit awk

Ein Texthistogramm macht Latenzverteilungen in einem Terminal oder CI-Log sofort lesbar. Das Vorgehen:

  1. Ordnen Sie jeden Latenzwert einem Intervall zu (z. B. 0–50 ms, 50–100 ms, …).
  2. Zählen Sie die Beobachtungen pro Intervall.
  3. Geben Sie einen Balken aus #-Zeichen aus, skaliert auf die maximale Anzahl.

Dies ist äußerst nützlich, um bimodale Verteilungen oder Ausreißer ohne ein Tool zur grafischen Darstellung zu erkennen.

#!/usr/bin/env bash
# ASCII latency histogram from a list of latency values in seconds
# Demo: generates synthetic data if no input file is provided

if [[ $# -eq 0 ]]; then
    # Generate 500 synthetic latencies (ms converted to s)
    python3 -c "
import random, math
for _ in range(500):
    # bimodal: fast cluster ~50ms, slow cluster ~300ms
    if random.random() < 0.75:
        v = max(1, random.gauss(50, 15))
    else:
        v = max(1, random.gauss(300, 80))
    print(f'{v/1000:.4f}')
" | sort -n | awk '
{ values[NR] = $1 * 1000 }  # convert to ms
END {
    buckets = 10; maxVal = 500
    step = maxVal / buckets
    for (i = 0; i < buckets; i++) hist[i] = 0
    for (i = 1; i <= NR; i++) {
        b = int(values[i] / step)
        if (b >= buckets) b = buckets - 1
        hist[b]++
    }
    maxCount = 0
    for (i = 0; i < buckets; i++) if (hist[i] > maxCount) maxCount = hist[i]
    print "Latency (ms)   Count   Distribution"
    print "---------------------------------------"
    for (i = 0; i < buckets; i++) {
        lo = i * step; hi = lo + step
        barLen = int(hist[i] / maxCount * 40)
        bar = ""
        for (j = 0; j < barLen; j++) bar = bar "#"
        printf "%4d-%4dms  %5d  %s\n", lo, hi, hist[i], bar
    }
}'
else
    echo "Usage: pipe a sorted latency file (in seconds) to this pattern"
fi

Metriken kombinieren: Der zusammenfassende Bericht in einem Durchlauf

Produktions-Runbooks benötigen häufig einen einzigen Befehl, der alle wichtigen Metriken auf einmal ausgibt: Rate, Latenzperzentile, Top-Endpunkte und Fehlerrate. Sie können alles, was Sie bisher gelernt haben, in einem Skript zusammenführen, das von einer Person oder einem Benachrichtigungssystem aufgerufen werden kann.

#!/usr/bin/env bash
# One-shot log summary report
# Usage: bash log_summary.sh access.log

LOG="${1:-access.log}"
[[ -f "$LOG" ]] || { echo "File not found: $LOG"; exit 1; }

TOTAL=$(wc -l < "$LOG")
ERRORS=$(awk '$9 ~ /^[45]/' "$LOG" | wc -l)
ERR_RATE=$(awk "BEGIN { printf \"%.1f\", ($ERRORS / ($TOTAL || 1)) * 100 }")

echo "====================================="
echo " Log Summary: $LOG"
echo "====================================="
printf " Total requests : %d\n" "$TOTAL"
printf " 4xx/5xx errors : %d (%.1f%%)\n" "$ERRORS" "$ERR_RATE"

echo
echo "--- Top 5 Endpoints ---"
awk -F'"' '{ print $2 }' "$LOG" | awk '{ print $2 }' \
    | sort | uniq -c | sort -rn | head -5 \
    | awk '{ printf "  %6d  %s\n", $1, $2 }'

echo
echo "--- Latency Percentiles ---"
awk '{ if ($NF ~ /^[0-9]+\.?[0-9]*$/) print $NF * 1000 }' "$LOG" \
    | sort -n \
    | awk '
{ v[NR]=$1 }
END {
  if (NR==0) { print "  No latency data"; exit }
  printf "  p50 = %.1fms\n", v[int(NR*0.50+0.9999)]
  printf "  p95 = %.1fms\n", v[int(NR*0.95+0.9999)]
  printf "  p99 = %.1fms\n", v[int(NR*0.99+0.9999)]
}'

Metriken über Named Pipes und tee streamen

In Observability-Pipelines müssen Sie einen Logstrom häufig auf mehrere Pfade verteilen: Rohzeilen auf die Festplatte schreiben und gleichzeitig Metriken berechnen. Mit tee und einer Named Pipe (mkfifo) ist dies möglich, ohne den gesamten Datenstrom im Speicher zu puffern.

  • mkfifo /tmp/log_pipe — Named Pipe erstellen
  • tee /tmp/log_pipe | metric_consumer & — einen Zweig an den Metrik-Consumer weiterleiten
  • Der andere Zweig schreibt in die Archivdatei

Dieses Muster entkoppelt Festplattenschreibvorgänge und Metrikaggregation und ermöglicht es, beide Seiten unabhängig voneinander neu zu starten.

#!/usr/bin/env bash
# Fan-out: write to archive AND count errors in real time
# Run: bash fanout_pipeline.sh /var/log/nginx/access.log

LOG="${1:-/var/log/nginx/access.log}"
ARCHIVE="/tmp/access_archive.log"
PIPE="/tmp/log_metrics_pipe"

# Clean up on exit
trap 'rm -f "$PIPE"' EXIT

mkfifo "$PIPE"

# Branch 1: count 5xx errors per minute from the pipe
awk '$9 ~ /^5/ {
    match($0, /\[([^:]+:[0-9]+:[0-9]+)/, arr)
    errors[arr[1]]++
} END {
    for (m in errors) printf "5xx errors at %s: %d\n", m, errors[m]
}' "$PIPE" &

# Branch 2: archive to disk + feed Branch 1 via pipe
tail -f "$LOG" | tee "$PIPE" >> "$ARCHIVE"

Welche awk-Technik berechnet das p95-Perzentil aus einem sortierten Array mit N Latenzwerten korrekt?

Sie haben N sortierte Latenzwerte in ein awk-Array v[1..N] geladen. Welcher Ausdruck ruft das p95-Perzentil korrekt ab?

Lektionszusammenfassung: Metriken und Histogramme aus Logströmen

In dieser Lektion haben Sie eine vollständige Metrik-Pipeline direkt in Bash erstellt:

  • Anfragerate: awk extrahiert das Minutenintervall aus Zeitstempeln und zählt die Vorkommen; tail -f + systime() liefern eine laufende Rate für ein gleitendes Zeitfenster.
  • Latenzperzentile: Extrahieren Sie die Latenzspalte, sortieren Sie mit sort -n und wählen Sie anschließend die Zeile an Position ceil(p/100 * N) mit int(N * p + 0.9999) in awk aus.
  • Top-N-Berichte: Die klassische Pipeline awk | sort | uniq -c | sort -rn | head -N funktioniert für jedes kategoriale Feld (Pfad, IP-Adresse, Statuscode).
  • ASCII-Histogramme: Werte in Klassen einteilen, pro Klasse zählen und die Balkenlänge anhand der maximalen Anzahl pro Klasse skalieren, um Verteilungen auf einen Blick darzustellen.
  • Verteilung mit Named Pipes: Mit mkfifo + tee können Sie rohe Logs archivieren und gleichzeitig Metrikverarbeiter versorgen, ohne den Stream in den Arbeitsspeicher zu laden.

Diese kombinierbaren Grundbausteine machen externe Werkzeuge während Incidents überflüssig und bilden das Fundament für leichtgewichtige Observability-Skripte, die überall dort ausgeführt werden können, wo Bash läuft.

Häufig gestellte Fragen

Ist die Lektion „Metriken und Histogramme aus Protokollströmen berechnen“ kostenlos?

Ja — der vollständige Text von „Metriken und Histogramme aus Protokollströmen berechnen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DevOps Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Metriken und Histogramme aus Protokollströmen berechnen“?

Aggregieren Sie Anfrageraten, Perzentile und Top-N-Berichte direkt aus gestreamten Protokolldaten. Du übst DevOps Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um DevOps Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. DevOps Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Metriken und Histogramme aus Protokollströmen berechnen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser DevOps Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede DevOps Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Web- und Anwendungsprotokolle in großem Maßstab auswerten
  2. Echtzeit-Überwachung von Protokollen und Streaming-Warnmeldungen
  3. journald mit journalctl in Skripten abfragen
  4. Metriken und Histogramme aus Protokollströmen berechnen
← Zurück zu DevOps Bootcamp