One Service Went Down.
The Entire App Crashed.

/* ── 1. Add dependency (build.gradle) ─────────────────── */
implementation 'io.github.resilience4j:resilience4j-spring-boot3:2.2.0'

/* ── 2. Configure in application.yml ──────────────────── */
resilience4j:
  circuitbreaker:
    instances:
      razorpay:
        slidingWindowType: COUNT_BASED
        slidingWindowSize: 10          # track last 10 calls
        failureRateThreshold: 50       # trip if >50% fail
        waitDurationInOpenState: 30s  # stay OPEN 30 seconds
        permittedNumberOfCallsInHalfOpenState: 3
        slowCallDurationThreshold: 2s # slow = failure too
        slowCallRateThreshold: 80

/* ── 3. Use in your service ────────────────────────────── */
@Service
public class PaymentService {

    // Primary: Razorpay. Fallback: Paytm
    @CircuitBreaker(name = "razorpay", fallbackMethod = "payViaPaytm")
    public PaymentResult payViaRazorpay(PaymentRequest req) {
        // This call is protected by the CB
        return razorpayClient.processPayment(req);
    }

    // Called automatically when CB is OPEN or call fails
    public PaymentResult payViaPaytm(PaymentRequest req, Exception ex) {
        log.warn("Razorpay CB open, using Paytm fallback", ex);
        return paytmClient.processPayment(req);
    }
}

/* ── 4. Monitor CB state changes ──────────────────────── */
@Component
public class CBEventListener {

    @EventListener
    public void onOpen(CircuitBreakerOnStateTransitionEvent e) {
        if (e.getStateTransition().getToState() == OPEN) {
            alertService.page("Razorpay CB tripped OPEN");
        }
    }
}

// npm install opossum

const CircuitBreaker = require('opossum');

// ── 1. Configure ─────────────────────────────────────────
const options = {
  timeout: 3000,                  // treat as failure if takes >3s
  errorThresholdPercentage: 50,    // trip OPEN if 50% of calls fail
  resetTimeout: 30000,             // wait 30s before HALF-OPEN
  volumeThreshold: 5,             // minimum calls before tripping
};

// ── 2. Wrap your external call ───────────────────────────
async function callRazorpay(req) {
  const res = await fetch('https://api.razorpay.com/v1/payments', {
    method: 'POST', body: JSON.stringify(req)
  });
  if (!res.ok) throw new Error(`Razorpay error: ${res.status}`);
  return res.json();
}

const breaker = new CircuitBreaker(callRazorpay, options);

// ── 3. Define fallback ───────────────────────────────────
breaker.fallback(async (req) => {
  console.warn('CB OPEN — routing to Paytm');
  return callPaytm(req);           // secondary payment provider
});

// ── 4. Listen to state changes ───────────────────────────
breaker.on('open',     () => logger.alert('Razorpay CB → OPEN'));
breaker.on('halfOpen', () => logger.info('Razorpay CB → HALF-OPEN (testing)'));
breaker.on('close',    () => logger.info('Razorpay CB → CLOSED (recovered)'));
breaker.on('fallback', () => metrics.increment('payment.fallback.paytm'));

// ── 5. Use it ────────────────────────────────────────────
app.post('/pay', async (req, res) => {
  try {
    const result = await breaker.fire(req.body);  // CB handles everything
    res.json({ success: true, data: result });
  } catch (err) {
    res.status(503).json({ error: 'Payment unavailable' });
  }
});

# pip install pybreaker requests

import pybreaker
import requests
import logging
from functools import wraps

# ── 1. Configure the breaker ──────────────────────────────
class PaymentListener(pybreaker.CircuitBreakerListener):
    def state_change(self, cb, old_state, new_state):
        logging.warning(
            f"CircuitBreaker '{cb.name}': {old_state} → {new_state}"
        )
        if str(new_state) == "open":
            alert_oncall(f"CB OPEN: {cb.name} — switching to fallback")

razorpay_breaker = pybreaker.CircuitBreaker(
    fail_max=5,                  # trip after 5 consecutive failures
    reset_timeout=30,            # wait 30s before HALF-OPEN
    name="razorpay",
    listeners=[PaymentListener()]
)

# ── 2. Protect the external call ──────────────────────────
@razorpay_breaker          # decorator wraps the function
def call_razorpay(payload: dict) -> dict:
    response = requests.post(
        "https://api.razorpay.com/v1/payments",
        json=payload,
        timeout=3             # always set a timeout!
    )
    response.raise_for_status()
    return response.json()

# ── 3. Route to fallback when CB is OPEN ──────────────────
def process_payment(payload: dict) -> dict:
    try:
        return call_razorpay(payload)
    except pybreaker.CircuitBreakerError:
        # CB is OPEN — fail fast, use Paytm
        logging.warning("Razorpay CB open — routing to Paytm")
        return call_paytm(payload)
    except requests.RequestException as e:
        # Real error — CB records it, may trip
        raise PaymentError(str(e)) from e

# ── 4. Check state programmatically ───────────────────────
def health_check():
    return {
        "razorpay_cb_state": str(razorpay_breaker.current_state),
        "fail_count": razorpay_breaker.fail_counter
    }

// go get github.com/sony/gobreaker

package payment

import (
    "errors"
    "log"
    "time"
    "github.com/sony/gobreaker"
)

// ── 1. Configure the breaker ──────────────────────────────
var razorpayCB = gobreaker.NewCircuitBreaker(gobreaker.Settings{
    Name:        "razorpay",
    MaxRequests: 3,           // max calls in HALF-OPEN state
    Interval:    10 * time.Second, // sliding window size
    Timeout:     30 * time.Second, // OPEN → HALF-OPEN after 30s

    // Trip OPEN when ≥50% of last 10 calls fail
    ReadyToTrip: func(counts gobreaker.Counts) bool {
        failureRatio := float64(counts.TotalFailures) /
                        float64(counts.Requests)
        return counts.Requests >= 10 && failureRatio >= 0.5
    },

    // Log every state change
    OnStateChange: func(name string, from, to gobreaker.State) {
        log.Printf("CB %s: %s → %s", name, from, to)
        if to == gobreaker.StateOpen {
            alertOncall("Razorpay CB tripped OPEN")
        }
    },
})

// ── 2. Wrap the external call ─────────────────────────────
func callRazorpay(payload PaymentRequest) (PaymentResult, error) {
    result, err := razorpayCB.Execute(func() (interface{}, error) {
        resp, err := httpClient.Post(
            "https://api.razorpay.com/v1/payments",
            payload,
        )
        if err != nil {
            return nil, err   // counts as failure in CB
        }
        return resp, nil
    })
    if err != nil {
        return PaymentResult{}, err
    }
    return result.(PaymentResult), nil
}

// ── 3. Use with fallback ──────────────────────────────────
func ProcessPayment(payload PaymentRequest) (PaymentResult, error) {
    result, err := callRazorpay(payload)

    if errors.Is(err, gobreaker.ErrOpenState) {
        // CB is OPEN — fast fail, use Paytm immediately
        log.Println("Razorpay CB open — routing to Paytm")
        return callPaytm(payload)
    }

    if err != nil {
        return PaymentResult{}, fmt.Errorf("payment failed: %w", err)
    }
    return result, nil
}