Cloud-Native Architecture

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 전체 마이크로서비스 아키텍처 구성도
# Client → API Gateway (Kong) → Service Mesh (Istio) → Order Service
#                              ↓
#                         User Service, Product Service, Payment Service
#                              ↓
#                         Database Layer (PostgreSQL)
#                              ↓
#                         Cache Layer (Redis)
#                              ↓
#                         Message Queue (Kafka)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

# 환경 설정 및 구성 관리 모듈
# 모든 환경 변수와 애플리케이션 설정을 중앙화하여 관리
import os
from typing import Optional
from pydantic import BaseSettings, Field

class DatabaseConfig(BaseSettings):
    """데이터베이스 연결 설정"""
    url: str = Field(default="postgresql://user:password@localhost/orderdb", env="DATABASE_URL")
    pool_pre_ping: bool = True
    pool_recycle: int = 300
    echo: bool = Field(default=False, env="DB_ECHO")  # SQL 쿼리 로깅

class RedisConfig(BaseSettings):
    """Redis 캐시 설정"""
    url: str = Field(default="redis://localhost:6379", env="REDIS_URL")
    decode_responses: bool = True
    socket_timeout: int = 5
    socket_connect_timeout: int = 5
    default_ttl: int = 300  # 기본 캐시 만료 시간 (초)

class KafkaConfig(BaseSettings):
    """Kafka 메시징 설정"""
    bootstrap_servers: str = Field(default="localhost:9092", env="KAFKA_SERVERS")
    topic_prefix: str = Field(default="ecommerce", env="KAFKA_TOPIC_PREFIX")
    order_events_topic: str = "order-events"
    retry_backoff_ms: int = 1000
    request_timeout_ms: int = 30000

class ExternalServiceConfig(BaseSettings):
    """외부 서비스 연결 설정"""
    user_service_url: str = Field(default="http://user-service:8080", env="USER_SERVICE_URL")
    product_service_url: str = Field(default="http://product-service:8080", env="PRODUCT_SERVICE_URL")
    payment_service_url: str = Field(default="http://payment-service:8080", env="PAYMENT_SERVICE_URL")
    http_timeout: int = 30  # HTTP 요청 타임아웃 (초)
    retry_attempts: int = 3  # 재시도 횟수

class ApplicationConfig(BaseSettings):
    """애플리케이션 전역 설정"""
    app_name: str = "Order Service"
    app_version: str = "1.0.0"
    environment: str = Field(default="development", env="ENVIRONMENT")
    log_level: str = Field(default="INFO", env="LOG_LEVEL")
    debug: bool = Field(default=False, env="DEBUG")
    
    # API 설정
    api_prefix: str = "/api/v1"
    docs_url: Optional[str] = "/docs"
    redoc_url: Optional[str] = "/redoc"
    
    # 보안 설정
    cors_origins: list = ["*"]  # 운영환경에서는 특정 도메인으로 제한
    cors_methods: list = ["*"]
    cors_headers: list = ["*"]

class Settings:
    """통합 설정 클래스"""
    def __init__(self):
        self.database = DatabaseConfig()
        self.redis = RedisConfig()
        self.kafka = KafkaConfig()
        self.external_services = ExternalServiceConfig()
        self.app = ApplicationConfig()
    
    @property
    def is_production(self) -> bool:
        """운영 환경 여부 확인"""
        return self.app.environment.lower() == "production"
    
    @property
    def is_development(self) -> bool:
        """개발 환경 여부 확인"""
        return self.app.environment.lower() == "development"

# 전역 설정 인스턴스
settings = Settings()

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

# 공통 유틸리티 및 로깅 설정 모듈
# 구조화된 로그, 헬스 체크, 메트릭 수집 등 공통 기능 제공
import logging
import json
import time
from datetime import datetime
from typing import Dict, Any
from functools import wraps
from config import settings

