Errors and Rate Limits

{
  "error": {
    "code": "invalid_request",
    "message": "Missing required parameter: api_key",
    "details": {
      "parameter": "api_key",
      "reason": "required"
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "Invalid params",
    "data": {
      "expected": "string",
      "actual": "number"
    }
  }
}

{
  "error": {
    "code": "unauthorized",
    "message": "Invalid API key"
  }
}

{
  "error": {
    "code": "forbidden",
    "message": "This API key does not have permission to upload plugins"
  }
}

{
  "error": {
    "code": "validation_error",
    "message": "Invalid request body",
    "details": {
      "field": "memory_limit",
      "issue": "must be valid Kubernetes format (e.g., 512Mi)"
    }
  }
}

{
  "error": {
    "code": "not_found",
    "message": "Plugin 'my-plugin' not found"
  }
}

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Too many requests. Retry after 60 seconds"
  }
}

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1711123260

{
  "error": {
    "code": "internal_error",
    "message": "An internal error occurred",
    "request_id": "req_abc123xyz"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32601,
    "message": "Method not found: invalid_method"
  }
}

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1711123200

if (response.headers['x-ratelimit-remaining'] === '0') {
  const resetTime = response.headers['x-ratelimit-reset'];
  console.log(`Rate limit reset at: ${new Date(resetTime * 1000)}`);
}

import time
import random

def call_with_retry(func, max_retries=3):
    for attempt in range(max_retries):
        try:
            return func()
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            wait_time = 2 ** attempt + random.random()
            print(f"Rate limited. Waiting {wait_time}s...")
            time.sleep(wait_time)

# ❌ Slow: 100 individual requests
for plugin in plugins:
  curl api/plugin/$plugin

# ✅ Better: Batch request
curl -X POST api/plugins/batch \
  -d '{"ids": ["p1", "p2", ..., "p100"]}'

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# Retry strategy
session = requests.Session()
retry = Retry(
    total=5,
    backoff_factor=1,
    status_forcelist=[429, 500, 502, 503, 504]
)
adapter = HTTPAdapter(max_retries=retry)
session.mount('https://', adapter)

try:
    resp = session.get(
        'https://api.noorle.com/v1/capabilities',
        headers={'X-API-Key': 'nk_...'},
        timeout=10
    )
    resp.raise_for_status()
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 429:
        reset_time = e.response.headers['X-RateLimit-Reset']
        print(f"Rate limited until {reset_time}")
    else:
        print(f"Error: {e.response.json()}")
except requests.exceptions.RequestException as e:
    print(f"Connection error: {e}")

async function apiCall(url: string, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(url, {
        headers: { "X-API-Key": "nk_..." },
      });

      if (!response.ok) {
        if (response.status === 429) {
          const resetTime = response.headers.get("X-RateLimit-Reset");
          const waitTime = Math.max(
            1000,
            Number(resetTime) * 1000 - Date.now()
          );
          console.log(`Rate limited. Waiting ${waitTime}ms`);
          await new Promise((resolve) => setTimeout(resolve, waitTime));
          continue;
        }

        throw new Error(`HTTP ${response.status}`);
      }

      return response.json();
    } catch (error) {
      if (i === retries - 1) throw error;

      const backoff = Math.pow(2, i) * 1000;
      await new Promise((resolve) => setTimeout(resolve, backoff));
    }
  }
}

#!/bin/bash

function api_call() {
  local url=$1
  local max_retries=3
  local retry=0

  while [ $retry -lt $max_retries ]; do
    response=$(curl -s -w "\n%{http_code}" \
      -H "X-API-Key: nk_..." \
      "$url")

    http_code=$(echo "$response" | tail -n1)
    body=$(echo "$response" | head -n-1)

    if [ "$http_code" == "200" ]; then
      echo "$body"
      return 0
    elif [ "$http_code" == "429" ]; then
      reset_time=$(curl -s -I -H "X-API-Key: nk_..." "$url" | \
        grep "X-RateLimit-Reset" | awk '{print $2}')
      sleep $((reset_time - $(date +%s)))
      ((retry++))
    else
      echo "Error: $body"
      return 1
    fi
  done

  return 1
}

curl -v https://api.noorle.com/v1/capabilities \
  -H "X-API-Key: nk_..."

# Response headers:
# X-Request-ID: req_abc123xyz

# cURL
curl -v https://api.noorle.com/v1/capabilities

# Python
import logging
logging.basicConfig(level=logging.DEBUG)

# Node.js
process.env.DEBUG = 'noorle:*'

curl https://api.noorle.com/health

# Response:
# {
#   "status": "healthy",
#   "version": "v1",
#   "timestamp": "2024-03-22T10:30:45Z"
# }