서킷 브레이커 패턴

using System;
using System.Collections.Generic;

var clock = new ManualClock();
var api = new FakeRatesApi(failFirst: 3);
var breaker = new CircuitBreaker(clock, failureThreshold: 3, openDuration: TimeSpan.FromSeconds(30));

Call(1);
Call(2);
Call(3);
Call(4);
clock.Advance(TimeSpan.FromSeconds(10));
Call(5);
clock.Advance(TimeSpan.FromSeconds(20));
Call(6);
Call(7);
Console.WriteLine($"api calls: {api.Calls}");

void Call(int n)
{
    CallResult result = breaker.Execute(api.GetRate);
    Console.WriteLine($"t={clock.Seconds}s call {n}: {result}");
}

enum CircuitState { Closed, Open, HalfOpen }
enum Outcome { Ok, Failed, Rejected }

readonly record struct CallResult(Outcome Outcome, string Detail)
{
    public override string ToString() => $"{Outcome} ({Detail})";
}

// 시험용 시계. GetUtcNow만 재정의하며, 그 값은 Advance를 부를 때만 바뀐다.
sealed class ManualClock : TimeProvider
{
    private static readonly DateTimeOffset Start = new(2026, 1, 1, 0, 0, 0, TimeSpan.Zero);
    private DateTimeOffset now = Start;
    public override DateTimeOffset GetUtcNow() => now;
    public void Advance(TimeSpan by) => now += by;
    public int Seconds => (int)(now - Start).TotalSeconds;
}

// 처음 failFirst번은 시간 초과로 실패하고, 그 뒤로는 성공하는 가짜 환율 API.
sealed class FakeRatesApi(int failFirst)
{
    public int Calls { get; private set; }

    public CallResult GetRate()
    {
        Calls++;
        return Calls <= failFirst
            ? new CallResult(Outcome.Failed, "timeout")
            : new CallResult(Outcome.Ok, "USD/KRW 1380");
    }
}

sealed class CircuitBreaker(TimeProvider clock, int failureThreshold, TimeSpan openDuration)
{
    private int consecutiveFailures;
    private DateTimeOffset openedAt;
    public CircuitState State { get; private set; } = CircuitState.Closed;

    public CallResult Execute(Func<CallResult> operation)
    {
        // 열린 지 openDuration이 지났으면 반열림으로 옮기고, 이번 호출을 시험 호출로 보낸다.
        if (State == CircuitState.Open && clock.GetUtcNow() - openedAt >= openDuration)
        {
            MoveTo(CircuitState.HalfOpen, "open duration elapsed");
        }

        // 열린 동안에는 의존성을 부르지 않고 바로 거절한다.
        if (State == CircuitState.Open)
        {
            return new CallResult(Outcome.Rejected, "circuit open");
        }

        CallResult result = operation();
        if (result.Outcome == Outcome.Ok)
        {
            OnSuccess();
            return result;
        }
        OnFailure();
        return result;
    }

    private void OnSuccess()
    {
        consecutiveFailures = 0;
        if (State == CircuitState.HalfOpen)
        {
            MoveTo(CircuitState.Closed, "trial call succeeded");
        }
    }

    private void OnFailure()
    {
        consecutiveFailures++;
        if (State == CircuitState.HalfOpen)
        {
            Trip("trial call failed");
            return;
        }
        if (consecutiveFailures >= failureThreshold)
        {
            Trip($"{consecutiveFailures} consecutive failures");
        }
    }

    private void Trip(string reason)
    {
        openedAt = clock.GetUtcNow();
        MoveTo(CircuitState.Open, reason);
    }

    private void MoveTo(CircuitState next, string reason)
    {
        Console.WriteLine($"  state {State} -> {next}: {reason}");
        State = next;
    }
}

t=0s call 1: Failed (timeout)
t=0s call 2: Failed (timeout)
  state Closed -> Open: 3 consecutive failures
