Cron Monitors

#!/bin/bash
PING_URL="https://app.flarewarden.com/ping/YOUR-TOKEN"

while true; do
    # Your process work here
    do_work

    # Send heartbeat
    curl -fsS -m 10 "$PING_URL" > /dev/null
    sleep 60
done

import time
import requests

PING_URL = "https://app.flarewarden.com/ping/YOUR-TOKEN"

while True:
    # Your process work here
    do_work()

    # Send heartbeat
    try:
        requests.get(PING_URL, timeout=10)
    except requests.RequestException:
        pass  # Don't let monitoring failures crash your process

    time.sleep(60)

const PING_URL = "https://app.flarewarden.com/ping/YOUR-TOKEN";

async function heartbeat() {
  try {
    await fetch(PING_URL, {
      signal: AbortSignal.timeout(10_000),
    });
  } catch {
    // Don't let monitoring failures crash your process
  }
}

// Send heartbeat every 60 seconds
setInterval(heartbeat, 60_000);

// Send first heartbeat immediately
heartbeat();

package main

import (
    "net/http"
    "time"
)

func main() {
    pingURL := "https://app.flarewarden.com/ping/YOUR-TOKEN"
    client := &http.Client{Timeout: 10 * time.Second}
    ticker := time.NewTicker(60 * time.Second)
    defer ticker.Stop()

    // Send first heartbeat immediately
    client.Get(pingURL)

    for range ticker.C {
        // Your process work here
        doWork()

        // Send heartbeat
        client.Get(pingURL)
    }
}

# Simple heartbeat — fire and forget after your job completes
curl -fsS --retry 3 https://app.flarewarden.com/ping/YOUR-UUID

# Full lifecycle with start/complete/fail signals
curl -fsS --retry 3 https://app.flarewarden.com/ping/YOUR-UUID/start

# ... your job runs here ...

# On success — report completion with structured metadata
curl -fsS --retry 3 -X POST \
  -H "Content-Type: application/json" \
  -d '{"message":"Processed 1,423 records","duration_ms":4200,"metadata":{"env":"prod","version":"2.1.0"}}' \
  https://app.flarewarden.com/ping/YOUR-UUID/complete

# On failure — report error details
curl -fsS --retry 3 -X POST \
  -H "Content-Type: application/json" \
  -d '{"message":"Connection refused","exit_code":1}' \
  https://app.flarewarden.com/ping/YOUR-UUID/fail

import requests
import time

PING_URL = "https://app.flarewarden.com/ping/YOUR-UUID"

def ping(endpoint="", data=None):
    try:
        requests.post(
            f"{PING_URL}{endpoint}",
            json=data,
            timeout=10,
        )
    except requests.RequestException:
        pass  # Don't let monitoring failures block your job

# Signal start
ping("/start")
start = time.monotonic()

try:
    # ... your job logic here ...

    duration_ms = int((time.monotonic() - start) * 1000)
    ping("/complete", {
        "message": "Processed 1,423 records",
        "duration_ms": duration_ms,
        "metadata": {"env": "prod"},
    })
except Exception as e:
    ping("/fail", {
        "message": str(e)[:1000],
        "exit_code": 1,
    })

const PING_URL = "https://app.flarewarden.com/ping/YOUR-UUID";

async function ping(endpoint = "", body = null) {
  try {
    await fetch(`${PING_URL}${endpoint}`, {
      method: "POST",
      headers: body ? { "Content-Type": "application/json" } : undefined,
      body: body ? JSON.stringify(body) : undefined,
      signal: AbortSignal.timeout(10_000),
    });
  } catch {
    // Don't let monitoring failures block your job
  }
}

async function runJob() {
  ping("/start");
  const start = Date.now();

  try {
    // ... your job logic here ...

    await ping("/complete", {
      message: "Processed 1,423 records",
      duration_ms: Date.now() - start,
      metadata: { env: "prod" },
    });
  } catch (err) {
    await ping("/fail", {
      message: err.message.slice(0, 1000),
      exit_code: 1,
    });
  }
}

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
    "time"
)

const pingURL = "https://app.flarewarden.com/ping/YOUR-UUID"

var client = &http.Client{Timeout: 10 * time.Second}

