# Envía líneas de log coincidentes a tu teléfono.

> Recibe una notificación push cuando coincida un patrón de logs. Conecta Loki, el stack ELK o Graylog a un webhook de Pocket Alert y la línea de error llega a tu teléfono en un segundo.

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

Última actualización: 2026-08-11

Loki, el stack ELK, Graylog o un script tail | grep ya detectan los picos de errores y las ráfagas de inicios de sesión fallidos. La línea coincidente llega a tu teléfono en menos de un segundo, así que la entrada de log que importa está en tu bolsillo.

## Tres pasos desde la línea de log hasta la push

1. **Define el patrón** — Añade una regla del ruler de Loki, un Elastic Watcher o un patrón grep que se active cuando una línea coincida.
2. **Conéctalo** — Haz curl a la API de mensajes desde un script tail | grep, o apunta Alertmanager a la URL de recepción de un webhook de Pocket Alert con una plantilla GJSON.
3. **Separa los canales** — Asigna a cada servicio o entorno su propia aplicación para que los logs de producción y staging permanezcan en canales separados.

## De la línea de log a la pantalla de bloqueo

Tu pipeline de logs ya encuentra las líneas problemáticas. Pocket Alert las lleva a tu teléfono.

- **Funciona con tu stack** — El ruler de Loki, Elastic Watcher, Graylog o un script tail | grep pueden enviar todos a un mismo webhook.
- **Alertas por patrón** — Una regla LogQL, una condición de Watcher o un patrón grep decide cuándo sale la push.
- **Mapeo de campos** — Las rutas GJSON extraen el nombre de la alerta, la línea coincidente y el número de coincidencias directamente del JSON de la alerta.
- **CLI o webhook** — Un script tail | grep puede usar curl directamente contra la API de mensajes, sin necesidad de una plataforma de monitorización.
- **Canales por aplicación** — Una aplicación de Pocket Alert por servicio o entorno mantiene los logs de producción y staging en canales separados.
- **Entrega en menos de un segundo** — El webhook se dispara y la push llega en menos de un segundo, lo bastante rápido para detectar un pod OOMKilled en directo.

## Envía una notificación push cuando se active un patrón de log

### 1. Lanza curl desde un script tail | grep (CLI)

Instala la CLI, autentícate una vez y luego sigue el log y envía cada línea que coincida.

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

O envía un POST directamente a la API de mensajes en lugar de usar 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. O reenvía Loki / Alertmanager mediante un webhook

Define una regla de alerta LogQL en el ruler de Loki que se active cuando las coincidencias superen un umbral.

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

El ruler envía las alertas a Alertmanager (`alertmanager_url`), que las reenvía a Pocket Alert. Crea un webhook en la página [Webhooks](https://pocketalert.app/es/webhooks) con una plantilla GJSON que mapee el payload de Alertmanager y, después, apunta un `webhook_config` a la URL de recepción.

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

Una acción `webhook` de Elastic Watcher o una definición de evento HTTP Notification de Graylog pueden hacer POST a la misma URL de recepción. La [documentación](https://info.pocketalert.app/api/webhooks/settings.html) explica el mapeo GJSON y el enrutamiento por aplicación.

## Preguntas frecuentes

### ¿Cómo recibo una push cuando coincide un patrón de log?

Configura una alerta del ruler de Loki, un Elastic Watcher o una definición de evento de Graylog que dispare un webhook a la URL de tu aplicación de Pocket Alert. La línea de log coincidente y el recuento llegan en el cuerpo JSON.

### ¿Necesito instalar un agente?

No se ejecuta nada extra en tus servidores. Pocket Alert se sitúa al final del pipeline que ya tienes, así que Loki, Elastic, Graylog o un script tail con cron hace la comparación y solo envía el resultado.

### ¿Cómo mapeo los campos del log en una notificación?

El mapeo de campos GJSON lee cualquier ruta del payload de la alerta. Pasa el nombre de la alerta al título y la línea coincidente o el recuento al mensaje, por ejemplo %alerts.0.labels.alertname% y %alerts.0.annotations.summary%.

### ¿Puedo separar un pico de 500 de una advertencia puntual?

Asigna a cada servicio o entorno su propia aplicación de Pocket Alert para que una avalancha de 500 en producción llegue a un canal distinto de una advertencia puntual del parser en staging. Los flujos tranquilos quedan separados de los que deberían despertarte.

### ¿Cómo mantengo separados los servicios y los entornos?

Asigna a cada servicio o entorno su propia aplicación de Pocket Alert. Así los fallos de autenticación de producción y los logs de trabajos de staging llegan a canales separados en lugar de a un único flujo ruidoso.

### ¿Puede un pico de errores atravesar No molestar por la noche?

Sí. Añade "level":"critical" al POST y Android lo entrega en un canal de notificación dedicado que se salta No molestar; basta con que concedas el acceso a No molestar una vez. En iPhone, high y critical llegan como notificaciones con prioridad temporal que atraviesan los modos de Concentración. También puedes definir default_level en el webhook para que todas las alertas de ese pipeline lleguen con la misma prioridad, y dejar los flujos más habladores en level silent: sin sonido ni vibración, pero siguen en el historial. El plan gratuito entrega critical como high: al instante, pero sin saltarse No molestar.