class StructuredLogger:
    """구조화된 JSON 로그 생성기"""
    
    def __init__(self, service_name: str = "order-service"):
        self.service_name = service_name
        self.logger = logging.getLogger(service_name)
        
        # 로그 핸들러 설정
        handler = logging.StreamHandler()
        formatter = logging.Formatter('%(message)s')
        handler.setFormatter(formatter)
        
        self.logger.addHandler(handler)
        self.logger.setLevel(getattr(logging, settings.app.log_level.upper()))
    
    def _format_log(self, level: str, message: str, **kwargs) -> str:
        """로그 메시지를 JSON 형태로 포맷팅"""
        log_data = {
            "timestamp": datetime.utcnow().isoformat(),
            "level": level,
            "service": self.service_name,
            "message": message,
            "environment": settings.app.environment
        }
        
        # 추가 컨텍스트 정보 포함
        if kwargs:
            log_data.update(kwargs)
        
        return json.dumps(log_data, ensure_ascii=False)
    
    def info(self, message: str, **kwargs):
        """정보 레벨 로그"""
        self.logger.info(self._format_log("INFO", message, **kwargs))
    
    def error(self, message: str, **kwargs):
        """에러 레벨 로그"""
        self.logger.error(self._format_log("ERROR", message, **kwargs))
    
    def warning(self, message: str, **kwargs):
        """경고 레벨 로그"""
        self.logger.warning(self._format_log("WARNING", message, **kwargs))
    
    def debug(self, message: str, **kwargs):
        """디버그 레벨 로그"""
        self.logger.debug(self._format_log("DEBUG", message, **kwargs))

# 전역 로거 인스턴스
logger = StructuredLogger()

class MetricsCollector:
    """애플리케이션 메트릭 수집기 (Prometheus 연동)"""
    
    def __init__(self):
        self.metrics = {}
        self.start_time = time.time()
    
    def increment_counter(self, metric_name: str, labels: Dict[str, str] = None):
        """카운터 메트릭 증가"""
        key = f"{metric_name}_{labels}" if labels else metric_name
        self.metrics[key] = self.metrics.get(key, 0) + 1
    
    def record_histogram(self, metric_name: str, value: float, labels: Dict[str, str] = None):
        """히스토그램 메트릭 기록"""
        key = f"{metric_name}_histogram_{labels}" if labels else f"{metric_name}_histogram"
        if key not in self.metrics:
            self.metrics[key] = []
        self.metrics[key].append(value)
    
    def get_metrics(self) -> Dict[str, Any]:
        """수집된 메트릭 반환"""
        return {
            "uptime_seconds": time.time() - self.start_time,
            "metrics": self.metrics,
            "timestamp": datetime.utcnow().isoformat()
        }

# 전역 메트릭 수집기
metrics = MetricsCollector()

def log_execution_time(operation_name: str):
    """함수 실행 시간을 로그로 기록하는 데코레이터"""
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            start_time = time.time()
            try:
                result = await func(*args, **kwargs)
                execution_time = time.time() - start_time
                
                logger.info(
                    f"{operation_name} 실행 완료",
                    execution_time=execution_time,
                    function=func.__name__
                )
                
                # 메트릭 기록
                metrics.record_histogram(f"{operation_name}_duration", execution_time)
                metrics.increment_counter(f"{operation_name}_total")
                
                return result
            except Exception as e:
                execution_time = time.time() - start_time
                logger.error(
                    f"{operation_name} 실행 실패",
                    error=str(e),
                    execution_time=execution_time,
                    function=func.__name__
                )
                
                # 에러 메트릭 기록
                metrics.increment_counter(f"{operation_name}_errors")
                raise
        return wrapper
    return decorator

class HealthChecker:
    """헬스 체크 관리 클래스"""
    
    def __init__(self):
        self.checks = {}
    
    def register_check(self, name: str, check_func):
        """헬스 체크 함수 등록"""
        self.checks[name] = check_func
    
    async def run_checks(self) -> Dict[str, Any]:
        """모든 헬스 체크 실행"""
        results = {
            "status": "healthy",
            "timestamp": datetime.utcnow().isoformat(),
            "checks": {}
        }
        
        overall_status = True
        
        for name, check_func in self.checks.items():
            try:
                check_result = await check_func()
                results["checks"][name] = {
                    "status": "healthy" if check_result else "unhealthy",
                    "details": check_result
                }
                if not check_result:
                    overall_status = False
            except Exception as e:
                results["checks"][name] = {
                    "status": "unhealthy",
                    "error": str(e)
                }
                overall_status = False
        
        results["status"] = "healthy" if overall_status else "unhealthy"
        return results

