# monolith/order_service.py
# モノリス: 全てが1つのプロセス内
 
class OrderService:
    def __init__(self, db_session):
        self.db = db_session
 
    def create_order(self, user_id: str, items: list) -> dict:
        # 同一DB内でトランザクション → ACID 保証
        with self.db.begin():
            # 1. ユーザー確認（同一DB）
            user = self.db.query(User).get(user_id)
            if not user:
                raise ValueError("User not found")
 
            # 2. 在庫確認（同一DB）
            for item in items:
                product = self.db.query(Product).get(item["product_id"])
                if product.stock < item["quantity"]:
                    raise ValueError(f"Insufficient stock: {product.name}")
                product.stock -= item["quantity"]
 
            # 3. 注文作成（同一DB）
            order = Order(user_id=user_id, items=items, status="pending")
            self.db.add(order)
 
            # 4. 決済処理（同一プロセス内で呼び出し）
            payment = PaymentService(self.db)
            payment.charge(user_id, order.total_amount)
 
            # 5. 通知送信（同一プロセス内で呼び出し）
            notification = NotificationService(self.db)
            notification.send_order_confirmation(user_id, order.id)
 
            order.status = "confirmed"
            return {"order_id": order.id, "status": order.status}
 
        # メリット:
        # - 1つのトランザクションで ACID 保証
        # - デバッグが容易 (スタックトレースで追跡可能)
        # - テストがシンプル (モックが少ない)
        #
        # デメリット:
        # - 全モジュールが密結合
        # - 決済処理が遅いと注文全体がブロック
        # - 通知サービスの障害が注文処理を失敗させる

# microservices/order_service/app.py
# マイクロサービス: 各サービスが独立
 
import httpx
import json
from kafka import KafkaProducer
 
class OrderService:
    def __init__(self, db, producer: KafkaProducer):
        self.db = db
        self.producer = producer
        self.user_service_url = "http://user-service:8080"
        self.inventory_service_url = "http://inventory-service:8080"
 
    async def create_order(self, user_id: str, items: list) -> dict:
        async with httpx.AsyncClient(timeout=5.0) as client:
            # 1. ユーザー確認（HTTPで別サービスに問い合わせ）
            resp = await client.get(
                f"{self.user_service_url}/users/{user_id}"
            )
            if resp.status_code != 200:
                raise ValueError("User not found")
 
            # 2. 在庫確認（HTTPで別サービスに問い合わせ）
            resp = await client.post(
                f"{self.inventory_service_url}/reserve",
                json={"items": items}
            )
            if resp.status_code != 200:
                raise ValueError("Insufficient stock")
            reservation_id = resp.json()["reservation_id"]
 
        # 3. 注文作成（自サービスのDB）
        order = Order(
            user_id=user_id,
            items=items,
            status="pending",
            reservation_id=reservation_id,
        )
        self.db.add(order)
        self.db.commit()
 
        # 4. イベント発行（非同期で決済・通知を処理）
        self.producer.send("order-events", json.dumps({
            "event_type": "order_created",
            "order_id": order.id,
            "user_id": user_id,
            "amount": order.total_amount,
            "reservation_id": reservation_id,
        }).encode())
 
        return {"order_id": order.id, "status": "pending"}
 
    # メリット:
    # - 独立デプロイ・スケール (注文サービスだけ 10台に拡張可能)
    # - 技術選択の自由 (決済は Java, 通知は Go でも OK)
    # - 障害の局所化 (通知障害が注文を止めない)
    #
    # デメリット:
    # - 分散トランザクション (在庫予約 + 注文 + 決済の整合性)
    # - ネットワークレイテンシ (HTTP 呼び出しのオーバーヘッド)
    # - テストの複雑化 (サービス間の統合テスト)
    # - 結果整合性 (注文ステータスの更新が遅延)

from enum import Enum
from dataclasses import dataclass, field
from typing import Callable, Any
import asyncio
import logging
 
logger = logging.getLogger(__name__)
 
class SagaStepStatus(Enum):
    PENDING = "pending"
    COMPLETED = "completed"
    FAILED = "failed"
    COMPENSATED = "compensated"
 