func ping(endpoint string, body any) {
    var buf bytes.Buffer
    if body != nil {
        json.NewEncoder(&buf).Encode(body)
    }
    req, _ := http.NewRequest("POST", pingURL+endpoint, &buf)
    if body != nil {
        req.Header.Set("Content-Type", "application/json")
    }
    resp, err := client.Do(req)
    if err == nil {
        resp.Body.Close()
    }
}

func main() {
    ping("/start", nil)
    start := time.Now()

    err := runJob() // your job logic

    if err != nil {
        ping("/fail", map[string]any{
            "message":   err.Error(),
            "exit_code": 1,
        })
        return
    }

    ping("/complete", map[string]any{
        "message":     "Processed 1,423 records",
        "duration_ms": time.Since(start).Milliseconds(),
        "metadata":    map[string]string{"env": "prod"},
    })
}

require "net/http"
require "json"
require "uri"

PING_URL = "https://app.flarewarden.com/ping/YOUR-UUID"

def ping(endpoint = "", body = nil)
  uri = URI("#{PING_URL}#{endpoint}")
  req = Net::HTTP::Post.new(uri)
  if body
    req["Content-Type"] = "application/json"
    req.body = body.to_json
  end
  Net::HTTP.start(uri.host, uri.port, use_ssl: true,
                  open_timeout: 5, read_timeout: 10) { |h| h.request(req) }
rescue StandardError
  # Don't let monitoring failures block your job
end

# Signal start
ping("/start")
start = Process.clock_gettime(Process::CLOCK_MONOTONIC)

begin
  # ... your job logic here ...

  duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).to_i
  ping("/complete", {
    message: "Processed 1,423 records",
    duration_ms: duration_ms,
    metadata: { env: "prod" },
  })
rescue => e
  ping("/fail", {
    message: e.message[0, 1000],
    exit_code: 1,
  })
end

<?php

define('PING_URL', 'https://app.flarewarden.com/ping/YOUR-UUID');

function ping(string $endpoint = '', ?array $body = null): void {
    $opts = ['http' => [
        'method'  => 'POST',
        'timeout' => 10,
        'ignore_errors' => true,
    ]];
    if ($body !== null) {
        $opts['http']['header']  = 'Content-Type: application/json';
        $opts['http']['content'] = json_encode($body);
    }
    @file_get_contents(PING_URL . $endpoint, false,
        stream_context_create($opts));
}

// Signal start
ping('/start');
$start = hrtime(true);

try {
    // ... your job logic here ...

    $durationMs = (int)((hrtime(true) - $start) / 1e6);
    ping('/complete', [
        'message'     => 'Processed 1,423 records',
        'duration_ms' => $durationMs,
        'metadata'    => ['env' => 'prod'],
    ]);
} catch (Throwable $e) {
    ping('/fail', [
        'message'   => mb_substr($e->getMessage(), 0, 1000),
        'exit_code' => 1,
    ]);
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class CronJob {
    static final String PING_URL = "https://app.flarewarden.com/ping/YOUR-UUID";
    static final HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(10))
        .build();

    static void ping(String endpoint, String json) {
        try {
            var rb = HttpRequest.newBuilder(URI.create(PING_URL + endpoint));
            if (json != null) {
                rb.header("Content-Type", "application/json")
                  .POST(HttpRequest.BodyPublishers.ofString(json));
            } else {
                rb.POST(HttpRequest.BodyPublishers.noBody());
            }
            client.send(rb.build(), HttpResponse.BodyHandlers.discarding());
        } catch (Exception ignored) {
            // Don't let monitoring failures block your job
        }
    }

    public static void main(String[] args) {
        ping("/start", null);
        long start = System.currentTimeMillis();

        try {
            // ... your job logic here ...

            long duration = System.currentTimeMillis() - start;
            ping("/complete", """
                {"message":"Processed 1,423 records",
                 "duration_ms":%d,
                 "metadata":{"env":"prod"}}
                """.formatted(duration));
        } catch (Exception e) {
            String msg = e.getMessage();
            if (msg != null && msg.length() > 1000) msg = msg.substring(0, 1000);
            ping("/fail", """
                {"message":"%s","exit_code":1}
                """.formatted(msg != null ? msg : "unknown error"));
        }
    }
}

using System.Net.Http.Json;
using System.Diagnostics;

const string PingUrl = "https://app.flarewarden.com/ping/YOUR-UUID";
using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };

