# Notificações push para linhas de log encontradas no seu celular.

> Receba uma notificação push quando um padrão de log der match. Conecte Loki, ELK stack ou Graylog a um webhook do Pocket Alert e a linha de erro chega no seu celular em um segundo.

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

Última atualização: 2026-08-11

Loki, a stack ELK, Graylog ou um script tail | grep já identificam picos de erro e rajadas de falhas de login. A linha encontrada chega no seu celular em menos de um segundo, para que o registro de log que importa esteja no seu bolso.

## Três passos da linha de log até a notificação push

1. **Defina o padrão** — Adicione uma regra no ruler do Loki, um Elastic Watcher ou um padrão grep que dispare quando uma linha corresponder.
2. **Conecte tudo** — Use curl na API de mensagens a partir de um script tail | grep, ou aponte o Alertmanager para a URL de recebimento de um webhook do Pocket Alert com um template GJSON.
3. **Separe os canais** — Dê a cada serviço ou ambiente seu próprio aplicativo para que os logs de produção e staging fiquem em canais separados.

## Da linha de log à tela de bloqueio

Seu pipeline de logs já encontra as linhas ruins. O Pocket Alert as leva até o seu celular.

- **Funciona com a sua stack** — Loki ruler, Elastic Watcher, Graylog ou um script tail | grep podem enviar para um mesmo webhook.
- **Alertas por padrão encontrado** — Uma regra LogQL, uma condição do Watcher ou um padrão grep decide quando a notificação push é enviada.
- **Mapeamento de campos** — Caminhos GJSON extraem o nome do alerta, a linha encontrada e o número de ocorrências direto do JSON do alerta.
- **CLI ou webhook** — Um script tail | grep pode usar curl diretamente na API de mensagens, sem precisar de plataforma de monitoramento.
- **Canais por aplicativo** — Um aplicativo do Pocket Alert por serviço ou ambiente mantém os logs de produção e staging em canais separados.
- **Entrega em menos de um segundo** — O webhook dispara e a notificação push chega em menos de um segundo, rápido o bastante para pegar um pod OOMKilled em tempo real.

## Envie uma notificação push quando um padrão de log disparar

### 1. Use curl direto de um script tail | grep (CLI)

Instale a CLI, autentique uma vez e depois acompanhe o log, enviando cada linha encontrada.

```
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 faça POST direto na API de mensagens, sem usar a 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 encaminhe Loki / Alertmanager por webhook

Defina uma regra de alerta LogQL no ruler do Loki que dispare quando as ocorrências ultrapassarem um limite.

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

O ruler encaminha para o Alertmanager (`alertmanager_url`), que repassa para o Pocket Alert. Crie um webhook na página de [Webhooks](https://pocketalert.app/pt/webhooks) com um template GJSON que mapeie o payload do Alertmanager e, em seguida, aponte um `webhook_config` para a URL de recebimento.

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

Uma ação `webhook` do Elastic Watcher ou uma definição de evento de Notificação HTTP do Graylog pode fazer POST para a mesma URL de recebimento. A [documentação](https://info.pocketalert.app/api/webhooks/settings.html) cobre o mapeamento GJSON e o roteamento por aplicativo.

## Perguntas frequentes

### Como recebo uma notificação push quando um padrão de log é encontrado?

Configure um alerta no ruler do Loki, um Elastic Watcher ou uma definição de evento no Graylog que dispare um webhook para a URL do seu aplicativo no Pocket Alert. A linha de log encontrada e a contagem chegam no corpo JSON.

### Preciso instalar um agente?

Nada extra roda nas suas máquinas. O Pocket Alert fica no fim do pipeline que você já tem, então o Loki, Elastic, Graylog ou um script tail com cron faz a busca e apenas envia o resultado.

### Como mapeio os campos de log em uma notificação?

O mapeamento de campos com GJSON lê qualquer caminho no payload do alerta. Coloque o nome do alerta no título e a linha encontrada ou a contagem na mensagem, por exemplo %alerts.0.labels.alertname% e %alerts.0.annotations.summary%.

### Consigo separar um pico de 500s de um aviso isolado?

Dê a cada serviço ou ambiente seu próprio aplicativo no Pocket Alert, para que uma enxurrada de 500s em produção chegue em um canal diferente de um aviso isolado do parser em staging. Feeds silenciosos ficam separados daqueles que devem te acordar.

### Como mantenho serviços e ambientes separados?

Dê a cada serviço ou ambiente seu próprio aplicativo no Pocket Alert. Assim, falhas de autenticação em produção e logs de jobs em staging chegam em canais separados, em vez de em um único feed barulhento.

### Um pico de erros consegue furar o Não perturbe à noite?

Sim. Adicione "level":"critical" no POST e o Android entrega em um canal de notificação dedicado que ignora o Não perturbe. Você concede o acesso ao Não perturbe uma única vez. No iPhone, high e critical chegam como notificações de horário sensível que atravessam os modos de Foco. Você também pode definir default_level no webhook para que todo alerta desse pipeline chegue com a mesma prioridade, e manter feeds barulhentos em level silent, sem som ou vibração, mas ainda no histórico. No plano gratuito, critical é entregue como high: instantâneo, mas sem ignorar o Não perturbe.
