5강 — 에러 처리와 재시도 로직

RETRYABLE_STATUS_CODES = {429, 500, 502, 503, 504}   # 재시도해 볼 만한 코드들

def is_retryable_error(status_code):
    """이 상태 코드가 재시도 가능한 에러인지 판단."""
    return status_code in RETRYABLE_STATUS_CODES

for code in [200, 400, 429, 500, 401]:
    print(code, "→", "재시도 가능" if is_retryable_error(code) else "재시도 불가")

import random

def calculate_backoff(attempt, base_delay=1, max_delay=60):
    """지수 백오프 대기 시간(초)을 계산. attempt는 0부터 시작.
    1, 2, 4, 8, 16 ... 으로 늘어나되 max_delay를 넘지 않음."""
    delay = base_delay * (2 ** attempt)            # 핵심: 2의 거듭제곱으로 증가
    jitter = random.uniform(0, 0.5) * delay        # 약간의 무작위(여러 요청이 동시에 몰리는 걸 분산)
    return min(delay + jitter, max_delay)          # 상한선 적용

total = 0
for attempt in range(5):
    d = calculate_backoff(attempt)
    total += d
    print(f"시도 {attempt+1}: {d:.1f}초 대기 (누적 {total:.1f}초)")
# 예시: 1.2 / 2.1 / 4.7 / 9.0 / 16.4 초 (jitter로 매번 조금씩 다름)

import time

class APIError(Exception):
    """API 호출 관련 커스텀 예외 — 상태 코드와 재시도 가능 여부를 함께 담는다."""
    def __init__(self, message, status_code=None, retryable=False):
        self.message = message
        self.status_code = status_code
        self.retryable = retryable
        super().__init__(message)

def call_llm_with_retry(system_prompt, user_message, max_retries=3):
    """재시도 로직이 포함된 LLM 호출. 성공 시 응답 텍스트, 끝내 실패 시 APIError."""
    last_error = None
    for attempt in range(max_retries + 1):       # 최초 1회 + 재시도 max_retries회
        try:
            response = client.chat.completions.create(
                model=MODEL,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_message},
                ],
                timeout=30,                       # 응답이 30초를 넘으면 타임아웃
            )
            return response.choices[0].message.content
        except Exception as e:
            last_error = e
            text = str(e).lower()
            # 에러 메시지로 종류를 판별 (재시도 가능한가?)
            retryable = ("429" in str(e) or "rate" in text                    # 레이트 리미트
                         or any(c in str(e) for c in ["500", "502", "503", "504"])  # 서버 오류
                         or "timeout" in text)                                # 타임아웃
            if retryable and attempt < max_retries:
                delay = calculate_backoff(attempt)
                print(f"  에러(시도 {attempt+1}/{max_retries+1}): {delay:.1f}초 후 재시도")
                time.sleep(delay)
            else:
                break                              # 재시도 불가 or 횟수 초과 → 중단
    raise APIError(f"API 호출 실패: {last_error}")

from datetime import datetime
import json

class ProcessingLogger:
    """처리 결과(성공/실패)를 기록하고 요약·저장하는 로거."""
    def __init__(self, log_file='processing_log.json'):
        self.log_file = log_file
        self.logs = []
        self.success_count = 0
        self.failure_count = 0

    def log_success(self, item_id, result):
        self.logs.append({"timestamp": datetime.now().isoformat(),
                          "status": "success", "item_id": item_id,
                          "result_preview": str(result)[:100]})
        self.success_count += 1

    def log_failure(self, item_id, error_message, input_data=None):
        self.logs.append({"timestamp": datetime.now().isoformat(),
                          "status": "failure", "item_id": item_id,
                          "error": error_message,
                          "input_preview": str(input_data)[:100] if input_data else None})
        self.failure_count += 1

    def save(self):
        total = len(self.logs)
        with open(self.log_file, 'w', encoding='utf-8') as f:
            json.dump({"summary": {"total": total,
                                   "success": self.success_count,
                                   "failure": self.failure_count},
                       "logs": self.logs}, f, ensure_ascii=False, indent=2)

    def print_summary(self):
        total = len(self.logs) or 1
        print(f"총 {len(self.logs)}건 / 성공 {self.success_count} "
              f"({self.success_count/total*100:.1f}%) / 실패 {self.failure_count}")

def analyze_review_safe(review, logger):
    """재시도 포함 분석. 성공하면 결과, 실패하면 None(+로그 기록)."""
    system_prompt = ('당신은 게임 리뷰 분석가입니다. '
                     'JSON으로만 응답: {"sentiment": "positive/negative/neutral", "keywords": ["..."]}')
    try:
        raw = call_llm_with_retry(system_prompt, f"분석해주세요: {review['text']}", max_retries=2)
        result = json.loads(clean_json_response(raw))   # 3강의 정제 함수 재사용
        result['review_id'] = review['id']
        logger.log_success(review['id'], result)
        return result
    except (APIError, json.JSONDecodeError) as e:
        logger.log_failure(review['id'], str(e), review['text'])
        print(f"  리뷰 {review['id']} 실패: {e}")
        return None

def process_reviews_robust(reviews, batch_size=2):
    """배치 + 재시도 + 로깅을 결합한 안정적 처리."""
    logger = ProcessingLogger('review_processing_log.json')
    results = []
    for batch in tqdm(list(chunk_list(reviews, batch_size)), desc="배치 처리 중"):
        for review in batch:
            r = analyze_review_safe(review, logger)
            if r:
                results.append(r)        # 실패(None)는 건너뛰고 나머지는 계속
            time.sleep(0.5)
    logger.save()
    logger.print_summary()
    return results, logger