Keandalan Microservices & Cloud
SRE, Chaos Engineering & SLO

# ================================================================
# S11409 - Sesi 12: Circuit Breaker & SLO Error Budget
# Dosen: Riadi Marta Dinata, S.Ti., M.Kom. | ISTN Jakarta
# ================================================================

import time, random, statistics
from dataclasses import dataclass, field
from enum import Enum
from typing import List, Callable

# ── CIRCUIT BREAKER IMPLEMENTATION ───────────────────────────
class CBState(Enum):
    CLOSED   = "CLOSED"    # Normal: request berjalan
    OPEN     = "OPEN"      # Gagal: request langsung ditolak
    HALF_OPEN = "HALF_OPEN" # Percobaan: tes apakah service pulih

@dataclass
class CircuitBreaker:
    name: str
    failure_threshold: int = 5      # Gagal berturut → OPEN
    recovery_timeout:  int = 10     # Detik sebelum coba HALF_OPEN
    success_threshold: int = 2      # Sukses berturut di HALF_OPEN → CLOSED

    _state: CBState = field(default=CBState.CLOSED, init=False)
    _failure_count: int = field(default=0, init=False)
    _success_count: int = field(default=0, init=False)
    _last_failure_time: float = field(default=0.0, init=False)
    _call_count: int = field(default=0, init=False)

    @property
    def state(self): return self._state

    def call(self, func: Callable, *args, **kwargs):
        self._call_count += 1

        if self._state == CBState.OPEN:
            elapsed = time.time() - self._last_failure_time
            if elapsed < self.recovery_timeout:
                return None, "CIRCUIT_OPEN — Request ditolak (fail-fast)"
            else:
                self._state = CBState.HALF_OPEN
                self._success_count = 0
                print(f"  [CB:{self.name}] OPEN → HALF_OPEN (mencoba recovery)")

        try:
            result = func(*args, **kwargs)
            self._on_success()
            return result, "OK"
        except Exception as e:
            self._on_failure()
            return None, f"FAILED: {e}"

    def _on_success(self):
        self._failure_count = 0
        if self._state == CBState.HALF_OPEN:
            self._success_count += 1
            if self._success_count >= self.success_threshold:
                self._state = CBState.CLOSED
                print(f"  [CB:{self.name}] HALF_OPEN → CLOSED (service pulih!)")

    def _on_failure(self):
        self._failure_count += 1
        self._last_failure_time = time.time()
        if self._failure_count >= self.failure_threshold:
            if self._state != CBState.OPEN:
                self._state = CBState.OPEN
                print(f"  [CB:{self.name}] CLOSED → OPEN (terlalu banyak error!)")

# ── SIMULASI PAYMENT SERVICE ──────────────────────────────────
def payment_service(amount, service_healthy=True):
    """Simulasi: service sehat vs sakit"""
    if not service_healthy:
        raise ConnectionError("Payment gateway timeout!")
    if amount <= 0:
        raise ValueError("Amount must be positive")
    return {"status": "SUCCESS", "amount": amount,
            "tx_id": f"TX-{random.randint(10000,99999)}"}

print("=" * 60)
print("    CIRCUIT BREAKER SIMULATION")
print("    S11409 ISTN Jakarta")
print("=" * 60)

cb = CircuitBreaker("payment-svc", failure_threshold=3, recovery_timeout=2)

# Fase 1: Service normal
print("\n--- Fase 1: Service Normal (5 request) ---")
for i in range(5):
    result, status = cb.call(payment_service, 100_000, service_healthy=True)
    print(f"  Request {i+1}: {status} | CB State: {cb.state.value}")

# Fase 2: Service mulai gagal
print("\n--- Fase 2: Service Gagal (5 request) ---")
for i in range(5):
    result, status = cb.call(payment_service, 100_000, service_healthy=False)
    print(f"  Request {i+1}: {status} | CB State: {cb.state.value}")

# Fase 3: Tunggu recovery timeout
print("\n--- Fase 3: Menunggu recovery timeout (2 detik)... ---")
time.sleep(2.1)

# Fase 4: Coba kembali (HALF_OPEN)
print("\n--- Fase 4: Coba kembali setelah timeout ---")
for i in range(4):
    result, status = cb.call(payment_service, 100_000, service_healthy=True)
    print(f"  Request {i+1}: {status} | CB State: {cb.state.value}")


# ── SLO ERROR BUDGET TRACKER ──────────────────────────────────
@dataclass
class SLOTracker:
    service_name: str
    slo_target: float = 0.999   # 99.9%
    window_days: int = 30

    _requests: List[dict] = field(default_factory=list, init=False)

    def record(self, success: bool, latency_ms: float):
        self._requests.append({
            "success": success, "latency": latency_ms,
            "timestamp": time.time()
        })

    @property
    def sli(self):
        if not self._requests: return 1.0
        return sum(1 for r in self._requests if r["success"]) / len(self._requests)

    @property
    def error_budget_total(self):
        """Total detik error budget dalam window"""
        return (1 - self.slo_target) * self.window_days * 24 * 3600

    @property
    def error_budget_used(self):
        """Perkiraan detik yang sudah terpakai"""
        error_rate = 1 - self.sli
        return error_rate * self.window_days * 24 * 3600

    @property
    def error_budget_remaining_pct(self):
        total = self.error_budget_total
        if total == 0: return 0
        used = min(self.error_budget_used, total)
        return max(0, (total - used) / total * 100)

    def report(self):
        latencies = [r["latency"] for r in self._requests]
        print(f"\n  Service  : {self.service_name}")
        print(f"  Total req: {len(self._requests)}")
        print(f"  SLI      : {self.sli:.4%}")
        print(f"  SLO Tgt  : {self.slo_target:.4%}")
        status = "OK" if self.sli >= self.slo_target else "VIOLATED"
        print(f"  SLO Status: {status}")
        print(f"  Error Budget Total    : {self.error_budget_total/60:.1f} menit/bulan")
        print(f"  Error Budget Used     : {self.error_budget_used/60:.1f} menit/bulan")
        print(f"  Error Budget Remaining: {self.error_budget_remaining_pct:.1f}%")
        if latencies:
            p50 = statistics.median(latencies)
            p99 = sorted(latencies)[int(len(latencies)*0.99)]
            print(f"  Latency p50: {p50:.0f}ms | p99: {p99:.0f}ms")
        if self.error_budget_remaining_pct < 20:
            print("  !! WARNING: Error budget hampir habis — tahan deploy baru!")

print("\n\n" + "=" * 60)
print("    SLO ERROR BUDGET TRACKER — SIAKAD ISTN")
print("=" * 60)

tracker = SLOTracker("siakad-api", slo_target=0.999)
random.seed(42)

# Simulasi 1000 request (99.2% success rate — di bawah SLO!)
for _ in range(1000):
    success  = random.random() > 0.008   # 0.8% error rate
    latency  = random.gauss(120, 40) if success else random.gauss(4500, 500)
    tracker.record(success, max(10, latency))

tracker.report()
print("\nDone! Gunakan sebagai baseline monitoring SIAKAD.")