@dataclass
class SagaStep:
    name: str
    action: Callable        # 正方向の処理
    compensation: Callable  # 補償処理（ロールバック）
    status: SagaStepStatus = SagaStepStatus.PENDING
    result: Any = None
 
class SagaOrchestrator:
    """
    Orchestration Saga: 中央のオーケストレーターが各ステップを制御
 
    フロー:
    1. 在庫予約 → 成功
    2. 決済処理 → 成功
    3. 注文確定 → 失敗！
    4. → 決済を返金 (補償)
    5. → 在庫予約を解除 (補償)
    """
 
    def __init__(self, saga_id: str):
        self.saga_id = saga_id
        self.steps: list[SagaStep] = []
        self.completed_steps: list[SagaStep] = []
 
    def add_step(
        self,
        name: str,
        action: Callable,
        compensation: Callable
    ):
        self.steps.append(SagaStep(name, action, compensation))
 
    async def execute(self, context: dict) -> dict:
        """Saga を実行"""
        logger.info(f"[SAGA {self.saga_id}] Starting saga")
 
        for step in self.steps:
            try:
                logger.info(f"[SAGA {self.saga_id}] Executing: {step.name}")
                result = await step.action(context)
                context.update(result or {})
                step.status = SagaStepStatus.COMPLETED
                step.result = result
                self.completed_steps.append(step)
            except Exception as e:
                logger.error(
                    f"[SAGA {self.saga_id}] Failed: {step.name} - {e}"
                )
                step.status = SagaStepStatus.FAILED
                await self._compensate(context)
                return {
                    "status": "failed",
                    "failed_step": step.name,
                    "error": str(e),
                }
 
        logger.info(f"[SAGA {self.saga_id}] Completed successfully")
        return {"status": "completed", "context": context}
 
    async def _compensate(self, context: dict):
        """完了済みステップを逆順に補償"""
        logger.info(f"[SAGA {self.saga_id}] Starting compensation")
        for step in reversed(self.completed_steps):
            try:
                logger.info(
                    f"[SAGA {self.saga_id}] Compensating: {step.name}"
                )
                await step.compensation(context)
                step.status = SagaStepStatus.COMPENSATED
            except Exception as e:
                logger.error(
                    f"[SAGA {self.saga_id}] Compensation failed: "
                    f"{step.name} - {e}"
                )
                # 補償失敗: 手動介入が必要 → DLQ に送信
                await self._send_to_dlq(step, context, e)
 
    async def _send_to_dlq(self, step, context, error):
        """補償失敗をデッドレターキューに送信"""
        logger.critical(
            f"[SAGA {self.saga_id}] Manual intervention required: "
            f"{step.name}"
        )
 
# 使用例: 注文処理 Saga
async def create_order_saga(
    user_id: str, items: list, amount: float
):
    saga = SagaOrchestrator(saga_id=f"order-{user_id}-{int(time.time())}")
 
    saga.add_step(
        "reserve_inventory",
        action=lambda ctx: inventory_service.reserve(ctx["items"]),
        compensation=lambda ctx: inventory_service.cancel_reservation(
            ctx["reservation_id"]
        ),
    )
    saga.add_step(
        "process_payment",
        action=lambda ctx: payment_service.charge(
            ctx["user_id"], ctx["amount"]
        ),
        compensation=lambda ctx: payment_service.refund(
            ctx["payment_id"]
        ),
    )
    saga.add_step(
        "confirm_order",
        action=lambda ctx: order_service.confirm(ctx["order_id"]),
        compensation=lambda ctx: order_service.cancel(ctx["order_id"]),
    )
    saga.add_step(
        "send_notification",
        action=lambda ctx: notification_service.send(
            ctx["user_id"], ctx["order_id"]
        ),
        compensation=lambda ctx: None,  # 通知は補償不要
    )
 
    context = {
        "user_id": user_id,
        "items": items,
        "amount": amount,
    }
    return await saga.execute(context)

