# Notification push des lignes de log correspondantes sur votre téléphone.

> Recevez une notification push dès qu’un motif correspond dans vos logs. Reliez Loki, la stack ELK ou Graylog à un webhook Pocket Alert : la ligne d’erreur détectée arrive sur votre téléphone en une seconde.

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

Dernière mise à jour : 2026-08-11

Loki, la pile ELK, Graylog ou un script tail | grep repèrent déjà les pics d’erreurs et les rafales d’échecs de connexion. La ligne correspondante arrive sur votre téléphone en moins d’une seconde, pour que l’entrée de log qui compte soit toujours dans votre poche.

## Trois étapes entre la ligne de log et la notification push

1. **Définir le motif** — Ajoutez une règle du ruler Loki, un Elastic Watcher ou un motif grep qui se déclenche lorsqu’une ligne correspond.
2. **Configurer la liaison** — Envoyez une requête curl à l’API des messages depuis un script tail | grep, ou pointez Alertmanager vers l’URL de réception d’un webhook Pocket Alert avec un modèle GJSON.
3. **Séparer les canaux** — Attribuez à chaque service ou environnement sa propre application pour que les logs de production et de préproduction restent dans des canaux séparés.

## De la ligne de log à l’écran verrouillé

Votre pipeline de logs repère déjà les mauvaises lignes. Pocket Alert les transmet sur votre téléphone.

- **Compatible avec votre stack** — Le ruler Loki, Elastic Watcher, Graylog ou un script tail | grep peuvent tous envoyer à un même webhook.
- **Alertes par motif** — Une règle LogQL, une condition Watcher ou un motif grep détermine le moment où la notification part.
- **Mapping des champs** — Les chemins GJSON extraient directement le nom de l’alerte, la ligne correspondante et le nombre de occurrences du JSON d’alerte.
- **CLI ou webhook** — Un script tail | grep peut envoyer une requête curl directement à l’API des messages, sans plateforme de supervision.
- **Canaux par application** — Une application Pocket Alert par service ou environnement garde les logs de production et de préproduction dans des canaux séparés.
- **Livraison en moins d’une seconde** — Le webhook se déclenche et la notification arrive en moins d’une seconde, assez rapide pour détecter en direct un pod OOMKilled.

## Envoyer une notification push lorsqu’un motif de log apparaît

### 1. Envoyer une requête curl depuis un script tail | grep (CLI)

Installez la CLI, authentifiez-vous une fois, puis suivez le log et envoyez chaque ligne correspondante.

```
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
```

Ou envoyez directement une requête POST à l’API des messages au lieu de passer par 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. Ou transférer Loki / Alertmanager via un webhook

Définissez une règle d’alerte LogQL dans le ruler de Loki qui se déclenche lorsque le nombre de correspondances dépasse un seuil.

```
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"
```

Le ruler envoie les alertes à Alertmanager (`alertmanager_url`), qui les transmet à Pocket Alert. Créez un webhook sur la page [Webhooks](https://pocketalert.app/fr/webhooks) avec un modèle GJSON qui mappe la charge utile d’Alertmanager, puis pointez un `webhook_config` vers l’URL de réception.

```
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
```

Une action `webhook` d’Elastic Watcher ou un événement HTTP Notification de Graylog peut envoyer une requête POST vers la même URL de réception. La [documentation](https://info.pocketalert.app/api/webhooks/settings.html) couvre le mapping GJSON et le routage par application.

## FAQ

### Comment recevoir une notification push lorsqu’un motif de log correspond ?

Configurez une alerte du ruler Loki, un Elastic Watcher ou une définition d’événement Graylog qui déclenche un webhook vers l’URL de votre application Pocket Alert. La ligne de log correspondante et le nombre d’occurrences sont transmis dans le corps JSON.

### Faut-il installer un agent ?

Rien de supplémentaire ne s’exécute sur vos serveurs. Pocket Alert se place à la fin du pipeline que vous utilisez déjà : Loki, Elastic, Graylog ou un script tail avec cron effectue la recherche et envoie simplement le résultat.

### Comment mapper les champs de log dans une notification ?

Le mapping de champs GJSON lit n’importe quel chemin de la charge utile d’alerte. Placez le nom de l’alerte dans le titre et la ligne correspondante ou le nombre dans le message, par exemple %alerts.0.labels.alertname% et %alerts.0.annotations.summary%.

### Puis-je isoler un pic de 500 d’un avertissement isolé ?

Attribuez à chaque service ou environnement sa propre application Pocket Alert : une avalanche de 500 en production n’arrive pas dans le même canal qu’un avertissement isolé de parseur en préproduction. Les flux calmes restent séparés de ceux qui doivent vous réveiller.

### Comment séparer les services et les environnements ?

Attribuez à chaque service ou environnement sa propre application Pocket Alert. Ainsi, les échecs d’authentification en production et les logs de tâches en préproduction arrivent dans des canaux séparés, au lieu d’un flux unique et bruyant.

### Un pic d’erreurs peut-il passer outre Ne pas déranger la nuit ?

Oui. Ajoutez "level":"critical" à la requête POST : Android la livre sur un canal de notification dédié qui contourne Ne pas déranger, une fois que vous avez accordé l’accès à Ne pas déranger. Sur iPhone, les niveaux high et critical arrivent sous forme de notifications importantes qui passent les modes Concentration. Vous pouvez aussi définir default_level sur le webhook afin que chaque alerte de ce pipeline arrive avec la même priorité, et réserver le niveau silent aux flux bavards : sans son ni vibration, mais toujours dans l’historique. L’offre gratuite livre critical comme high : instantanément, mais sans contournement de Ne pas déranger.
