# Scheduled Jobs That Disappear: Detect Removed and Unregistered Jobs

By Dan Ochoa · Published 2026-11-16 · Updated 2026-11-16
Canonical: https://cronradar.com/blog/detect-disappeared-scheduled-jobs

> A job removed in a deploy never fails, it just stops. Where jobs vanish in Hangfire, Quartz.NET, Celery, Laravel and crontab, and how to catch it in time.

**A scheduled job that disappears doesn't fail. It stops being scheduled, so there is no error, no failed run, and no log line: the scheduler is healthy and has simply been told less than before. The only way to notice is to compare the jobs the scheduler holds now with the jobs it held before, or with a list kept somewhere else, and to treat a difference as something a person must confirm.** This guide covers where jobs vanish in common schedulers, how to list what each one holds, and how monitors handle a job that's no longer there.

## Three Kinds of Silence

A monitored job can go quiet for three different reasons, and they need different responses:

| Situation            | What the scheduler knows    | Right response                           |
| -------------------- | --------------------------- | ---------------------------------------- |
| **Missed run**       | The job, and that it's due  | Alert: something stopped it from running |
| **Never registered** | Nothing: the code never ran | Alert, if anything expected it           |
| **Removed**          | Nothing any more            | Ask: was this intended?                  |

A heartbeat monitor treats all three the same, because all it sees is a ping that didn't arrive. That's fine for a missed run. For a removed job, it means an alert that says "late" when the truth is "gone," and someone spends an hour checking a server that's working. For a job that was removed by mistake, it's worse when nobody had a monitor for it at all: then nothing alerts.

## Where Jobs Vanish

Jobs rarely vanish because someone deleted them on purpose. More often the code that registered them changed.

### Hangfire