from fastapi import FastAPI, Request, HTTPException, Depends
from fastapi.middleware.cors import CORSMiddleware
import httpx
import time
import asyncio
from collections import defaultdict
from dataclasses import dataclass, field
from enum import Enum
 
app = FastAPI(title="API Gateway")
 
# CORS 設定
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://example.com"],
    allow_methods=["*"],
    allow_headers=["*"],
)
 
SERVICE_REGISTRY = {
    "users":         "http://user-service:8080",
    "orders":        "http://order-service:8080",
    "payments":      "http://payment-service:8080",
    "notifications": "http://notification-service:8080",
}
 
# ── レートリミッター ──
class RateLimiter:
    """スライディングウィンドウレートリミッター"""
 
    def __init__(self, max_requests: int = 100, window_seconds: int = 60):
        self.max_requests = max_requests
        self.window = window_seconds
        self.requests: dict[str, list[float]] = defaultdict(list)
 
    def is_allowed(self, client_id: str) -> bool:
        now = time.time()
        # 古いリクエストを削除
        self.requests[client_id] = [
            t for t in self.requests[client_id]
            if now - t < self.window
        ]
        if len(self.requests[client_id]) >= self.max_requests:
            return False
        self.requests[client_id].append(now)
        return True
 
rate_limiter = RateLimiter(max_requests=100, window_seconds=60)
 
# ── サーキットブレーカー ──
class CircuitState(Enum):
    CLOSED = "closed"      # 正常
    OPEN = "open"          # 遮断中
    HALF_OPEN = "half_open"  # 試行中
 
@dataclass
class CircuitBreaker:
    failure_threshold: int = 5
    recovery_timeout: float = 30.0
    state: CircuitState = CircuitState.CLOSED
    failure_count: int = 0
    last_failure_time: float = 0
 
    def record_success(self):
        self.failure_count = 0
        self.state = CircuitState.CLOSED
 
    def record_failure(self):
        self.failure_count += 1
        self.last_failure_time = time.time()
        if self.failure_count >= self.failure_threshold:
            self.state = CircuitState.OPEN
 
    def is_available(self) -> bool:
        if self.state == CircuitState.CLOSED:
            return True
        if self.state == CircuitState.OPEN:
            if time.time() - self.last_failure_time > self.recovery_timeout:
                self.state = CircuitState.HALF_OPEN
                return True
            return False
        return True  # HALF_OPEN: 1回だけ試行
 
circuit_breakers: dict[str, CircuitBreaker] = {
    name: CircuitBreaker() for name in SERVICE_REGISTRY
}
 
# ── ルーティング ──
@app.api_route(
    "/{service}/{path:path}",
    methods=["GET", "POST", "PUT", "DELETE", "PATCH"]
)
async def gateway(service: str, path: str, request: Request):
    """全リクエストをルーティング"""
    # 1. サービス存在チェック
    base_url = SERVICE_REGISTRY.get(service)
    if not base_url:
        raise HTTPException(404, f"Service '{service}' not found")
 
    # 2. レートリミットチェック
    client_ip = request.client.host
    if not rate_limiter.is_allowed(client_ip):
        raise HTTPException(429, "Rate limit exceeded")
 
    # 3. サーキットブレーカーチェック
    cb = circuit_breakers[service]
    if not cb.is_available():
        raise HTTPException(503, f"Service '{service}' is temporarily unavailable")
 
    # 4. リクエスト転送
    target_url = f"{base_url}/{path}"
    try:
        async with httpx.AsyncClient(timeout=10.0) as client:
            response = await client.request(
                method=request.method,
                url=target_url,
                headers={
                    k: v for k, v in request.headers.items()
                    if k.lower() not in ("host", "content-length")
                },
                content=await request.body(),
                params=dict(request.query_params),
            )
            cb.record_success()
            return response.json()
 
    except (httpx.TimeoutException, httpx.ConnectError) as e:
        cb.record_failure()
        raise HTTPException(502, f"Service '{service}' error: {e}")

import httpx
import asyncio
from functools import wraps
from typing import Optional, Any
from dataclasses import dataclass
import time
 
