What is cron job monitoring?

Cron job monitoring is the practice of tracking whether your scheduled tasks run on time, complete successfully, and perform within expected parameters. It alerts you when jobs fail, run late, or take too long — preventing silent failures that can cause data loss, missed reports, or broken workflows.

Why do cron jobs fail silently?

Cron jobs fail silently because they run in the background without user interaction. By default, cron only sends output to local mail (which is rarely checked). If a job crashes, times out, or produces wrong results, nobody knows until downstream effects are noticed — sometimes hours or days later.

What is the best way to monitor cron jobs?

The most reliable method is heartbeat monitoring (also called dead man's switch). Your cron job pings an external service when it runs. If the ping doesn't arrive on schedule, you get an alert. This catches failures, crashes, and server issues that log-based monitoring would miss.

How does heartbeat monitoring work?

Heartbeat monitoring works on a "dead man's switch" principle: your cron job sends an HTTP ping to a monitoring service after each successful run. The service expects this ping on your job's schedule. If the ping doesn't arrive within the expected window (plus a grace period), it triggers an alert.

Can I monitor cron jobs for free?

Yes. You can set up basic monitoring with email notifications or log checking scripts at no cost. For heartbeat monitoring, Healthchecks.io offers a free tier with 20 checks. CronRadar offers a 14-day free trial with all features. For production workloads, a dedicated monitoring service is recommended.

How do I monitor cron jobs in Docker or Kubernetes?

For Docker, add a curl/wget ping at the end of your entrypoint script. For Kubernetes CronJobs, add a sidecar container or init container that pings your monitoring service. CronRadar and similar tools work with any environment that can make HTTP requests.

What should I do when a cron job fails?

When alerted to a cron job failure: 1) Check the job's logs for error messages, 2) Verify the server/container is running, 3) Check for resource issues (disk, memory, CPU), 4) Try running the job manually, 5) Fix the root cause and verify the next scheduled run succeeds. Having lifecycle monitoring (start/success/fail) makes diagnosis much faster.

How to Monitor Cron Jobs: A Complete Guide

Learn the 5 proven methods to monitor cron jobs, from simple email alerts to framework-native integrations. Includes code examples for Bash, Python, Node.js, PHP, Laravel, Hangfire, and Celery.

Last updated: December 2025 • 12 min read

Why Monitor Cron Jobs?

Cron jobs fail silently. Without monitoring, you won't know until it's too late.

Silent Failures

A cron job that crashes produces no output. If your nightly backup fails, you won't know until you need that backup — when it's too late. Monitoring catches failures immediately.

Schedule Drift

Server reboots, timezone changes, or crontab edits can silently change when jobs run — or stop them entirely. Monitoring detects when jobs don't run on schedule.

Runtime Degradation

A job that takes 5 minutes today might take 50 minutes next month as data grows. Duration monitoring catches performance degradation before jobs start overlapping or timing out.

Compliance & Auditing

Many industries require proof that scheduled processes run correctly. Monitoring provides an audit trail of job execution times, durations, and outcomes.

5 Methods to Monitor Cron Jobs

From basic to advanced — choose the right approach for your needs

Email Notifications (Basic)

The simplest approach: pipe cron output to email. Cron has built-in support for mailing output via the MAILTO variable.

crontab

MAILTO="team@example.com"

# Sends stdout/stderr to team@example.com
0 2 * * * /usr/local/bin/backup.sh

# Only email on failure (suppress stdout)
0 2 * * * /usr/local/bin/backup.sh > /dev/null

Limitation: Email monitoring only tells you when jobs produce output or errors. It does not alert you when a job fails to run at all (the most dangerous failure mode). If the server is down or cron daemon stops, no email is sent.

Log File Monitoring

Write job output to log files and use a log monitoring tool (like Loki, Datadog, or ELK) to detect errors and missing log entries.

crontab

# Log output with timestamps
0 2 * * * /usr/local/bin/backup.sh >> /var/log/cron/backup.log 2>&1

# Check logs for errors
grep -i "error|fail" /var/log/cron/backup.log

Limitation: Like email, log monitoring can't detect jobs that never ran. You need to check for the absence of a log entry, which is harder to implement reliably.

Heartbeat Monitoring (Recommended)

The most reliable method. Your cron job pings an external monitoring service after each run. If the ping doesn't arrive on schedule, you get an alert. This catches all failure modes: crashes, server outages, crontab misconfigurations, and more.

crontab (with heartbeat)

# Ping monitoring service after successful completion
0 2 * * * /usr/local/bin/backup.sh && curl -s https://cron.life/ping/nightly-backup

Why this is best: Heartbeat monitoring uses an "inverse" approach — instead of detecting errors, it expects a success signal. No signal = problem. This catches server outages, daemon failures, and any issue that prevents the job from running at all.

Wrapper Scripts

Wrap your cron job in a script that tracks start time, exit code, duration, and sends results to a monitoring endpoint. Combines logging with heartbeat monitoring.

cronwrap.sh

#!/bin/bash
# Wrapper script: tracks duration, exit code, sends heartbeat
JOB_NAME="$1"
shift

# Signal start
curl -s "https://cron.life/ping/$JOB_NAME/start" \
  -H "Authorization: Bearer $CRONRADAR_API_KEY"

# Run the actual job
START=$(date +%s)
"$@"
EXIT_CODE=$?
DURATION=$(($(date +%s) - START))

# Signal completion or failure
if [ $EXIT_CODE -eq 0 ]; then
  curl -s "https://cron.life/ping/$JOB_NAME" \
    -H "Authorization: Bearer $CRONRADAR_API_KEY"
else
  curl -s "https://cron.life/ping/$JOB_NAME/fail" \
    -H "Authorization: Bearer $CRONRADAR_API_KEY"
