Explain the 'Circuit Breaker' pattern. When would you use it in a Node.js microservice environment?

Question

Accepted Answer

The Circuit Breaker pattern is a fault-tolerance design that wraps calls to external services or APIs, monitoring their success and failure rates . When failures reach a configured threshold, the circuit "trips" (opens), and subsequent calls fail immediately or return a fallback response without attempting the actual service call. After a timeout period, the circuit allows limited test requests (half-open state) to determine if the service has recovered . This pattern draws its name from electrical circuit breakers—just as an electrical breaker stops current flow to prevent fires, a software circuit breaker stops request flow to prevent system overload and cascading failures . The core principle is failing fast: rather than waiting for timeouts on every request to an unhealthy service, the circuit breaker immediately returns errors, preserving system resources and responsiveness . **Closed (Normal Operation)**: Requests pass through to the service. The circuit tracks failures; if failures exceed the threshold (e.g., 50% of requests fail), it transitions to open . **Open (Tripped)**: Requests are blocked immediately, returning errors or fallback responses. The circuit remains open for a configured recovery timeout (e.g., 10 seconds) . **Half-Open (Testing Recovery)**: After the timeout, the circuit allows a limited number of test requests. If successful, it closes; if failures persist, it reopens . const CircuitBreaker = require('opossum');

// Service call to protect
async function callExternalAPI() {
  const response = await axios.get('https://api.example.com/data');
  return response.data;
}

// Circuit breaker options
const options = {
  timeout: 3000,                      // 3 second timeout
  errorThresholdPercentage: 50,       // Trip when 50% of requests fail
  resetTimeout: 10000                 // Wait 10 seconds before retry
};

const breaker = new CircuitBreaker(callExternalAPI, options);

// Optional: Define fallback response
breaker.fallback(() => ({ data: 'Service unavailable, using cached data' }));

// Use in your route
app.get('/data', async (req, res) => {
  try {
    const result = await breaker.fire();
    res.json(result);
  } catch (err) {
    res.status(503).json({ error: 'Service temporarily unavailable' });
  }
});

// Event monitoring
breaker.on('open', () => console.log('Circuit opened - service failing'));
breaker.on('halfOpen', () => console.log('Circuit half-open - testing service'));
breaker.on('close', () => console.log('Circuit closed - service recovered')); Opossum is the most widely used circuit breaker library for Node.js, with over 230,000 weekly downloads . Red Hat provides a supported version (`@redhat/opossum`) for enterprise use . The library offers comprehensive event monitoring (`open`, `close`, `halfOpen`, `timeout`, `failure`) for observability integration . **External API Calls**: When your service depends on third-party APIs that may experience outages or rate limiting . **Database Connections**: For protecting against database connection failures or query timeouts that could cascade through your service . **Inter-Service Communication**: When microservices call each other synchronously over HTTP or gRPC . **Legacy System Integration**: When integrating with unstable internal systems that cannot be easily modified . **Any Unreliable Dependency**: Any downstream service where failures are possible and could impact your service's responsiveness . **Failure Threshold**: Set based on your service's normal error rate—too low causes false trips, too high delays failure detection . **Timeout Duration**: Should align with your service's acceptable response time; shorter timeouts detect failures faster . **Reset Timeout**: Determines how long before testing recovery; balance between quick recovery and giving the service time to heal . **Fallback Strategy**: Provide meaningful fallback responses—cached data, default values, or degraded functionality . **Monitoring**: Track circuit state changes and failure rates for observability and alerting . The Circuit Breaker pattern is essential in microservice architectures where a single failing service can trigger cascading failures across the entire system . By failing fast and providing fallbacks, it maintains system stability and user experience even when dependencies are unavailable . In Node.js environments, libraries like Opossum provide battle-tested implementations that integrate seamlessly with existing HTTP clients and Promise-based code .

Explain the 'Circuit Breaker' pattern. When would you use it in a Node.js microservice environment?

The Circuit Breaker pattern prevents cascading failures in distributed systems by monitoring service calls and temporarily stopping requests to a failing service, allowing it time to recover.

Explain the 'Circuit Breaker' pattern. When would you use it in a Node.js microservice environment?

The Circuit Breaker pattern prevents cascading failures in distributed systems by monitoring service calls and temporarily stopping requests to a failing service, allowing it time to recover.

Scenario Questions

Follow-up Questions