# Quartz.NET Monitoring Tools Compared: Listeners, Sentry, and CronRadar

By Dan Ochoa · Published 2026-11-16 · Updated 2026-11-16
Canonical: https://cronradar.com/blog/quartz-net-monitoring-tools

> Compare ways to monitor Quartz.NET jobs: your own job listener, Sentry.Quartz with MonitorAllJobs, heartbeat services and CronRadar.Quartz, with limits.

**Quartz.NET has a good hook for monitoring, `IJobListener`, and the serious options all build on it. The differences are in what happens around the listener: whether every job is covered by default, how a Quartz cron trigger becomes a schedule the monitor can check, which time zone that schedule is read in, and whether a job that never fires at all is noticed. Sentry.Quartz and CronRadar.Quartz both cover every triggered job with one registration; a hand-written listener or a heartbeat service covers what you wire up yourself.** This comparison covers Quartz.NET 3.x and 4.x on .NET. The code samples use the Quartz.NET 3.x API, which is what CronRadar.Quartz runs on .NET 8 and 9; Quartz.NET 4 changed the interfaces you implement (they return `ValueTask`, jobs take a `CancellationToken`, and `StdSchedulerFactory` is gone), as [the Quartz.NET 4 upgrade guide](https://cronradar.com/blog/quartz-net-4-upgrade) explains. Vendor facts were checked against each vendor's documentation on November 16, 2026.

## What Quartz.NET Gives You on Its Own

Quartz.NET logs, and it raises listener callbacks: `JobToBeExecuted`, `JobWasExecuted` (with the `JobExecutionException`, if any), `JobExecutionVetoed`, plus trigger and scheduler listeners for misfires and errors. It has no alerting and no notion of "this should have happened by now." If the scheduler isn't running, the host was scaled to zero, or a trigger was removed in a deploy, no callback fires and nothing is logged.

That gap shapes every option below. A listener inside the process sees what runs. Seeing what didn't run needs an expectation stored outside it: the job's schedule, and a clock that compares it with the reports that arrived. [Quartz.NET job not firing](https://cronradar.com/blog/quartz-net-job-not-firing) lists the causes of a trigger that never fires; [Quartz.NET misfire instructions](https://cronradar.com/blog/quartz-net-misfire-instructions) explains what Quartz does once it notices a missed time.

## Option 1: Your Own Job Listener

A listener that reports to your alerting system takes a few dozen lines. With the Quartz.NET 3.x DI integration:

```csharp
using Quartz;

builder.Services.AddQuartz(q =>
{
    q.AddJobListener<AlertingJobListener>();
});
builder.Services.AddQuartzHostedService(options => options.WaitForJobsToComplete = true);

public sealed class AlertingJobListener(ILogger<AlertingJobListener> logger) : IJobListener
{
    public string Name => "alerting";

    public Task JobToBeExecuted(IJobExecutionContext context, CancellationToken cancellationToken = default)
        => Task.CompletedTask;

    public Task JobExecutionVetoed(IJobExecutionContext context, CancellationToken cancellationToken = default)
        => Task.CompletedTask;

    public Task JobWasExecuted(IJobExecutionContext context, JobExecutionException? jobException,
        CancellationToken cancellationToken = default)
    {
        if (jobException is not null)
        {
            // Send to your alerting channel here; never throw from a listener.
            logger.LogError(jobException, "Quartz job {JobKey} failed", context.JobDetail.Key);
        }
        return Task.CompletedTask;
    }
}
```

This catches failures with full exception detail and costs nothing. It doesn't catch a job that never fires, a scheduler that stopped, or a run that hangs, because each of those produces no callback. Use it for failure detail; pair it with something outside the process for schedules.

## Option 2: Sentry.Quartz

Sentry's .NET SDK added Quartz.NET support in version 6.13.0 ([Sentry Quartz.NET Crons](https://docs.sentry.io/platforms/dotnet/crons/quartz/)). Use `Sentry.Quartz` with Quartz.NET 4.x and `Sentry.Quartz3` with Quartz.NET 3.6 and later. For Quartz.NET 4:

```csharp
builder.Services.AddQuartz(q =>
{
    q.AddSentry();
});
```

On Quartz.NET 3.x you register `SentryJobListener` with `q.AddJobListener<SentryJobListener>()` instead. What Sentry documents:

- **Coverage.** `MonitorAllJobs` monitors every job whose trigger has a schedule Sentry can send; `ExcludedJobs` takes names or regular expressions. With it off, each job needs `[SentryMonitorSlug]`.
- **Slugs.** Derived from the job's group and name, lowercased and cut to 50 characters. Jobs built without `WithIdentity` are skipped by `MonitorAllJobs`.
- **Schedules and time zones.** Cron triggers are sent with the trigger's own time zone; simple triggers only when they repeat forever at whole minutes, hours, or days. Cron expressions must use fixed seconds and no year, `L`, `W`, or `#`. Triggers with a calendar, other trigger types, and non-IANA time zones are sent without a schedule, and `MonitorAllJobs` skips them.
- **Quartz.NET 3.x caveat.** The SDK doesn't capture job exceptions there; errors reach Sentry only through other integrations.
- **Monitor creation.** Monitors are created from check-ins, so a job is known to Sentry after it first runs, and check-ins overwrite the monitor's schedule and time zone.

If Sentry is already your error tracker, this is a strong option: failures arrive with the exception and trace context. Every Sentry plan includes one cron monitor, and more cost $0.78 each from a paid plan's pay-as-you-go budget ([pricing](https://sentry.io/pricing/)). [Sentry Crons vs a dedicated cron monitor](https://cronradar.com/blog/sentry-crons-vs-dedicated-cron-monitoring) and the [Sentry Crons comparison](https://cronradar.com/alternatives/sentry-crons) go further.

## Option 3: A Heartbeat Service

Cronitor, Healthchecks.io, Better Stack, and Dead Man's Snitch don't ship Quartz.NET packages; Cronitor's community `Cronitor.Quartz` package had a few hundred downloads in total when checked. The usual pattern is the listener from Option 1 calling a ping URL per job, with one check per job created on the service by hand and given the same schedule as the trigger.

That works, with two costs: the checks are a second list to keep in step with your triggers, and Quartz's six- or seven-field expressions (`0 0 2 ? * MON-FRI`) have to be rewritten as five-field cron or an interval for most services. [Quartz.NET cron expressions](https://cronradar.com/blog/quartz-net-cron-expressions) covers the seconds field, `?`, and the `L`, `W`, and `#` characters that don't translate.

## Option 4: CronRadar.Quartz

CronRadar is a monitor for scheduled jobs only. CronRadar.Quartz 0.2.0 walks every registered job and trigger, declares each job with a translated schedule, and registers an `IJobListener` that reports start, completion, and failure ([Quartz.NET integration guide](https://docs.cronradar.com/integrations/quartz)). It uses Quartz.NET 4 on .NET 10 and Quartz.NET 3.13 or later on earlier frameworks.

```bash
dotnet add package CronRadar.Quartz
```

With a Quartz.NET 3.x scheduler you build yourself, call it after scheduling jobs:

```csharp
using CronRadar.Quartz;
using Quartz;
using Quartz.Impl;

IScheduler scheduler = await new StdSchedulerFactory().GetScheduler();

var job = JobBuilder.Create<NightlyExportJob>()
    .WithIdentity("nightly-export", "reports")
    .Build();
var trigger = TriggerBuilder.Create()
    .WithIdentity("nightly-export-trigger", "reports")
    .WithCronSchedule("0 0 2 ? * MON-FRI")
    .Build();
await scheduler.ScheduleJob(job, trigger);

// Reads the application key from the CRONRADAR_API_KEY environment variable.
await scheduler.MonitorAll();
await scheduler.Start();

public class NightlyExportJob : IJob
{
    public Task Execute(IJobExecutionContext context)
    {
        Console.WriteLine("Exporting");
        return Task.CompletedTask;
    }
}
```

On Quartz.NET 4, where the container builds the scheduler, and with `AddQuartz()` on 3.x, call `MonitorAll()` from an `IHostedService` after the scheduler starts; the integration guide has the snippet.

What to expect:

- **Every job by default.** `[SkipMonitor]` on an `IJob` class opts it out; `[CronRadar("key")]` overrides the monitor key, which otherwise comes from the job's group and name.
- **Schedules.** `0 0 2 ? * MON-FRI` is declared as `0 2 * * 1-5`. An expression with no five-field form, such as one that fires every 30 seconds, logs a warning and that job stays unmonitored.
- **Time zones.** CronRadar evaluates every schedule in the application's time zone, an IANA name set in the application's settings, UTC if unset. The extension doesn't convert hours between zones, so a trigger built with `InTimeZone(...)` should use the same zone as the CronRadar application, or be checked carefully.
- **Never-ran jobs.** Monitors are declared before the first run, so a job whose trigger never fires sends a never-executed alert after its first expected time plus grace, not just a job that stops later.
- **Grace.** 60 seconds by default, adjustable per monitor in the dashboard.

Alerts go to email, Slack, webhook, Discord, or PagerDuty; see [pricing](https://cronradar.com/pricing) for the free allowance. The [Quartz.NET page](https://cronradar.com/quartz) summarizes the integration and [Quartz.NET monitoring](https://cronradar.com/blog/quartz-net-monitoring) is the longer guide.

## Side by Side

| Option            | Covers every job                | Missed runs                   | Failure detail    | Never-ran jobs       | Quartz cron handling                         |
| ----------------- | ------------------------------- | ----------------------------- | ----------------- | -------------------- | -------------------------------------------- |
| Own listener      | Yes (in process)                | No                            | Full exception    | No                   | Not needed                                   |
| Sentry.Quartz     | With `MonitorAllJobs`           | Yes, after the first check-in | Exception on 4.x  | Not before first run | Sent as-is with trigger zone; no `L`/`W`/`#` |
| Heartbeat service | One check per job, by hand      | Yes, if the check exists      | Whatever you send | If the check exists  | Rewrite by hand                              |
| CronRadar.Quartz  | Yes, `[SkipMonitor]` to opt out | Yes                           | Exception message | Yes                  | Translated to five fields; others skipped    |

## Which to Choose

- **Already on Sentry, jobs run at least once:** Sentry.Quartz with `MonitorAllJobs` gives schedule checks plus exception context with little setup.
- **You care about the job that never fires the first time,** or want job monitoring separate from error tracking: a monitor that declares jobs ahead of their first run. That's CronRadar.Quartz.
- **Either way,** keep your own listener for logging, since no hosted monitor replaces your logs.

## Frequently Asked Questions

### Does Quartz.NET have built-in job monitoring?

It has listeners, not monitoring. `IJobListener`, `ITriggerListener`, and `ISchedulerListener` report what the scheduler does, including exceptions and misfires, but nothing alerts and nothing notices a job that never fires. An external monitor supplies the schedule expectation and the alerts.

### Can Sentry monitor all Quartz.NET jobs automatically?

Yes, from Sentry .NET SDK 6.13.0 with `MonitorAllJobs`, for jobs built with `WithIdentity` whose trigger has a schedule Sentry can send. Use `Sentry.Quartz` for Quartz.NET 4.x and `Sentry.Quartz3` for 3.6 and later. Cron triggers with `L`, `W`, `#`, a year field, or a calendar are skipped.

### How are Quartz cron expressions checked by a five-field monitor?

They're translated: the seconds field must be fixed and is dropped, and `?` becomes `*`, so `0 0 2 ? * MON-FRI` becomes `0 2 * * 1-5`. Expressions that need seconds or Quartz-only characters have no five-field form. CronRadar.Quartz logs a warning for those and leaves the job unmonitored.

### Which time zone does a Quartz.NET monitor use?

Quartz runs a cron trigger in its own time zone, the server's local zone unless set with `InTimeZone`. Sentry sends the trigger's zone with each check-in. CronRadar uses the CronRadar application's IANA zone for every schedule, so set that zone to match your triggers, or build triggers in UTC.