t=0s call 3: Failed (timeout)
t=0s call 4: Rejected (circuit open)
t=10s call 5: Rejected (circuit open)
  state Open -> HalfOpen: open duration elapsed
  state HalfOpen -> Closed: trial call succeeded
t=30s call 6: Ok (USD/KRW 1380)
t=30s call 7: Ok (USD/KRW 1380)
api calls: 5

using System;
using System.Collections.Generic;

var clock = new ManualClock();
// 의존성마다 브레이커를 따로 둔다. 환율 API가 죽어도 재고 API 호출은 막지 않는다.
var policy = new BreakerPolicy(
    FailureThreshold: 3,
    OpenDuration: TimeSpan.FromSeconds(30),
    CountsAsFailure: kind => kind is ErrorKind.Timeout or ErrorKind.Unavailable);
var ratesApi = new ScriptedApi(["timeout", "timeout", "invalid", "unavailable", "timeout", "ok"]);
var stockApi = new ScriptedApi(["ok"]);
var rates = new CircuitBreaker("rates", clock, policy);
var stock = new CircuitBreaker("stock", clock, policy);

GetRate(1);
GetRate(2);
GetRate(3);
GetRate(4);
Print("stock", 1, 1, stock.Execute(stockApi.Call), stock);
clock.Advance(TimeSpan.FromSeconds(30));
GetRate(5);
clock.Advance(TimeSpan.FromSeconds(14));
GetRate(6);
clock.Advance(TimeSpan.FromSeconds(16));
GetRate(7);
Console.WriteLine($"rates api calls: {ratesApi.Calls}, stock api calls: {stockApi.Calls}");

// 환율 조회는 읽기 전용이라 다시 보내도 서버 상태가 바뀌지 않는다. 그래서 재시도해도 된다.
// 재시도는 브레이커 바깥에 두고, 브레이커가 열려 있거나 거절하면 더 시도하지 않는다.
void GetRate(int request)
{
    const int maxAttempts = 2;
    for (int attempt = 1; ; attempt++)
    {
        CallResult result = rates.Execute(ratesApi.Call);
        Print("rates", request, attempt, result, rates);
        bool retryable = result.Outcome == Outcome.Failed && policy.CountsAsFailure(result.Kind);
        if (!retryable || attempt == maxAttempts)
        {
            return;
        }
        // 이 실패로 회로가 열렸으면 백오프를 기다리지 않고 멈춘다. 다음 시도는 어차피 거절된다.
        if (rates.State == CircuitState.Open)
        {
            Console.WriteLine("  retry stopped: circuit open");
            return;
        }
        // 실제 코드라면 백오프만큼 기다린다. 여기서는 가짜 시계를 1초 앞으로 돌린다.
        clock.Advance(TimeSpan.FromSeconds(1));
    }
}

void Print(string name, int request, int attempt, CallResult result, CircuitBreaker breaker) =>
    Console.WriteLine($"t={clock.Seconds}s {name} #{request} try {attempt}: {result} [failures {breaker.ConsecutiveFailures}]");

enum CircuitState { Closed, Open, HalfOpen }
enum Outcome { Ok, Failed, Rejected }
enum ErrorKind { None, Timeout, Unavailable, InvalidRequest, CircuitOpen }

readonly record struct CallResult(Outcome Outcome, ErrorKind Kind)
{
    public override string ToString() => Outcome == Outcome.Ok ? "Ok" : $"{Outcome} {Kind}";
}

// 무엇을 실패로 셀지, 몇 번에 열지, 얼마나 열어 둘지를 한곳에 모은 정책.
sealed record BreakerPolicy(int FailureThreshold, TimeSpan OpenDuration, Func<ErrorKind, bool> CountsAsFailure);

