OrderService → PaymentService → InventoryService

public class KafkaPublisher
{
    private readonly IProducer<Null, string> _producer;
    
    public KafkaPublisher(string bootstrapServers) {
        var config = new ProducerConfig { BootstrapServers = bootstrapServers };
        _producer = new ProducerBuilder<Null, string>(config).Build();
    }

    public async Task PublishOrderPlacedAsync(OrderPlacedEvent orderPlaced) {
        var message = JsonSerializer.Serialize(orderPlaced);
        await _producer.ProduceAsync("order-events", new Message<Null, string> { Value = message });
    }
}

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
        onRetry: (exception, timeSpan, retryCount, context) => {
            Console.WriteLine($"Retry {retryCount} after {timeSpan.TotalSeconds}s due to: {exception.Message}");
        });

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(
        exceptionsAllowedBeforeBreaking: 2,
        durationOfBreak: TimeSpan.FromSeconds(30),
        onBreak: (ex, breakDelay) => {
            Console.WriteLine($"Circuit broken! Delay: {breakDelay.TotalSeconds}s");
        },
        onReset: () => Console.WriteLine("Circuit closed, operations resumed."),
        onHalfOpen: () => Console.WriteLine("Circuit half-open, testing service."));

var policyWrap = Policy.WrapAsync(retryPolicy, circuitBreakerPolicy);
var response = await policyWrap.ExecuteAsync(() => httpClient.GetAsync("https://inventory-service/api/check-stock"));

public interface IInventoryService {
    Task<string> CheckStockAsync(string productId);
}

public class PrimaryInventoryService : IInventoryService {
    public async Task<string> CheckStockAsync(string productId) {
        throw new HttpRequestException("Primary service unavailable");
    }
}

public class BackupInventoryService : IInventoryService {
    public async Task<string> CheckStockAsync(string productId) {
        return await Task.FromResult("Stock from backup service: 10 units");
    }
}

var backupService = new BackupInventoryService();
var primaryService = new PrimaryInventoryService();

var fallbackPolicy = Policy<string>
    .Handle<HttpRequestException>()
    .FallbackAsync(
        fallbackAction: async cancellationToken => {
            Console.WriteLine("Primary service failed. Using backup...");
            return await backupService.CheckStockAsync("P123");
        });

var result = await fallbackPolicy.ExecuteAsync(async () => {
    return await primaryService.CheckStockAsync("P123");
});

Console.WriteLine(result);