# 전역 헬스 체커
health_checker = HealthChecker()

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

# 데이터베이스 연결 및 세션 관리 모듈
# SQLAlchemy ORM 설정과 데이터베이스 연결 풀 관리
from sqlalchemy import create_engine, event
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
from sqlalchemy.pool import QueuePool
from contextlib import contextmanager
from config import settings
from utils import logger

class DatabaseManager:
    """데이터베이스 연결 및 세션 관리 클래스"""
    
    def __init__(self):
        self.engine = None
        self.SessionLocal = None
        self.Base = declarative_base()
        self._initialize_engine()
    
    def _initialize_engine(self):
        """SQLAlchemy 엔진 초기화"""
        self.engine = create_engine(
            settings.database.url,
            poolclass=QueuePool,
            pool_size=10,              # 기본 연결 풀 크기
            max_overflow=20,           # 최대 오버플로우 연결 수
            pool_pre_ping=settings.database.pool_pre_ping,
            pool_recycle=settings.database.pool_recycle,
            echo=settings.database.echo,
            pool_timeout=30,           # 연결 대기 타임아웃
            pool_reset_on_return='commit'  # 연결 반환 시 커밋
        )
        
        # 데이터베이스 연결 이벤트 리스너 등록
        self._register_event_listeners()
        
        # 세션 팩토리 생성
        self.SessionLocal = sessionmaker(
            autocommit=False,
            autoflush=False,
            bind=self.engine,
            expire_on_commit=False     # 커밋 후 객체 만료 방지
        )
        
        logger.info("데이터베이스 엔진 초기화 완료")
    
    def _register_event_listeners(self):
        """데이터베이스 이벤트 리스너 등록"""
        
        @event.listens_for(self.engine, "connect")
        def set_sqlite_pragma(dbapi_connection, connection_record):
            """연결 시 데이터베이스별 설정 적용"""
            if "sqlite" in str(dbapi_connection):
                cursor = dbapi_connection.cursor()
                cursor.execute("PRAGMA foreign_keys=ON")
                cursor.close()
        
        @event.listens_for(self.engine, "before_cursor_execute")
        def receive_before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
            """쿼리 실행 전 로깅"""
            if settings.database.echo:
                logger.debug("SQL 쿼리 실행", query=statement, params=parameters)
    
    def create_tables(self):
        """데이터베이스 테이블 생성"""
        try:
            self.Base.metadata.create_all(bind=self.engine)
            logger.info("데이터베이스 테이블 생성 완료")
        except Exception as e:
            logger.error("데이터베이스 테이블 생성 실패", error=str(e))
            raise
    
    def get_session(self) -> Session:
        """데이터베이스 세션 생성"""
        return self.SessionLocal()
    
    @contextmanager
    def get_session_context(self):
        """컨텍스트 매니저를 사용한 세션 관리"""
        session = self.get_session()
        try:
            yield session
            session.commit()
        except Exception as e:
            session.rollback()
            logger.error("데이터베이스 트랜잭션 롤백", error=str(e))
            raise
        finally:
            session.close()
    
    async def health_check(self) -> bool:
        """데이터베이스 연결 상태 확인"""
        try:
            with self.get_session_context() as session:
                session.execute("SELECT 1")
            return True
        except Exception as e:
            logger.error("데이터베이스 헬스 체크 실패", error=str(e))
            return False
    
    def close(self):
        """데이터베이스 연결 종료"""
        if self.engine:
            self.engine.dispose()
            logger.info("데이터베이스 연결 종료")

# 전역 데이터베이스 매니저 인스턴스
db_manager = DatabaseManager()

