Notifiche push per righe di log corrispondenti sul tuo telefono.
Loki, lo stack ELK, Graylog o uno script tail | grep individuano già i picchi di errori e le raffiche di login falliti. La riga corrispondente arriva sul telefono in meno di un secondo, così la voce di log che conta è sempre in tasca.
Dalla riga di log alla schermata di blocco
La tua pipeline di log trova già le righe problematiche. Pocket Alert le porta sul tuo telefono.
Funziona con il tuo stack
Loki ruler, Elastic Watcher, Graylog o uno script tail | grep possono inviare tutti a un unico webhook.
Avvisi basati su pattern
Una regola LogQL, una condizione di Watcher o un pattern grep decide quando parte la notifica push.
Mapping dei campi
I percorsi GJSON estraggono direttamente dal JSON dell'alert il nome, la riga corrispondente e il numero di occorrenze.
CLI o webhook
Uno script tail | grep può fare curl direttamente alle API dei messaggi, senza bisogno di una piattaforma di monitoraggio.
Canali per applicazione
Un'applicazione Pocket Alert per servizio o ambiente tiene separati i log di produzione e staging su canali distinti.
Consegna in meno di un secondo
Il webhook parte e la notifica push arriva in meno di un secondo, abbastanza veloce da intercettare in tempo reale un pod OOMKilled.
Tre passaggi dalla riga di log alla notifica push
Definisci il pattern
Aggiungi una regola nel ruler di Loki, un Elastic Watcher o un pattern grep che scatta quando una riga corrisponde.
Collegalo
Fai curl alle API dei messaggi da uno script tail | grep, oppure punta Alertmanager all'URL di ricezione di un webhook Pocket Alert con un template GJSON.
Separa i canali
Assegna a ogni servizio o ambiente una sua applicazione, così i log di produzione e staging restano su canali separati.
Invia una notifica push quando scatta un pattern di log
1. Curl direttamente da uno script tail | grep (CLI)
Installa la CLI, autenticati una volta, poi segui il log e invia una notifica push per ogni riga corrispondente.
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
Oppure invia una POST direttamente all'API dei messaggi invece che tramite la 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. Oppure inoltra Loki / Alertmanager tramite un webhook
Definisci una regola di alert LogQL nel ruler di Loki che scatta quando le corrispondenze superano una soglia.
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"
Il ruler invia a Alertmanager (alertmanager_url), che inoltra a Pocket Alert. Crea un webhook nella pagina Webhooks con un template GJSON che mappa il payload di Alertmanager, poi punta un webhook_config all'URL di ricezione.
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
Un'azione webhook di Elastic Watcher o una event definition HTTP Notification di Graylog possono inviare una POST allo stesso URL di ricezione. La documentazione copre il mapping GJSON e il routing per applicazione.
Le risposte alle tue domande
Configura un alert ruler di Loki, un Elastic Watcher o una event definition di Graylog che invii un webhook all'URL della tua applicazione Pocket Alert. La riga di log corrispondente e il conteggio arrivano nel corpo JSON.
Non serve eseguire nulla in più sulle tue macchine. Pocket Alert si inserisce alla fine della pipeline che hai già, quindi Loki, Elastic, Graylog o uno script cron con tail fa il confronto e invia solo il risultato.
Il mapping dei campi GJSON legge qualsiasi percorso nel payload dell'alert. Inserisci il nome dell'alert nel titolo e la riga corrispondente o il conteggio nel messaggio, ad esempio %alerts.0.labels.alertname% e %alerts.0.annotations.summary%.
Assegna a ogni servizio o ambiente una sua applicazione Pocket Alert, così un'ondata di 500 in produzione arriva su un canale diverso da un semplice warning del parser in staging. I feed silenziosi restano separati da quelli che devono svegliarti.
Assegna a ogni servizio o ambiente una sua applicazione Pocket Alert. Così i fallimenti di autenticazione in produzione e i log dei job in staging arrivano su canali separati invece che su un unico feed rumoroso.
Sì. Aggiungi "level":"critical" alla POST e Android la consegna su un canale di notifica dedicato che ignora Non disturbare: concedi l'accesso a DND una sola volta. Su iPhone, high e critical arrivano come notifiche time-sensitive che superano le modalità Full immersion. Puoi anche impostare default_level sul webhook così ogni alert di quella pipeline arriva con la stessa priorità, e tenere i feed più verbosi a level silent: nessun suono né vibrazione, ma restano nella cronologia. Il piano gratuito consegna critical come high: immediata, ma senza il bypass di Non disturbare.
La riga di errore che conta, sempre in tasca.
Punta la tua pipeline di log a un webhook e ricevi sul telefono il prossimo picco di errori.