Heartbeat & cron monitoring

Get alerted when a scheduled job stops pinging.

Your job reports in. Silence is the alert.

  • Every other check reaches out to your systems. A heartbeat waits for yours to reach in. The monitor gets a ping URL, your job calls it when it finishes, and silence is the failure signal.

    That inversion is the point: it's the only way to watch something with no address. A cron job on a box behind a firewall, a nightly backup, a queue worker, a container that wakes up once an hour. None of them have a URL to probe, and all of them can call one.

  • You declare how often the ping should arrive, and a grace buffer for the run that goes long. Miss both and the monitor goes down: the deadline is the last ping plus the interval plus the grace.

    Set the grace to your job's worst normal night, not its average one. A backup that usually takes five minutes and sometimes twenty wants a grace that covers twenty, or you'll be woken by a job that was going to finish anyway.

  • Put the ping at the end of the job and behind a success condition. && in a shell, if: success() in CI. A job that pings when it starts is a job that reports healthy while it crashes.

    A new heartbeat sits waiting until its first ping arrives, so wire the call in right after you create it. Until then there's nothing to be late.

Call the URL when the job finishes

Any method works, GET or POST, and there's no auth and no body. The URL is the whole secret, so treat it like one.

Everything around the check.

Tune it when the defaults aren't right.

Interval, slow threshold, timeout, failure streak, redirects, SSL and domain expiry. Every knob the create form has, with a sane default on each.

Alerts on the change, not every minute.

Once when it breaks, once when it recovers, to Slack, Discord, a webhook, email, or your phone. A confirmation streak holds back the blips.

A status page your users can read.

Every monitor can back a public status page with ninety days of history, on your own domain, so the question answers itself.

Every outage, written down as it happens.

A confirmed failure opens an incident and keeps the timeline, detected to resolved. The first half of the post-mortem writes itself.

Planned downtime that pages no one.

Schedule a window and the monitors it covers stop being checked, so nothing alerts, no incident opens, and the time is left out of your uptime.

Everything else you can watch.

HTTP / Website, Keyword, API, Scheduler, DNS, and Port. Every one reports up, slow, or down, on the same interval, into the same alerts.

Heartbeat questions

When the last ping plus the interval plus the grace passes with no new ping. Before the first ping ever arrives, that clock runs from when you created the monitor.

The run that goes long. It defaults to 60 seconds. Set it to your job's worst normal runtime, so a slow night isn't a false alarm.

Either. GET and POST both count, there's no auth and no body, so a plain curl at the end of the job is enough.

No. Ping at the end and only on success, behind && in a shell, or if: success() in CI. A ping at the start reports healthy for a job that then crashes.

Know the second it breaks

Free to start. No credit card.