Idempotency and retries

import os
import random
import time

import requests

ENDPOINT = "https://gerncrjtrdjtjvybvseb.supabase.co/functions/v1/notify"


def send_alert(payload: dict, event_id: str, attempts: int = 5) -> dict:
    headers = {
        "Authorization": f"Bearer {os.environ['ZONA_SOURCE_TOKEN']}",
        "Idempotency-Key": event_id,
    }
    for attempt in range(attempts):
        wait = min(2 ** attempt, 30) + random.uniform(0, 1)
        try:
            response = requests.post(ENDPOINT, headers=headers, json=payload, timeout=10)
        except (requests.ConnectionError, requests.Timeout):
            response = None

        if response is not None:
            if response.status_code in (200, 202):
                return response.json()
            if response.status_code != 429 and response.status_code < 500:
                raise RuntimeError(f"Zona rejected the alert: {response.status_code} {response.text}")
            retry_after = response.headers.get("Retry-After", "")
            if retry_after.isdigit():
                wait = max(wait, int(retry_after))

        if attempt < attempts - 1:
            time.sleep(wait)
    raise RuntimeError("Zona did not confirm the alert; retry later with the same key")


send_alert(
    {"title": "Backup complete", "body": "The nightly backup finished successfully."},
    event_id="backup-20260726-020000",
)

const ENDPOINT = 'https://gerncrjtrdjtjvybvseb.supabase.co/functions/v1/notify';
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

export async function sendAlert(payload, eventId, attempts = 5) {
  const body = JSON.stringify(payload); // serialise once, so every attempt is identical
  for (let attempt = 0; attempt < attempts; attempt++) {
    let wait = Math.min(2 ** attempt, 30) * 1000 + Math.random() * 1000;
    try {
      const response = await fetch(ENDPOINT, {
        method: 'POST',
        headers: {
          authorization: `Bearer ${process.env.ZONA_SOURCE_TOKEN}`,
          'idempotency-key': eventId,
          'content-type': 'application/json',
        },
        body,
        signal: AbortSignal.timeout(10_000),
      });
      if (response.status === 200 || response.status === 202) return await response.json();
      if (response.status !== 429 && response.status < 500) {
        throw Object.assign(new Error(`Zona rejected the alert: ${response.status} ${await response.text()}`), { fatal: true });
      }
      const retryAfter = Number(response.headers.get('retry-after'));
      if (retryAfter > 0) wait = Math.max(wait, retryAfter * 1000);
    } catch (error) {
      if (error.fatal) throw error; // network errors and timeouts fall through to a retry
    }
    if (attempt < attempts - 1) await sleep(wait);
  }
  throw new Error('Zona did not confirm the alert; retry later with the same key');
}

await sendAlert(
  { title: 'Backup complete', body: 'The nightly backup finished successfully.' },
  'backup-20260726-020000',
);