# Der Moment, in dem ein Job fehlschlägt.

> Bekomme eine Push-Benachrichtigung, wenn ein Hintergrundjob oder Worker fehlschlägt. Binde Pocket Alert in Sidekiq, Celery, Laravel-Queues oder BullMQ ein, und Worker-Fehler landen sofort auf deinem Handy.

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

Zuletzt aktualisiert: 2026-08-11

Ruf Pocket Alert aus dem Failure-Hook deines Jobs in Sidekiq, Celery, Laravel oder BullMQ auf. Ein abgestürzter Worker bringt Jobname, Argumente und Exception auf dein Handy, und bei kritischen Jobs kommt ein Ping, wenn sie fertig sind.

## Drei Schritte zu Alerts für Background-Jobs

1. **API-Schlüssel oder CLI holen** — Erstelle einen API-Schlüssel oder installiere die Pocket Alert CLI für Worker, die in der Shell laufen.
2. **In Fehler einklinken** — Ruf Pocket Alert aus dem Failure-Hook deines Queue-Frameworks auf und übergib Jobname und Fehler.
3. **Tote Worker abfangen** — Lass einen Job absichtlich fehlschlagen. Dein Handy vibriert und sagt dir, welcher Worker abgestürzt ist und warum.

## Verpasse nie einen toten Worker

Ein Worker, der still stirbt, reißt deine Jobs mit sich. Lass dir sagen, wenn eine Aufgabe abstürzt.

- **Klinkt sich in jede Queue ein** — Sidekiq, Celery, Laravel, BullMQ und Hangfire rufen Pocket Alert aus einem Failure-Hook auf, den du ohnehin schon hast.
- **Alert bei Fehlschlag** — Binde es an den Death-Handler an, dann erreichen dich nur fehlgeschlagene Jobs.
- **Vollständiger Fehlerkontext** — Job-Klasse, Argumente und Exception kommen in der Nachricht an, sodass du ohne Tracker-Besuch priorisieren kannst.
- **Bestätige, dass er lief** — Bei kritischen Jobs gibt es einen Ping nach Abschluss. Ein stiller nächtlicher Import heißt, dass er nicht gelaufen ist.
- **Ein Kanal pro Worker** — Gib jedem Worker eine eigene Anwendung, damit eine hängende Queue in einem Kanal landet, den du auf einen Blick erkennst.
- **Sofort bei Absturz** — Ein abgestürzter Worker meldet sich auf deinem Handy, lange bevor du daran denkst, in die Logs zu schauen.

## Alerts direkt aus deinem Job-Handler

### Laravel-Queue — der failed()-Hook

```
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 — ein Death-Handler

Trag in `config/initializers/sidekiq.rb` ein, dass er auslöst, sobald die Wiederholungen aufgebraucht sind:

```
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 — das task_failure-Signal

```
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 — das failed-Event des Workers

```
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}`,
    }),
  });
});
```

In der [Dokumentation](https://info.pocketalert.app/getting-started.html) erfährst du, wie du eine bestimmte Anwendung oder ein bestimmtes Gerät ansprichst.

## FAQ

### Wie richte ich Alerts für fehlgeschlagene Background-Jobs ein?

Ruf die Pocket Alert API oder CLI aus dem Failure-Handler deines Jobs oder dem rescue-Block auf. Ein abgestürzter Worker sendet eine Push-Benachrichtigung auf dein Handy, mit Jobname und angehängtem Fehler.

### Kann ich mich in mein Queue-Framework einklinken?

Ja. Die meisten Queue-Frameworks bieten einen Failure-Callback: Sidekiq-Death-Handler, Celery task_failure und Laravel failed(). Ruf dort Pocket Alert auf, dann werden nur echte Fehler gemeldet.

### Kann ich Job und Fehler mitschicken?

Schreib Job-Klasse, Argumente und Exception-Nachricht in den Text. Der Alert sagt dir, welcher Job abgestürzt ist und warum, sodass du meist nicht extra in deinen Error-Tracker schauen musst.

### Welche Queue-Systeme werden unterstützt?

Sidekiq, Resque, Celery, RQ, Laravel-Queues, BullMQ, Hangfire und Kubernetes Jobs funktionieren alle über einen Failure-Hook oder einen Exit-Code ungleich null.

### Kann ich bestätigen, dass ein Job wirklich gelaufen ist?

Schick bei kritischen Jobs eine Abschluss-Benachrichtigung. Wenn ein nächtlicher Import nie meldet, hat der Worker wahrscheinlich aufgehört zu arbeiten, ohne einen Fehler zu werfen.

### Kann ein Alert eines toten Workers Nicht stören umgehen?

Ja. Übergib level=critical im Failure-Hook, dann leitet Android die Push-Benachrichtigung über einen Kanal, der Nicht stören umgeht, und das iPhone stellt sie als zeitkritische Benachrichtigung zu, die den Fokus durchbricht. Abschluss-Pings für Routine-Jobs können level=silent nutzen und bleiben ohne Ton im Verlauf.
