Log-Monitoring

Push-Benachrichtigungen für passende Log-Zeilen auf dein Handy.

Loki, der ELK-Stack, Graylog oder ein tail | grep-Skript erkennen Fehler-Anstiege und Serien fehlgeschlagener Logins bereits. Die passende Zeile landet in unter einer Sekunde auf deinem Handy, sodass der entscheidende Logeintrag in deiner Tasche ist.

Push in <1sLoki · ELK · GraylogKein zusätzlicher AgentAktualisiert am
Funktionen

Von der Log-Zeile zum Sperrbildschirm

Deine Log-Pipeline findet die fehlerhaften Zeilen bereits. Pocket Alert bringt sie auf dein Handy.

Funktioniert mit deinem Stack

Loki-Ruler, Elastic Watcher, Graylog oder ein tail | grep-Skript können alle an denselben Webhook senden.

Muster-basierte Alarme

Eine LogQL-Regel, eine Watcher-Bedingung oder ein grep-Muster bestimmt, wann die Push-Benachrichtigung rausgeht.

Feld-Mapping

GJSON-Pfade holen Alarmnamen, passende Zeile und Trefferanzahl direkt aus dem Alarm-JSON.

CLI oder Webhook

Ein tail | grep-Skript kann die Messages-API direkt per curl ansprechen, ganz ohne Monitoring-Plattform.

Kanäle pro Anwendung

Eine Pocket-Alert-Anwendung pro Service oder Umgebung hält Produktions- und Staging-Logs in getrennten Kanälen.

Zustellung in unter einer Sekunde

Der Webhook feuert und die Push-Benachrichtigung kommt in unter einer Sekunde an, schnell genug, um einen OOMKilled-Pod live zu erwischen.

Los geht's

Drei Schritte von der Log-Zeile zur Push-Benachrichtigung

1

Muster definieren

Füge eine Loki-Ruler-Regel, einen Elastic Watcher oder ein grep-Muster hinzu, das auslöst, wenn eine Zeile passt.

2

Anbinden

Sende per curl an die Messages-API aus einem tail | grep-Skript oder richte Alertmanager auf eine Pocket-Alert-Webhook-Empfangs-URL mit GJSON-Template aus.

3

Kanäle trennen

Gib jedem Service oder jeder Umgebung eine eigene Anwendung, damit Produktions- und Staging-Logs in getrennten Kanälen bleiben.

Push-Benachrichtigung senden, wenn ein Log-Muster anschlägt

1. Direkt aus einem tail | grep-Skript per curl (CLI)

Installiere die CLI, melde dich einmalig an und verfolge dann das Log, um jede passende Zeile zu pushen.

sudo mv pocketalert /usr/local/bin/ && chmod +x /usr/local/bin/pocketalert
pocketalert auth YOUR_API_KEY
tail -Fn0 /var/log/app.log | grep --line-buffered "OutOfMemory" | while read -r line; do
  pocketalert send -t "OOM on $(hostname)" -m "$line"
done

Oder sende direkt per POST an die Messages-API statt über die CLI.

tail -Fn0 /var/log/app.log | grep --line-buffered "ERROR" | while read -r line; do
  curl -X POST 'https://api.pocketalert.app/v1/messages' \
    -H 'Token: YOUR_API_KEY' \
    -H 'Content-Type: application/json' \
    -d "{\"title\":\"Log error\",\"level\":\"critical\",\"message\":\"${line//\"/\\\"}\"}"
done

2. Oder Loki / Alertmanager per Webhook weiterleiten

Definiere in der Loki-Ruler eine LogQL-Alarmregel, die auslöst, wenn Treffer einen Schwellenwert überschreiten.

groups:
  - name: app-errors
    rules:
      - alert: HighErrorRate
        expr: sum(count_over_time({app="api"} |= "ERROR" [5m])) > 20
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "{{ $value }} ERROR lines in the last 5m"

Die Ruler leitet an Alertmanager weiter (alertmanager_url), der an Pocket Alert sendet. Erstelle auf der Seite Webhooks einen Webhook mit einem GJSON-Template für die Alertmanager-Payload und richte dann ein webhook_config auf die Empfangs-URL aus.

curl -X POST 'https://api.pocketalert.app/v1/webhooks' \
  -H 'Token: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"name":"Loki Alerts","application_id":"qm47b9pzxzxg","message":"%status%: %alerts.0.labels.alertname% — %alerts.0.annotations.summary%"}'
receivers:
  - name: pocketalert
    webhook_configs:
      - url: 'https://p4a.me/wh/1234abcd'
        send_resolved: true

Eine Elastic-Watcher-webhook-Aktion oder eine Graylog-HTTP-Notification-Event-Definition kann an dieselbe Empfangs-URL senden. In der Dokumentation findest du GJSON-Mapping und das Routing pro Anwendung.

FAQ

Fragen und Antworten

Richte eine Loki-Ruler-Regel, einen Elastic Watcher oder eine Graylog-Event-Definition ein, die einen Webhook an deine Pocket-Alert-Anwendungs-URL sendet. Die passende Log-Zeile und die Anzahl werden im JSON-Body übermittelt.

Auf deinen Servern läuft nichts Zusätzliches. Pocket Alert sitzt am Ende der Pipeline, die du bereits hast. Loki, Elastic, Graylog oder ein Cronjob-Tail-Skript übernimmt den Abgleich und sendet nur das Ergebnis.

Mit dem GJSON-Feld-Mapping kannst du jeden Pfad in der Alarm-Payload auslesen. Übernimm den Alarmnamen in den Titel und die passende Zeile oder Anzahl in die Nachricht, zum Beispiel %alerts.0.labels.alertname% und %alerts.0.annotations.summary%.

Gib jedem Service oder jeder Umgebung eine eigene Pocket-Alert-Anwendung. So landet eine Flut von 500ern in Produktion in einem anderen Kanal als eine vereinzelte Parser-Warnung in Staging. Ruhige Feeds bleiben getrennt von denen, die dich wecken sollen.

Gib jedem Service oder jeder Umgebung eine eigene Pocket-Alert-Anwendung. Dann landen Auth-Fehler in Produktion und Job-Logs aus Staging in getrennten Kanälen statt in einem unübersichtlichen Feed.

Ja. Füge "level":"critical" zum POST hinzu, dann liefert Android sie auf einem eigenen Benachrichtigungskanal aus, der Nicht stören umgeht. Den DND-Zugriff erteilst du einmalig. Auf dem iPhone kommen high- und critical-Benachrichtigungen als zeitkritische Benachrichtigungen an und durchbrechen Fokus-Modi. Außerdem kannst du default_level am Webhook setzen, sodass jeder Alarm aus dieser Pipeline mit derselben Priorität ankommt. Vielschreibende Feeds stellst du auf level silent: kein Ton und keine Vibration, aber weiterhin im Verlauf. Im kostenlosen Tarif wird critical als high zugestellt: sofort, aber ohne Umgehung von Nicht stören.

Die Fehlerzeile, die zählt, in deiner Tasche.

Leite deine Log-Pipeline an einen Webhook weiter und erhalte den nächsten Fehler-Anstieg direkt auf dein Handy.