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

> Erhalte eine Push-Benachrichtigung, sobald ein Log-Muster greift. Verbinde Loki, den ELK-Stack oder Graylog mit einem Pocket Alert Webhook, und die passende Fehlerzeile landet in einer Sekunde auf deinem Handy.

<!-- source: https://pocketalert.app/de/use-cases/log-monitoring-alerts -->

Zuletzt aktualisiert: 2026-08-11

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.

## 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.

## 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.

## 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](https://pocketalert.app/de/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](https://info.pocketalert.app/api/webhooks/settings.html) findest du GJSON-Mapping und das Routing pro Anwendung.

## FAQ

### Wie bekomme ich eine Push-Benachrichtigung, wenn ein Log-Muster passt?

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.

### Muss ich einen Agenten installieren?

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.

### Wie ordne ich die Log-Felder einer Benachrichtigung zu?

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%.

### Kann ich einen 500er-Anstieg von einer vereinzelten Warnung trennen?

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.

### Wie halte ich Services und Umgebungen auseinander?

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.

### Kann ein Fehler-Anstieg nachts Nicht stören durchbrechen?

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.
