Pattern: Circuit Breaker for resilient service calls

When a downstream service is failing, continuing to call it wastes resources and can cascade failures. Need automatic detection of failures and temporary bypass.

Implement the Circuit Breaker pattern with three states:

1. CLOSED (normal): Requests pass through. Count failures.

If failures exceed threshold -> switch to OPEN

1. OPEN (failing): Requests fail immediately without calling the service.

After timeout period -> switch to HALF_OPEN

1. HALF_OPEN (testing): Allow one request through.

If success -> switch to CLOSED
If failure -> switch back to OPEN

class CircuitBreaker:
def __init__(self, failure_threshold=5, reset_timeout=60):
self.state = 'CLOSED'
self.failures = 0
self.threshold = failure_threshold
self.reset_timeout = reset_timeout
self.last_failure_time = None

def call(self, func, *args):
if self.state == 'OPEN':
if time.time() - self.last_failure_time > self.reset_timeout:
self.state = 'HALF_OPEN'
else:
raise CircuitOpenError('Circuit is open')

try:
result = func(*args)
self._on_success()
return result
except Exception as e:
self._on_failure()
raise

def _on_success(self):
self.failures = 0
self.state = 'CLOSED'

def _on_failure(self):
self.failures += 1
self.last_failure_time = time.time()
if self.failures >= self.threshold:
self.state = 'OPEN'

Circuit breakers prevent cascade failures by failing fast when a service is down, giving it time to recover instead of overwhelming it.