Circuit Breaker & Resilience

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;

// Configure circuit breaker
CircuitBreakerConfig config = CircuitBreakerConfig.custom()
    .failureRateThreshold(50)                    // Open at 50% failure rate
    .waitDurationInOpenState(Duration.ofSeconds(60))  // Stay open for 60s
    .slidingWindowSize(10)                       // Look at last 10 calls
    .minimumNumberOfCalls(5)                     // Need 5 calls before checking
    .permittedNumberOfCallsInHalfOpenState(3)   // Try 3 calls in half-open
    .build();

CircuitBreakerRegistry registry = CircuitBreakerRegistry.of(config);
CircuitBreaker breaker = registry.circuitBreaker("paymentService");

// Use circuit breaker
public PaymentResult processPayment(PaymentRequest request) {
    return breaker.executeSupplier(() -> {
        // This code is protected by circuit breaker
        return paymentClient.process(request);
    });
}

import time
import random

def retry_with_backoff(func, max_retries=5):
    for attempt in range(max_retries):
        try:
            return func()
        except Exception as e:
            if attempt == max_retries - 1:
                raise  # Last attempt, give up

            # Exponential backoff: 1s, 2s, 4s, 8s, 16s
            wait_time = (2 ** attempt) + random.uniform(0, 1)
            print(f"Attempt {attempt + 1} failed. Retrying in {wait_time:.1f}s...")
            time.sleep(wait_time)

# Usage
result = retry_with_backoff(lambda: call_external_api())

const { Worker } = require('worker_threads');

class Bulkhead {
    constructor(maxConcurrent = 10) {
        this.maxConcurrent = maxConcurrent;
        this.currentRunning = 0;
        this.queue = [];
    }

    async execute(task) {
        // Check if we have capacity
        if (this.currentRunning >= this.maxConcurrent) {
            // Wait in queue
            return new Promise((resolve, reject) => {
                this.queue.push({ task, resolve, reject });
            });
        }

        return this._run(task);
    }

    async _run(task) {
        this.currentRunning++;
        try {
            const result = await task();
            return result;
        } finally {
            this.currentRunning--;
            this._processQueue();
        }
    }

    _processQueue() {
        if (this.queue.length > 0 && this.currentRunning < this.maxConcurrent) {
            const { task, resolve, reject } = this.queue.shift();
            this._run(task).then(resolve).catch(reject);
        }
    }
}

// Usage: Separate bulkheads for different services
const paymentBulkhead = new Bulkhead(5);   // Max 5 concurrent payment calls
const shippingBulkhead = new Bulkhead(10); // Max 10 concurrent shipping calls

await paymentBulkhead.execute(() => processPayment(order));
await shippingBulkhead.execute(() => shipOrder(order));