feat: new retries updates

Author: yenfryherrerafeliz

src/DynamoDb/DynamoDbClient.php

@@ -157,7 +157,7 @@ public function registerSessionHandler(array $config = [])
     }
 
     /** @internal */
-    public static function _applyRetryConfig($value, array &$args, HandlerList $list)
+    public static function _applyRetryConfig($value, array &$args, HandlerList $list, string $service = 'dynamodb')
     {
         if ($value) {
             $config = \Aws\Retry\ConfigurationProvider::unwrap($value);
@@ -181,12 +181,21 @@ function ($retries) {
                     'retry'
                 );
             } else {
+                // Default to 4 max attempts for DynamoDB/DynamoDB Streams
+                // when no explicit max attempts is configured
+                if ($config->getMaxAttempts() === \Aws\Retry\ConfigurationProvider::DEFAULT_MAX_ATTEMPTS) {
+                    $config = new \Aws\Retry\Configuration(
+                        $config->getMode(),
+                        4
+                    );
+                }
                 $list->appendSign(
                     RetryMiddlewareV2::wrap(
                         $config,
                         [
                             'collect_stats' => $args['stats']['retries'],
-                            'transient_error_codes' => ['TransactionInProgressException']
+                            'transient_error_codes' => ['TransactionInProgressException'],
+                            'service' => $service,
                         ]
                     ),
                     'retry'

src/DynamoDbStreams/DynamoDbStreamsClient.php

@@ -3,6 +3,7 @@
 
 use Aws\AwsClient;
 use Aws\DynamoDb\DynamoDbClient;
+use Aws\HandlerList;
 
 /**
  * This client is used to interact with the **Amazon DynamoDb Streams** service.
@@ -22,8 +23,14 @@ public static function getArguments()
     {
         $args = parent::getArguments();
         $args['retries']['default'] = 11;
-        $args['retries']['fn'] = [DynamoDbClient::class, '_applyRetryConfig'];
+        $args['retries']['fn'] = [__CLASS__, '_applyRetryConfig'];
 
         return $args;
     }
-}
+
+    /** @internal */
+    public static function _applyRetryConfig($value, array &$args, HandlerList $list)
+    {
+        DynamoDbClient::_applyRetryConfig($value, $args, $list, 'dynamodb-streams');
+    }
+}

src/Retry/ConfigurationProvider.php

@@ -46,7 +46,7 @@ class ConfigurationProvider extends AbstractConfigurationProvider
     implements ConfigurationProviderInterface
 {
     const DEFAULT_MAX_ATTEMPTS = 3;
-    const DEFAULT_MODE = 'legacy';
+    const DEFAULT_MODE = 'standard';
     const ENV_MAX_ATTEMPTS = 'AWS_MAX_ATTEMPTS';
     const ENV_MODE = 'AWS_RETRY_MODE';
     const ENV_PROFILE = 'AWS_PROFILE';

src/Retry/ErrorClassifier.php

@@ -36,6 +36,7 @@ final class ErrorClassifier
     private const TRANSIENT_ERRORS = [
         'RequestTimeout'          => true,
         'RequestTimeoutException' => true,
+        'InternalError'           => true,
     ];
 
     private const TRANSIENT_STATUS_CODES = [

src/Retry/ExponentialBackoffDelay.php

@@ -7,40 +7,75 @@
  * Computes delay using exponential backoff with full jitter.
  * Implements __invoke so it can be used as a callable delayer.
  *
+ * Supports error-type-aware and service-aware base values per SEP v2.1:
+ * - Throttling errors: base = 1000 ms
+ * - Non-throttling, non-DynamoDB: base = 50 ms
+ * - Non-throttling, DynamoDB/DynamoDB Streams: base = 25 ms
+ *
+ * Jitter is applied AFTER the MAX_BACKOFF cap:
+ *   delay = b * min(x * 2^i, MAX_BACKOFF)
+ *
  * @internal
  */
 final class ExponentialBackoffDelay
 {
+    private const DYNAMODB_SERVICES = [
+        'dynamodb' => true,
+        'dynamodb-streams' => true,
+    ];
+
     public function __construct(private readonly int $maxBackoff = 20000)
     {}
 
     /**
      * Computes delay in milliseconds for the given attempt number.
      *
      * @param int $attempts Current attempt number
+     * @param bool $isThrottlingError Whether the error is a throttling error
+     * @param string|null $service The service name (e.g. 'dynamodb')
      * @return int Delay in milliseconds
      */
-    public function __invoke(int $attempts): int
-    {
-        return $this->computeDelay($attempts);
+    public function __invoke(
+        int $attempts,
+        bool $isThrottlingError = false,
+        ?string $service = null
+    ): int {
+        return $this->computeDelay($attempts, $isThrottlingError, $service);
     }
 
     /**
      * Computes delay in milliseconds using exponential backoff with full jitter.
      *
+     * Formula: b * min(x * 2^i, MAX_BACKOFF)
+     * where b is random jitter [0,1], x is error/service-aware base, i is attempt number.
+     *
      * @param int $attempts Current attempt number
+     * @param bool $isThrottlingError Whether the error is a throttling error
+     * @param string|null $service The service name
      * @return int Delay in milliseconds
      */
-    public function computeDelay(int $attempts): int
-    {
+    public function computeDelay(
+        int $attempts,
+        bool $isThrottlingError = false,
+        ?string $service = null
+    ): int {
         $max = mt_getrandmax();
         try {
             $rand = random_int(0, $max) / $max;
         } catch (Exception $_) {
-            // fallback to prevent failing
             $rand = mt_rand(0, $max) / $max;
         }
 
-        return (int) min(1000 * $rand * pow(2, $attempts), $this->maxBackoff);
+        // Determine base in milliseconds based on error type and service
+        if ($isThrottlingError) {
+            $baseMs = 1000;
+        } elseif ($service !== null && isset(self::DYNAMODB_SERVICES[strtolower($service)])) {
+            $baseMs = 25;
+        } else {
+            $baseMs = 50;
+        }
+
+        // Apply MAX_BACKOFF cap BEFORE jitter: b * min(x * 2^i, MAX_BACKOFF)
+        return (int) ($rand * min($baseMs * pow(2, $attempts), $this->maxBackoff));
     }
 }

src/Retry/QuotaManager.php

@@ -12,7 +12,7 @@ class QuotaManager
     private readonly int $initialRetryTokens;
     private readonly int $noRetryIncrement;
     private readonly int $retryCost;
-    private readonly int $timeoutRetryCost;
+    private readonly int $throttlingRetryCost;
     private readonly int $maxCapacity;
     private int $availableCapacity;
     private ?int $capacityAmount = null;
@@ -21,16 +21,16 @@ public function __construct(array $config = [])
     {
         $this->initialRetryTokens = $config['initial_retry_tokens'] ?? 500;
         $this->noRetryIncrement = $config['no_retry_increment'] ?? 1;
-        $this->retryCost = $config['retry_cost'] ?? 5;
-        $this->timeoutRetryCost = $config['timeout_retry_cost'] ?? 10;
+        $this->retryCost = $config['retry_cost'] ?? 14;
+        $this->throttlingRetryCost = $config['throttling_retry_cost'] ?? 5;
         $this->maxCapacity = $this->initialRetryTokens;
         $this->availableCapacity = $this->initialRetryTokens;
     }
 
-    public function hasRetryQuota(mixed $result): bool
+    public function hasRetryQuota(mixed $result, bool $isThrottlingError = false): bool
     {
-        if ($result instanceof AwsException && $result->isConnectionError()) {
-            $this->capacityAmount = $this->timeoutRetryCost;
+        if ($isThrottlingError) {
+            $this->capacityAmount = $this->throttlingRetryCost;
         } else {
             $this->capacityAmount = $this->retryCost;
         }

src/Retry/RetryDecider.php

@@ -45,17 +45,19 @@ public function __invoke(
         $isRetryable = $this->classifier->isRetryable($result);
 
         if ($isRetryable) {
-            // Retrieve retry tokens and check if quota has been exceeded
-            if (!$this->quotaManager->hasRetryQuota($result)) {
-                return false;
-            }
-
+            // Check max attempts BEFORE deducting quota tokens
             if ($attempts >= $maxAttempts) {
                 if ($result instanceof AwsException) {
                     $result->setMaxRetriesExceeded();
                 }
                 return false;
             }
+
+            // Retrieve retry tokens and check if quota has been exceeded
+            $isThrottlingError = $this->classifier->isThrottlingError($result);
+            if (!$this->quotaManager->hasRetryQuota($result, $isThrottlingError)) {
+                return false;
+            }
         }
 
         return $isRetryable;