Create Retry Pattern

Retry Pattern Generator

Creates Retry pattern infrastructure for handling transient failures.

When to Use

Component Characteristics

RetryPolicy

• Configures retry behavior
• Maximum attempts
• Delay strategy (fixed, exponential, linear)
• Jitter support to prevent thundering herd

RetryExecutor

• Executes operations with retry logic
• Tracks attempt count
• Applies delay between retries
• Logs retry attempts

Backoff Strategies

• Fixed: Same delay every time
• Linear: Delay increases linearly
• Exponential: Delay doubles (with optional jitter)

Generation Process

Step 1: Generate Core Components

Path: src/Infrastructure/Resilience/Retry/

1. BackoffStrategy.php — Enum for delay strategies
2. RetryPolicy.php — Configuration with shouldRetry/calculateDelay
3. RetryContext.php — Attempt context value object
4. RetryException.php — Exception with attempt history

Step 2: Generate Executor

Path: src/Infrastructure/Resilience/Retry/

1. RetryExecutor.php — Main retry logic with callbacks
2. SleepInterface.php — For testability

Step 3: Generate Tests

1. RetryPolicyTest.php — Policy behavior tests
2. RetryExecutorTest.php — Executor tests

File Placement

Naming Conventions

Quick Template Reference

RetryPolicy

final readonly class RetryPolicy
{
    public function __construct(
        public int $maxAttempts = 3,
        public int $baseDelayMs = 100,
        public int $maxDelayMs = 10000,
        public float $multiplier = 2.0,
        public bool $useJitter = true,
        public BackoffStrategy $strategy = BackoffStrategy::Exponential,
        public array $retryableExceptions = [],
        public array $nonRetryableExceptions = []
    ) {}

    public static function exponential(int $maxAttempts = 5, int $baseDelayMs = 100): self;
    public static function linear(int $maxAttempts = 5, int $baseDelayMs = 500): self;
    public function shouldRetry(\Throwable $e, int $attempt): bool;
    public function calculateDelay(int $attempt): int;
}

RetryExecutor

final readonly class RetryExecutor
{
    public function execute(
        callable $operation,
        RetryPolicy $policy,
        ?callable $onRetry = null
    ): mixed;
}

Usage Example

$policy = new RetryPolicy(
    maxAttempts: 3,
    baseDelayMs: 200,
    retryableExceptions: [
        ConnectionException::class,
        TimeoutException::class,
    ],
    nonRetryableExceptions: [
        ClientException::class,
    ]
);

try {
    $result = $retryExecutor->execute(
        operation: fn() => $httpClient->get($url),
        policy: $policy,
        onRetry: fn($e, $ctx) => $logger->warning('Retrying...', ['attempt' => $ctx->attempt])
    );
} catch (RetryException $e) {
    // All retries exhausted
    $deadLetter->send($message, $e);
}

Anti-patterns to Avoid

References

For complete PHP templates and examples, see:

• references/templates.md — RetryPolicy, BackoffStrategy, RetryExecutor, RetryContext templates
• references/examples.md — HTTP client, database, message consumer examples and tests