Circuit Breaker Pattern — Bảo vệ hệ thống khỏi Cascading Failure

#⚡ Ý tưởng gốc

Circuit Breaker trong software mượn khái niệm từ cầu dao điện (electrical circuit breaker) — khi dòng điện quá tải → cầu dao tự ngắt → bảo vệ cả hệ thống khỏi cháy nổ.

Tương tự, khi một dependency (ví dụ AirHost API) liên tục fail → Circuit Breaker ngắt kết nối, không gọi nữa → bảo vệ hệ thống của bạn khỏi cascading failure.

Pattern này được phổ biến bởi Michael Nygard trong cuốn Release It! (2007) và là một trong những core patterns của resilient distributed systems.

#🔄 3 trạng thái của Circuit Breaker

stateDiagram-v2
    [*] --> Closed
    Closed --> Open : Failures vượt threshold
    Open --> HalfOpen : Hết thời gian chờ (cooldown)
    HalfOpen --> Closed : Request thử thành công
    HalfOpen --> Open : Request thử vẫn fail

#🤔 Tại sao cần Circuit Breaker? (Không có thì sao?)

#Scenario: AirHost down 5 phút, KHÔNG có Circuit Breaker

1. Mỗi request tạo booking → gọi AirHost → chờ timeout 10s → fail
2. 100 request/phút → 100 worker/thread bị block 10s mỗi cái
3. Worker pool cạn kiệt → API của bạn cũng chết theo (cascading failure)
4. Các endpoint khác (search, list bookings) cũng bị ảnh hưởng vì không còn worker
5. Toàn bộ system down chỉ vì 1 dependency down

#Scenario: CÓ Circuit Breaker

1. AirHost fail 10 lần → breaker Open
2. Request tiếp theo → trả lỗi ngay trong 0ms ("Service temporarily unavailable")
3. Worker không bị block → các endpoint khác hoạt động bình thường
4. Sau 30s → Half-Open → thử 1 request → AirHost recover → Closed → hoạt động lại

#🔧 Các thông số cấu hình quan trọng

#💻 Implementation trong Laravel/PHP

#Cách 1: Tự implement đơn giản với Redis

class CircuitBreaker
{
    private string $service;
    private int $failureThreshold;
    private int $cooldownPeriod;

    const STATE_CLOSED = 'closed';
    const STATE_OPEN = 'open';
    const STATE_HALF_OPEN = 'half_open';

    public function __construct(
        string $service,
        int $failureThreshold = 5,
        int $cooldownPeriod = 30
    ) {
        $this->service = $service;
        $this->failureThreshold = $failureThreshold;
        $this->cooldownPeriod = $cooldownPeriod;
    }

    public function call(callable $action, callable $fallback = null)
    {
        $state = $this->getState();

        if ($state === self::STATE_OPEN) {
            // Fail-fast: không gọi dependency
            return $fallback ? $fallback() : throw new CircuitOpenException(
                "Circuit breaker is OPEN for {$this->service}"
            );
        }

        try {
            $result = $action();
            $this->recordSuccess();
            return $result;
        } catch (\Throwable $e) {
            $this->recordFailure();
            if ($fallback) return $fallback();
            throw $e;
        }
    }

    private function getState(): string
    {
        $failures = (int) Redis::get("cb:{$this->service}:failures");
        $openedAt = Redis::get("cb:{$this->service}:opened_at");

        if ($failures >= $this->failureThreshold) {
            if ($openedAt && (time() - $openedAt) >= $this->cooldownPeriod) {
                return self::STATE_HALF_OPEN;
            }
            return self::STATE_OPEN;
        }

        return self::STATE_CLOSED;
    }

    private function recordFailure(): void
    {
        $failures = Redis::incr("cb:{$this->service}:failures");
        if ($failures >= $this->failureThreshold) {
            Redis::set("cb:{$this->service}:opened_at", time());
        }
    }

    private function recordSuccess(): void
    {
        Redis::del("cb:{$this->service}:failures");
        Redis::del("cb:{$this->service}:opened_at");
    }
}

#Sử dụng:

$breaker = new CircuitBreaker('airhost_api', failureThreshold: 5, cooldownPeriod: 30);

$result = $breaker->call(
    action: fn() => Http::timeout(5)->post('https://api.airhost.co/bookings', $data),
    fallback: fn() => ['status' => 'queued', 'message' => 'Booking sẽ được xử lý sau']
);

#Cách 2: Dùng package ackintosh/ganesha (production-ready)

composer require ackintosh/ganesha

use Ackintosh\Ganesha;
use Ackintosh\Ganesha\Builder;
use Ackintosh\Ganesha\Storage\Adapter\Redis as GaneshaRedis;

$ganesha = Builder::withRateStrategy()
    ->adapter(new GaneshaRedis($redis))
    ->failureRateThreshold(50)       // 50% failure rate
    ->intervalToHalfOpen(10)          // 10s cooldown
    ->minimumRequests(10)             // Ít nhất 10 request trước khi tính rate
    ->timeWindow(30)                  // Sliding window 30s
    ->build();

if (!$ganesha->isAvailable('airhost_api')) {
    // Circuit is OPEN → fail-fast
    return response()->json(['error' => 'Service temporarily unavailable'], 503);
}

try {
    $response = Http::timeout(5)->post('https://api.airhost.co/bookings', $data);
    $ganesha->success('airhost_api');
    return $response;
} catch (\Exception $e) {
    $ganesha->failure('airhost_api');
    throw $e;
}

#🧩 Circuit Breaker kết hợp với các pattern khác

#⚠️ Những sai lầm phổ biến khi implement

#📊 Monitoring & Alerting

Circuit Breaker phải có observability — nếu không bạn sẽ không biết khi nào breaker mở:

• Metrics cần track:
  • Số lần state transition (Closed → Open, Open → Half-Open, ...)
  • Current state per service
  • Failure rate trong sliding window
  • Số request bị reject (fail-fast) khi breaker Open
• Alerting:
  • Alert khi breaker chuyển sang Open → team biết dependency đang có vấn đề
  • Alert khi breaker ở Open quá lâu (>5 phút) → cần manual intervention
• Tools: Prometheus + Grafana, Datadog, hoặc đơn giản là Laravel Log + Slack webhook

// Log state transitions
Log::warning('Circuit breaker OPENED', [
    'service' => 'airhost_api',
    'failures' => $failures,
    'threshold' => $this->failureThreshold,
]);

// Slack notification
Slack::send("🔴 Circuit Breaker OPEN for airhost_api — {$failures} failures in last 60s");

#🏗️ Khi nào KHÔNG cần Circuit Breaker?

• Dependency là internal service cùng infra và có health check + auto-restart → retry + timeout đủ rồi
• Fire-and-forget jobs — job fail thì retry sau, không block user request
• Read-only cache (Redis cache) — miss cache thì fallback về DB, không cần breaker
• Hệ thống monolith đơn giản — chỉ 1–2 external API, traffic thấp → try-catch + retry là đủ

#📚 Tham khảo

• Martin Fowler — Circuit Breaker
• Microsoft — Circuit Breaker Pattern
• Release It! — Michael Nygard
• ackintosh/ganesha — PHP Circuit Breaker
• Resilience4j (Java) — Circuit Breaker docs — tham khảo concept dù không dùng Java