@dataclass
class RetryConfig:
    max_retries: int = 3
    base_delay: float = 0.5      # 初回待機 500ms
    max_delay: float = 10.0      # 最大待機 10s
    exponential_base: float = 2  # 指数バックオフの基数
    retry_on_status: set = None  # リトライ対象のステータスコード
 
    def __post_init__(self):
        if self.retry_on_status is None:
            self.retry_on_status = {502, 503, 504, 429}
 
class ResilientServiceClient:
    """障害耐性のあるサービス間通信"""
 
    def __init__(
        self,
        base_url: str,
        timeout: float = 5.0,
        retry_config: RetryConfig = None,
        fallback: Optional[Any] = None,
    ):
        self.base_url = base_url
        self.timeout = timeout
        self.retry_config = retry_config or RetryConfig()
        self.fallback = fallback
        self._metrics = {
            'total_requests': 0,
            'successful': 0,
            'retries': 0,
            'failures': 0,
            'fallbacks': 0,
        }
 
    async def get(self, path: str, **kwargs) -> dict:
        return await self._request("GET", path, **kwargs)
 
    async def post(self, path: str, data: dict = None, **kwargs) -> dict:
        return await self._request("POST", path, json=data, **kwargs)
 
    async def _request(self, method: str, path: str, **kwargs):
        self._metrics['total_requests'] += 1
        last_error = None
 
        for attempt in range(self.retry_config.max_retries):
            try:
                async with httpx.AsyncClient(
                    base_url=self.base_url,
                    timeout=self.timeout
                ) as client:
                    resp = await client.request(method, path, **kwargs)
 
                    # リトライ対象のステータスコードか確認
                    if resp.status_code in self.retry_config.retry_on_status:
                        raise httpx.HTTPStatusError(
                            f"Status {resp.status_code}",
                            request=resp.request,
                            response=resp,
                        )
 
                    resp.raise_for_status()
                    self._metrics['successful'] += 1
                    return resp.json()
 
            except (
                httpx.TimeoutException,
                httpx.HTTPStatusError,
                httpx.ConnectError,
            ) as e:
                last_error = e
                self._metrics['retries'] += 1
 
                if attempt < self.retry_config.max_retries - 1:
                    # 指数バックオフ + ジッター
                    delay = min(
                        self.retry_config.base_delay *
                        (self.retry_config.exponential_base ** attempt),
                        self.retry_config.max_delay
                    )
                    # ジッター: 0.5x〜1.5x のランダム化
                    import random
                    jitter = delay * (0.5 + random.random())
                    print(
                        f"[Retry {attempt+1}/{self.retry_config.max_retries}] "
                        f"{method} {path}: {e}, waiting {jitter:.1f}s"
                    )
                    await asyncio.sleep(jitter)
 
        # 全リトライ失敗
        self._metrics['failures'] += 1
 
        # フォールバック
        if self.fallback is not None:
            self._metrics['fallbacks'] += 1
            if callable(self.fallback):
                return self.fallback()
            return self.fallback
 
        raise last_error
 
    @property
    def metrics(self) -> dict:
        total = self._metrics['total_requests']
        return {
            **self._metrics,
            'success_rate': (
                self._metrics['successful'] / total if total > 0 else 0
            ),
            'fallback_rate': (
                self._metrics['fallbacks'] / total if total > 0 else 0
            ),
        }
 
# 使用例
user_client = ResilientServiceClient(
    "http://user-service:8080",
    timeout=3.0,
    retry_config=RetryConfig(max_retries=3, base_delay=0.5),
    fallback={"id": "unknown", "name": "Guest"},  # フォールバック値
)
 
order_client = ResilientServiceClient(
    "http://order-service:8080",
    timeout=10.0,
    retry_config=RetryConfig(max_retries=2, base_delay=1.0),
)

"""モジュラーモノリス: モジュール境界を明確にした設計"""
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Optional
 
# ── モジュール間のインターフェース定義 ──
 
class UserModuleInterface(ABC):
    """User モジュールの公開インターフェース"""
    @abstractmethod
    def get_user(self, user_id: str) -> Optional[dict]: ...
    @abstractmethod
    def validate_user(self, user_id: str) -> bool: ...
 
