7장: 장애 대응과 회복 탄력성

type CircuitState = "closed" | "open" | "half-open";
 
interface CircuitBreakerConfig {
  failureThreshold: number;
  resetTimeoutMs: number;
  halfOpenMaxAttempts: number;
  monitorWindowMs: number;
}
 
class CircuitBreaker {
  private state: CircuitState = "closed";
  private failureCount = 0;
  private lastFailureTime = 0;
  private halfOpenAttempts = 0;
 
  constructor(
    private readonly name: string,
    private readonly config: CircuitBreakerConfig
  ) {}
 
  async execute<T>(
    operation: () => Promise<T>,
    fallback: () => Promise<T>
  ): Promise<T> {
    if (this.state === "open") {
      if (this.shouldAttemptReset()) {
        this.state = "half-open";
        this.halfOpenAttempts = 0;
      } else {
        console.warn(
          `[CircuitBreaker:${this.name}] 회로 개방 상태, 폴백 실행`
        );
        return fallback();
      }
    }
 
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
 
      if (this.state === "open") {
        return fallback();
      }
      throw error;
    }
  }
 
  private onSuccess(): void {
    if (this.state === "half-open") {
      this.halfOpenAttempts++;
      if (this.halfOpenAttempts >= this.config.halfOpenMaxAttempts) {
        this.state = "closed";
        this.failureCount = 0;
        console.info(`[CircuitBreaker:${this.name}] 회로 복구 완료`);
      }
    } else {
      this.failureCount = 0;
    }
  }
 
  private onFailure(): void {
    this.failureCount++;
    this.lastFailureTime = Date.now();
 
    if (this.failureCount >= this.config.failureThreshold) {
      this.state = "open";
      console.error(
        `[CircuitBreaker:${this.name}] 회로 개방: ${this.failureCount}회 연속 실패`
      );
    }
  }
 
  private shouldAttemptReset(): boolean {
    return Date.now() - this.lastFailureTime >= this.config.resetTimeoutMs;
  }
 
  getState(): CircuitState {
    return this.state;
  }
}

interface FallbackResult<T> {
  data: T;
  source: "primary" | "secondary" | "cache" | "static";
  degraded: boolean;
}
 
class LLMFallbackChain {
  constructor(
    private readonly primaryBreaker: CircuitBreaker,
    private readonly secondaryBreaker: CircuitBreaker,
    private readonly cacheService: SemanticCacheService,
    private readonly staticResponses: Map<string, string>
  ) {}
 
  async execute(
    prompt: string,
    category: string
  ): Promise<FallbackResult<string>> {
    // 1단계: 기본 모델
    try {
      const result = await this.primaryBreaker.execute(
        () => this.callPrimaryModel(prompt),
        () => Promise.reject(new Error("primary circuit open"))
      );
      return { data: result, source: "primary", degraded: false };
    } catch {
      // 1단계 실패, 2단계로 진행
    }
 
    // 2단계: 대체 모델
    try {
      const result = await this.secondaryBreaker.execute(
        () => this.callSecondaryModel(prompt),
        () => Promise.reject(new Error("secondary circuit open"))
      );
      return { data: result, source: "secondary", degraded: true };
    } catch {
      // 2단계 실패, 3단계로 진행
    }
 
    // 3단계: 캐시 검색
    const cached = await this.cacheService.findSimilar(prompt);
    if (cached) {
      return { data: cached, source: "cache", degraded: true };
    }
 
    // 4단계: 정적 응답
    const staticResponse =
      this.staticResponses.get(category) ??
      "현재 AI 서비스를 이용할 수 없습니다. 잠시 후 다시 시도해 주세요.";
 
    return { data: staticResponse, source: "static", degraded: true };
  }
 
  private async callPrimaryModel(prompt: string): Promise<string> {
    // Anthropic Claude API 호출
    throw new Error("구현 필요");
  }
 
  private async callSecondaryModel(prompt: string): Promise<string> {
    // OpenAI GPT API 호출 (프롬프트 변환 포함)
    throw new Error("구현 필요");
  }
}

interface RetryConfig {
  maxAttempts: number;
  baseDelayMs: number;
  maxDelayMs: number;
  retryableErrors: string[];
}
 
async function withRetry<T>(
  operation: () => Promise<T>,
  config: RetryConfig
): Promise<T> {
  let lastError: Error | undefined;
 
  for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
    try {
      return await operation();
    } catch (error) {
      lastError = error as Error;
 
      if (!isRetryable(lastError, config.retryableErrors)) {
        throw lastError;
      }
 
      if (attempt < config.maxAttempts - 1) {
        const delay = calculateBackoff(attempt, config);
        console.warn(
          `재시도 ${attempt + 1}/${config.maxAttempts}, ${delay}ms 후 재시도`
        );
        await sleep(delay);
      }
    }
  }
 
  throw lastError;
}
 
function calculateBackoff(attempt: number, config: RetryConfig): number {
  // 지수 백오프 + 지터
  const exponentialDelay = config.baseDelayMs * Math.pow(2, attempt);
  const jitter = Math.random() * config.baseDelayMs;
  return Math.min(exponentialDelay + jitter, config.maxDelayMs);
}
 
function isRetryable(error: Error, retryableErrors: string[]): boolean {
  return retryableErrors.some(
    (code) => error.message.includes(code) || error.name.includes(code)
  );
}
 
function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}