# No instante em que um job lança um erro.

> Receba uma notificação push quando um job em segundo plano ou worker falhar. Conecte o Pocket Alert ao Sidekiq, Celery, filas do Laravel ou BullMQ e receba as falhas no celular na hora.

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

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

Chame o Pocket Alert a partir do hook de falha dos seus jobs no Sidekiq, Celery, Laravel ou BullMQ. Um worker que lança um erro envia para o seu celular o nome do job, os argumentos e a exceção, e um aviso de conclusão chega quando os jobs críticos terminam.

## Três passos para alertas de jobs em segundo plano

1. **Obtenha a chave de API ou a CLI** — Crie uma chave de API ou instale a CLI do Pocket Alert para workers que rodam em shell.
2. **Conecte-se às falhas** — Chame o Pocket Alert a partir do hook de falha do framework de fila e passe o nome do job e o erro.
3. **Capture workers que morreram** — Dispare um job que falha. Seu celular vibra mostrando qual worker morreu e por quê.

## Nunca perca um worker que morreu

Um worker que morre em silêncio derruba os seus jobs junto. Seja avisado quando uma tarefa lança um erro.

- **Conecta com qualquer fila** — Sidekiq, Celery, Laravel, BullMQ e Hangfire chamam o Pocket Alert a partir de um hook de falha que você já tem.
- **Alerta em caso de falha** — Conecte no death handler e só os jobs que falharam chegam até você.
- **Contexto completo da falha** — A classe do job, os argumentos e a exceção chegam na mensagem, então você pode fazer a triagem sem abrir o seu rastreador.
- **Confirme que rodou** — Envie um aviso na conclusão de jobs críticos. Uma importação noturna silenciosa significa que ela parou de rodar.
- **Um canal por worker** — Dê a cada worker o seu próprio aplicativo, para que uma fila travada caia em um canal que você identifica de relance.
- **Imediato no momento do erro** — Um worker que lança um erro envia um push para o seu celular bem antes de você pensar em acompanhar os logs.

## Alerte direto do seu handler de jobs

### Fila do Laravel — o 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 — um death handler

Em `config/initializers/sidekiq.rb`, dispare quando as tentativas se esgotarem:

```
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 — o sinal 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 — o evento failed do 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}`,
    }),
  });
});
```

A [documentação](https://info.pocketalert.app/getting-started.html) explica como direcionar para um aplicativo ou dispositivo específico.

## Perguntas frequentes

### Como faço para receber alertas de jobs em segundo plano que falharam?

Chame a API ou a CLI do Pocket Alert a partir do handler de falha do seu job ou do bloco rescue. Um worker que lança um erro envia uma notificação push para o seu celular, com o nome do job e o erro anexados.

### Posso me conectar ao framework de fila que eu uso?

Sim. A maioria dos frameworks de fila expõe um callback de falha: os death handlers do Sidekiq, o task_failure do Celery e o failed() do Laravel. Coloque a chamada ao Pocket Alert ali e você só será notificado sobre falhas reais.

### Posso incluir o job e o erro?

Coloque a classe do job, os argumentos e a mensagem da exceção no corpo. O alerta informa qual job morreu e por quê, o que normalmente evita abrir o seu rastreador de erros.

### Quais sistemas de fila são suportados?

Sidekiq, Resque, Celery, RQ, filas do Laravel, BullMQ, Hangfire e Jobs do Kubernetes funcionam, seja por um hook de falha, seja por uma saída com código diferente de zero.

### Posso confirmar que um job realmente rodou?

Envie uma notificação de conclusão em jobs críticos. Se uma importação noturna nunca avisar que terminou, o worker provavelmente parou de processar sem lançar nenhum erro.

### Um alerta de worker com falha pode passar pelo modo Não perturbe?

Sim. Passe level=critical no hook de falha e o Android encaminha o push por um canal que ignora o Não perturbe, enquanto o iPhone entrega como notificação sensível ao tempo que atravessa o Foco. Avisos de conclusão de jobs rotineiros podem usar level=silent e ficar no histórico sem som.
