Hangfire Monitoring Tools Compared: Dashboard, Health Checks, Sentry, CronRadar
Contents
Hangfire's own dashboard shows what happened inside the storage it reads; it can't tell you that a recurring job should have run and didn't. For that you need a check outside the process that knows each job's schedule. The options differ mainly in how much you set up per job: health checks watch the server, not individual jobs; Sentry Crons needs a slug attribute on every job you want monitored; CronRadar.Hangfire reads the recurring-job registry and monitors every job unless you opt it out. This guide compares the common choices for Hangfire 1.8 in ASP.NET Core and worker services. Vendor facts were checked against each vendor's documentation on November 16, 2026.
What a Hangfire Monitor Has to Catch#
A recurring job fails in four distinct ways, and each tool covers a different subset:
| Failure | What it looks like | Needs |
|---|---|---|
| Missed run | No server created or ran the job: process asleep, no server, wrong queue | An outside check that knows the schedule |
| Failed run | The job threw and Hangfire's retries are exhausted | A hook into Hangfire's state changes |
| Stuck run | A run started and never finished | A start signal and an expected duration |
| Disappeared job | The recurring entry was removed or renamed in a deploy, so nothing is due | A comparison of the registry against last time |
The first and last are the ones teams miss. When the server is down, nothing inside Hangfire runs to report it. When a deploy removes a recurring job, there is no failure at all, just silence that looks like a job with nothing to do. Hangfire recurring job not running walks through the causes of a missed run.
The Hangfire Dashboard#
The dashboard is the operational UI: servers, queues, retries, and the Recurring Jobs page with Last execution and Next execution for every entry. It is the first place to look when you already suspect a problem, and nothing below replaces it.
It doesn't send alerts. It runs in the same application and reads the same storage as the server, so when the host is stopped, pointed at another database, or never started a server, the dashboard either isn't reachable or shows nothing wrong. Keep it for diagnosis, behind dashboard authorization, and pair it with something that pages you.
ASP.NET Core Health Checks#
The AspNetCore.HealthChecks.Hangfire package from the Xabaril health-checks project adds a check that reads Hangfire's monitoring API and reports unhealthy when too many jobs have failed or too few servers are running:
builder.Services.AddHealthChecks()
.AddHangfire(options =>
{
options.MinimumAvailableServers = 1;
options.MaximumJobsFailed = 10;
});
app.MapHealthChecks("/health");That answers "is a Hangfire server alive, and is the failed list growing?" It doesn't answer "did nightly-report run at 02:00?" A server can be healthy while one recurring job's registration was removed, its queue has no listener, or its type no longer loads. A health endpoint also needs something to poll it and alert, usually an uptime tool, and the failed-job count is shared by every job in the storage.
Use health checks for server liveness in your orchestrator (Kubernetes probes, load balancer checks). Don't count on them for per-job schedules.
Sentry Crons for Hangfire#
If the team already uses Sentry, its .NET SDK includes a Hangfire filter. You enable it with UseSentry() and give each job you want monitored a monitor slug (Sentry Hangfire Crons):
using Hangfire;
using Sentry.Hangfire;
// Assumes the Sentry .NET SDK is already initialized.
builder.Services.AddHangfire(configuration => configuration
.UseSentry());
public class ReportJobs
{
[SentryMonitorSlug("nightly-report")]
public void SendNightlyReport() => Console.WriteLine("Sending nightly report");
}Strengths: check-ins land next to the exceptions and traces Sentry already captures, and Sentry.Hangfire is widely used (about 667,000 NuGet downloads in total when checked). Trade-offs:
- Opt-in per job. A job without
[SentryMonitorSlug]is not monitored, so a new recurring job is unwatched until someone remembers the attribute. - No registry view. The filter reports executions. Sentry's Hangfire page doesn't describe reading the recurring-job registry, so a job removed in a deploy isn't distinguished from a job that stopped.
- Pricing. Every Sentry plan includes one cron monitor; more come from a pay-as-you-go budget on paid plans, at $0.78 each per Sentry's pricing page.
Sentry Crons vs a dedicated cron monitor covers check-in settings, max runtime, and alerts in depth, and the Sentry Crons comparison puts the two side by side.
Cronitor and Other Heartbeat Services#
Cronitor has no official Hangfire package. A community package, Cronitor.Hangfire, existed with a few hundred downloads in total when checked, so evaluate its maintenance before depending on it. Without it, any heartbeat service works the same way: call its ping URL at the end of each job method, or from a job filter you write yourself. Healthchecks.io, Better Stack, and Dead Man's Snitch all fit this pattern, each with one check per job that you create and keep in sync with the code by hand.
A hand-written filter is less code than it sounds, and it's a good way to see what any monitor needs from Hangfire. This one reports success and terminal failure for every recurring job to a generic heartbeat URL:
using Hangfire.Common;
using Hangfire.States;
using Hangfire.Storage;
public sealed class HeartbeatFilter : JobFilterAttribute, IApplyStateFilter
{
private static readonly HttpClient Http = new() { Timeout = TimeSpan.FromSeconds(5) };
public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
{
var recurringJobId = context.Connection.GetJobParameter(context.BackgroundJob.Id, "RecurringJobId");
if (string.IsNullOrEmpty(recurringJobId)) return;
// Hangfire stores the parameter as JSON, so the ID arrives quoted.
var key = recurringJobId.Trim('"');
var outcome = context.NewState switch
{
SucceededState => "success",
FailedState => "fail",
_ => null,
};
if (outcome is null) return;
// Fire and forget: monitoring must never block or fail the state transition.
_ = Http.GetAsync($"https://heartbeat.example.com/{key}/{outcome}")
.ContinueWith(_ => { }, TaskContinuationOptions.OnlyOnFaulted);
}
public void OnStateUnapplied(ApplyStateContext context, IWriteOnlyTransaction transaction) { }
}Register it with GlobalJobFilters.Filters.Add(new HeartbeatFilter());. Notice what's still missing: each heartbeat check has to exist on the service with the right schedule, a new job isn't watched until someone creates its check, and a removed job's check keeps alerting until someone deletes it. That bookkeeping is what the next option automates.
CronRadar.Hangfire#
CronRadar is a monitor for scheduled jobs only. Its Hangfire package reads the recurring-job registry, so names and schedules come from the code that already declares them (Hangfire integration guide). Store the application key as CRONRADAR_API_KEY and add one call after AddHangfire():
dotnet add package CronRadar.Hangfireusing CronRadar.Hangfire;
using Hangfire;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHangfire(config => config
.UseSqlServerStorage(builder.Configuration.GetConnectionString("Hangfire")));
builder.Services.AddHangfireServer();
// Reads the application key from the CRONRADAR_API_KEY environment variable.
builder.Services.AddCronRadarHangfire();
var app = builder.Build();
app.Run();What it does, in CronRadar.Hangfire 0.2.1:
- Discovery. At startup it declares every recurring job and its cron expression, and reconciles the registry every 15 minutes through its own
cronradar:reconcilerecurring job. - Lifecycle. A server filter reports start, completion, and failure, so nothing goes inside job methods. A failure is reported only after Hangfire's automatic retries are exhausted, including cancellations.
- Missed and never-run jobs. Because monitors exist before the first run, a job that never runs alerts too, not only one that stops.
- Disappeared jobs. When a reconciliation no longer contains a recurring-job ID, CronRadar pauses that monitor and keeps its history instead of alerting forever or deleting it.
- Opt-out, not opt-in. Every job is monitored unless its method has
[SkipMonitor].
Limits to know: only recurring jobs are discovered, not one-time Enqueue or Schedule jobs; a job that succeeds on retry doesn't alert; and schedules are evaluated in the CronRadar application's time zone (UTC unless you set an IANA zone in the application's settings), so a recurring job registered with a different TimeZone should be checked against Hangfire's Next execution before you rely on missed-run alerts. Alerts go to email, Slack, webhook, Discord, or PagerDuty. See pricing for the free allowance and the per-monitor price.
Side by Side#
| Option | Per-job setup | Missed runs | Failures after retries | Stuck runs | Removed jobs |
|---|---|---|---|---|---|
| Hangfire dashboard | None | Visible, not alerted | Visible, not alerted | Visible | Silent |
| Health checks | None | Only if every server is down | Count across all jobs | No | Silent |
| Sentry Crons | [SentryMonitorSlug] |
Yes, for slugged jobs | Yes | Max runtime | Not distinguished |
| Heartbeat service + filter | A check per job | Yes, if the check exists | Yes, with your filter | With start pings | Check keeps alerting |
| CronRadar.Hangfire | None ([SkipMonitor] to opt out) |
Yes, including never-ran | Yes | Yes | Monitor paused |
Which to Choose#
- A handful of jobs and Sentry already in place: Sentry Crons is the least new infrastructure. Add the attribute to every recurring job and a code-review rule so new ones don't slip through.
- Server liveness for the orchestrator: health checks, in addition to whichever per-job monitor you pick.
- Many recurring jobs, or jobs added and removed often: a registry-driven monitor saves keeping a second list in sync. That is the case CronRadar.Hangfire is built for; the Hangfire page and the .NET overview summarize it.
- Plain .NET scheduled work outside Hangfire: the base
CronRadarSDK wraps any method withWrapAsync; Hangfire vs Quartz.NET vs BackgroundService covers when Hangfire is the right scheduler at all.
Frequently Asked Questions#
Does Hangfire send alerts when a job fails?#
No. Hangfire records failures in storage and shows them on the dashboard's Failed page, and its AutomaticRetry filter retries up to 10 times by default. Alerting needs a filter of your own or a monitoring package that hooks into state changes and notifies someone.
Can a health check tell me a recurring job didn't run?#
Not for a single job. The Hangfire health check reports server count and failed-job count across the whole storage. A recurring job whose registration was removed, or whose queue no server listens on, leaves both numbers healthy. Per-job schedule checks need a monitor that knows each job's cron expression.
Do I need an attribute on every Hangfire job to monitor it?#
With Sentry Crons, yes: each monitored job needs [SentryMonitorSlug]. With CronRadar.Hangfire, no: it reads the recurring-job registry and monitors every job, and [SkipMonitor] opts one out. A hand-rolled heartbeat filter can cover all jobs, but you still create a check for each one on the heartbeat service.
How do I find out when a recurring job is removed from Hangfire?#
Compare the registry with what it held before. You can list entries with JobStorage.Current.GetConnection().GetRecurringJobs() and diff them in a deploy step, or use a monitor that reconciles the registry. CronRadar.Hangfire does this every 15 minutes and pauses the monitor of a job that disappeared, keeping its history.
Put this guide to work
Connect your Hangfire job to monitoring
Follow the current integration guide, check the release limitations, and verify a real run and alert delivery.
NuGet installs CronRadar.Hangfire 0.2.2. Failures are reported only after Hangfire finishes retrying, including cancellations. Discovered monitors start with a 60-second grace period unless the code sets another; a grace period or schedule edited in the dashboard stays until the code declares a different value.