// 시험용 시계. GetUtcNow만 재정의하며, 그 값은 Advance를 부를 때만 바뀐다.
sealed class ManualClock : TimeProvider
{
    private static readonly DateTimeOffset Start = new(2026, 1, 1, 0, 0, 0, TimeSpan.Zero);
    private DateTimeOffset now = Start;
    public override DateTimeOffset GetUtcNow() => now;
    public void Advance(TimeSpan by) => now += by;
    public int Seconds => (int)(now - Start).TotalSeconds;
}

// 정해 둔 순서대로 응답하는 가짜 API.
sealed class ScriptedApi(string[] script)
{
    public int Calls { get; private set; }

    public CallResult Call()
    {
        string next = script[Calls];
        Calls++;
        return next switch
        {
            "ok" => new CallResult(Outcome.Ok, ErrorKind.None),
            "timeout" => new CallResult(Outcome.Failed, ErrorKind.Timeout),
            "unavailable" => new CallResult(Outcome.Failed, ErrorKind.Unavailable),
            "invalid" => new CallResult(Outcome.Failed, ErrorKind.InvalidRequest),
            _ => throw new InvalidOperationException($"unknown script step: {next}"),
        };
    }
}

sealed class CircuitBreaker(string name, TimeProvider clock, BreakerPolicy policy)
{
    private DateTimeOffset openedAt;
    public CircuitState State { get; private set; } = CircuitState.Closed;
    public int ConsecutiveFailures { get; private set; }

    public CallResult Execute(Func<CallResult> operation)
    {
        if (State == CircuitState.Open && clock.GetUtcNow() - openedAt >= policy.OpenDuration)
        {
            MoveTo(CircuitState.HalfOpen, "open duration elapsed");
        }
        if (State == CircuitState.Open)
        {
            return new CallResult(Outcome.Rejected, ErrorKind.CircuitOpen);
        }

        CallResult result = operation();
        if (result.Outcome == Outcome.Ok)
        {
            OnSuccess();
            return result;
        }
        // 잘못된 요청은 상대가 살아 있다는 응답이다. 실패로도 성공으로도 세지 않는다.
        if (!policy.CountsAsFailure(result.Kind))
        {
            return result;
        }
        OnFailure();
        return result;
    }

    private void OnSuccess()
    {
        ConsecutiveFailures = 0;
        if (State == CircuitState.HalfOpen)
        {
            MoveTo(CircuitState.Closed, "trial call succeeded");
        }
    }

    private void OnFailure()
    {
        ConsecutiveFailures++;
        if (State == CircuitState.HalfOpen)
        {
            // 시험 호출이 실패하면 다시 열고, 열린 시각을 지금으로 옮겨 openDuration을 새로 센다.
            Trip("trial call failed");
            return;
        }
        if (ConsecutiveFailures >= policy.FailureThreshold)
        {
            Trip($"{ConsecutiveFailures} consecutive failures");
        }
    }

    private void Trip(string reason)
    {
        openedAt = clock.GetUtcNow();
        MoveTo(CircuitState.Open, reason);
    }

    private void MoveTo(CircuitState next, string reason)
    {
        Console.WriteLine($"  {name}: {State} -> {next}: {reason}");
        State = next;
    }
}

t=0s rates #1 try 1: Failed Timeout [failures 1]
t=1s rates #1 try 2: Failed Timeout [failures 2]
t=1s rates #2 try 1: Failed InvalidRequest [failures 2]
  rates: Closed -> Open: 3 consecutive failures
t=1s rates #3 try 1: Failed Unavailable [failures 3]
  retry stopped: circuit open
t=1s rates #4 try 1: Rejected CircuitOpen [failures 3]
t=1s stock #1 try 1: Ok [failures 0]
  rates: Open -> HalfOpen: open duration elapsed
  rates: HalfOpen -> Open: trial call failed
t=31s rates #5 try 1: Failed Timeout [failures 4]
  retry stopped: circuit open
t=45s rates #6 try 1: Rejected CircuitOpen [failures 4]
  rates: Open -> HalfOpen: open duration elapsed
  rates: HalfOpen -> Closed: trial call succeeded
