# Notifiche push per righe di log corrispondenti sul tuo telefono.

> Ricevi una notifica push quando un pattern nei log trova corrispondenza. Collega Loki, lo stack ELK o Graylog a un webhook di Pocket Alert e la riga di errore arriva sul tuo telefono in un secondo.

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

Ultimo aggiornamento: 2026-08-11

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.

## Tre passaggi dalla riga di log alla notifica push

1. **Definisci il pattern** — Aggiungi una regola nel ruler di Loki, un Elastic Watcher o un pattern grep che scatta quando una riga corrisponde.
2. **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.
3. **Separa i canali** — Assegna a ogni servizio o ambiente una sua applicazione, così i log di produzione e staging restano su canali separati.

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

## 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](https://pocketalert.app/it/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](https://info.pocketalert.app/api/webhooks/settings.html) copre il mapping GJSON e il routing per applicazione.

## FAQ

### Come ricevo una notifica push quando un pattern di log corrisponde?

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.

### Devo installare un agent?

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.

### Come mappo i campi dei log in una notifica?

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

### Posso tenere separato un picco di 500 da un warning isolato?

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.

### Come tengo separati servizi e ambienti?

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.

### Un picco di errori può superare Non disturbare di notte?

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.