async Task Ping(string endpoint = "", object? body = null)
{
    try
    {
        if (body is not null)
            await client.PostAsJsonAsync($"{PingUrl}{endpoint}", body);
        else
            await client.PostAsync($"{PingUrl}{endpoint}", null);
    }
    catch
    {
        // Don't let monitoring failures block your job
    }
}

// Signal start
await Ping("/start");
var sw = Stopwatch.StartNew();

try
{
    // ... your job logic here ...

    await Ping("/complete", new
    {
        message = "Processed 1,423 records",
        duration_ms = sw.ElapsedMilliseconds,
        metadata = new { env = "prod" },
    });
}
catch (Exception ex)
{
    await Ping("/fail", new
    {
        message = ex.Message.Length > 1000
            ? ex.Message[..1000]
            : ex.Message,
        exit_code = 1,
    });
}

Wrap your existing cron command with start and complete pings:

# Database backup — every day at 2 AM
# Pattern: start → run job → complete on success, fail on error
0 2 * * * /usr/bin/curl -fsS --retry 3 https://app.flarewarden.com/ping/YOUR-UUID/start && \
  /usr/local/bin/backup.sh && \
  /usr/bin/curl -fsS --retry 3 https://app.flarewarden.com/ping/YOUR-UUID || \
  /usr/bin/curl -fsS --retry 3 https://app.flarewarden.com/ping/YOUR-UUID/fail

# Quick job — heartbeat only, no start signal needed
*/15 * * * * /usr/local/bin/sync-cache.sh && /usr/bin/curl -fsS --retry 3 https://app.flarewarden.com/ping/YOUR-UUID

A reusable wrapper script with proper error handling:

#!/bin/bash
set -euo pipefail

PING_URL="https://app.flarewarden.com/ping/YOUR-UUID"

# Signal start
curl -fsS --retry 3 "$PING_URL/start"
START_TIME=$(date +%s%3N)

# Run the actual job, capture output and exit code
set +e
OUTPUT=$(/usr/local/bin/my-job.sh 2>&1)
EXIT_CODE=$?
set -e

END_TIME=$(date +%s%3N)
DURATION_MS=$(( END_TIME - START_TIME ))

if [ "$EXIT_CODE" -eq 0 ]; then
    # Signal success with duration
    curl -fsS --retry 3 -X POST \
      -H "Content-Type: application/json" \
      -d "{\"message\":\"Job completed\",\"exit_code\":0,\"duration_ms\":$DURATION_MS}" \
      "$PING_URL/complete"
else
    # Signal failure with truncated error output (max 1000 chars)
    MSG="${OUTPUT:0:900}"
    curl -fsS --retry 3 -X POST \
      -H "Content-Type: application/json" \
      -d "{\"message\":\"$MSG\",\"exit_code\":$EXIT_CODE,\"duration_ms\":$DURATION_MS}" \
      "$PING_URL/fail"
fi

Add pings to your container's command in the CronJob spec:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-report
spec:
  schedule: "0 6 * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: report
            image: myapp:latest
            env:
            - name: PING_URL
              valueFrom:
                secretKeyRef:
                  name: flarewarden
                  key: ping-url
            command:
            - /bin/sh
            - -c
            - |
              curl -fsS --retry 3 "$PING_URL/start"
              /app/generate-report && \
                curl -fsS --retry 3 "$PING_URL/complete" || \
                curl -fsS --retry 3 "$PING_URL/fail"
          restartPolicy: Never

Use an entrypoint wrapper in your Dockerfile:

# Dockerfile
FROM python:3.12-slim

ENV PING_URL="https://app.flarewarden.com/ping/YOUR-UUID"

RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

COPY my-job.py /app/my-job.py

CMD ["/bin/sh", "-c", "curl -fsS --retry 3 $PING_URL/start && python /app/my-job.py && curl -fsS --retry 3 $PING_URL/complete || curl -fsS --retry 3 $PING_URL/fail"]

Or with docker compose:

# docker-compose.yml
services:
  backup:
    image: myapp:latest
    environment:
      - PING_URL=https://app.flarewarden.com/ping/YOUR-UUID
    entrypoint:
      - /bin/sh
      - -c
      - |
        curl -fsS --retry 3 "$$PING_URL/start"
        /app/backup.sh && \
          curl -fsS --retry 3 "$$PING_URL/complete" || \
          curl -fsS --retry 3 "$$PING_URL/fail"