Idempotency and retries

curl -X POST https://portal.bridgelinepf.com/api/v1/quotes/qte_2lo4LFk5rf8toDFJHSUZ2O/hosted-link \
  -H "Authorization: Bearer $BRIDGELINE_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)"

const res = await fetch(`https://portal.bridgelinepf.com/api/v1/quotes/${quoteId}/hosted-link`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.BRIDGELINE_API_KEY}`,
    'Idempotency-Key': crypto.randomUUID(),
  },
})
const data = await res.json()

import os
import uuid
import requests

res = requests.post(
    f"https://portal.bridgelinepf.com/api/v1/quotes/{quote_id}/hosted-link",
    headers={
        "Authorization": f"Bearer {os.environ['BRIDGELINE_API_KEY']}",
        "Idempotency-Key": str(uuid.uuid4()),
    },
    timeout=30,
)
data = res.json()

const RETRYABLE = new Set(['IDEMPOTENCY_REQUEST_IN_PROGRESS', 'RATE_LIMITED', 'SERVICE_UNAVAILABLE', 'INTERNAL'])

async function postWithRetries(url, body, { attempts = 5 } = {}) {
  const idempotencyKey = crypto.randomUUID() // one key for every attempt
  const payload = JSON.stringify(body)       // the same bytes on every attempt

  for (let attempt = 1; ; attempt++) {
    let res
    try {
      res = await fetch(url, {
        method: 'POST',
        headers: {
          Authorization: `Bearer ${process.env.BRIDGELINE_API_KEY}`,
          'Content-Type': 'application/json',
          'Idempotency-Key': idempotencyKey,
        },
        body: payload,
      })
    } catch (networkError) {
      if (attempt >= attempts) throw networkError
      await sleep(backoff(attempt))
      continue
    }

    if (res.ok) return res.json()

    const { error } = await res.json()
    const replayed = res.headers.get('Idempotent-Replayed') === 'true'
    if (!RETRYABLE.has(error.code) || replayed || attempt >= attempts) {
      throw Object.assign(new Error(error.message), { code: error.code, requestId: error.request_id })
    }
    const retryAfter = Number(res.headers.get('Retry-After'))
    await sleep(retryAfter > 0 ? retryAfter * 1000 : backoff(attempt))
  }
}

const backoff = (attempt) => Math.min(30_000, 500 * 2 ** attempt) * (0.5 + Math.random() / 2)
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

import json
import os
import random
import time
import uuid

import requests

RETRYABLE = {"IDEMPOTENCY_REQUEST_IN_PROGRESS", "RATE_LIMITED", "SERVICE_UNAVAILABLE", "INTERNAL"}


def post_with_retries(url, body, attempts=5):
    idempotency_key = str(uuid.uuid4())  # one key for every attempt
    payload = json.dumps(body)            # the same bytes on every attempt
    headers = {
        "Authorization": f"Bearer {os.environ['BRIDGELINE_API_KEY']}",
        "Content-Type": "application/json",
        "Idempotency-Key": idempotency_key,
    }

    for attempt in range(1, attempts + 1):
        try:
            res = requests.post(url, data=payload, headers=headers, timeout=30)
        except requests.RequestException:
            if attempt >= attempts:
                raise
            time.sleep(backoff(attempt))
            continue

        if res.ok:
            return res.json()

        error = res.json()["error"]
        replayed = res.headers.get("Idempotent-Replayed") == "true"
        if error["code"] not in RETRYABLE or replayed or attempt >= attempts:
            raise RuntimeError(f"{error['code']}: {error['message']} ({error['request_id']})")
        retry_after = int(res.headers.get("Retry-After") or 0)
        time.sleep(retry_after if retry_after > 0 else backoff(attempt))


def backoff(attempt):
    return min(30, 0.5 * 2 ** attempt) * random.uniform(0.5, 1.0)