class OrderModuleInterface(ABC):
    """Order モジュールの公開インターフェース"""
    @abstractmethod
    def create_order(self, user_id: str, items: list) -> dict: ...
    @abstractmethod
    def get_order(self, order_id: str) -> Optional[dict]: ...
 
class PaymentModuleInterface(ABC):
    """Payment モジュールの公開インターフェース"""
    @abstractmethod
    def charge(self, user_id: str, amount: float) -> dict: ...
    @abstractmethod
    def refund(self, payment_id: str) -> dict: ...
 
# ── User モジュールの実装 ──
 
class UserModule(UserModuleInterface):
    """User モジュール: users_* テーブルのみアクセス"""
 
    def __init__(self, db_session):
        self.db = db_session
 
    def get_user(self, user_id: str) -> Optional[dict]:
        user = self.db.query(User).get(user_id)
        if not user:
            return None
        return {"id": user.id, "name": user.name, "email": user.email}
 
    def validate_user(self, user_id: str) -> bool:
        return self.db.query(User).get(user_id) is not None
 
# ── Order モジュールの実装 ──
 
class OrderModule(OrderModuleInterface):
    """Order モジュール: orders_* テーブルのみアクセス"""
 
    def __init__(
        self,
        db_session,
        user_module: UserModuleInterface,      # 依存はインターフェース経由
        payment_module: PaymentModuleInterface,
    ):
        self.db = db_session
        self.users = user_module      # 直接 DB アクセスしない
        self.payments = payment_module
 
    def create_order(self, user_id: str, items: list) -> dict:
        # User モジュールのインターフェースを通じてアクセス
        if not self.users.validate_user(user_id):
            raise ValueError("User not found")
 
        order = Order(user_id=user_id, items=items, status="pending")
        self.db.add(order)
        self.db.flush()
 
        # Payment モジュールのインターフェースを通じてアクセス
        total = sum(item["price"] * item["quantity"] for item in items)
        payment = self.payments.charge(user_id, total)
 
        order.payment_id = payment["id"]
        order.status = "confirmed"
        self.db.commit()
 
        return {"order_id": order.id, "status": order.status}
 
    def get_order(self, order_id: str) -> Optional[dict]:
        order = self.db.query(Order).get(order_id)
        return {"id": order.id, "status": order.status} if order else None
 
# ── モジュール組み立て (Composition Root) ──
 
class Application:
    """アプリケーションのエントリーポイント"""
 
    def __init__(self, db_session):
        # モジュールの初期化（依存性注入）
        self.user_module = UserModule(db_session)
        self.payment_module = PaymentModule(db_session)
        self.order_module = OrderModule(
            db_session,
            user_module=self.user_module,
            payment_module=self.payment_module,
        )
 
# メリット:
# - モノリスの簡便さ (1つのデプロイ単位、ACID トランザクション)
# - モジュール間の境界が明確 (将来のマイクロサービス化が容易)
# - 型安全なインターフェース
# - テストが容易 (モジュール単位でモック可能)

"""Strangler Fig パターン: API Gateway でルーティングを制御"""
from fastapi import FastAPI, Request, Response
import httpx
import re
 
app = FastAPI(title="Strangler Gateway")
 
# 移行ルーティング設定
# status: "monolith" → "dual" → "microservice"
MIGRATION_ROUTES = {
    # 完全移行済み
    "/api/notifications": {
        "status": "microservice",
        "service_url": "http://notification-service:8080",
    },
    # ダブルライト中 (両方に送信して結果を比較)
    "/api/payments": {
        "status": "dual",
        "monolith_url": "http://monolith:8080",
        "service_url": "http://payment-service:8080",
    },
    # まだモノリス
    "/api/users": {
        "status": "monolith",
        "monolith_url": "http://monolith:8080",
    },
    "/api/orders": {
        "status": "monolith",
        "monolith_url": "http://monolith:8080",
    },
}
 
