# api_gateway.py
import aiohttp
from flask import Flask, jsonify
import asyncio

app = Flask(__name__)

class ServiceClient:
    def __init__(self, base_url):
        self.base_url = base_url
        self.session = None
    
    async def __aenter__(self):
        self.session = aiohttp.ClientSession()
        return self
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.session.close()
    
    async def get(self, path):
        async with self.session.get(f"{self.base_url}{path}") as resp:
            return await resp.json()

@app.route('/api/users/<user_id>/orders')
async def get_user_orders(user_id):
    async with ServiceClient("http://user-service:8000") as user_client, \
               ServiceClient("http://order-service:8001") as order_client:
        
        # 並列API呼び出し
        user_task = asyncio.create_task(user_client.get(f"/users/{user_id}"))
        orders_task = asyncio.create_task(order_client.get(f"/users/{user_id}/orders"))
        
        user, orders = await asyncio.gather(user_task, orders_task)
        
        return jsonify({
            "user": user,
            "orders": orders
        })

# order_service.py
import pika
import json

class OrderService:
    def __init__(self):
        self.connection = pika.BlockingConnection(
            pika.ConnectionParameters('rabbitmq')
        )
        self.channel = self.connection.channel()
        
        # イベント発行用のExchange
        self.channel.exchange_declare(
            exchange='order_events',
            exchange_type='topic'
        )
    
    def create_order(self, order_data):
        # 注文処理
        order = self.process_order(order_data)
        
        # イベント発行
        event = {
            'event_type': 'order_created',
            'order_id': order['id'],
            'user_id': order['user_id'],
            'total': order['total'],
            'timestamp': datetime.utcnow().isoformat()
        }
        
        self.channel.basic_publish(
            exchange='order_events',
            routing_key='order.created',
            body=json.dumps(event)
        )
        
        return order

# tracing.py
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.instrumentation.flask import FlaskInstrumentor
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor

def setup_tracing(service_name, otlp_endpoint="otel-collector:4317"):
    """分散トレーシングのセットアップ"""
    
    # トレーサープロバイダー設定
    trace.set_tracer_provider(TracerProvider())
    tracer_provider = trace.get_tracer_provider()
    
    # OTLPエクスポーター
    otlp_exporter = OTLPSpanExporter(
        endpoint=otlp_endpoint,
        insecure=True
    )
    
    # バッチプロセッサー
    span_processor = BatchSpanProcessor(otlp_exporter)
    tracer_provider.add_span_processor(span_processor)
    
    # 自動インストルメンテーション
    FlaskInstrumentor().instrument()
    RequestsInstrumentor().instrument()
    SQLAlchemyInstrumentor().instrument()
    
    return trace.get_tracer(service_name)

# 使用例
from flask import Flask, request
import requests

app = Flask(__name__)
tracer = setup_tracing("order-service")

@app.route('/orders', methods=['POST'])
def create_order():
    with tracer.start_as_current_span("create_order") as span:
        # リクエスト情報をスパンに追加
        span.set_attribute("user.id", request.json.get('user_id'))
        span.set_attribute("order.total", request.json.get('total'))
        
        # ユーザーサービス呼び出し
        with tracer.start_as_current_span("validate_user"):
            user_response = requests.get(
                f"http://user-service/users/{request.json['user_id']}"
            )
            
        # 在庫確認
        with tracer.start_as_current_span("check_inventory"):
            for item in request.json['items']:
                inventory_response = requests.post(
                    "http://inventory-service/check",
                    json={'product_id': item['product_id'], 'quantity': item['quantity']}
                )
        
        # 注文作成
        with tracer.start_as_current_span("save_order"):
            order = create_order_in_db(request.json)
        
        return jsonify(order), 201

# logging_config.py
import logging
import json
from opentelemetry import trace

class StructuredFormatter(logging.Formatter):
    def format(self, record):
        # 現在のスパンコンテキストを取得
        span = trace.get_current_span()
        span_context = span.get_span_context() if span else None
        
        log_data = {
            'timestamp': self.formatTime(record),
            'level': record.levelname,
            'service': 'order-service',
            'message': record.getMessage(),
            'logger': record.name,
        }
        
        # トレース情報を追加
        if span_context and span_context.is_valid:
            log_data['trace_id'] = format(span_context.trace_id, '032x')
            log_data['span_id'] = format(span_context.span_id, '016x')
        
        # 追加のコンテキスト情報
        if hasattr(record, 'user_id'):
            log_data['user_id'] = record.user_id
        
        return json.dumps(log_data)

# ロガー設定
def setup_logging():
    handler = logging.StreamHandler()
    handler.setFormatter(StructuredFormatter())
    
    logger = logging.getLogger()
    logger.addHandler(handler)
    logger.setLevel(logging.INFO)
    
    return logger

# circuit_breaker.py
import time
from enum import Enum
from functools import wraps
import threading

class CircuitState(Enum):
    CLOSED = "closed"
    OPEN = "open"
    HALF_OPEN = "half_open"

class CircuitBreaker:
    def __init__(self, failure_threshold=5, recovery_timeout=60, expected_exception=Exception):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.expected_exception = expected_exception
        self.failure_count = 0
        self.last_failure_time = None
        self.state = CircuitState.CLOSED
        self._lock = threading.Lock()
    
    def __call__(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            with self._lock:
                if self.state == CircuitState.OPEN:
                    if self._should_attempt_reset():
                        self.state = CircuitState.HALF_OPEN
                    else:
                        raise Exception(f"Circuit breaker is OPEN for {func.__name__}")
            
            try:
                result = func(*args, **kwargs)
                with self._lock:
                    self._on_success()
                return result
            except self.expected_exception as e:
                with self._lock:
                    self._on_failure()
                raise e
        
        return wrapper
    
    def _should_attempt_reset(self):
        return (
            self.last_failure_time and
            time.time() - self.last_failure_time >= self.recovery_timeout
        )
    
    def _on_success(self):
        self.failure_count = 0
        self.state = CircuitState.CLOSED
    
    def _on_failure(self):
        self.failure_count += 1
        self.last_failure_time = time.time()
        if self.failure_count >= self.failure_threshold:
            self.state = CircuitState.OPEN

# 使用例
@CircuitBreaker(failure_threshold=3, recovery_timeout=30)
def call_payment_service(payment_data):
    response = requests.post(
        "http://payment-service/process",
        json=payment_data,
        timeout=5
    )
    response.raise_for_status()
    return response.json()

# resilience.py
import time
import random
from functools import wraps

def exponential_backoff_retry(max_retries=3, base_delay=1, max_delay=60):
    """指数バックオフによるリトライ"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            retries = 0
            delay = base_delay
            
            while retries < max_retries:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    retries += 1
                    if retries == max_retries:
                        raise e
                    
                    # ジッターを加えた指数バックオフ
                    jitter = random.uniform(0, delay * 0.1)
                    sleep_time = min(delay + jitter, max_delay)
                    
                    time.sleep(sleep_time)
                    delay *= 2
            
        return wrapper
    return decorator

# 使用例
@exponential_backoff_retry(max_retries=3)
def fetch_user_data(user_id):
    response = requests.get(
        f"http://user-service/users/{user_id}",
        timeout=3
    )
    response.raise_for_status()
    return response.json()