Rate limits, retries, and backoff

import random
import time
from typing import Any

import requests

BLUESTONE_AUTH_BASE = "https://idp.test.bluestonepim.com/op/token"
BLUESTONE_API_BASE = "https://api.test.bluestonepim.com"
CLIENT_ID = "YOUR_CLIENT_ID"
CLIENT_SECRET = "YOUR_CLIENT_SECRET"

RETRY_STATUSES = {429, 500, 502, 503, 504}
MAX_RETRIES = 5
TIMEOUT_SECONDS = 20


def get_token() -> str:
    response = requests.post(
        BLUESTONE_AUTH_BASE,
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        data={
            "grant_type": "client_credentials",
            "client_id": CLIENT_ID,
            "client_secret": CLIENT_SECRET,
        },
        timeout=TIMEOUT_SECONDS,
    )
    response.raise_for_status()
    return response.json()["access_token"]


def retry_delay_seconds(attempt: int) -> float:
    base_delay = 2 ** attempt
    jitter = random.uniform(0, 0.25)
    return min(base_delay + jitter, 30)


def request_api(method: str, path: str, token: str, json_body: dict[str, Any] | None = None) -> Any:
    url = f"{BLUESTONE_API_BASE}/{path.lstrip('/')}"
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
        "context-fallback": "true",
    }

    for attempt in range(MAX_RETRIES):
        try:
            response = requests.request(
                method,
                url,
                headers=headers,
                json=json_body,
                timeout=TIMEOUT_SECONDS,
            )

            if response.status_code not in RETRY_STATUSES:
                response.raise_for_status()
                return response.json() if response.content else None

            if attempt == MAX_RETRIES - 1:
                response.raise_for_status()

            time.sleep(retry_delay_seconds(attempt))
        except (requests.ConnectionError, requests.Timeout):
            if attempt == MAX_RETRIES - 1:
                raise
            time.sleep(retry_delay_seconds(attempt))

    raise RuntimeError("Request failed after retries")


token = get_token()
catalogs = request_api("GET", "/pim/catalogs", token)
print(catalogs)

const BLUESTONE_AUTH_BASE = "https://idp.test.bluestonepim.com/op/token";
const BLUESTONE_API_BASE = "https://api.test.bluestonepim.com";
const CLIENT_ID = "YOUR_CLIENT_ID";
const CLIENT_SECRET = "YOUR_CLIENT_SECRET";

const RETRY_STATUSES = new Set([429, 500, 502, 503, 504]);
const MAX_RETRIES = 5;

function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function retryDelayMs(attempt: number): number {
  const baseDelay = 2 ** attempt * 1000;
  const jitter = Math.floor(Math.random() * 250);
  return Math.min(baseDelay + jitter, 30000);
}

async function getToken(): Promise<string> {
  const body = new URLSearchParams({
    grant_type: "client_credentials",
    client_id: CLIENT_ID,
    client_secret: CLIENT_SECRET,
  });

  const response = await fetch(BLUESTONE_AUTH_BASE, {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body,
  });

  if (!response.ok) {
    throw new Error(`Token request failed: ${response.status}`);
  }

  const json = await response.json();
  return json.access_token;
}

async function requestApi<T>(method: string, path: string, token: string, body?: unknown): Promise<T> {
  const url = `${BLUESTONE_API_BASE}/${path.replace(/^\/+/, "")}`;

  for (let attempt = 0; attempt < MAX_RETRIES; attempt += 1) {
    try {
      const response = await fetch(url, {
        method,
        headers: {
          Authorization: `Bearer ${token}`,
          "Content-Type": "application/json",
          "context-fallback": "true",
        },
        body: body === undefined ? undefined : JSON.stringify(body),
      });

      if (!RETRY_STATUSES.has(response.status)) {
        if (!response.ok) {
          throw new Error(`API request failed: ${response.status}`);
        }
        return response.status === 204 ? (undefined as T) : ((await response.json()) as T);
      }

      if (attempt === MAX_RETRIES - 1) {
        throw new Error(`API request failed after retries: ${response.status}`);
      }

      await sleep(retryDelayMs(attempt));
    } catch (error) {
      if (!(error instanceof TypeError)) {
        throw error;
      }
      if (attempt === MAX_RETRIES - 1) {
        throw error;
      }
      await sleep(retryDelayMs(attempt));
    }
  }

  throw new Error("API request failed after retries");
}

const token = await getToken();
const catalogs = await requestApi<unknown>("GET", "/pim/catalogs", token);
console.log(catalogs);

#!/usr/bin/env bash
set -euo pipefail

BLUESTONE_AUTH_BASE="https://idp.test.bluestonepim.com/op/token"
BLUESTONE_API_BASE="https://api.test.bluestonepim.com"
CLIENT_ID="YOUR_CLIENT_ID"
CLIENT_SECRET="YOUR_CLIENT_SECRET"

MAX_RETRIES=5

# Retryable statuses: 429, 500, 502, 503, 504
is_retryable() {
  case "$1" in
    429|500|502|503|504) return 0 ;;
    *) return 1 ;;
  esac
}

# Exponential backoff with jitter, capped at 30 seconds.
backoff_sleep() {
  local attempt="$1"
  local base=$((2 ** attempt))
  local jitter_ms=$((RANDOM % 250))
  local delay
  delay=$(awk -v b="$base" -v j="$jitter_ms" 'BEGIN { d = b + j/1000; if (d > 30) d = 30; print d }')
  sleep "$delay"
}

get_token() {
  curl -fsS -X POST "$BLUESTONE_AUTH_BASE" \
    -H "Content-Type: application/x-www-form-urlencoded" \
    -d "grant_type=client_credentials" \
    -d "client_id=${CLIENT_ID}" \
    -d "client_secret=${CLIENT_SECRET}" \
  | sed -n 's/.*"access_token":"\([^"]*\)".*/\1/p'
}

# Usage: request_api GET /pim/catalogs
request_api() {
  local method="$1" path="$2"
  local url="${BLUESTONE_API_BASE}/${path#/}"
  local attempt status body

  for ((attempt = 0; attempt < MAX_RETRIES; attempt++)); do
    body=$(mktemp)
    status=$(curl -sS -o "$body" -w "%{http_code}" -X "$method" "$url" \
      -H "Authorization: Bearer ${TOKEN}" \
      -H "Content-Type: application/json" \
      -H "context-fallback: true" || echo "000")

    if [[ "$status" == "000" ]] || is_retryable "$status"; then
      if (( attempt == MAX_RETRIES - 1 )); then
        echo "Request failed after retries (last status: ${status})" >&2
        cat "$body" >&2; rm -f "$body"; return 1
      fi
      rm -f "$body"
      backoff_sleep "$attempt"
      continue
    fi

    cat "$body"; rm -f "$body"
    return 0
  done
}

TOKEN="$(get_token)"
request_api GET /pim/catalogs