Fault Tolerance & Circuit Breakers

# Python Circuit Breaker with 3 States & Fallback
import time
from enum import Enum

class State(Enum):
    CLOSED = "CLOSED"
    OPEN = "OPEN"
    HALF_OPEN = "HALF_OPEN"

class CircuitBreaker:
    def __init__(self, failure_threshold=3, recovery_time=10):
        self.state = State.CLOSED
        self.failure_count = 0
        self.failure_threshold = failure_threshold
        self.recovery_time = recovery_time
        self.last_failure_time = 0

    def call(self, func, fallback_func):
        now = time.time()
        if self.state == State.OPEN:
            if now - self.last_failure_time > self.recovery_time:
                self.state = State.HALF_OPEN
            else:
                return fallback_func() # Fail-Fast in 0.2ms!

        try:
            result = func()
            if self.state == State.HALF_OPEN:
                self.state = State.CLOSED
                self.failure_count = 0
            return result
        except Exception as e:
            self.failure_count += 1
            self.last_failure_time = now
            if self.failure_count >= self.failure_threshold:
                self.state = State.OPEN
            return fallback_func()

// C++20 Thread-Safe Circuit Breaker
#include <chrono>
#include <functional>
#include <mutex>

enum class CBState { CLOSED, OPEN, HALF_OPEN };

class CircuitBreaker {
    CBState state = CBState::CLOSED;
    int failures = 0, threshold = 3;
    std::chrono::seconds cooldown{10};
    std::chrono::steady_clock::time_point lastTrip;
    std::mutex mtx;
public:
    template<typename T>
    T execute(std::function<T()> op, std::function<T()> fallback) {
        std::lock_guard<std::mutex> lock(mtx);
        auto now = std::chrono::steady_clock::now();
        if (state == CBState::OPEN) {
            if (now - lastTrip > cooldown) state = CBState::HALF_OPEN;
            else return fallback();
        }
        try {
            T res = op();
            if (state == CBState::HALF_OPEN) { state = CBState::CLOSED; failures = 0; }
            return res;
        } catch (...) {
            if (++failures >= threshold) { state = CBState::OPEN; lastTrip = now; }
            return fallback();
        }
    }
};

// Java Resilience4j Circuit Breaker Pattern
public class ResilientOrderService {
    private final CircuitBreaker breaker = CircuitBreaker.of("inventoryService", 
        CircuitBreakerConfig.custom()
            .failureRateThreshold(50.0f)
            .waitDurationInOpenState(Duration.ofSeconds(10))
            .slidingWindowSize(100)
            .build());

    public InventoryResponse getInventory(String itemId) {
        return Try.ofSupplier(CircuitBreaker.decorateSupplier(breaker, () -> remoteCall(itemId)))
            .recover(CallNotPermittedException.class, e -> fallbackCache(itemId))
            .get();
    }
}

// Go Circuit Breaker (Sony/gobreaker style)
type CircuitBreaker struct {
    state       State
    failures    int
    lastFailure time.Time
    mu          sync.Mutex
}

func (cb *CircuitBreaker) Execute(req func() (any, error), fallback func() any) (any, error) {
    cb.mu.Lock()
    if cb.state == StateOpen {
        if time.Since(cb.lastFailure) > 10*time.Second {
            cb.state = StateHalfOpen
        } else {
            cb.mu.Unlock()
            return fallback(), nil // Instant fallback!
        }
    }
    cb.mu.Unlock()

    res, err := req()
    if err != nil {
        cb.recordFailure()
        return fallback(), nil
    }
    cb.recordSuccess()
    return res, nil
}

// TypeScript Circuit Breaker with Jitter
export class CircuitBreaker {
  private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
  private failures = 0;
  private lastFailure = 0;

  constructor(private threshold = 3, private cooldownMs = 10000) {}

  async exec<T>(fn: () => Promise<T>, fallback: () => T): Promise<T> {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailure > this.cooldownMs) {
        this.state = 'HALF_OPEN';
      } else {
        return fallback(); // Fail-Fast in 0.1ms
      }
    }
    try {
      const res = await fn();
      this.state = 'CLOSED';
      this.failures = 0;
      return res;
    } catch (err) {
      this.failures++;
      this.lastFailure = Date.now();
      if (this.failures >= this.threshold) this.state = 'OPEN';
      return fallback();
    }
  }
}