stuff

Author: swaroopAkkineniWorkos

tests/test_audit_logs.py

@@ -106,6 +106,33 @@ def test_sends_idempotency_key(
             assert request_kwargs["headers"]["idempotency-key"] == idempotency_key
             assert response is None
 
+        def test_auto_generates_idempotency_key(
+            self, mock_audit_log_event, capture_and_mock_http_client_request
+        ):
+            """Test that idempotency key is auto-generated when not provided."""
+            organization_id = "org_123456789"
+
+            request_kwargs = capture_and_mock_http_client_request(
+                self.http_client, {"success": True}, 200
+            )
+
+            response = self.audit_logs.create_event(
+                organization_id=organization_id,
+                event=mock_audit_log_event,
+                # No idempotency_key provided
+            )
+
+            # Assert header exists and is a valid UUID v4
+            assert "idempotency-key" in request_kwargs["headers"]
+            idempotency_key = request_kwargs["headers"]["idempotency-key"]
+            assert len(idempotency_key) == 36  # UUID format: 8-4-4-4-12
+            assert idempotency_key.count("-") == 4
+            # Verify it's a valid UUID by checking the version field (4th section starts with '4')
+            uuid_parts = idempotency_key.split("-")
+            assert len(uuid_parts) == 5
+            assert uuid_parts[2][0] == "4"  # UUID v4 identifier
+            assert response is None
+
         def test_throws_unauthorized_exception(
             self, mock_audit_log_event, mock_http_client_with_response
         ):

workos/audit_logs.py

@@ -1,3 +1,4 @@
+import uuid
 from typing import Optional, Protocol, Sequence
 
 from workos.types.audit_logs import AuditLogExport
@@ -82,8 +83,11 @@ def create_event(
         json = {"organization_id": organization_id, "event": event}
 
         headers = {}
-        if idempotency_key:
-            headers["idempotency-key"] = idempotency_key
+        # Auto-generate UUID v4 if not provided
+        if idempotency_key is None:
+            idempotency_key = str(uuid.uuid4())
+        
+        headers["idempotency-key"] = idempotency_key
 
         self._http_client.request(
             EVENTS_PATH, method=REQUEST_METHOD_POST, json=json, headers=headers

workos/utils/_base_http_client.py

@@ -1,4 +1,6 @@
 import platform
+import random
+from dataclasses import dataclass
 from typing import (
     Any,
     Mapping,
@@ -33,6 +35,15 @@
 DEFAULT_REQUEST_TIMEOUT = 25
 
 
+@dataclass
+class RetryConfig:
+    """Configuration for retry logic with exponential backoff."""
+    max_retries: int = 3
+    base_delay: float = 1.0  # seconds
+    max_delay: float = 30.0  # seconds
+    jitter: float = 0.25  # 25% jitter
+
+
 ParamsType = Optional[Mapping[str, Any]]
 HeadersType = Optional[Dict[str, str]]
 JsonType = Optional[Union[Mapping[str, Any], Sequence[Any]]]
@@ -56,6 +67,7 @@ class BaseHTTPClient(Generic[_HttpxClientT]):
     _base_url: str
     _version: str
     _timeout: int
+    _retry_config: RetryConfig
 
     def __init__(
         self,
@@ -65,12 +77,14 @@ def __init__(
         client_id: str,
         version: str,
         timeout: Optional[int] = DEFAULT_REQUEST_TIMEOUT,
+        retry_config: Optional[RetryConfig] = None,
     ) -> None:
         self._api_key = api_key
         self._base_url = base_url
         self._client_id = client_id
         self._version = version
         self._timeout = DEFAULT_REQUEST_TIMEOUT if timeout is None else timeout
+        self._retry_config = retry_config if retry_config is not None else RetryConfig()
 
     def _generate_api_url(self, path: str) -> str:
         return f"{self._base_url}{path}"
@@ -196,6 +210,49 @@ def _handle_response(self, response: httpx.Response) -> ResponseJson:
 
         return cast(ResponseJson, response_json)
 
+    def _is_retryable_error(self, response: httpx.Response) -> bool:
+        """Determine if an error should be retried."""
+        status_code = response.status_code
+        
+        # Retry on 5xx server errors
+        if 500 <= status_code < 600:
+            return True
+        
+        # Retry on 429 rate limit
+        if status_code == 429:
+            return True
+        
+        # Do NOT retry 4xx client errors (except 429)
+        return False
+
+    def _get_retry_delay(self, attempt: int, response: httpx.Response) -> float:
+        """Calculate delay with exponential backoff and jitter."""
+        # Check for Retry-After header on 429 responses
+        if response.status_code == 429:
+            retry_after = response.headers.get("Retry-After")
+            if retry_after:
+                try:
+                    return float(retry_after)
+                except ValueError:
+                    pass  # Fall through to exponential backoff
+        
+        # Exponential backoff: base_delay * 2^attempt
+        delay = self._retry_config.base_delay * (2 ** attempt)
+        
+        # Cap at max_delay
+        delay = min(delay, self._retry_config.max_delay)
+        
+        # Add jitter: random variation of 0-25% of delay
+        jitter_amount = delay * self._retry_config.jitter * random.random()
+        return delay + jitter_amount
+
+    def _should_retry_exception(self, exc: Exception) -> bool:
+        """Determine if an exception should trigger a retry."""
+        # Retry on network errors (connection, timeout)
+        if isinstance(exc, (httpx.ConnectError, httpx.TimeoutException)):
+            return True
+        return False
+
     def build_request_url(
         self,
         url: str,

workos/utils/http_client.py

@@ -1,4 +1,6 @@
 import asyncio
+import random
+import time
 from types import TracebackType
 from typing import Optional, Type, Union
 
@@ -13,6 +15,7 @@
     JsonType,
     ParamsType,
     ResponseJson,
+    RetryConfig,
 )
 from workos.utils.request_helper import REQUEST_METHOD_GET
 
@@ -38,6 +41,7 @@ def __init__(
         client_id: str,
         version: str,
         timeout: Optional[int] = None,
+        retry_config: Optional[RetryConfig] = None,
         # If no custom transport is provided, let httpx use the default
         # so we don't overwrite environment configurations like proxies
         transport: Optional[httpx.BaseTransport] = None,
@@ -48,6 +52,7 @@ def __init__(
             client_id=client_id,
             version=version,
             timeout=timeout,
+            retry_config=retry_config,
         )
         self._client = SyncHttpxClientWrapper(
             base_url=base_url,
@@ -110,8 +115,38 @@ def request(
             headers=headers,
             exclude_default_auth_headers=exclude_default_auth_headers,
         )
-        response = self._client.request(**prepared_request_parameters)
-        return self._handle_response(response)
+        
+        last_exception = None
+        
+        for attempt in range(self._retry_config.max_retries + 1):
+            try:
+                response = self._client.request(**prepared_request_parameters)
+                
+                # Check if we should retry based on status code
+                if attempt < self._retry_config.max_retries and self._is_retryable_error(response):
+                    delay = self._get_retry_delay(attempt, response)
+                    time.sleep(delay)
+                    continue
+                
+                # No retry needed or max retries reached
+                return self._handle_response(response)
+                
+            except Exception as exc:
+                last_exception = exc
+                if attempt < self._retry_config.max_retries and self._should_retry_exception(exc):
+                    delay = self._retry_config.base_delay * (2 ** attempt)
+                    delay = min(delay, self._retry_config.max_delay)
+                    jitter_amount = delay * self._retry_config.jitter * random.random()
+                    time.sleep(delay + jitter_amount)
+                    continue
+                raise
+        
+        # Should not reach here, but raise last exception if we do
+        if last_exception is not None:
+            raise last_exception
+        
+        # Fallback: this should never happen
+        raise RuntimeError("Unexpected state in retry logic")
 
 
 class AsyncHttpxClientWrapper(httpx.AsyncClient):
@@ -138,6 +173,7 @@ def __init__(
         client_id: str,
         version: str,
         timeout: Optional[int] = None,
+        retry_config: Optional[RetryConfig] = None,
         # If no custom transport is provided, let httpx use the default
         # so we don't overwrite environment configurations like proxies
         transport: Optional[httpx.AsyncBaseTransport] = None,
@@ -148,6 +184,7 @@ def __init__(
             client_id=client_id,
             version=version,
             timeout=timeout,
+            retry_config=retry_config,
         )
         self._client = AsyncHttpxClientWrapper(
             base_url=base_url,
@@ -207,8 +244,38 @@ async def request(
             headers=headers,
             exclude_default_auth_headers=exclude_default_auth_headers,
         )
-        response = await self._client.request(**prepared_request_parameters)
-        return self._handle_response(response)
+        
+        last_exception = None
+        
+        for attempt in range(self._retry_config.max_retries + 1):
+            try:
+                response = await self._client.request(**prepared_request_parameters)
+                
+                # Check if we should retry based on status code
+                if attempt < self._retry_config.max_retries and self._is_retryable_error(response):
+                    delay = self._get_retry_delay(attempt, response)
+                    await asyncio.sleep(delay)
+                    continue
+                
+                # No retry needed or max retries reached
+                return self._handle_response(response)
+                
+            except Exception as exc:
+                last_exception = exc
+                if attempt < self._retry_config.max_retries and self._should_retry_exception(exc):
+                    delay = self._retry_config.base_delay * (2 ** attempt)
+                    delay = min(delay, self._retry_config.max_delay)
+                    jitter_amount = delay * self._retry_config.jitter * random.random()
+                    await asyncio.sleep(delay + jitter_amount)
+                    continue
+                raise
+        
+        # Should not reach here, but raise last exception if we do
+        if last_exception is not None:
+            raise last_exception
+        
+        # Fallback: this should never happen
+        raise RuntimeError("Unexpected state in retry logic")
 
 
 HTTPClient = Union[AsyncHTTPClient, SyncHTTPClient]