# En cuanto una tarea falla.

> Recibe una notificación push cuando falle una tarea en segundo plano o un worker. Conecta Pocket Alert con Sidekiq, Celery, las colas de Laravel o BullMQ y los fallos llegan rápido a tu teléfono.

<!-- source: https://pocketalert.app/es/use-cases/background-job-alerts -->

Última actualización: 2026-08-11

Llama a Pocket Alert desde el hook de fallo de tu tarea en Sidekiq, Celery, Laravel o BullMQ. Un worker que lanza un error envía a tu teléfono el nombre de la tarea, sus argumentos y la excepción, y una notificación de finalización llega cuando terminan las tareas críticas.

## Tres pasos para alertas de tareas en segundo plano

1. **Obtén la clave de API o la CLI** — Crea una clave de API o instala la CLI de Pocket Alert para los workers basados en shell.
2. **Engánchate a los fallos** — Llama a Pocket Alert desde el hook de fallo de tu framework de colas y pasa el nombre de la tarea y el error.
3. **Detecta los workers caídos** — Lanza una tarea que falle. Tu teléfono vibra indicando qué worker cayó y por qué.

## No te pierdas ningún worker caído

Un worker que muere en silencio arrastra tus tareas con él. Entérate cuando una tarea lance un error.

- **Se engancha a cualquier cola** — Sidekiq, Celery, Laravel, BullMQ y Hangfire llaman a Pocket Alert desde un hook de fallo que ya tienes.
- **Alerta ante fallos** — Conéctalo al death handler y solo te llegarán las tareas fallidas.
- **Contexto completo del fallo** — La clase de la tarea, sus argumentos y la excepción llegan en el mensaje, así que puedes diagnosticar sin abrir tu herramienta de seguimiento.
- **Confirma que se ejecutó** — Notifica al completarse las tareas críticas. Si una importación nocturna no avisa, significa que dejó de ejecutarse.
- **Un canal por worker** — Asigna a cada worker su propia aplicación para que una cola atascada llegue a un canal que localizas de un vistazo.
- **Aviso inmediato al lanzar un error** — Un worker que lanza un error envía una push a tu teléfono mucho antes de que se te ocurra revisar los logs.

## Envía alertas directamente desde el manejador de tu tarea

### Cola de Laravel: el hook failed()

```
public function failed(Throwable $e): void
{
    Http::withHeaders(['Token' => 'YOUR_API_KEY'])
        ->post('https://api.pocketalert.app/v1/messages', [
            'title' => 'Job failed: ' . class_basename($this),
            'message' => $e->getMessage(),
            'level' => 'critical',
        ]);
}
```

### Sidekiq: un death handler

En `config/initializers/sidekiq.rb`, dispáralo cuando se agoten los reintentos:

```
Sidekiq.configure_server do |config|
  config.death_handlers << ->(job, ex) do
    Net::HTTP.post(
      URI('https://api.pocketalert.app/v1/messages'),
      { title: "Job died: #{job['class']}",
        message: "jid #{job['jid']}: #{ex.message}" }.to_json,
      'Token' => 'YOUR_API_KEY', 'Content-Type' => 'application/json')
  end
end
```

### Celery: la señal task_failure

```
import requests
from celery.signals import task_failure

@task_failure.connect
def notify_failure(sender=None, task_id=None, exception=None, **kw):
    requests.post(
        'https://api.pocketalert.app/v1/messages',
        headers={'Token': 'YOUR_API_KEY'},
        json={'title': f'Task failed: {sender.name}',
              'message': f'{task_id}: {exception}'})
```

### BullMQ: el evento failed del worker

```
worker.on('failed', async (job, err) => {
  await fetch('https://api.pocketalert.app/v1/messages', {
    method: 'POST',
    headers: { 'Token': 'YOUR_API_KEY', 'Content-Type': 'application/json' },
    body: JSON.stringify({
      title: `Job failed: ${job?.name}`,
      message: `${job?.id}: ${err.message}`,
    }),
  });
});
```

La [documentación](https://info.pocketalert.app/getting-started.html) explica cómo dirigir las notificaciones a una aplicación o un dispositivo concretos.

## Preguntas frecuentes

### ¿Cómo configuro alertas para tareas en segundo plano fallidas?

Llama a la API o a la CLI de Pocket Alert desde el hook de fallo de tu tarea o desde el bloque rescue. Un worker que lanza un error envía una notificación push a tu teléfono con el nombre de la tarea y el error adjunto.

### ¿Puedo engancharme al framework de mi cola?

Sí. La mayoría de los frameworks de colas exponen un callback de fallo: los death handlers de Sidekiq, task_failure en Celery y failed() en Laravel. Pon la llamada a Pocket Alert ahí y solo recibirás notificaciones de fallos reales.

### ¿Puedo incluir la tarea y el error?

Incluye la clase de la tarea, sus argumentos y el mensaje de la excepción en el cuerpo. La alerta te dice qué tarea falló y por qué, lo que normalmente te ahorra ir a tu herramienta de seguimiento de errores.

### ¿Qué sistemas de colas son compatibles?

Sidekiq, Resque, Celery, RQ, las colas de Laravel, BullMQ, Hangfire y los Jobs de Kubernetes funcionan mediante un hook de fallo o con una salida distinta de cero.

### ¿Puedo confirmar que una tarea se ejecutó?

Envía una notificación de finalización en las tareas críticas. Si una importación nocturna nunca avisa, es probable que el worker haya dejado de procesar sin lanzar ningún error.

### ¿Una alerta de worker caído puede saltarse No molestar?

Sí. Pasa level=critical en el hook de fallo y Android enviará la push por un canal que salta No molestar, mientras que iPhone la entrega como notificación sensible al tiempo que atraviesa Concentración. Las notificaciones de finalización de tareas rutinarias pueden usar level=silent y quedarse en el historial sin sonido.