Recurring jobs live in storage, keyed by ID, and stay there until something removes them ([recurring tasks](https://docs.hangfire.io/en/latest/background-methods/performing-recurrent-tasks.html)). They vanish when:

- **A cleanup loop removes everything not in a list,** and a refactor dropped an entry from the list. Search for `RemoveIfExists`.
- **The ID changed.** A new ID creates a new entry; the old one either keeps running (if its type still loads) or fails to schedule and is disabled after retries. The overloads without an explicit ID, obsolete since Hangfire 1.8, derive it from `{TypeName}.{MethodName}`, so a rename changes it silently.
- **Registration moved** behind an environment check or into a service that wasn't deployed, and the old entries were cleaned up.
- **Storage changed.** A new connection string, SQL Server schema, or Redis prefix starts with an empty registry.

[Hangfire recurring job not running](https://cronradar.com/blog/hangfire-recurring-job-not-running) covers causes 4 and 5 in detail.

### Quartz.NET

With a persistent job store (`AdoJobStore`), jobs and triggers persist across restarts; with `RAMJobStore`, the registry is rebuilt from code at every start. Either way, a job registered conditionally, or a trigger whose end time passed, is gone without an error. A trigger that completes (a simple trigger with a fixed repeat count, or one with `EndAt`) is removed when it has no more fire times, unless the job is durable. [Quartz.NET job not firing](https://cronradar.com/blog/quartz-net-job-not-firing) has the checklist.

### Celery Beat

`beat_schedule` is rebuilt from configuration each time beat starts. An entry disappears when the setting moves to a module beat no longer imports, when a settings refactor renames `CELERY_BEAT_SCHEDULE`, or when a per-environment override replaces the whole dictionary instead of extending it. With django-celery-beat, an admin can disable a `PeriodicTask` or delete it, and a one-off task disables itself after running. [Celery beat not running](https://cronradar.com/blog/celery-beat-not-running) covers the schedule beat actually loaded.

### Laravel

The schedule is whatever `routes/console.php` (Laravel 11 and later) or `app/Console/Kernel.php` defines when `schedule:run` boots. Tasks vanish with a merge conflict resolved the wrong way, a constraint such as `->environments('production')` that no longer matches a renamed environment, or a schedule split into a file nothing loads. `php artisan schedule:list` shows what Laravel sees right now.

### crontab

A crontab is replaced wholesale by `crontab file`. A deploy that installs a crontab from the repository drops anything added by hand on the server, and a configuration management run can do the same. Server rebuilds lose user crontabs entirely unless they're provisioned. [Crontab version control](https://cronradar.com/blog/crontab-version-control) shows how to keep the source of truth in the repository and detect drift.

## List What the Scheduler Holds

You can't compare without a list. Each scheduler can produce one:

```bash
# crontab: every user's table and the system directories
for user in $(cut -d: -f1 /etc/passwd); do crontab -l -u "$user" 2>/dev/null | sed "s/^/$user: /"; done
cat /etc/crontab /etc/cron.d/* 2>/dev/null

# Laravel
php artisan schedule:list

# Celery beat with the default scheduler: print the loaded schedule
python -c "from proj.celery import app; print(sorted(app.conf.beat_schedule))"
```

For Hangfire, the storage connection lists recurring jobs:

```csharp
using Hangfire;
using Hangfire.Storage;

public static class RecurringJobAudit
{
    public static IReadOnlyList<string> CurrentIds(JobStorage storage)
    {
        using var connection = storage.GetConnection();
        return connection.GetRecurringJobs()
            .Select(job => job.Id)
            .OrderBy(id => id, StringComparer.Ordinal)
            .ToList();
    }
}
```

For Quartz.NET, `scheduler.GetJobKeys(GroupMatcher<JobKey>.AnyGroup())` returns every job key and `scheduler.GetTriggersOfJob(key)` its triggers.

The simplest detection is to save this list as a deploy artifact and diff it against the previous deploy's. A removed ID in the diff is either intended (and the change should say so) or a bug caught before the first missed run. [Scheduled job inventory](https://cronradar.com/blog/scheduled-job-inventory) goes further, into finding jobs across servers and platforms.

## Reconciliation: Let the Monitor Do the Diff

A monitor that reads the scheduler's registry can do the comparison continuously. Each sync sends the complete set of jobs; anything present last time and missing now has disappeared. The important design choice is what happens next:

- **Delete the monitor:** quiet, but it erases the history and the evidence. A job removed by mistake leaves no trace.
- **Keep alerting as missed:** noisy, and the alert names the wrong cause.
- **Pause and mark it:** the monitor stops expecting runs, keeps its history, and shows that it's no longer in the registry, so a person can confirm the removal or restore the job.

CronRadar does the third for integrations that send the complete registry. The ingestion API's sync endpoint has an explicit `reconcile` mode: the list it receives is authoritative for that source, monitors from the same source that are missing from it trigger one `Vanished` alert and are then paused rather than deleted, and a key that reappears later resumes ([ingestion API](https://docs.cronradar.com/api-reference)). Anything else, including a partial list, only adds or updates.

Today that applies to:

- **Hangfire.** CronRadar.Hangfire 0.2.1 reconciles the recurring-job registry at startup and every 15 minutes. When an ID is gone, CronRadar sends one `Vanished` alert, then pauses the monitor and marks it as no longer discovered, with history kept. See the [Hangfire page](https://cronradar.com/hangfire).
- **Your own scheduler.** Any registry you can list can be sent to the sync endpoint with `"mode": "reconcile"`:

```bash
curl --fail-with-body --silent --show-error \
  --user "$CRONRADAR_API_KEY:" \
  --header "Content-Type: application/json" \
  --data '{
    "source": "internal-scheduler",
    "version": "1.0.0",
    "mode": "reconcile",
    "monitors": [
      { "key": "daily-backup", "name": "Daily backup", "schedule": "0 2 * * *", "gracePeriod": 300 },
      { "key": "hourly-rollup", "name": "Hourly rollup", "schedule": "@hourly" }
    ]
  }' \
  "https://cron.life/api/v1/sync"
```

Send the whole registry every time, from the place that knows it. A reconcile request with a missing entry pauses that monitor, so a partial list in reconcile mode is a bug. If any declaration in the request is rejected, for example an invalid schedule, CronRadar skips removal processing for that request, so one bad entry can't pause everything else.

The Quartz.NET, Celery, and Laravel integrations discover jobs and declare them before their first run, which catches jobs that never run, but their documentation doesn't describe pausing removed jobs. With cronradar/laravel, removed tasks stay until you delete them. For those, the deploy-time diff above is the safeguard.

## Jobs That Were Never Registered

A job that never made it into the registry is the hardest case: nothing knows it should exist. A heartbeat monitor that creates itself on the first ping can't help, because there is no first ping. Two things do:

1. **A list kept outside the code that registers jobs:** a runbook, an inventory, or monitors created ahead in the dashboard. A monitor that exists before the job's first run starts `pending`; if nothing arrives by the first expected time plus grace, CronRadar sends a never-executed alert, repeated at most once every 24 hours while it stays silent.
2. **Discovery from the framework,** which declares every job the code does register, so the gap narrows to jobs whose registration code never ran.

The second is why framework discovery matters: it removes the second list for everything the scheduler knows about, and leaves people to watch only the code paths that register jobs.

## A Checklist

- Give every recurring job an explicit, stable ID or key, and treat renames as a remove plus an add.
- Search the code for removal calls (`RemoveIfExists`, Quartz's `DeleteJob` and `UnscheduleJob`, `crontab -r`, cleanup loops) and review them like deletes in a database migration.
- Export the registry at every deploy and diff it against the last one.
- Use a monitor that knows the difference between missed, never ran, and removed, and route "removed" to a person, not a pager.
- Keep one CronRadar application per environment, so a staging deploy that drops jobs can't pause production monitors.

## Frequently Asked Questions

### Why didn't I get an alert when a cron job was deleted?

Because a deleted job doesn't fail. A heartbeat monitor alerts only if it was set up for that job, and then it reports a missed run, not a removal. An error tracker sees nothing at all. Catching removals needs a comparison of the scheduler's current jobs with a previous list, either in your deploy pipeline or in a monitor that reconciles the registry.

### How do I list all Hangfire recurring jobs in code?

Open a storage connection and call `GetRecurringJobs()`: `using var connection = JobStorage.Current.GetConnection(); var jobs = connection.GetRecurringJobs();`. Each `RecurringJobDto` has the ID, cron expression, queue, next and last execution, and any scheduling error. Resolve `JobStorage` from dependency injection in ASP.NET Core rather than relying on `JobStorage.Current`.

### Should a monitor delete itself when a job is removed?

Pausing is safer. Deleting erases the job's history, and if the removal was a mistake there is no record that the job existed. A paused monitor stops alerting, keeps its runs, and can resume if the job comes back. CronRadar alerts once when monitors drop out of a reconciled registry, one combined alert if many go at once, and then pauses them for this reason.

### Can CronRadar detect removed jobs for every framework?

Removal detection runs where an integration sends the complete registry in reconcile mode: CronRadar.Hangfire does this every 15 minutes, and your own code can do it through the sync endpoint. The Quartz.NET, Celery, and Laravel integrations declare jobs before their first run but don't document pausing removed ones, so keep a deploy-time diff for those.
