Monitorización de logs

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

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.

Push en <1sLoki · ELK · GraylogSin agente extraActualizado el
Funciones

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.

Primeros pasos

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.

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 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 explica el mapeo GJSON y el enrutamiento por aplicación.

FAQ

Preguntas y respuestas

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.

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.

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

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.

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.

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.

La línea de error que importa, en tu bolsillo.

Apunta tu pipeline de logs a un webhook y recibe el próximo pico de errores en tu teléfono.