Why Your Cron Monitor Alerts an Hour Early or Late: Time Zones
Contents
A cron monitor that alerts at the wrong hour is almost always reading the job's schedule in a different time zone than the scheduler does. The cron expression is the same in both places, but 0 9 * * * in New York and 0 9 * * * in UTC are different instants, so the monitor expects the run four or five hours away from when it happens. The fix is to make both sides use one zone: set the monitor's zone to the scheduler's, or put both on UTC.
This guide covers crontab (cronie, Debian, BusyBox), systemd timers, Kubernetes CronJobs, Hangfire 1.8, Quartz.NET, Celery 5, and Laravel 10 to 13, and CronRadar's handling of zones, checked November 16, 2026. How each scheduler picks its own zone is covered in depth in cron time zones; this post is about the monitor's side.
Read the Symptom#
The pattern of false alerts tells you what's wrong:
| What happens | Likely cause |
|---|---|
| Every run alerts as late, then recovers a fixed number of hours later | Monitor and scheduler in zones with a constant offset |
| Alerts start or stop in March, or in late October or early November | One side observes daylight saving time and the other doesn't |
| Off by exactly one hour, half the year | Monitor on a fixed offset or UTC conversion, job on local time |
| A false alert or a missed alert only on transition nights | The two sides treat skipped or repeated hours differently |
| The monitor never expects runs, or expects them in UTC unexpectedly | Misspelled or unset zone that silently fell back to UTC |
With a heartbeat monitor, an early expectation shows as a late run: the monitor expects the job at 09:00 UTC, the job runs at 09:00 New York time (13:00 or 14:00 UTC), and in between the monitor goes warning and then critical. When the run arrives, it recovers, so you get an alert and a recovery every day. A late expectation is quieter and worse: the monitor doesn't expect the run until hours after it was due, so a run that never happens is reported hours late.
Why the Two Sides Disagree#
A cron expression has no zone of its own. Each system that reads it applies a zone from somewhere else:
- The scheduler reads it in the zone of the daemon, the host, the cluster's controller, or a per-job setting.
- The monitor reads it in whatever zone it's configured with, often UTC by default.
Converting the expression to UTC once doesn't solve it either. 0 9 * * * in New York is 0 13 * * * UTC in summer and 0 14 * * * UTC in winter, so any single UTC expression is an hour wrong for half the year. Workarounds like "send the earlier UTC time with an extra hour of grace" trade false alerts for slower ones. The clean answer is a monitor that evaluates the expression in the job's own IANA zone, so the conversion follows daylight saving rules the same way the scheduler does.
How CronRadar Reads Schedules#
CronRadar evaluates schedules in the application's time zone, an IANA name such as America/New_York set in the application's settings. An unset or unrecognized name means UTC, so a typo like America/NewYork can quietly make the application UTC. Check the name against the tz database list after setting it.
There is one zone per application. Jobs that run in different zones go in different applications, or are written in the application's zone. Since you should already use a separate application and API key per environment, a common layout is one application per environment and zone, such as billing-prod-utc and billing-prod-new-york.
Daylight saving transitions are handled by rule:
| Transition | Example (America/New_York) | CronRadar expects the run |
|---|---|---|
| Spring forward, time skipped | 30 2 * * * on March 14, 2027: 02:30 never exists |
At the first valid minute after the gap, 03:00 |
| Fall back, time repeated | 30 1 * * * on November 7, 2027: 01:30 happens twice |
Once, at the first 01:30 |
| Any other time | 0 9 * * * |
09:00 local, whatever the UTC offset |
Schedulers don't all agree with this, which is where transition-night alerts come from. Cron and daylight saving time traces each one. Two examples from it: Kubernetes CronJobs skip a run scheduled inside the spring-forward gap and run twice in the repeated hour, so CronRadar alerts that the 02:30 run is missing, which is true, and sees an extra run in November, which doesn't alert. Behavior varies between cron daemons too. If a transition-night alert would be noise, move the job out of the 01:00 to 03:00 window, or run it in UTC.
Where Each Scheduler Takes Its Zone#
Set the CronRadar application's zone to whatever the left column resolves to:
| Scheduler | Zone the schedule is read in | Where to set it |
|---|---|---|
| cronie | The daemon's zone, or CRON_TZ= for the lines below it |
System zone, then restart crond |
| Debian / Ubuntu cron | The daemon's zone; no CRON_TZ |
System zone, then restart cron |
| BusyBox crond | TZ in the daemon's environment |
The container image or entrypoint |
systemd OnCalendar= |
The system zone, unless the expression ends with a zone name | timedatectl, or OnCalendar=... Europe/Berlin |
| Kubernetes CronJob | .spec.timeZone, or kube-controller-manager's local zone without it |
.spec.timeZone on each CronJob |
| Hangfire 1.8 | RecurringJobOptions.TimeZone, UTC by default |
Per recurring job |
| Quartz.NET | The cron trigger's time zone, the server's local zone by default | InTimeZone(...) on the cron schedule builder |
| Celery beat | The app's timezone setting, UTC by default |
app.conf.timezone |
| Laravel scheduler | The task's ->timezone(), else schedule_timezone, else the app's timezone |
config/app.php or per task |
A few notes that matter for monitoring:
- Quartz.NET defaults to local time. A trigger built without
InTimeZonefollows the server's zone, so the same code runs at different instants on a UTC container and on a developer laptop. CronRadar.Quartz translates cron triggers to five-field form but doesn't convert hours between zones, so set the application's zone to the triggers' zone, or build every trigger withInTimeZone(TimeZoneInfo.Utc). - Hangfire defaults to UTC, so the default case already matches a UTC application. A job registered with a local
TimeZoneneeds an application in that zone. Hangfire cron expressions and time zones covers Windows versus IANA IDs, which matter when the Hangfire server runs on Windows. - Celery and Laravel apply one zone to most schedules, which maps cleanly onto one CronRadar application. A Laravel task with its own
->timezone()that differs from the rest needs its own application, or a schedule rewritten in the application's zone. - Crontab on a server follows the system zone, which can change when an image is rebuilt or a host is reprovisioned. Running servers on UTC and putting local times on the jobs that need them, as cron time zones recommends, makes this whole problem smaller.
A Checklist to Align Them#
- Find the scheduler's zone for each job, from the table above. For a crontab, check the daemon's environment, not your shell:
sudo cat /proc/$(pgrep -o -x cron || pgrep -o -x crond)/environ | tr '\0' '\n' | grep TZandtimedatectl. - Group jobs by zone. Most systems have one; anything that differs is a candidate for UTC or its own application.
- Set each CronRadar application's zone to the group's IANA name, copied from the scheduler's configuration rather than typed.
- Compare next runs. Take the scheduler's next fire time (
systemd-analyze calendar, a CronJob'slastScheduleTimeafter a run, the Hangfire dashboard, Laravel'sphp artisan schedule:list) and the monitor's next expected run, and confirm they're the same instant. - Check a transition date. For a local-zone job, compare the next runs across the next daylight saving change, and decide whether a job inside the 01:00 to 03:00 window should move.
- Re-check after infrastructure changes. A new base image, a rebuilt control plane, or a moved host can change a scheduler's default zone without touching the job.
Getting the Alerts Right#
Missed-run detection depends entirely on the expected time. After the expected time plus the grace period with no report, the monitor goes from warning to critical and alerts. With the zones aligned, that alert means what it says; with them misaligned, it fires every day for a job that's fine, and people learn to ignore it. A fail report alerts immediately and doesn't depend on zones at all.
Framework integrations take the schedule from the scheduler, so the expression always matches: Hangfire, Quartz.NET, Celery, and Laravel. The zone is the one thing to set by hand. For crontab, systemd, and Kubernetes, each job reports over HTTP with its schedule, as in cron dead man's switch. The schedule syntax page covers the accepted expressions.
Frequently Asked Questions#
Why does my cron monitor alert before the job has run?#
The monitor is evaluating the schedule in an earlier zone than the scheduler, often UTC against a job on local time. The monitor expects the run hours before it happens, alerts, and recovers when the run arrives. Set the monitor's zone to the scheduler's, or schedule the job in UTC.
Why are my alerts off by exactly one hour?#
One side follows daylight saving time and the other doesn't, typically a monitor given a fixed UTC conversion of a local-time job. The offset is right for half the year and an hour off for the other half. Use an IANA zone like Europe/London on both sides instead of a converted expression.
What happens to a monitored job on a daylight saving night?#
CronRadar expects a run whose local time is skipped at the first valid minute after the gap, and a run whose local time repeats once, at its first instance. Schedulers differ: some skip the run, some run twice. Jobs outside the 01:00 to 03:00 window aren't affected in zones that change at 02:00.
Can one CronRadar application monitor jobs in several time zones?#
Each application has one time zone. Put jobs from different zones in different applications, or write their schedules in the application's zone, which for local-time jobs means accepting a daylight saving shift.
What time zone does CronRadar use if I don't set one?#
UTC. An unrecognized name also means UTC, so a typo in the zone name quietly falls back. Check the application's next expected runs after setting it.
Put this guide to work
Know when the next run is missing
Connect one scheduled job, confirm a real completion, then verify the alert destination. Keep your existing scheduler in charge of running the work.