정상: Redis 조회 → 캐시 히트 → 빠른 응답 (10ms)
장애: Redis 장애 → Connection Wait Timeout (3초) × Retry (3회) = 9초 대기!

장애 감지 후: Redis 건너뛰기 → 직접 RDB 조회 → 빠른 응답 (100ms)

// Timeout 설정만으로는 부족하다
val response = restClient.post()
    .uri("/payment")
    .timeout(Duration.ofSeconds(3))
    .retrieve()
    .body<PaymentResponse>()

resilience4j.circuitbreaker:
  instances:
    paymentService:
      failureRateThreshold: 50          # 실패율 50% 초과 시
      slidingWindowSize: 10             # 최근 10개 요청 기준
      waitDurationInOpenState: 10s      # Open 상태 10초 유지
      permittedNumberOfCallsInHalfOpenState: 3  # Half-Open에서 3개 테스트

@CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
fun processPayment(orderId: Long): PaymentResult {
    return paymentClient.pay(orderId)
}

// Fallback 메서드
fun paymentFallback(orderId: Long, ex: Exception): PaymentResult {
    logger.warn("Payment service unavailable for order $orderId", ex)
    return PaymentResult.pending(orderId, "결제 대기 중입니다")
}

resilience4j.retry:
  instances:
    inventoryService:
      maxAttempts: 3
      waitDuration: 1s

시도 1: 실패 → 1초 대기
시도 2: 실패 → 1초 대기
시도 3: 실패 → 포기

resilience4j.retry:
  instances:
    inventoryService:
      maxAttempts: 4
      waitDuration: 1s
      exponentialBackoffMultiplier: 2

시도 1: 실패 → 1초 대기
시도 2: 실패 → 2초 대기
시도 3: 실패 → 4초 대기
시도 4: 실패 → 포기

randomizedWaitFactor: 0.5  # 50% 랜덤 변동

2초 대기 → 1~3초 사이 랜덤

// ❌ 위험: 중복 결제 가능
@Retry(name = "paymentService")
fun charge(amount: Int) {
    paymentGateway.charge(amount)
}

// ✅ 안전: 멱등성 키 사용
@Retry(name = "paymentService")
fun charge(idempotencyKey: String, amount: Int) {
    paymentGateway.charge(idempotencyKey, amount)
}

// ❌ Circuit Breaker 안쪽에 Retry
@CircuitBreaker(name = "payment")
@Retry(name = "payment", maxAttempts = 5)
fun pay() { ... }

// ✅ Retry 안쪽에 Circuit Breaker
@Retry(name = "payment", maxAttempts = 3)
@CircuitBreaker(name = "payment")
fun pay() { ... }

dependencies {
    implementation("io.github.resilience4j:resilience4j-spring-boot3:2.2.0")
    implementation("io.github.resilience4j:resilience4j-kotlin:2.2.0")
    implementation("org.springframework.boot:spring-boot-starter-actuator")
    implementation("io.micrometer:micrometer-registry-prometheus")
}

┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│ Instance 1  │  │ Instance 2  │  │ Instance 3  │
│ CB: CLOSED  │  │ CB: OPEN    │  │ CB: CLOSED  │
└─────────────┘  └─────────────┘  └─────────────┘
       ↓                ↓                ↓
    Payment Service (장애 중)

┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│ Instance 1  │  │ Instance 2  │  │ Instance 3  │
└──────┬──────┘  └──────┬──────┘  └──────┬──────┘
       │                │                │
       └────────┬───────┴───────┬────────┘
                ↓               ↓
         ┌──────────────────────────┐
         │ Redis (공유 상태)        │
         │ paymentService: OPEN     │
         │ failureCount: 15         │
         └──────────────────────────┘

# Spring Cloud Gateway 예제
resilience4j:
  circuitbreaker:
    instances:
      user-service:
        failureRateThreshold: 50
        waitDurationInOpenState: 30s
      order-service:
        failureRateThreshold: 60
        waitDurationInOpenState: 20s
      payment-service:
        failureRateThreshold: 40  # 결제는 더 엄격하게
        waitDurationInOpenState: 60s

// 실행 순서: RateLimiter → Retry → CircuitBreaker
@RateLimiter(name = "payment")
@Retry(name = "payment")
@CircuitBreaker(name = "payment")
fun processPayment() { ... }

{
  "error": "CircuitBreaker 'paymentService' is OPEN and does not permit further calls"
}

{
  "status": "UNAVAILABLE",
  "message": "결제 서비스가 일시적으로 사용 불가능합니다.",
  "userMessage": "잠시 후 다시 시도해주세요. (예상 복구 시간: 30초)",
  "retryAfter": 30,
  "alternatives": [
    "장바구니에 담기",
    "나중에 결제하기"
  ]
}

@CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
fun processPayment(request: PaymentRequest): PaymentResponse {
    return paymentClient.pay(request)
}

private fun paymentFallback(request: PaymentRequest, ex: Exception): PaymentResponse {
    return when (ex) {
        is CallNotPermittedException -> {
            // Circuit Breaker Open
            PaymentResponse(
                status = PaymentStatus.UNAVAILABLE,
                message = "결제 서비스가 일시적으로 사용 불가능합니다.",
                userMessage = "잠시 후 다시 시도해주세요.",
                retryAfter = 30,
                alternatives = listOf("장바구니에 담기", "나중에 결제하기")
            )
        }
        is TimeoutException -> {
            // Timeout
            PaymentResponse(
                status = PaymentStatus.TIMEOUT,
                message = "결제 처리 시간이 초과되었습니다.",
                userMessage = "네트워크 상태를 확인하고 다시 시도해주세요."
            )
        }
        else -> {
            // 기타 에러
            PaymentResponse(
                status = PaymentStatus.ERROR,
                message = "결제 처리 중 오류가 발생했습니다.",
                userMessage = "고객센터로 문의해주세요."
            )
        }
    }
}

@CircuitBreaker(name = "recommendationService", fallbackMethod = "recommendationFallback")
fun getRecommendations(userId: Long): List<Product> {
    return recommendationClient.getPersonalized(userId)
}

private fun recommendationFallback(userId: Long, ex: Exception): List<Product> {
    logger.warn { "Recommendation service unavailable, using cached data" }

    // 1. 캐시된 인기 상품 반환
    return cacheService.getPopularProducts()
        ?:
    // 2. 캐시도 없으면 기본 추천 상품
    defaultRecommendations
}

# 알림 우선순위
Critical: Circuit Open (즉시 알림)
Warning: 실패율 40% 이상 (3분 지속 시 알림)
Info: Circuit Closed (복구 알림)