@app.api_route("/api/{path:path}", methods=["GET","POST","PUT","DELETE"])
async def strangler_route(path: str, request: Request):
    """Strangler Fig ルーティング"""
    full_path = f"/api/{path}"
 
    # ルート設定の検索 (最長一致)
    route_config = None
    for prefix, config in sorted(
        MIGRATION_ROUTES.items(), key=lambda x: -len(x[0])
    ):
        if full_path.startswith(prefix):
            route_config = config
            break
 
    if not route_config:
        route_config = {
            "status": "monolith",
            "monolith_url": "http://monolith:8080",
        }
 
    # ステータスに応じたルーティング
    status = route_config["status"]
 
    if status == "microservice":
        return await forward_request(
            request, route_config["service_url"], full_path
        )
 
    elif status == "dual":
        # ダブルライト: 両方に送信してレスポンスを比較
        monolith_resp, service_resp = await asyncio.gather(
            forward_request(
                request, route_config["monolith_url"], full_path
            ),
            forward_request(
                request, route_config["service_url"], full_path
            ),
            return_exceptions=True,
        )
 
        # モノリスのレスポンスを返す (安全側)
        # バックグラウンドで差分をログに記録
        if monolith_resp != service_resp:
            log_diff(full_path, monolith_resp, service_resp)
 
        return monolith_resp
 
    else:  # monolith
        return await forward_request(
            request, route_config["monolith_url"], full_path
        )
 
async def forward_request(request: Request, base_url: str, path: str):
    """リクエストを転送"""
    async with httpx.AsyncClient(timeout=10.0) as client:
        resp = await client.request(
            method=request.method,
            url=f"{base_url}{path}",
            headers={
                k: v for k, v in request.headers.items()
                if k.lower() not in ("host",)
            },
            content=await request.body(),
        )
        return resp.json()
 
def log_diff(path: str, monolith: dict, service: dict):
    """モノリスとサービスのレスポンス差分をログに記録"""
    import json
    print(f"[DIFF] {path}")
    print(f"  Monolith: {json.dumps(monolith, indent=2)}")
    print(f"  Service:  {json.dumps(service, indent=2)}")

"""サービス切り出しの優先度判断"""
from dataclasses import dataclass
 
@dataclass
class ServiceExtractionCandidate:
    """切り出し候補の評価"""
    name: str
    change_frequency: str    # "高" / "中" / "低"
    coupling: str            # "低" / "中" / "高"
    team_ownership: str      # "明確" / "不明確"
    scalability_need: str    # "高" / "中" / "低"
    data_independence: str   # "独立" / "部分的" / "共有"
    priority: str            # "高" / "中" / "低"
 
EXTRACTION_CANDIDATES = [
    ServiceExtractionCandidate(
        name="通知サービス",
        change_frequency="高",
        coupling="低",
        team_ownership="明確",
        scalability_need="高",
        data_independence="独立",
        priority="高 (最初に切り出すべき)",
    ),
    ServiceExtractionCandidate(
        name="決済サービス",
        change_frequency="中",
        coupling="中",
        team_ownership="明確",
        scalability_need="中",
        data_independence="部分的",
        priority="中 (2番目に切り出す)",
    ),
    ServiceExtractionCandidate(
        name="ユーザーサービス",
        change_frequency="低",
        coupling="高",
        team_ownership="不明確",
        scalability_need="低",
        data_independence="共有",
        priority="低 (最後に切り出す、または切り出さない)",
    ),
]
 
# 切り出し判断基準:
# 1. 結合度が低い → 切り出しが容易
# 2. 変更頻度が高い → 独立デプロイのメリットが大きい
# 3. スケーラビリティ要件がある → 独立スケールが必要
# 4. チームの所有が明確 → 運用が容易
# 5. データが独立している → データ移行が容易

"""マイクロサービスの分散トレーシング実装"""
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
import uuid
 
# トレーサーの初期化
provider = TracerProvider()
processor = BatchSpanProcessor(
    OTLPSpanExporter(endpoint="http://jaeger:4317")
)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)
tracer = trace.get_tracer(__name__)
 
# FastAPI と httpx の自動計装
FastAPIInstrumentor().instrument_app(app)
HTTPXClientInstrumentor().instrument()
 