t=61s rates #7 try 1: Ok [failures 0]
rates api calls: 6, stock api calls: 1

type CircuitState = "Closed" | "Open" | "HalfOpen";
type CallResult = { outcome: "Ok" | "Failed" | "Rejected"; detail: string };

interface Clock { now(): number; }

// 시험용 시계. advance를 부를 때만 시간이 흐른다.
class ManualClock implements Clock {
  #ms = 0;
  now(): number { return this.#ms; }
  advance(ms: number): void { this.#ms += ms; }
  get seconds(): number { return this.#ms / 1000; }
}

// 처음 failFirst번은 시간 초과로 실패하고, 그 뒤로는 성공하는 가짜 환율 API.
class FakeRatesApi {
  calls = 0;
  constructor(private readonly failFirst: number) {}
  getRate = (): CallResult => {
    this.calls++;
    return this.calls <= this.failFirst
      ? { outcome: "Failed", detail: "timeout" }
      : { outcome: "Ok", detail: "USD/KRW 1380" };
  };
}

class CircuitBreaker {
  #state: CircuitState = "Closed";
  #consecutiveFailures = 0;
  #openedAt = 0;

  constructor(
    private readonly clock: Clock,
    private readonly failureThreshold: number,
    private readonly openDurationMs: number,
  ) {}

  execute(operation: () => CallResult): CallResult {
    // 열린 지 openDuration이 지났으면 반열림으로 옮기고, 이번 호출을 시험 호출로 보낸다.
    if (this.#state === "Open" && this.clock.now() - this.#openedAt >= this.openDurationMs) {
      this.#moveTo("HalfOpen", "open duration elapsed");
    }
    // 열린 동안에는 의존성을 부르지 않고 바로 거절한다.
    if (this.#state === "Open") {
      return { outcome: "Rejected", detail: "circuit open" };
    }
    const result = operation();
    if (result.outcome === "Ok") {
      this.#onSuccess();
      return result;
    }
    this.#onFailure();
    return result;
  }

  #onSuccess(): void {
    this.#consecutiveFailures = 0;
    if (this.#state === "HalfOpen") this.#moveTo("Closed", "trial call succeeded");
  }

  #onFailure(): void {
    this.#consecutiveFailures++;
    if (this.#state === "HalfOpen") {
      this.#trip("trial call failed");
      return;
    }
    if (this.#consecutiveFailures >= this.failureThreshold) {
      this.#trip(`${this.#consecutiveFailures} consecutive failures`);
    }
  }

  #trip(reason: string): void {
    this.#openedAt = this.clock.now();
    this.#moveTo("Open", reason);
  }

  #moveTo(next: CircuitState, reason: string): void {
    console.log(`  state ${this.#state} -> ${next}: ${reason}`);
    this.#state = next;
  }
}

const clock = new ManualClock();
const api = new FakeRatesApi(3);
const breaker = new CircuitBreaker(clock, 3, 30_000);

function call(n: number): void {
  const result = breaker.execute(api.getRate);
  console.log(`t=${clock.seconds}s call ${n}: ${result.outcome} (${result.detail})`);
}

call(1);
call(2);
call(3);
call(4);
clock.advance(10_000);
call(5);
clock.advance(20_000);
call(6);
call(7);
console.log(`api calls: ${api.calls}`);

t=0s call 1: Failed (timeout)
t=0s call 2: Failed (timeout)
  state Closed -> Open: 3 consecutive failures
t=0s call 3: Failed (timeout)
t=0s call 4: Rejected (circuit open)
t=10s call 5: Rejected (circuit open)
  state Open -> HalfOpen: open duration elapsed
  state HalfOpen -> Closed: trial call succeeded
t=30s call 6: Ok (USD/KRW 1380)
t=30s call 7: Ok (USD/KRW 1380)
api calls: 5