fi

Usage in crontab

0 2 * * * /usr/local/bin/cronwrap.sh nightly-backup /usr/local/bin/backup.sh

Dedicated Monitoring Service

Use a purpose-built cron monitoring tool like CronRadar, Healthchecks.io, or Cronitor. These combine heartbeat monitoring with dashboards, alerting, team collaboration, and framework integrations.

Best for production: Dedicated services offer the most reliable monitoring with the least maintenance. Features like auto-discovery, grace periods, and multi-channel alerting make them ideal for production workloads.

Try CronRadar Free Compare All Tools

Implementing Heartbeat Monitoring

Code examples in popular languages

Bash / curl

The simplest integration. Add a curl command to any cron job.

bash

#!/bin/bash
# Simple: ping on success
/usr/local/bin/backup.sh && \
  curl -fsS --retry 3 https://cron.life/ping/nightly-backup \
    -H "Authorization: Bearer $CRONRADAR_API_KEY"

# Advanced: lifecycle tracking (start + success/fail)
curl -fsS https://cron.life/ping/nightly-backup/start \
  -H "Authorization: Bearer $CRONRADAR_API_KEY"

if /usr/local/bin/backup.sh; then
  curl -fsS https://cron.life/ping/nightly-backup \
    -H "Authorization: Bearer $CRONRADAR_API_KEY"
else
  curl -fsS https://cron.life/ping/nightly-backup/fail \
    -H "Authorization: Bearer $CRONRADAR_API_KEY"
fi

Python

Use the requests library or CronRadar's Python SDK.

python

import requests

API_KEY = "your-api-key"
BASE_URL = "https://cron.life/ping"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def run_with_monitoring(job_name: str, job_func):
    """Run a job with heartbeat monitoring."""
    # Signal start
    requests.get(f"{BASE_URL}/{job_name}/start", headers=HEADERS)
    try:
        job_func()
        # Signal success
        requests.get(f"{BASE_URL}/{job_name}", headers=HEADERS)
    except Exception as e:
        # Signal failure
        requests.get(f"{BASE_URL}/{job_name}/fail", headers=HEADERS)
        raise

# Usage
run_with_monitoring("data-sync", lambda: sync_database())

Node.js

Use the built-in fetch API or CronRadar's Node.js SDK.

javascript

const API_KEY = process.env.CRONRADAR_API_KEY;
const BASE_URL = "https://cron.life/ping";

async function runWithMonitoring(jobName, jobFn) {
  const headers = { Authorization: `Bearer ${API_KEY}` };

  // Signal start
  await fetch(`${BASE_URL}/${jobName}/start`, { headers });

  try {
    await jobFn();
    // Signal success
    await fetch(`${BASE_URL}/${jobName}`, { headers });
  } catch (error) {
    // Signal failure
    await fetch(`${BASE_URL}/${jobName}/fail`, { headers });
    throw error;
  }
}

// Usage
await runWithMonitoring("send-reports", async () => {
  await generateAndSendReports();
});

PHP

Use file_get_contents or cURL for HTTP pings.

php

<?php
$apiKey = getenv('CRONRADAR_API_KEY');
$baseUrl = 'https://cron.life/ping';

function pingMonitor(string $jobName, string $event = ''): void {
    global $apiKey, $baseUrl;
    $url = "$baseUrl/$jobName" . ($event ? "/$event" : '');
    $context = stream_context_create([
        'http' => [
            'header' => "Authorization: Bearer $apiKey",
            'timeout' => 5,
        ]
    ]);
    @file_get_contents($url, false, $context);
}

// Usage
pingMonitor('invoice-generation', 'start');
try {
    generateInvoices();
    pingMonitor('invoice-generation');
} catch (Exception $e) {
    pingMonitor('invoice-generation', 'fail');
    throw $e;
}

Framework-Specific Monitoring

One-line setup for popular frameworks

If you use one of these frameworks, you can monitor all scheduled tasks with a single line of code using CronRadar's framework packages.

LaravelView SDK →

// In App\Console\Kernel.php
protected function schedule(Schedule $schedule)
{
    // Auto-discover ALL scheduled tasks
    $schedule->monitorAll();

    $schedule->command('reports:send')
        ->daily();
    $schedule->command('backups:run')
        ->hourly();
    // All tasks above are auto-monitored
}

Hangfire (.NET)View SDK →

// In Startup.cs or Program.cs
services.AddHangfire(config => config
    .UseSqlServerStorage(connectionString)
);

// One line monitors all recurring jobs
services.AddCronRadar(options => {
    options.ApiKey = "your-api-key";
}).MonitorAll();

Celery (Python)View SDK →

from cronradar_celery import setup_cronradar

app = Celery('myapp')

# Auto-discover all Celery Beat tasks
setup_cronradar(app, mode='all')

@app.task
def send_daily_report():
    # This task is auto-monitored
    generate_report()

Quartz.NETView SDK →

// In your scheduler setup
var scheduler = await StdSchedulerFactory
    .GetDefaultScheduler();

// Monitor all Quartz.NET triggers
scheduler.AddCronRadar(options => {
    options.ApiKey = "your-api-key";
}).MonitorAll();

await scheduler.Start();

Monitoring Methods Compared

Choose the right approach for your use case

Method	Detects Failures	Detects Non-Runs	Setup Effort	Cost
Email (MAILTO)	Partial	No	Minimal	Free
Log Monitoring	Yes	Difficult	Medium	Varies
Heartbeat Service	Yes	Yes	Easy	$1-5/monitor
Wrapper Scripts	Yes	Yes	Medium	Free + service
Dedicated Service	Yes	Yes	Easy	$1-200/mo