# 의존성 주입용 함수
def get_db() -> Session:
    """FastAPI 의존성 주입용 데이터베이스 세션 생성 함수"""
    session = db_manager.get_session()
    try:
        yield session
    finally:
        session.close()

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

# 데이터베이스 모델 및 API 스키마 정의 모듈
# SQLAlchemy ORM 모델과 Pydantic 스키마를 분리하여 관리
from sqlalchemy import Column, Integer, String, Float, DateTime, Enum, Index, ForeignKey
from sqlalchemy.orm import relationship
from pydantic import BaseModel, Field, validator
from datetime import datetime
from typing import Optional, List
import enum
from database import db_manager

# SQLAlchemy 베이스 클래스
Base = db_manager.Base

# 주문 상태 열거형
class OrderStatus(str, enum.Enum):
    """주문 상태 정의"""
    PENDING = "pending"           # 주문 대기
    CONFIRMED = "confirmed"       # 주문 확인
    PAID = "paid"                # 결제 완료
    PROCESSING = "processing"     # 주문 처리 중
    SHIPPED = "shipped"          # 배송 중
    DELIVERED = "delivered"      # 배송 완료
    CANCELLED = "cancelled"      # 주문 취소
    REFUNDED = "refunded"        # 환불 완료

class PaymentStatus(str, enum.Enum):
    """결제 상태 정의"""
    PENDING = "pending"          # 결제 대기
    PROCESSING = "processing"    # 결제 처리 중
    COMPLETED = "completed"      # 결제 완료
    FAILED = "failed"           # 결제 실패
    CANCELLED = "cancelled"     # 결제 취소
    REFUNDED = "refunded"       # 환불 완료

# SQLAlchemy 모델 정의
class OrderModel(Base):
    """주문 정보 데이터베이스 모델"""
    __tablename__ = "orders"
    
    # 기본 필드
    id = Column(Integer, primary_key=True, index=True, comment="주문 ID")
    order_number = Column(String(50), unique=True, nullable=False, index=True, comment="주문 번호")
    user_id = Column(Integer, nullable=False, index=True, comment="사용자 ID")
    
    # 주문 상세 정보
    product_id = Column(Integer, nullable=False, comment="상품 ID")
    product_name = Column(String(255), nullable=False, comment="상품명")
    product_price = Column(Float, nullable=False, comment="상품 단가")
    quantity = Column(Integer, nullable=False, comment="주문 수량")
    total_amount = Column(Float, nullable=False, comment="총 주문 금액")
    
    # 상태 및 메타데이터
    status = Column(Enum(OrderStatus), default=OrderStatus.PENDING, nullable=False, comment="주문 상태")
    payment_status = Column(Enum(PaymentStatus), default=PaymentStatus.PENDING, nullable=False, comment="결제 상태")
    
    # 주소 정보
    shipping_address = Column(String(500), comment="배송 주소")
    billing_address = Column(String(500), comment="청구지 주소")
    
    # 추가 정보
    notes = Column(String(1000), comment="주문 메모")
    metadata = Column(String(2000), comment="추가 메타데이터 (JSON)")
    
    # 타임스탬프
    created_at = Column(DateTime, default=datetime.utcnow, nullable=False, comment="생성 시간")
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False, comment="수정 시간")
    confirmed_at = Column(DateTime, comment="주문 확인 시간")
    shipped_at = Column(DateTime, comment="배송 시작 시간")
    delivered_at = Column(DateTime, comment="배송 완료 시간")
    cancelled_at = Column(DateTime, comment="취소 시간")
    
    # 인덱스 정의 (쿼리 성능 최적화)
    __table_args__ = (
        Index('idx_user_created', 'user_id', 'created_at'),
        Index('idx_status_created', 'status', 'created_at'),
        Index('idx_payment_status', 'payment_status'),
    )