# カスタムスパンの追加
@app.post("/api/orders")
async def create_order(request: OrderRequest):
    with tracer.start_as_current_span("create_order") as span:
        span.set_attribute("user_id", request.user_id)
        span.set_attribute("item_count", len(request.items))
 
        # 子スパン: ユーザー検証
        with tracer.start_as_current_span("validate_user"):
            user = await user_client.get(f"/users/{request.user_id}")
 
        # 子スパン: 在庫確認
        with tracer.start_as_current_span("check_inventory"):
            inventory = await inventory_client.post(
                "/check", data={"items": request.items}
            )
 
        # 子スパン: 注文保存
        with tracer.start_as_current_span("save_order"):
            order = await save_to_db(request)
            span.set_attribute("order_id", order.id)
 
        return {"order_id": order.id}
 
# トレース結果 (Jaeger UI で可視化):
#
# create_order [Order Service] ─── 150ms
#   ├── validate_user [→ User Service] ─── 30ms
#   ├── check_inventory [→ Inventory Service] ─── 45ms
#   └── save_order [DB] ─── 20ms
#
# ボトルネックの特定:
# - check_inventory が遅い → Inventory Service の最適化
# - DB への書き込みが遅い → インデックス追加

"""マイクロサービスのヘルスチェック実装"""
from fastapi import FastAPI
from datetime import datetime
import psycopg2
import redis
 
app = FastAPI()
 
@app.get("/health/live")
async def liveness():
    """Liveness: プロセスが生きているか (K8s livenessProbe)"""
    return {"status": "alive"}
 
@app.get("/health/ready")
async def readiness():
    """Readiness: リクエストを受け付けられるか (K8s readinessProbe)"""
    checks = {}
 
    # DB 接続チェック
    try:
        conn = psycopg2.connect(DB_DSN, connect_timeout=2)
        conn.close()
        checks["database"] = "ok"
    except Exception as e:
        checks["database"] = f"error: {e}"
 
    # Redis 接続チェック
    try:
        r = redis.Redis.from_url(REDIS_URL, socket_timeout=2)
        r.ping()
        checks["redis"] = "ok"
    except Exception as e:
        checks["redis"] = f"error: {e}"
 
    # 依存サービスチェック
    for service_name, url in SERVICE_REGISTRY.items():
        try:
            async with httpx.AsyncClient(timeout=2.0) as client:
                resp = await client.get(f"{url}/health/live")
                checks[service_name] = "ok" if resp.status_code == 200 else "degraded"
        except Exception:
            checks[service_name] = "unreachable"
 
    all_ok = all(v == "ok" for v in checks.values())
 
    return {
        "status": "ready" if all_ok else "degraded",
        "checks": checks,
        "timestamp": datetime.utcnow().isoformat(),
    }
 
# Kubernetes マニフェスト例:
# livenessProbe:
#   httpGet:
#     path: /health/live
#     port: 8080
#   initialDelaySeconds: 10
#   periodSeconds: 10
#   failureThreshold: 3
#
# readinessProbe:
#   httpGet:
#     path: /health/ready
#     port: 8080
#   initialDelaySeconds: 5
#   periodSeconds: 5
#   failureThreshold: 2

# NG: マイクロサービスに分割したが密結合
class DistributedMonolith:
    """分散モノリスの典型例"""
 
    def create_order(self, user_id: str, items: list):
        # 問題1: 全サービスが同期HTTPで密結合
        user = requests.get(f"http://user-service/users/{user_id}").json()
        inventory = requests.post(
            "http://inventory-service/check", json=items
        ).json()
        payment = requests.post(
            "http://payment-service/charge",
            json={"user_id": user_id, "amount": 100}
        ).json()
        notification = requests.post(
            "http://notification-service/send",
            json={"user_id": user_id, "type": "order"}
        ).json()
 
        # 問題2: 1サービスの障害が全体に波及
        # notification-service が 503 → 注文全体が失敗
        # → マイクロサービスのデメリットだけ享受した最悪の構成
 
        # 問題3: 共有データベースを使い続けている
        # → 全サービスが同じ DB スキーマに依存
        # → スキーマ変更で全サービスの再デプロイが必要
 
