# L’instant où une tâche plante.

> Recevez une notification push dès qu’une tâche de fond ou un worker échoue. Branchez Pocket Alert sur Sidekiq, Celery, les files Laravel ou BullMQ : les échecs arrivent vite sur votre téléphone.

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

Dernière mise à jour : 2026-08-11

Appelez Pocket Alert depuis le hook d’échec de vos tâches dans Sidekiq, Celery, Laravel ou BullMQ. Un worker qui plante transmet à votre téléphone le nom de sa tâche, ses arguments et l’exception, et un signalement de fin vous prévient quand les tâches critiques se terminent.

## Trois étapes pour des alertes sur les tâches en arrière-plan

1. **Obtenez la clé API ou la CLI** — Créez une clé API, ou installez la CLI de Pocket Alert pour les workers en shell.
2. **Branchez-vous aux échecs** — Appelez Pocket Alert depuis le hook d’échec de votre framework de files et transmettez le nom de la tâche et l’erreur.
3. **Repérez les workers en panne** — Déclenchez une tâche en échec. Votre téléphone vibre et vous indique quel worker a planté et pourquoi.

## Ne manquez jamais un worker en panne

Un worker qui meurt en silence entraîne vos tâches avec lui. Soyez prévenu dès qu’une tâche lève une erreur.

- **Compatible avec toutes les files** — Sidekiq, Celery, Laravel, BullMQ et Hangfire appellent Pocket Alert depuis un hook d’échec que vous avez déjà.
- **Alerte en cas d’échec** — Branchez-le sur le death handler et seules les tâches en échec vous parviennent.
- **Contexte complet de l’échec** — La classe de la tâche, ses arguments et l’exception arrivent dans le message : vous pouvez trier sans ouvrir votre outil de suivi.
- **Vérifiez l’exécution** — Signalez la fin des tâches critiques. Un import nocturne silencieux signifie qu’il ne s’est pas exécuté.
- **Un canal par worker** — Donnez à chaque worker sa propre application pour qu’une file bloquée apparaisse dans un canal que vous repérez d’un coup d’œil.
- **Immédiat dès l’erreur** — Un worker qui plante vous envoie une notification push bien avant que vous pensiez à consulter les logs.

## Alertez directement depuis votre gestionnaire de tâches

### File Laravel — le 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

Dans `config/initializers/sidekiq.rb`, déclenchez l’appel une fois les tentatives épuisées :

```
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 — le signal 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’événement failed du 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 [documentation](https://info.pocketalert.app/getting-started.html) explique comment cibler une application ou un appareil précis.

## FAQ

### Comment être alerté en cas d’échec d’une tâche en arrière-plan ?

Appelez l’API ou la CLI de Pocket Alert depuis le gestionnaire d’échec de votre tâche ou depuis le bloc rescue. Un worker qui plante envoie une notification push sur votre téléphone, avec le nom de la tâche et l’erreur en pièce jointe.

### Puis-je me brancher sur le framework de files que j’utilise ?

Oui. La plupart des frameworks de files exposent un callback d’échec : les death handlers de Sidekiq, task_failure pour Celery et failed() pour Laravel. Placez-y l’appel à Pocket Alert et vous ne serez notifié que des véritables échecs.

### Puis-je inclure la tâche et l’erreur ?

Indiquez la classe de la tâche, ses arguments et le message de l’exception dans le corps de la notification. L’alerte vous dit quelle tâche a échoué et pourquoi, ce qui vous évite en général de passer par votre outil de suivi des erreurs.

### Quels systèmes de files sont pris en charge ?

Sidekiq, Resque, Celery, RQ, les files Laravel, BullMQ, Hangfire et les Jobs Kubernetes fonctionnent tous via un hook d’échec ou une sortie avec un code non nul.

### Puis-je vérifier qu’une tâche s’est bien exécutée ?

Envoyez une notification de fin pour les tâches critiques. Si un import nocturne ne signale jamais sa fin, le worker s’est probablement arrêté sans lever d’erreur.

### Une alerte de worker en panne peut-elle passer outre Ne pas déranger ?

Oui. Passez level=critical dans le hook d’échec : sous Android, la notification passe par un canal qui contourne Ne pas déranger, et sur iPhone elle est livrée comme notification sensible au temps qui traverse le mode Concentration. Les signalements de fin des tâches courantes peuvent utiliser level=silent : ils restent dans l’historique sans son.
