Resilience¶

Effect methods can be decorated with resilience attributes on the target interface. The generator wraps the Eff with LanguageExt-native retry(), timeout(), circuit breaker, and recovery — no Polly dependency.

Attributes¶

[Retry]¶

public interface IPaymentGateway
{
    [Retry(MaxAttempts = 5, DelayMs = 500)]
    Task<string> ChargeAsync(decimal amount);
}

[Timeout]¶

[Timeout(5_000)]
Task<List<Result>> SearchAsync(string query);

[CircuitBreaker]¶

States: Closed → calls pass through; Open → immediate failure; Half-Open → one call allowed, success closes, failure reopens.

[Recover]¶

Handles permanent failures after retries are exhausted.

public interface IConfigService
{
    [Retry(MaxAttempts = 3)]
    [Recover(typeof(HttpRequestException), Fallback = nameof(LoadFromFile))]
    Task<AppConfig> LoadConfigAsync(string environment);

    Task<AppConfig> LoadFromFile(string environment);
}

For simple cases:

[Recover(typeof(NotFoundException), Default = "User.Guest")]
Task<User> GetUserAsync(int id);

The *Unrecovered companion method is always generated alongside for cases where you need the raw failure to propagate.

Composition Order¶

When multiple attributes are combined, they compose inside-out:

retry(                              ← outermost
  timeout(                          ← middle
    liftEff(...)                    ← raw call
      .WithActivity(...)            ← tracing per attempt
  ).WithCircuitBreaker(...)         ← wraps timed call
).As()
  | @catch(recovery)                ← recovery after all retries

Each retry attempt gets its own OpenTelemetry span.

Interfaces You Don't Own¶

When the target interface is generated or from a third-party library, extend it:

public interface IResilientArticleStore : IArticleStore
{
    [Retry(MaxAttempts = 3, DelayMs = 500)]
    [Timeout(5_000)]
    new Task<Option<Article>> GetByIdAsync(ArticleId id);
}

[EffectsModule(typeof(IResilientArticleStore))]
public sealed partial class ResilientArticleEffects;

Redeclared methods get resilience wrapping; inherited methods pass through unchanged.

Resilience in Event Queue Handlers¶

Effects resilience and event queue retry policies operate at different layers and are complementary:

They compose naturally in the call stack:

Queue retry (ChannelWorker — transport level)
  └─ DispatchAsync → handler.Handle(evt)
       └─ Eff composition
            └─ [Retry] on IPaymentGateway.ChargeAsync     ← Effects resilience
            └─ [Timeout] on IInventoryService.ReserveAsync ← Effects resilience

Use Effects resilience for transient infrastructure failures (network blips, 503s, connection timeouts) — fast retries, low delay, circuit breakers to protect downstream services.

Use queue retry for handler-level failures (unhandled exceptions, poison messages, resource unavailable) — slow retries with transport-level backoff, dead-lettering after exhaustion.

Diagnostics¶