# OK: 正しいマイクロサービス設計
class ProperMicroservice:
    """疎結合のマイクロサービス"""
 
    def create_order(self, user_id: str, items: list):
        # 1. 必要な同期呼び出しは最小限 + タイムアウト + フォールバック
        try:
            user = await self.user_client.get(
                f"/users/{user_id}", timeout=3.0
            )
        except Exception:
            user = {"id": user_id}  # フォールバック: キャッシュから
 
        # 2. 注文作成 (自サービスの DB に書き込み)
        order = await self.save_order(user_id, items)
 
        # 3. 残りは非同期イベントで処理
        await self.publish_event("order_created", {
            "order_id": order.id,
            "user_id": user_id,
            "items": items,
        })
        # → 在庫サービスがイベントを消費して在庫を減らす
        # → 決済サービスがイベントを消費して課金する
        # → 通知サービスがイベントを消費して通知を送る
        # → 各サービスが独立して処理、障害は局所化
 
        return {"order_id": order.id, "status": "processing"}

# NG: スタートアップが Day 1 から20個のマイクロサービス
class PrematureMicroservices:
    """早すぎるマイクロサービス化"""
    services = [
        "user-service", "auth-service", "profile-service",
        "order-service", "cart-service", "inventory-service",
        "payment-service", "notification-service", "email-service",
        "search-service", "recommendation-service", "analytics-service",
        "logging-service", "config-service", "gateway-service",
        # ... 合計20サービス
    ]
 
    # 問題:
    # - サービス境界が不明確 (ドメイン理解が浅い段階)
    # - K8s + Kafka + Jaeger + CI/CD x 20 の構築コスト
    # - 3人のチームで20サービスの運用は不可能
    # - ピボット時にサービス境界の再設計が必要
    # - 初期開発速度が 3-5 倍遅い
 
# OK: 正しいアプローチ
class MonolithFirst:
    """まずモノリスで始めて、ドメインを理解してから分割"""
 
    # Phase 1: モノリスで MVP を作る (3-6ヶ月)
    # - ドメインを理解する
    # - ユーザーのニーズを検証する
    # - サービス境界の候補を特定する
 
    # Phase 2: モジュラーモノリスに移行 (6-12ヶ月)
    # - モジュール間のインターフェースを定義
    # - DB スキーマをモジュール別に分離
    # - 将来の切り出しに備える
 
    # Phase 3: 必要に応じてサービスを切り出す (12ヶ月+)
    # - 変更頻度が高いモジュール
    # - スケーラビリティ要件があるモジュール
    # - チームが所有するモジュール
 
    # Martin Fowler:
    # "Almost all the successful microservice stories have started
    #  with a monolith that got too big and was broken up."
    pass

# NG: 全サービスが異なる技術スタック
class TechStackChaos:
    """技術スタックの乱立"""
    services = {
        "user-service": "Python + Django + PostgreSQL",
        "order-service": "Go + Gin + MongoDB",
        "payment-service": "Java + Spring Boot + MySQL",
        "notification-service": "Node.js + Express + Redis",
        "search-service": "Rust + Actix + Elasticsearch",
        "analytics-service": "Scala + Play + ClickHouse",
    }
    # 問題:
    # - 6種類の言語を知る人材の採用が困難
    # - 共通ライブラリ (認証、ログ、メトリクス) を6言語で維持
    # - CI/CD パイプラインが6種類
    # - デバッグ・トラブルシューティングの難易度が極めて高い
 
# OK: 技術スタックを2-3種類に制限
class ControlledTechStack:
    """技術スタックの統制"""
    standards = {
        "primary": "Python + FastAPI + PostgreSQL",  # 80% のサービス
        "performance": "Go + PostgreSQL",             # 高性能が必要な 15%
        "data": "Python + Spark + ClickHouse",       # データパイプライン 5%
    }
    # メリット:
    # - 採用が容易 (2言語を知っていれば OK)
    # - 共通ライブラリを2言語で管理
    # - チーム間の異動が容易