class OrderItemModel(Base):
    """주문 아이템 상세 정보 모델 (다중 상품 주문 지원)"""
    __tablename__ = "order_items"
    
    id = Column(Integer, primary_key=True, index=True)
    order_id = Column(Integer, ForeignKey('orders.id'), nullable=False, comment="주문 ID")
    product_id = Column(Integer, nullable=False, comment="상품 ID")
    product_name = Column(String(255), nullable=False, comment="상품명")
    product_sku = Column(String(100), comment="상품 SKU")
    unit_price = Column(Float, nullable=False, comment="단가")
    quantity = Column(Integer, nullable=False, comment="수량")
    subtotal = Column(Float, nullable=False, comment="소계")
    
    # 관계 정의
    order = relationship("OrderModel", backref="items")

# Pydantic 스키마 정의 (API 요청/응답)
class OrderCreateRequest(BaseModel):
    """주문 생성 요청 스키마"""
    user_id: int = Field(..., gt=0, description="사용자 ID")
    product_id: int = Field(..., gt=0, description="상품 ID")
    quantity: int = Field(..., gt=0, le=1000, description="주문 수량")
    shipping_address: Optional[str] = Field(None, max_length=500, description="배송 주소")
    billing_address: Optional[str] = Field(None, max_length=500, description="청구지 주소")
    notes: Optional[str] = Field(None, max_length=1000, description="주문 메모")
    
    @validator('quantity')
    def validate_quantity(cls, v):
        """수량 유효성 검증"""
        if v <= 0:
            raise ValueError('수량은 0보다 커야 합니다')
        if v > 1000:
            raise ValueError('수량은 1000개를 초과할 수 없습니다')
        return v

class OrderItemCreate(BaseModel):
    """주문 아이템 생성 스키마"""
    product_id: int = Field(..., gt=0, description="상품 ID")
    quantity: int = Field(..., gt=0, description="수량")

class MultiOrderCreateRequest(BaseModel):
    """다중 상품 주문 생성 요청 스키마"""
    user_id: int = Field(..., gt=0, description="사용자 ID")
    items: List[OrderItemCreate] = Field(..., min_items=1, max_items=50, description="주문 아이템 목록")
    shipping_address: Optional[str] = Field(None, max_length=500, description="배송 주소")
    billing_address: Optional[str] = Field(None, max_length=500, description="청구지 주소")
    notes: Optional[str] = Field(None, max_length=1000, description="주문 메모")

class OrderStatusUpdateRequest(BaseModel):
    """주문 상태 업데이트 요청 스키마"""
    status: OrderStatus = Field(..., description="변경할 주문 상태")
    notes: Optional[str] = Field(None, max_length=500, description="상태 변경 사유")

class PaymentStatusUpdateRequest(BaseModel):
    """결제 상태 업데이트 요청 스키마"""
    payment_status: PaymentStatus = Field(..., description="변경할 결제 상태")
    transaction_id: Optional[str] = Field(None, description="결제 거래 ID")

class OrderResponse(BaseModel):
    """주문 응답 스키마"""
    id: int
    order_number: str
    user_id: int
    product_id: int
    product_name: str
    product_price: float
    quantity: int
    total_amount: float
    status: OrderStatus
    payment_status: PaymentStatus
    shipping_address: Optional[str]
    billing_address: Optional[str]
    notes: Optional[str]
    created_at: datetime
    updated_at: datetime
    confirmed_at: Optional[datetime]
    shipped_at: Optional[datetime]
    delivered_at: Optional[datetime]
    cancelled_at: Optional[datetime]
    
    class Config:
        from_attributes = True

class OrderListResponse(BaseModel):
    """주문 목록 응답 스키마"""
    orders: List[OrderResponse]
    total_count: int
    page: int
    page_size: int
    has_next: bool
    has_previous: bool

class OrderSummaryResponse(BaseModel):
    """주문 요약 응답 스키마"""
    total_orders: int
    pending_orders: int
    completed_orders: int
    cancelled_orders: int
    total_revenue: float
    average_order_value: float

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258

# Redis 캐시 관리 모듈
# 주문 정보 캐싱, 세션 관리, 분산 락 구현
import redis
import json
import asyncio
from typing import Optional, Dict, Any, List
from datetime import datetime, timedelta
from config import settings
from utils import logger, log_execution_time

