DEV Community: Gabrian Mak

Turn a missed cron into a GitHub or Linear ticket

Gabrian Mak — Mon, 24 Aug 2026 17:14:16 +0000

Email is a bad place for “the backup never ran.”

You get the Down ping, maybe a Slack message, then it scrolls off. The job that failed is sitting next to a GitHub repo or a Linear team. That is where someone actually closes work.

Gonewatch now opens a ticket when a monitor misses its window — GitHub Issues or Linear — instead of only sending chat.

Chat vs ticket

Slack, Discord, and Telegram are “look at this.” A ticket is “this is work.”

Same heartbeat as before: the job POSTs when it succeeds. If the window is missed, Gonewatch marks the monitor Down. With tickets on:

Down opens one issue (Down · nightly-backup), labeled gonewatch. Body has the schedule, last heartbeat, and a link to the monitor. JSON payloads stay on the dashboard — they are not dumped into the ticket.
Reminders comment on that same issue. If you closed it while the job is still Down, Gonewatch reopens it (GitHub) or moves it back to an open state (Linear) and comments.
Recovery comments that it is Up, closes it (GitHub) or marks it Done (Linear), and stops tracking it. The next miss opens a new issue.

Reminders do not spam a new ticket every hour.

GitHub Issues vs the heartbeat Action

Two different GitHub pieces:

gonewatch/heartbeat@v1 — last step of a workflow. POSTs that the job ran.
GitHub App on Account — opens Issues in one repo when a monitor is Down. Issues write + metadata read. It does not read your code.

You can use both. The Action is the ping. The App is the ticket.

Linear is the same ticket loop in one team. Issues are created as the Gonewatch app, in that team’s first Todo state so they show under Active.

Setup

GitHub

Gonewatch → Account → Connect GitHub.
Install the app on one repository.
Check connection (this does not open a test issue).
Edit the monitor → enable GitHub Issues.

Linear

Account → Connect Linear → approve the app.
Pick one team.
Check connection.
Enable Linear on the monitor.

Connecting does not turn tickets on for monitors you already have. One repo / one team per Gonewatch account. GitHub and Linear will not email you unless you already watch that repo or team.

Free is still email only. Tickets are Basic and Pro, same as Slack.

A backup that files its own bug

- name: Gonewatch heartbeat
  if: success()
  uses: gonewatch/heartbeat@v1
  with:
    url: ${{ secrets.GONEWATCH_URL }}

If tonight’s workflow never reaches that step, there is no ping, the monitor goes Down, and you get Down · production-db-backup in the repo (or LIN-123 in the team) instead of hoping someone saw the email.

Docs: GitHub Issues and Linear tickets. Product: gonewatch.com.

Don't just ping that the backup ran — send how long it took

Gabrian Mak — Thu, 20 Aug 2026 14:31:01 +0000

A heartbeat tells you the job ran. It does not tell you the dump took 3 minutes last week and 47 minutes tonight.

I already POSTed after a successful backup. Adding a small JSON body on that same request was enough to keep duration and size next to the ping — without standing up metrics infra.

Empty POST still counts. JSON is optional. Nested objects and log blobs are dropped on purpose. This is not log storage.

Ping only on success, with a few scalars

# After backup.sh succeeds
curl -fsS -X POST https://www.gonewatch.com/api/heartbeat/YOUR_TOKEN \
  -H "Content-Type: application/json" \
  -d '{"duration_ms":184320,"bytes":2147483648,"tables":42}'

Keys are yours. Typical ones from real jobs:

duration_ms — how long the run took
bytes — how big the artifact was
tables / rows / failed — whatever you already print at the end of the script
Same idea in Node or Python: POST JSON, top-level numbers and strings only.

What you get

Last values on the monitor, plus a sparkline for each numeric field.

duration_ms shows as time (184320 → 3m 4s). bytes shows as size (2147483648 → 2 GB). Other numbers stay grouped digits.

If a key is nested, an array, or too large, that key is ignored. The ping still records. The job is still “up.”

What not to send

Stdout, HTML, the backup file, PII, secrets. Keep the heartbeat URL itself secret — it is the credential.

One URL per job still holds. Dump, file sync, and offsite copy are three different stories. Mixing them into one payload will not tell you which part got slow.

Where I put it

I wired this into Gonewatch so the same monitor that alerts on silence also keeps last values and charts. Free to start.

Get emailed if a cron job never ran

Gabrian Mak — Wed, 19 Aug 2026 15:54:55 +0000

A cron that never starts cannot email you. I found that out the hard way with a nightly database backup. I ended up hardcoding a ping that only fired after the dump finished. If the ping never showed up, the backup did not happen. Silent failure. No email from the job itself.

Same class of bugs: crontab removed in a deploy, the box down at 2am, a lock file that never cleared, a script that exited before it did the real work.

The pattern
Do not wait for the job to report failure. Expect a heartbeat after success. If the next one never arrives, that is the failure.

This is not uptime monitoring. You are not polling a public URL. The job tells you it ran.

Ping only when the script actually succeeded:
# Nightly job at 2:00 AM — ping only if backup.sh succeeded 0 2 * * * /usr/local/bin/backup.sh && curl -fsS -X POST https://www.gonewatch.com/api/heartbeat/YOUR_TOKEN
&& matters. A failed dump should not look healthy.

One URL per job. Database dump, file sync, and offsite copy are three different things. If you fold them into one ping, you will not know which part died.

Give yourself a grace window. A dump that runs 20 minutes late is not the same as a dump that never ran. Tune grace to how late the job can be without it being a problem.

GitHub Actions
GitHub emails a failed run. It does not email a scheduled workflow that never started. Last step, success only:
- name: Heartbeat if: success() run: curl -fsS -X POST "$HEARTBEAT_URL" env: HEARTBEAT_URL: ${{ secrets.HEARTBEAT_URL }}

What I wrapped it in
I got tired of maintaining that ping by hand, so I put it in Gonewatch. Same idea: create a monitor, paste the curl (or a tiny GitHub Action), get emailed if the ping stops. Free to start, no credit card.