Celery Beat Monitoring Tools Compared: Flower, Sentry, Cronitor, CronRadar
Contents
Worker monitoring tells you about tasks that ran. Celery beat problems are mostly about tasks that didn't: beat stopped, beat sent to a queue no worker reads, or the schedule it loaded isn't the one you wrote. Only a check that knows each periodic task's schedule and alerts on silence catches those. Sentry Crons, Cronitor, and CronRadar all read the beat schedule and do this with one setup call; Flower and Prometheus exporters show worker activity but don't know when a periodic task was due. This comparison covers Celery 5.x. Vendor facts were checked against each vendor's documentation on November 16, 2026.
The Failures a Beat Monitor Has to Catch#
| Failure | Seen by worker metrics? | Seen by a schedule monitor? |
|---|---|---|
| Beat process stopped or never deployed | No, workers look idle | Yes, nothing arrives |
| Beat sends to a queue no worker consumes | Queue length grows | Yes |
| Task raises and retries are exhausted | Yes | Yes, with failure reporting |
| Task hangs | Active task count | Yes, with start reports |
| Two beat processes send every task twice | Higher task counts | Duplicate runs in history |
| Schedule changed in code or the database | No | Depends on discovery |
Celery beat not running works through each cause and how to confirm it.
Flower and Prometheus#
Flower is the standard real-time view of workers and tasks: which tasks ran, how long they took, which failed, and what each worker is doing. It needs events enabled (celery -A proj worker -E) and shows what happened, not what should have. It doesn't alert, and since beat doesn't run tasks itself, a stopped beat process just makes Flower quiet.
Prometheus exporters, including Flower's own /metrics endpoint, turn the same events into counters you can alert on: failure rates, queue length, worker count. A rule such as "no send_daily_report success in 26 hours" is possible in principle, but you write and maintain one per task, and it fails silently if the exporter stops scraping. Monitor cron jobs with Prometheus shows the pattern and its blind spots.
Keep both for worker health. Neither is a beat monitor.
Sentry Crons#
Sentry's Celery integration can monitor beat tasks automatically (Celery Crons):
import sentry_sdk
from celery import Celery, signals
from sentry_sdk.integrations.celery import CeleryIntegration
app = Celery("proj", broker="redis://localhost:6379/0")
@signals.beat_init.connect
@signals.celeryd_init.connect
def init_sentry(**kwargs):
sentry_sdk.init(
dsn="https://[email protected]/0",
integrations=[CeleryIntegration(monitor_beat_tasks=True)],
)Sentry initializes in both the beat and worker processes when they're separate. What its docs say:
- Coverage. Every beat task, with
exclude_beat_taskstaking names or regular expressions to leave some out. - Schedulers. The default beat scheduler and RedBeat are documented. django-celery-beat isn't mentioned on that page.
- Schedules. "Only schedules that can be parsed by crontab will be successfully updated or inserted," so interval schedules aren't covered there.
- Creation. "A cron monitor will only be created the first time your task runs," so a task that never runs once isn't known to Sentry.
- No double instrumentation. Don't also use the
@sentry_sdk.monitordecorator on the same tasks.
Strong if Sentry is already your error tracker, since a failing task's exception lands next to its check-in. Every plan includes one cron monitor; more are $0.78 each from a paid plan's pay-as-you-go budget (pricing). See the Sentry Crons comparison.
Cronitor#
Cronitor's Python SDK discovers Celery tasks with one call (cronitor-python):
import cronitor.celery
from celery import Celery
app = Celery("proj", broker="redis://localhost:6379/0")
cronitor.celery.initialize(app, api_key="apiKey123")Its README says it discovers declared Celery tasks, including beat-scheduled ones, creates monitors for them, and pings when they run, succeed, or fail. It also says: tasks on solar schedules are ignored, the beat integration overrides the default celerybeat-schedule database when you use the default PersistentScheduler, and django-celery-beat "is not yet supported, but is in the works." Cronitor's free plan covers 5 monitors, with paid monitors priced per monitor plus per user. The Cronitor comparison has the details.
CronRadar#
CronRadar is a monitor for scheduled jobs only. The cronradar-celery package (0.1.1) reads app.conf.beat_schedule at worker and beat startup, declares each periodic task with its schedule, and records start, completion, and failure through Celery's task_prerun, task_success, and task_failure signals (Celery integration guide):
pip install cronradar-celeryfrom celery import Celery
from celery.schedules import crontab
from cronradar_celery import setup_cronradar, skip_monitor
app = Celery("proj", broker="redis://localhost:6379/0")
app.conf.beat_schedule = {
"send-daily-report": {
"task": "tasks.send_daily_report",
"schedule": crontab(hour=8, minute=0),
},
}
# Reads the application key from the CRONRADAR_API_KEY environment variable.
setup_cronradar(app)
@app.task
def send_daily_report():
print("Sending the daily report")
@app.task
@skip_monitor
def internal_cleanup():
print("Not monitored")What to expect:
- Every beat task by default.
@skip_monitorgoes under@app.taskto opt one out. - Schedules.
crontab(...)entries are translated to five-field cron.schedule(timedelta(...))intervals, cron strings,solar(...)and sub-minute schedules have no exact five-field form, so they log a warning and stay unmonitored. - Never-ran tasks. Because tasks are declared at startup, a periodic task that never runs once still alerts after its first expected time plus grace.
- Time zones. CronRadar evaluates schedules in the CronRadar application's IANA time zone (UTC if unset). Set it to your Celery
timezonesetting, or keep both in UTC, socrontab(hour=8)means the same 08:00 on both sides. - django-celery-beat. Not discovered: the package reads only
app.conf.beat_schedule, notPeriodicTaskrows. For database-defined tasks, report from inside the task with the basecronradarSDK (with cronradar.job("key", schedule="0 8 * * *"):) or over HTTP.
Alerts go to email, Slack, webhook, Discord, or PagerDuty; see pricing. The Celery page and Python overview summarize the integrations.
Side by Side#
| Option | Setup | Discovers beat schedule | Alerts on silence | Before first run | django-celery-beat |
|---|---|---|---|---|---|
| Flower | Run Flower, enable events | No | No | No | Shows runs only |
| Prometheus | Exporter plus rules per task | No | With per-task rules | No | Shows runs only |
| Sentry Crons | monitor_beat_tasks=True |
Yes, crontab schedules | Yes | No | Not documented |
| Cronitor | cronitor.celery.initialize |
Yes, except solar | Yes | Not documented | Not yet supported (README) |
| CronRadar | setup_cronradar(app) |
Yes, crontab, interval, cron strings | Yes | Yes | Report explicitly per task |
Which to Choose#
- Sentry already in place, crontab schedules only:
monitor_beat_tasks=Trueis the smallest change. - Interval schedules, or tasks that may never run once: a monitor that declares tasks at startup covers both; that's what cronradar-celery does.
- django-celery-beat: none of the hosted integrations above documents reading
PeriodicTaskrows today. Wrap each task with an explicit check-in that carries its schedule, and review those keys when someone edits a schedule in the admin. - Always: keep Flower or an exporter for worker health. A beat monitor tells you a task is late; worker metrics help explain why.
Frequently Asked Questions#
How do I know if Celery beat stopped?#
Beat stopping doesn't raise an error anywhere: workers just receive no periodic tasks. Watch the tasks themselves with a monitor that knows each schedule and alerts when a run doesn't arrive. A process supervisor or container restart policy keeps beat running, but only an outside schedule check tells you it actually sent the tasks.
Does Flower alert when a periodic task fails?#
No. Flower shows task state, history, and worker status in real time and exposes Prometheus metrics, but it doesn't send notifications. Alerting needs Prometheus rules on its metrics or a separate monitor.
Can Sentry monitor django-celery-beat tasks?#
Sentry's Celery Crons page documents the default beat scheduler and RedBeat and doesn't mention django-celery-beat. Sentry's manual @sentry_sdk.monitor decorator works inside any task, wherever its schedule is stored, as long as you give it the monitor slug and configuration.
Which Celery schedules can be monitored as cron?#
Any crontab(...) entry, and intervals that map onto cron, such as every 15 minutes or every hour. solar(...) schedules depend on sunrise and sunset for a location and have no cron form, and sub-minute intervals are finer than cron's minute resolution. Monitor those with explicit check-ins and an interval-style grace period instead.
Put this guide to work
Connect your Celery job to monitoring
Follow the current integration guide, check the release limitations, and verify a real run and alert delivery.
PyPI installs cronradar-celery 0.1.3, which discovers beat-scheduled crontab tasks. Interval, solar and plain cron-string schedules are skipped with a warning.