Release: Phase 8.1 - Complete Polly Resilience Integration

src/StarGate.Api/Endpoints/ProcessEndpoints.cs

@@ -27,7 +27,7 @@ public static void MapProcessEndpoints(this IEndpointRouteBuilder app)
             .WithName("CreateProcess")
             .RequireRateLimiting("CreateProcess") // Apply rate limiting policy
             .AddValidation<CreateProcessRequest>()
-            .Produces<ProcessResponse>(StatusCodes.Status201Created)
+            .Produces<ProcessResponse>(StatusCodes.Status202Accepted)
             .Produces(StatusCodes.Status400BadRequest)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden)
@@ -127,7 +127,7 @@ private static async Task<IResult> CreateProcessAsync(
                 "Process created successfully: ProcessId={ProcessId}",
                 process.ProcessId);
 
-            return Results.Created($"/api/processes/{process.ProcessId}", response);
+            return Results.Accepted($"/api/processes/{process.ProcessId}", response);
         }
         catch (PolicyViolationException ex)
         {

src/StarGate.Api/StarGate.Api.csproj

@@ -6,13 +6,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AspNetCore.HealthChecks.MongoDb" Version="8.0.1" />
+    <PackageReference Include="AspNetCore.HealthChecks.MongoDb" Version="8.1.0" />
     <PackageReference Include="AspNetCore.HealthChecks.Rabbitmq" Version="8.0.1" />
     <PackageReference Include="AspNetCore.HealthChecks.Redis" Version="8.0.1" />
     <PackageReference Include="AspNetCore.HealthChecks.UI.Client" Version="8.0.1" />
-    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="12.1.1" />
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="11.9.2" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.0" />
-    <PackageReference Include="MongoDB.Driver" Version="2.22.0" />
+    <PackageReference Include="MongoDB.Driver" Version="2.28.0" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
   </ItemGroup>
 

src/StarGate.Infrastructure/Extensions/ResilienceServiceCollectionExtensions.cs

@@ -0,0 +1,96 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Polly;
+using Polly.Wrap;
+using StarGate.Infrastructure.Resilience;
+
+namespace StarGate.Infrastructure.Extensions;
+
+/// <summary>
+/// Extension methods for registering resilience policies.
+/// </summary>
+public static class ResilienceServiceCollectionExtensions
+{
+    /// <summary>
+    /// Adds resilience policies to the service collection.
+    /// </summary>
+    /// <param name="services">The service collection.</param>
+    /// <param name="configuration">Application configuration.</param>
+    /// <returns>The service collection for chaining.</returns>
+    public static IServiceCollection AddResiliencePolicies(
+        this IServiceCollection services,
+        IConfiguration configuration)
+    {
+        // Register timeout configuration
+        services.Configure<TimeoutConfiguration>(
+            configuration.GetSection("Resilience:Timeout"));
+
+        // Register retry policy configuration
+        services.Configure<RetryPolicyConfiguration>(
+            configuration.GetSection("Resilience:Retry"));
+
+        // Register circuit breaker configuration
+        services.Configure<CircuitBreakerConfiguration>(
+            configuration.GetSection("Resilience:CircuitBreaker"));
+
+        // Register complete wrapped resilience policies (timeout + circuit breaker + retry)
+        services.AddSingleton(provider =>
+        {
+            var timeoutConfig = provider.GetRequiredService<IOptions<TimeoutConfiguration>>().Value;
+            var retryConfig = provider.GetRequiredService<IOptions<RetryPolicyConfiguration>>().Value;
+            var circuitConfig = provider.GetRequiredService<IOptions<CircuitBreakerConfiguration>>().Value;
+            var logger = provider.GetRequiredService<ILogger<RetryPolicyConfiguration>>();
+            return ResiliencePolicyWrapper.CreateCompleteDatabaseResiliencePolicy(
+                timeoutConfig, retryConfig, circuitConfig, logger);
+        });
+
+        services.AddSingleton(provider =>
+        {
+            var timeoutConfig = provider.GetRequiredService<IOptions<TimeoutConfiguration>>().Value;
+            var retryConfig = provider.GetRequiredService<IOptions<RetryPolicyConfiguration>>().Value;
+            var circuitConfig = provider.GetRequiredService<IOptions<CircuitBreakerConfiguration>>().Value;
+            var logger = provider.GetRequiredService<ILogger<RetryPolicyConfiguration>>();
+            return ResiliencePolicyWrapper.CreateCompleteBrokerResiliencePolicy(
+                timeoutConfig, retryConfig, circuitConfig, logger);
+        });
+
+        // Register HTTP complete resilience policy factory as singleton
+        services.AddSingleton(provider =>
+        {
+            var timeoutConfig = provider.GetRequiredService<IOptions<TimeoutConfiguration>>().Value;
+            var retryConfig = provider.GetRequiredService<IOptions<RetryPolicyConfiguration>>().Value;
+            var circuitConfig = provider.GetRequiredService<IOptions<CircuitBreakerConfiguration>>().Value;
+            var loggerFactory = provider.GetRequiredService<ILoggerFactory>();
+
+            // Return a factory function that creates HTTP complete resilience policies with appropriate logger
+            return new Func<ILogger, CompleteHttpResiliencePolicy>(
+                logger => ResiliencePolicyWrapper.CreateCompleteHttpResiliencePolicy(
+                    timeoutConfig, retryConfig, circuitConfig, logger));
+        });
+
+        return services;
+    }
+
+    /// <summary>
+    /// Adds HTTP client without automatic resilience policy.
+    /// Consumers should inject CompleteHttpResiliencePolicy and wrap calls manually.
+    /// </summary>
+    /// <typeparam name="TClient">HTTP client interface type.</typeparam>
+    /// <param name="services">The service collection.</param>
+    /// <param name="name">HTTP client name.</param>
+    /// <returns>HTTP client builder for further configuration.</returns>
+    /// <remarks>
+    /// To use resilience policies:
+    /// 1. Inject CompleteHttpResiliencePolicy via factory
+    /// 2. Wrap HTTP calls: await policy.ExecuteAsync(() => httpClient.SendAsync(request))
+    /// </remarks>
+    public static IHttpClientBuilder AddHttpClientWithResilience<TClient>(
+        this IServiceCollection services,
+        string name)
+        where TClient : class
+    {
+        return services.AddHttpClient<TClient>(name);
+    }
+}

src/StarGate.Infrastructure/Resilience/CircuitBreakerConfiguration.cs

@@ -0,0 +1,42 @@
+namespace StarGate.Infrastructure.Resilience;
+
+/// <summary>
+/// Configuration for circuit breaker policies.
+/// </summary>
+public class CircuitBreakerConfiguration
+{
+    /// <summary>
+    /// Number of consecutive failures before breaking the circuit.
+    /// </summary>
+    public int FailureThreshold { get; set; } = 5;
+
+    /// <summary>
+    /// Percentage of failures in sampling duration before breaking.
+    /// </summary>
+    public double FailureRateThreshold { get; set; } = 0.5; // 50%
+
+    /// <summary>
+    /// Minimum throughput before considering failure rate.
+    /// </summary>
+    public int MinimumThroughput { get; set; } = 10;
+
+    /// <summary>
+    /// Duration to keep circuit open before testing recovery (seconds).
+    /// </summary>
+    public double BreakDurationSeconds { get; set; } = 30.0;
+
+    /// <summary>
+    /// Duration to sample for failure rate calculation (seconds).
+    /// </summary>
+    public double SamplingDurationSeconds { get; set; } = 60.0;
+
+    /// <summary>
+    /// Gets the break duration as TimeSpan.
+    /// </summary>
+    public TimeSpan BreakDuration => TimeSpan.FromSeconds(BreakDurationSeconds);
+
+    /// <summary>
+    /// Gets the sampling duration as TimeSpan.
+    /// </summary>
+    public TimeSpan SamplingDuration => TimeSpan.FromSeconds(SamplingDurationSeconds);
+}

src/StarGate.Infrastructure/Resilience/CircuitBreakerFactory.cs

@@ -0,0 +1,125 @@
+using Microsoft.Extensions.Logging;
+using Polly;
+using Polly.CircuitBreaker;
+
+namespace StarGate.Infrastructure.Resilience;
+
+/// <summary>
+/// Factory for creating Polly circuit breaker policies.
+/// </summary>
+public static class CircuitBreakerFactory
+{
+    /// <summary>
+    /// Creates a circuit breaker policy for HTTP operations.
+    /// </summary>
+    /// <param name="config">Circuit breaker configuration.</param>
+    /// <param name="logger">Logger instance.</param>
+    /// <returns>Configured async circuit breaker policy for HTTP responses.</returns>
+    public static AsyncCircuitBreakerPolicy<HttpResponseMessage> CreateHttpCircuitBreaker(
+        CircuitBreakerConfiguration config,
+        ILogger logger)
+    {
+        return Policy
+            .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
+            .Or<HttpRequestException>()
+            .Or<TimeoutException>()
+            .AdvancedCircuitBreakerAsync(
+                failureThreshold: config.FailureRateThreshold,
+                samplingDuration: config.SamplingDuration,
+                minimumThroughput: config.MinimumThroughput,
+                durationOfBreak: config.BreakDuration,
+                onBreak: (outcome, breakDuration, context) =>
+                {
+                    var statusCode = outcome.Result?.StatusCode.ToString() ?? "N/A";
+                    var exception = outcome.Exception?.GetType().Name ?? "None";
+
+                    logger.LogError(
+                        "HTTP circuit breaker opened: StatusCode={StatusCode}, Exception={Exception}, BreakDuration={BreakDuration}s",
+                        statusCode,
+                        exception,
+                        breakDuration.TotalSeconds);
+                },
+                onReset: context =>
+                {
+                    logger.LogInformation("HTTP circuit breaker reset: Circuit closed");
+                },
+                onHalfOpen: () =>
+                {
+                    logger.LogWarning("HTTP circuit breaker half-open: Testing recovery");
+                });
+    }
+
+    /// <summary>
+    /// Creates a circuit breaker policy for database operations.
+    /// </summary>
+    /// <param name="config">Circuit breaker configuration.</param>
+    /// <param name="logger">Logger instance.</param>
+    /// <returns>Configured async circuit breaker policy for database operations.</returns>
+    public static AsyncCircuitBreakerPolicy CreateDatabaseCircuitBreaker(
+        CircuitBreakerConfiguration config,
+        ILogger logger)
+    {
+        return Policy
+            .Handle<TimeoutException>()
+            .Or<IOException>()
+            .Or<InvalidOperationException>(ex => ex.Message.Contains("connection", StringComparison.OrdinalIgnoreCase))
+            .AdvancedCircuitBreakerAsync(
+                failureThreshold: config.FailureRateThreshold,
+                samplingDuration: config.SamplingDuration,
+                minimumThroughput: config.MinimumThroughput,
+                durationOfBreak: config.BreakDuration,
+                onBreak: (exception, breakDuration, context) =>
+                {
+                    logger.LogError(
+                        exception,
+                        "Database circuit breaker opened: Exception={Exception}, BreakDuration={BreakDuration}s",
+                        exception.GetType().Name,
+                        breakDuration.TotalSeconds);
+                },
+                onReset: context =>
+                {
+                    logger.LogInformation("Database circuit breaker reset: Circuit closed");
+                },
+                onHalfOpen: () =>
+                {
+                    logger.LogWarning("Database circuit breaker half-open: Testing recovery");
+                });
+    }
+
+    /// <summary>
+    /// Creates a circuit breaker policy for message broker operations.
+    /// </summary>
+    /// <param name="config">Circuit breaker configuration.</param>
+    /// <param name="logger">Logger instance.</param>
+    /// <returns>Configured async circuit breaker policy for broker operations.</returns>
+    public static AsyncCircuitBreakerPolicy CreateBrokerCircuitBreaker(
+        CircuitBreakerConfiguration config,
+        ILogger logger)
+    {
+        return Policy
+            .Handle<TimeoutException>()
+            .Or<IOException>()
+            .Or<InvalidOperationException>(ex => ex.Message.Contains("connection", StringComparison.OrdinalIgnoreCase))
+            .AdvancedCircuitBreakerAsync(
+                failureThreshold: config.FailureRateThreshold,
+                samplingDuration: config.SamplingDuration,
+                minimumThroughput: config.MinimumThroughput,
+                durationOfBreak: config.BreakDuration,
+                onBreak: (exception, breakDuration, context) =>
+                {
+                    logger.LogError(
+                        exception,
+                        "Broker circuit breaker opened: Exception={Exception}, BreakDuration={BreakDuration}s",
+                        exception.GetType().Name,
+                        breakDuration.TotalSeconds);
+                },
+                onReset: context =>
+                {
+                    logger.LogInformation("Broker circuit breaker reset: Circuit closed");
+                },
+                onHalfOpen: () =>
+                {
+                    logger.LogWarning("Broker circuit breaker half-open: Testing recovery");
+                });
+    }
+}

src/StarGate.Infrastructure/Resilience/CircuitBreakerStateService.cs

@@ -0,0 +1,50 @@
+using System.Collections.Concurrent;
+using Polly.CircuitBreaker;
+
+namespace StarGate.Infrastructure.Resilience;
+
+/// <summary>
+/// Service for tracking circuit breaker states.
+/// </summary>
+public class CircuitBreakerStateService
+{
+    private readonly ConcurrentDictionary<string, CircuitState> _states = new();
+
+    /// <summary>
+    /// Records circuit state change.
+    /// </summary>
+    /// <param name="circuitName">Name of the circuit.</param>
+    /// <param name="state">New state of the circuit.</param>
+    public void RecordStateChange(string circuitName, CircuitState state)
+    {
+        _states.AddOrUpdate(circuitName, state, (_, __) => state);
+    }
+
+    /// <summary>
+    /// Gets current state of a circuit.
+    /// </summary>
+    /// <param name="circuitName">Name of the circuit.</param>
+    /// <returns>Current state if circuit exists, null otherwise.</returns>
+    public CircuitState? GetState(string circuitName)
+    {
+        return _states.TryGetValue(circuitName, out var state) ? state : null;
+    }
+
+    /// <summary>
+    /// Gets all circuit states.
+    /// </summary>
+    /// <returns>Dictionary of circuit names and their states.</returns>
+    public Dictionary<string, CircuitState> GetAllStates()
+    {
+        return new Dictionary<string, CircuitState>(_states);
+    }
+
+    /// <summary>
+    /// Checks if any circuit is open.
+    /// </summary>
+    /// <returns>True if at least one circuit is open, false otherwise.</returns>
+    public bool HasOpenCircuit()
+    {
+        return _states.Values.Any(state => state == CircuitState.Open);
+    }
+}