class CacheManager:
    """Redis 캐시 관리 클래스"""
    
    def __init__(self):
        self.redis_client = None
        self._initialize_client()
    
    def _initialize_client(self):
        """Redis 클라이언트 초기화"""
        try:
            self.redis_client = redis.from_url(
                settings.redis.url,
                decode_responses=settings.redis.decode_responses,
                socket_timeout=settings.redis.socket_timeout,
                socket_connect_timeout=settings.redis.socket_connect_timeout,
                retry_on_timeout=True,
                health_check_interval=30
            )
            
            # 연결 테스트
            self.redis_client.ping()
            logger.info("Redis 클라이언트 초기화 완료")
            
        except Exception as e:
            logger.error("Redis 연결 실패", error=str(e))
            raise

class OrderCacheService:
    """주문 정보 캐시 서비스"""
    
    def __init__(self, cache_manager: CacheManager):
        self.cache = cache_manager.redis_client
        self.default_ttl = settings.redis.default_ttl
    
    def _get_order_key(self, order_id: int) -> str:
        """주문 캐시 키 생성"""
        return f"order:{order_id}"
    
    def _get_user_orders_key(self, user_id: int) -> str:
        """사용자 주문 목록 캐시 키 생성"""
        return f"user_orders:{user_id}"
    
    @log_execution_time("cache_order_set")
    async def set_order(self, order_id: int, order_data: Dict[str, Any], ttl: Optional[int] = None) -> bool:
        """주문 정보 캐시 저장"""
        try:
            key = self._get_order_key(order_id)
            ttl = ttl or self.default_ttl
            
            # 데이터 직렬화 (datetime 객체 처리)
            serialized_data = json.dumps(order_data, default=str, ensure_ascii=False)
            
            result = self.cache.setex(key, ttl, serialized_data)
            
            if result:
                logger.info("주문 캐시 저장 완료", order_id=order_id, ttl=ttl)
            
            return result
            
        except Exception as e:
            logger.error("주문 캐시 저장 실패", order_id=order_id, error=str(e))
            return False
    
    @log_execution_time("cache_order_get")
    async def get_order(self, order_id: int) -> Optional[Dict[str, Any]]:
        """주문 정보 캐시 조회"""
        try:
            key = self._get_order_key(order_id)
            cached_data = self.cache.get(key)
            
            if cached_data:
                logger.info("캐시에서 주문 조회 성공", order_id=order_id)
                return json.loads(cached_data)
            
            logger.debug("캐시에서 주문 정보 없음", order_id=order_id)
            return None
            
        except Exception as e:
            logger.error("주문 캐시 조회 실패", order_id=order_id, error=str(e))
            return None
    
    @log_execution_time("cache_order_delete")
    async def delete_order(self, order_id: int) -> bool:
        """주문 정보 캐시 삭제"""
        try:
            key = self._get_order_key(order_id)
            result = self.cache.delete(key)
            
            if result:
                logger.info("주문 캐시 삭제 완료", order_id=order_id)
            
            return bool(result)
            
        except Exception as e:
            logger.error("주문 캐시 삭제 실패", order_id=order_id, error=str(e))
            return False
    
    async def set_user_orders(self, user_id: int, order_list: List[Dict[str, Any]], ttl: Optional[int] = None) -> bool:
        """사용자 주문 목록 캐시 저장"""
        try:
            key = self._get_user_orders_key(user_id)
            ttl = ttl or self.default_ttl
            
            serialized_data = json.dumps(order_list, default=str, ensure_ascii=False)
            result = self.cache.setex(key, ttl, serialized_data)
            
            if result:
                logger.info("사용자 주문 목록 캐시 저장 완료", user_id=user_id, count=len(order_list))
            
            return result
            
        except Exception as e:
            logger.error("사용자 주문 목록 캐시 저장 실패", user_id=user_id, error=str(e))
            return False
    
    async def get_user_orders(self, user_id: int) -> Optional[List[Dict[str, Any]]]:
        """사용자 주문 목록 캐시 조회"""
        try:
            key = self._get_user_orders_key(user_id)
            cached_data = self.cache.get(key)
            
            if cached_data:
                logger.info("캐시에서 사용자 주문 목록 조회 성공", user_id=user_id)
                return json.loads(cached_data)
            
            return None
            
        except Exception as e:
            logger.error("사용자 주문 목록 캐시 조회 실패", user_id=user_id, error=str(e))
            return None

