# Nell'istante in cui un job va in errore.

> Ricevi una notifica push quando un job in background o un worker fallisce. Collega Pocket Alert a Sidekiq, Celery, alle code di Laravel o a BullMQ e gli errori dei worker arrivano subito sul tuo telefono.

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

Ultimo aggiornamento: 2026-08-11

Chiama Pocket Alert dall'hook di errore dei tuoi job in Sidekiq, Celery, Laravel o BullMQ. Un worker che va in errore porta sul tuo telefono nome del job, argomenti ed eccezione, e una notifica di completamento arriva quando finiscono i job critici.

## Tre passaggi per gli avvisi sui job in background

1. **Ottieni la chiave API o la CLI** — Crea una chiave API, oppure installa la CLI di Pocket Alert per i worker da shell.
2. **Collega gli errori** — Chiama Pocket Alert dall'hook di errore del tuo framework di code e passa nome del job ed errore.
3. **Intercetta i worker bloccati** — Fai partire un job che fallisce. Il telefono vibra e ti dice quale worker si è fermato e perché.

## Non perdere mai un worker bloccato

Un worker che muore in silenzio trascina con sé i tuoi job. Ricevi un avviso appena un task va in errore.

- **Si integra con qualsiasi coda** — Sidekiq, Celery, Laravel, BullMQ e Hangfire chiamano Pocket Alert da un hook di errore che hai già.
- **Avviso in caso di errore** — Collegalo al death handler e ricevi solo i job falliti.
- **Contesto completo dell'errore** — Classe del job, argomenti ed eccezione arrivano nel messaggio, così puoi fare triage senza aprire il tracker.
- **Verifica che sia stato eseguito** — Ricevi una notifica al completamento dei job critici. Un import notturno silenzioso significa che ha smesso di girare.
- **Un canale per ogni worker** — Assegna a ogni worker la sua applicazione, così una coda bloccata finisce in un canale che riconosci a colpo d'occhio.
- **Immediato al momento dell'errore** — Un worker che va in errore ti raggiunge sul telefono molto prima che ti venga in mente di controllare i log.

## Avvisi direttamente dal tuo job handler

### Coda Laravel — l'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

In `config/initializers/sidekiq.rb`, attivalo quando i tentativi sono esauriti:

```
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 — il segnale 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 — l'evento worker failed

```
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 [documentazione](https://info.pocketalert.app/getting-started.html) spiega come indirizzare una specifica applicazione o dispositivo.

## FAQ

### Come ricevo notifiche push quando un job in background fallisce?

Chiama l'API o la CLI di Pocket Alert dal failure handler del tuo job o dal blocco rescue. Un worker che va in errore invia una notifica push al tuo telefono con il nome del job e l'errore allegati.

### Posso agganciarmi al framework di code che uso?

Sì. La maggior parte dei framework per code espone una callback di errore: death handler di Sidekiq, task_failure di Celery e failed() di Laravel. Inserisci lì la chiamata a Pocket Alert e riceverai notifiche solo per i fallimenti reali.

### Posso includere nella notifica il job e l'errore?

Inserisci nel corpo la classe del job, gli argomenti e il messaggio dell'eccezione. La notifica ti dice quale job si è interrotto e perché, e di solito ti evita di aprire il tracker degli errori.

### Quali sistemi di code sono supportati?

Sidekiq, Resque, Celery, RQ, le code di Laravel, BullMQ, Hangfire e i Kubernetes Jobs funzionano tutti tramite un hook di errore o un'uscita con codice diverso da zero.

### Posso verificare che un job sia stato eseguito davvero?

Invia una notifica di completamento per i job critici. Se un import notturno non manda mai il suo segnale, probabilmente il worker si è fermato senza sollevare alcun errore.

### Un'allerta per un worker bloccato può superare Non disturbare?

Sì. Passa level=critical nell'hook di errore e su Android la notifica viene inviata tramite un canale che aggira Non disturbare, mentre su iPhone arriva come notifica time-sensitive che supera Full immersion. Le notifiche di completamento per i job di routine possono usare level=silent e restare nella cronologia senza suono.
