Refactor retry interfaces to use exception-based information

Author: JordonPhillips

packages/smithy-core/src/smithy_core/interfaces/retries.py

@@ -1,7 +1,6 @@
 #  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #  SPDX-License-Identifier: Apache-2.0
 from dataclasses import dataclass
-from enum import Enum
 from typing import Protocol, runtime_checkable
 
 
@@ -29,43 +28,6 @@ class ErrorRetryInfo(Protocol):
     """Whether the error is a throttling error."""
 
 
-class RetryErrorType(Enum):
-    """Classification of errors based on desired retry behavior."""
-
-    TRANSIENT = 1
-    """A connection level error such as a socket timeout, socket connect error, TLS
-    negotiation timeout."""
-
-    THROTTLING = 2
-    """The server explicitly told the client to back off, for example with HTTP status
-    429 or 503."""
-
-    SERVER_ERROR = 3
-    """A server error that should be retried and does not match the definition of
-    ``THROTTLING``."""
-
-    CLIENT_ERROR = 4
-    """Doesn't count against any budgets.
-
-    This could be something like a 401 challenge in HTTP.
-    """
-
-
-@dataclass(kw_only=True)
-class RetryErrorInfo:
-    """Container for information about a retryable error."""
-
-    error_type: RetryErrorType
-    """Classification of error based on desired retry behavior."""
-
-    retry_after_hint: float | None = None
-    """Protocol hint for computing the timespan to delay before the next retry.
-
-    This could come from HTTP's 'retry-after' header or similar mechanisms in other
-    protocols.
-    """
-
-
 class RetryBackoffStrategy(Protocol):
     """Stateless strategy for computing retry delays based on retry attempt account."""
 
@@ -113,7 +75,7 @@ def acquire_initial_retry_token(
         ...
 
     def refresh_retry_token_for_retry(
-        self, *, token_to_renew: RetryToken, error_info: RetryErrorInfo
+        self, *, token_to_renew: RetryToken, error: Exception
     ) -> RetryToken:
         """Replace an existing retry token from a failed attempt with a new token.
 
@@ -124,10 +86,7 @@ def refresh_retry_token_for_retry(
         the retry attempt and raise the error as exception.
 
         :param token_to_renew: The token used for the previous failed attempt.
-
-        :param error_info: If no further retry is allowed, this information is used to
-        construct the exception.
-
+        :param error: The error that triggered the need for a retry.
         :raises SmithyRetryException: If no further retry attempts are allowed.
         """
         ...

packages/smithy-core/src/smithy_core/retries.py

@@ -5,8 +5,6 @@
 from dataclasses import dataclass
 from enum import Enum
 
-from smithy_core.interfaces.retries import RetryErrorType
-
 from .exceptions import SmithyRetryException
 from .interfaces import retries as retries_interface
 
@@ -220,21 +218,18 @@ def refresh_retry_token_for_retry(
         self,
         *,
         token_to_renew: retries_interface.RetryToken,
-        error_info: retries_interface.RetryErrorInfo,
+        error: Exception,
     ) -> SimpleRetryToken:
         """Replace an existing retry token from a failed attempt with a new token.
 
         This retry strategy always returns a token until the attempt count stored in
         the new token exceeds the ``max_attempts`` value.
 
         :param token_to_renew: The token used for the previous failed attempt.
-
-        :param error_info: If no further retry is allowed, this information is used to
-        construct the exception.
-
+        :param error: The error that triggered the need for a retry.
         :raises SmithyRetryException: If no further retry attempts are allowed.
         """
-        if error_info.error_type is not RetryErrorType.CLIENT_ERROR:
+        if isinstance(error, retries_interface.ErrorRetryInfo) and error.is_retry_safe:
             retry_count = token_to_renew.retry_count + 1
             if retry_count >= self.max_attempts:
                 raise SmithyRetryException(
@@ -243,7 +238,7 @@ def refresh_retry_token_for_retry(
             retry_delay = self.backoff_strategy.compute_next_backoff_delay(retry_count)
             return SimpleRetryToken(retry_count=retry_count, retry_delay=retry_delay)
         else:
-            raise SmithyRetryException(f"Error is not retryable: {error_info}")
+            raise SmithyRetryException(f"Error is not retryable: {error}")
 
     def record_success(self, *, token: retries_interface.RetryToken) -> None:
         """Not used by this retry strategy."""

packages/smithy-core/tests/unit/test_retries.py

@@ -2,8 +2,7 @@
 #  SPDX-License-Identifier: Apache-2.0
 
 import pytest
-from smithy_core.exceptions import SmithyRetryException
-from smithy_core.interfaces.retries import RetryErrorInfo, RetryErrorType
+from smithy_core.exceptions import CallException, SmithyRetryException
 from smithy_core.retries import ExponentialBackoffJitterType as EBJT
 from smithy_core.retries import ExponentialRetryBackoffStrategy, SimpleRetryStrategy
 
@@ -61,26 +60,43 @@ def test_simple_retry_strategy(max_attempts: int) -> None:
         backoff_strategy=ExponentialRetryBackoffStrategy(backoff_scale_value=5),
         max_attempts=max_attempts,
     )
-    error_info = RetryErrorInfo(error_type=RetryErrorType.THROTTLING)
+    error = CallException(is_retry_safe=True)
     token = strategy.acquire_initial_retry_token()
     for _ in range(max_attempts - 1):
         token = strategy.refresh_retry_token_for_retry(
-            token_to_renew=token, error_info=error_info
+            token_to_renew=token, error=error
         )
     with pytest.raises(SmithyRetryException):
-        strategy.refresh_retry_token_for_retry(
-            token_to_renew=token, error_info=error_info
-        )
+        strategy.refresh_retry_token_for_retry(token_to_renew=token, error=error)
 
 
-def test_simple_retry_strategy_does_not_retry_client_errors() -> None:
+def test_simple_retry_does_not_retry_unclassified() -> None:
     strategy = SimpleRetryStrategy(
         backoff_strategy=ExponentialRetryBackoffStrategy(backoff_scale_value=5),
         max_attempts=2,
     )
-    error_info = RetryErrorInfo(error_type=RetryErrorType.CLIENT_ERROR)
     token = strategy.acquire_initial_retry_token()
     with pytest.raises(SmithyRetryException):
-        strategy.refresh_retry_token_for_retry(
-            token_to_renew=token, error_info=error_info
-        )
+        strategy.refresh_retry_token_for_retry(token_to_renew=token, error=Exception())
+
+
+def test_simple_retry_does_not_retry_when_safety_unknown() -> None:
+    strategy = SimpleRetryStrategy(
+        backoff_strategy=ExponentialRetryBackoffStrategy(backoff_scale_value=5),
+        max_attempts=2,
+    )
+    error = CallException(is_retry_safe=None)
+    token = strategy.acquire_initial_retry_token()
+    with pytest.raises(SmithyRetryException):
+        strategy.refresh_retry_token_for_retry(token_to_renew=token, error=error)
+
+
+def test_simple_retry_does_not_retry_unsafe() -> None:
+    strategy = SimpleRetryStrategy(
+        backoff_strategy=ExponentialRetryBackoffStrategy(backoff_scale_value=5),
+        max_attempts=2,
+    )
+    error = CallException(fault="client", is_retry_safe=False)
+    token = strategy.acquire_initial_retry_token()
+    with pytest.raises(SmithyRetryException):
+        strategy.refresh_retry_token_for_retry(token_to_renew=token, error=error)