class DistributedLockService:
    """분산 락 서비스 (동시성 제어)"""
    
    def __init__(self, cache_manager: CacheManager):
        self.cache = cache_manager.redis_client
    
    async def acquire_lock(self, resource_id: str, timeout: int = 30, blocking_timeout: int = 10) -> Optional[str]:
        """분산 락 획득"""
        lock_key = f"lock:{resource_id}"
        lock_value = f"{datetime.utcnow().isoformat()}:{resource_id}"
        
        try:
            # 논블로킹 락 시도
            acquired = self.cache.set(lock_key, lock_value, nx=True, ex=timeout)
            
            if acquired:
                logger.info("분산 락 획득 성공", resource_id=resource_id, lock_value=lock_value)
                return lock_value
            
            # 블로킹 락 시도
            start_time = datetime.utcnow()
            while (datetime.utcnow() - start_time).total_seconds() < blocking_timeout:
                await asyncio.sleep(0.1)
                acquired = self.cache.set(lock_key, lock_value, nx=True, ex=timeout)
                if acquired:
                    logger.info("분산 락 획득 성공 (블로킹)", resource_id=resource_id)
                    return lock_value
            
            logger.warning("분산 락 획득 타임아웃", resource_id=resource_id)
            return None
            
        except Exception as e:
            logger.error("분산 락 획득 실패", resource_id=resource_id, error=str(e))
            return None
    
    async def release_lock(self, resource_id: str, lock_value: str) -> bool:
        """분산 락 해제"""
        lock_key = f"lock:{resource_id}"
        
        try:
            # Lua 스크립트를 사용한 원자적 락 해제
            lua_script = """
            if redis.call("get", KEYS[1]) == ARGV[1] then
                return redis.call("del", KEYS[1])
            else
                return 0
            end
            """
            
            result = self.cache.eval(lua_script, 1, lock_key, lock_value)
            
            if result:
                logger.info("분산 락 해제 완료", resource_id=resource_id)
            else:
                logger.warning("분산 락 해제 실패 - 잘못된 락 값", resource_id=resource_id)
            
            return bool(result)
            
        except Exception as e:
            logger.error("분산 락 해제 실패", resource_id=resource_id, error=str(e))
            return False

class SessionCacheService:
    """세션 캐시 서비스"""
    
    def __init__(self, cache_manager: CacheManager):
        self.cache = cache_manager.redis_client
        self.session_ttl = 3600  # 1시간
    
    async def set_session(self, session_id: str, session_data: Dict[str, Any]) -> bool:
        """세션 데이터 저장"""
        try:
            key = f"session:{session_id}"
            serialized_data = json.dumps(session_data, default=str)
            
            result = self.cache.setex(key, self.session_ttl, serialized_data)
            
            if result:
                logger.info("세션 저장 완료", session_id=session_id)
            
            return result
            
        except Exception as e:
            logger.error("세션 저장 실패", session_id=session_id, error=str(e))
            return False
    
    async def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
        """세션 데이터 조회"""
        try:
            key = f"session:{session_id}"
            cached_data = self.cache.get(key)
            
            if cached_data:
                # TTL 갱신
                self.cache.expire(key, self.session_ttl)
                return json.loads(cached_data)
            
            return None
            
        except Exception as e:
            logger.error("세션 조회 실패", session_id=session_id, error=str(e))
            return None

# 전역 캐시 서비스 인스턴스
cache_manager = CacheManager()
order_cache = OrderCacheService(cache_manager)
distributed_lock = DistributedLockService(cache_manager)
session_cache = SessionCacheService(cache_manager)

async def health_check_redis() -> bool:
    """Redis 헬스 체크"""
    try:
        cache_manager.redis_client.ping()
        return True
    except Exception as e:
        logger.error("Redis 헬스 체크 실패", error=str(e))
        return False