API Integration Architect

# Standard API Client Template
import httpx
import asyncio
from datetime import datetime, timedelta
from typing import Optional, Any
import logging
import json

logger = logging.getLogger(__name__)

class APIClient:
    """Production-ready API client with retry, auth, and observability."""
    
    def __init__(
        self,
        base_url: str,
        api_key: str,
        timeout: float = 30.0,
        max_retries: int = 3,
        rate_limit_rps: float = 10.0,
    ):
        self.base_url = base_url.rstrip("/")
        self.max_retries = max_retries
        self._client = httpx.AsyncClient(
            base_url=self.base_url,
            headers={
                "Authorization": f"Bearer {api_key}",
                "Content-Type": "application/json",
                "User-Agent": "APIClient/1.0",
            },
            timeout=httpx.Timeout(timeout, connect=5.0),
        )
        self._rate_limiter = asyncio.Semaphore(int(rate_limit_rps))
    
    async def _request(
        self,
        method: str,
        path: str,
        *,
        params: Optional[dict] = None,
        json_data: Optional[dict] = None,
        correlation_id: Optional[str] = None,
    ) -> Any:
        """Make a resilient API request with retry and logging."""
        import uuid
        cid = correlation_id or str(uuid.uuid4())[:8]
        
        for attempt in range(self.max_retries):
            async with self._rate_limiter:
                try:
                    logger.info(
                        "api_request",
                        extra={
                            "correlation_id": cid,
                            "method": method,
                            "path": path,
                            "attempt": attempt + 1,
                        },
                    )
                    
                    response = await self._client.request(
                        method, path, params=params, json=json_data
                    )
                    response.raise_for_status()
                    
                    logger.info(
                        "api_success",
                        extra={
                            "correlation_id": cid,
                            "status_code": response.status_code,
                        },
                    )
                    return response.json()
                    
                except httpx.HTTPStatusError as e:
                    if e.response.status_code == 429:
                        retry_after = float(e.response.headers.get("Retry-After", 2 ** attempt))
                        logger.warning(f"rate_limited retry={retry_after}s", extra={"correlation_id": cid})
                        await asyncio.sleep(retry_after)
                        continue
                    if e.response.status_code >= 500 and attempt < self.max_retries - 1:
                        wait = 2 ** attempt
                        logger.warning(f"server_error retry in {wait}s", extra={"correlation_id": cid})
                        await asyncio.sleep(wait)
                        continue
                    logger.error(f"api_error {e.response.status_code}", extra={"correlation_id": cid})
                    raise
                except httpx.TimeoutException:
                    if attempt < self.max_retries - 1:
                        wait = 2 ** attempt
                        logger.warning(f"timeout retry in {wait}s", extra={"correlation_id": cid})
                        await asyncio.sleep(wait)
                        continue
                    raise
        
        raise RuntimeError(f"Failed after {self.max_retries} attempts: {method} {path}")
    
    async def get(self, path: str, **kwargs) -> Any:
        return await self._request("GET", path, **kwargs)
    
    async def post(self, path: str, **kwargs) -> Any:
        return await self._request("POST", path, **kwargs)
    
    async def close(self):
        await self._client.aclose()