chore: Add Correlation ID to API Error Response (#35)

* chore: Add Correlation ID to API Error Response

* release 0.0.8

* changelog

Author: John-peterson-coinbase

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## [0.0.8] - 2024-10-28
+
+### Added
+
+- Include correlation ID in API Errors.
+
 ## [0.0.7] - 2024-10-25
 
 ### Added

cdp/__version__.py

@@ -1 +1 @@
-__version__ = "0.0.7"
+__version__ = "0.0.8"

cdp/errors.py

@@ -12,11 +12,13 @@ def __init__(
         err: ApiException,
         code: str | None = None,
         message: str | None = None,
+        correlation_id: str | None = None,
         unhandled: bool = False,
     ) -> None:
         self._http_code = err.status
         self._api_code = code
         self._api_message = message
+        self._correlation_id = correlation_id
         self._handled = bool(code and message and not unhandled)
         super().__init__(str(err))
 
@@ -47,11 +49,16 @@ def from_error(cls, err: ApiException) -> "ApiError":
 
         message = body.get("message")
         code = body.get("code")
+        correlation_id = body.get("correlation_id")
 
         if code in ERROR_CODE_TO_ERROR_CLASS:
-            return ERROR_CODE_TO_ERROR_CLASS[code](err, code=code, message=message)
+            return ERROR_CODE_TO_ERROR_CLASS[code](
+                err, code=code, message=message, correlation_id=correlation_id
+            )
         else:
-            return cls(err, code=code, message=message, unhandled=True)
+            return cls(
+                err, code=code, message=message, correlation_id=correlation_id, unhandled=True
+            )
 
     @property
     def http_code(self) -> int:
@@ -83,6 +90,16 @@ def api_message(self) -> str | None:
         """
         return self._api_message
 
+    @property
+    def correlation_id(self) -> str | None:
+        """Get the correlation ID.
+
+        Returns:
+            str | None: The correlation ID.
+
+        """
+        return self._correlation_id
+
     @property
     def handled(self) -> bool:
         """Get whether the error is handled.
@@ -101,9 +118,9 @@ def __str__(self) -> str:
 
         """
         if self.handled:
-            return f"ApiError(http_code={self.http_code}, api_code={self.api_code}, api_message={self.api_message})"
+            return f"ApiError(http_code={self.http_code}, api_code={self.api_code}, api_message={self.api_message}, correlation_id={self.correlation_id})"
         else:
-            return f"ApiError(http_code={self.http_code}, api_code={self.api_code}, api_message={self.api_message}, unhandled=True)"
+            return f"ApiError(http_code={self.http_code}, api_code={self.api_code}, api_message={self.api_message}, correlation_id={self.correlation_id}, unhandled={self.handled})"
 
 
 class InvalidConfigurationError(Exception):

cdp/wallet.py

@@ -301,7 +301,9 @@ def create_webhook(self, notification_uri: str) -> "Webhook":
             Exception: If there's an error creating the webhook.
 
         """
-        create_wallet_webhook_request = CreateWalletWebhookRequest(notification_uri = notification_uri)
+        create_wallet_webhook_request = CreateWalletWebhookRequest(
+            notification_uri=notification_uri
+        )
         model = Cdp.api_clients.webhooks.create_wallet_webhook(
             wallet_id=self.id, create_wallet_webhook_request=create_wallet_webhook_request
         )

cdp/webhook.py

@@ -82,12 +82,12 @@ def event_filters(self) -> list[WebhookEventFilter]:
 
     @classmethod
     def create(
-            cls,
-            notification_uri: str,
-            event_type: WebhookEventType,
-            event_type_filter: WebhookEventTypeFilter | None = None,
-            event_filters: list[WebhookEventFilter] | None = None,
-            network_id: str = "base-sepolia",
+        cls,
+        notification_uri: str,
+        event_type: WebhookEventType,
+        event_type_filter: WebhookEventTypeFilter | None = None,
+        event_filters: list[WebhookEventFilter] | None = None,
+        network_id: str = "base-sepolia",
     ) -> "Webhook":
         """Create a new webhook.
 
@@ -103,11 +103,11 @@ def create(
 
         """
         create_webhook_request = CreateWebhookRequest(
-                network_id=network_id,
-                event_type=event_type,
-                event_type_filter=event_type_filter,
-                event_filters=event_filters,
-                notification_uri=notification_uri,
+            network_id=network_id,
+            event_type=event_type,
+            event_type_filter=event_type_filter,
+            event_filters=event_filters,
+            notification_uri=notification_uri,
         )
 
         model = Cdp.api_clients.webhooks.create_webhook(create_webhook_request)
@@ -149,7 +149,7 @@ def delete(webhook_id: str) -> None:
     def update(
         self,
         notification_uri: str | None = None,
-        event_type_filter: WebhookEventTypeFilter | None = None
+        event_type_filter: WebhookEventTypeFilter | None = None,
     ) -> "Webhook":
         """Update the webhook with a new notification URI, and/or a new list of addresses to monitor.
 

docs/conf.py

@@ -14,7 +14,7 @@
 
 project = 'CDP SDK'
 author = 'Coinbase Developer Platform'
-release = '0.0.7'
+release = '0.0.8'
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cdp-sdk"
-version = "0.0.7"
+version = "0.0.8"
 description = "CDP Python SDK"
 readme = "README.md"
 authors = [{name = "John Peterson", email = "[email protected]"}]

tests/factories/webhook_factory.py

@@ -6,21 +6,22 @@
 @pytest.fixture
 def webhook_factory():
     """Create and return a factory for Webhook fixtures."""
+
     def _create_webhook(
         webhook_id="webhook-123",
         network_id="base-sepolia",
         notification_uri="https://example.com/webhook",
         event_type=WebhookEventType.WALLET_ACTIVITY,
         event_type_filter=None,
-        event_filters=None
+        event_filters=None,
     ):
         model = WebhookModel(
             id=webhook_id,
             network_id=network_id,
             notification_uri=notification_uri,
             event_type=event_type,
             event_type_filter=event_type_filter,
-            event_filters=event_filters or []
+            event_filters=event_filters or [],
         )
         return Webhook(model)
 

tests/test_errors.py

@@ -19,23 +19,33 @@
 def test_api_error_init():
     """Test API error initialization."""
     err = ApiException(400, "Bad Request")
-    api_error = ApiError(err, code="test_code", message="Test message")
+    api_error = ApiError(
+        err, code="test_code", message="Test message", correlation_id="test-correlation-id"
+    )
 
     assert api_error.http_code == 400
     assert api_error.api_code == "test_code"
     assert api_error.api_message == "Test message"
+    assert api_error.correlation_id == "test-correlation-id"
     assert api_error.handled is True
 
 
 def test_api_error_from_error_with_valid_json():
     """Test API error from error with valid JSON."""
     err = ApiException(400, "Bad Request")
-    err.body = json.dumps({"code": "invalid_wallet_id", "message": "Invalid wallet ID"})
+    err.body = json.dumps(
+        {
+            "code": "invalid_wallet_id",
+            "message": "Invalid wallet ID",
+            "correlation_id": "test-correlation-id",
+        }
+    )
     api_error = ApiError.from_error(err)
 
     assert isinstance(api_error, ERROR_CODE_TO_ERROR_CLASS["invalid_wallet_id"])
     assert api_error.api_code == "invalid_wallet_id"
     assert api_error.api_message == "Invalid wallet ID"
+    assert api_error.correlation_id == "test-correlation-id"
 
 
 def test_api_error_from_error_with_invalid_json():
@@ -47,26 +57,39 @@ def test_api_error_from_error_with_invalid_json():
     assert isinstance(api_error, ApiError)
     assert api_error.api_code is None
     assert api_error.api_message is None
+    assert api_error.correlation_id is None
 
 
 def test_api_error_from_error_with_unknown_code():
     """Test API error from error with unknown code."""
     err = ApiException(400, "Bad Request")
-    err.body = json.dumps({"code": "unknown_code", "message": "Unknown error"})
+    err.body = json.dumps(
+        {
+            "code": "unknown_code",
+            "message": "Unknown error",
+            "correlation_id": "test-correlation-id",
+        }
+    )
     api_error = ApiError.from_error(err)
 
     assert isinstance(api_error, ApiError)
     assert api_error.api_code == "unknown_code"
     assert api_error.api_message == "Unknown error"
+    assert api_error.correlation_id == "test-correlation-id"
     assert api_error.handled is False
 
 
 def test_api_error_str_representation():
     """Test API error string representation."""
     err = ApiException(400, "Bad Request")
-    api_error = ApiError(err, code="test_code", message="Test message")
-
-    assert str(api_error) == "ApiError(http_code=400, api_code=test_code, api_message=Test message)"
+    api_error = ApiError(
+        err, code="test_code", message="Test message", correlation_id="test-correlation-id"
+    )
+
+    assert (
+        str(api_error)
+        == "ApiError(http_code=400, api_code=test_code, api_message=Test message, correlation_id=test-correlation-id)"
+    )
 
 
 def test_invalid_configuration_error():

tests/test_wallet.py

@@ -617,6 +617,7 @@ def test_wallet_deploy_multi_token_with_server_signer(wallet_factory):
             "https://example.com/multi-token/{id}.json"
         )
 
+
 @patch("cdp.Cdp.api_clients")
 def test_create_webhook(mock_api_clients, wallet_factory, webhook_factory):
     """Test Wallet create_webhook method."""
@@ -636,8 +637,7 @@ def test_create_webhook(mock_api_clients, wallet_factory, webhook_factory):
 
     # Assert that the API client was called with the correct parameters
     mock_api_clients.webhooks.create_wallet_webhook.assert_called_once_with(
-        wallet_id=wallet.id,
-        create_wallet_webhook_request=expected_request
+        wallet_id=wallet.id, create_wallet_webhook_request=expected_request
     )
 
     # Assert that the returned webhook is an instance of Webhook