# src/chapter05-saas-platform/backend/app/core/cache.py（重要部分を抜粋）

import redis
import json
from datetime import timedelta
from typing import Any, Optional
from functools import wraps

class CacheManager:
    """高速キャッシュ管理システム（コンビニの冷蔵庫みたいな仕組み）"""
    
    def __init__(self):
        # Redis接続（超高速なデータ保存場所）
        self.redis_client = redis.from_url(
            settings.REDIS_URL,
            decode_responses=False,
            socket_keepalive=True,  # 接続を維持して高速化
            health_check_interval=30  # 30秒ごとに健康チェック
        )
        self.default_ttl = 3600  # 1時間でデータ自動削除
    
    def get(self, key: str, default: Any = None) -> Any:
        """データを高速取得（冷蔵庫からドリンクを取り出す感じ）"""
        try:
            cached_data = self.redis_client.get(self._make_key(key))
            if cached_data is None:
                return default  # キャッシュにない場合はデフォルト値
            
            # データを元の形に復元
            try:
                return json.loads(cached_data)  # JSON形式で保存されている場合
            except json.JSONDecodeError:
                import pickle
                return pickle.loads(cached_data)  # バイナリ形式の場合
                
        except Exception as e:
            print(f"キャッシュ取得エラー: {e}")
            return default
    
    def set(self, key: str, value: Any, ttl: Optional[int] = None) -> bool:
        """データを高速保存（冷蔵庫にドリンクを入れる感じ）"""
        try:
            # 保存期間設定
            if ttl is None:
                ttl = self.default_ttl  # デフォルト1時間
            elif isinstance(ttl, timedelta):
                ttl = int(ttl.total_seconds())
            
            # データを保存用に変換
            try:
                serialized_value = json.dumps(value, default=str)
            except (TypeError, ValueError):
                import pickle
                serialized_value = pickle.dumps(value)
            
            # Redis に保存（期限付き）
            return self.redis_client.setex(
                self._make_key(key),
                ttl,
                serialized_value
            )
            
        except Exception as e:
            print(f"キャッシュ保存エラー: {e}")
            return False
    
    def get_or_set(self, key: str, callable_obj, ttl: Optional[int] = None) -> Any:
        """キャッシュがあれば使う、なければ計算して保存"""
        # まずキャッシュを確認
        cached_value = self.get(key)
        if cached_value is not None:
            return cached_value  # キャッシュヒット！高速で返す
        
        # キャッシュになければ、時間のかかる処理を実行
        fresh_value = callable_obj()
        self.set(key, fresh_value, ttl)  # 次回のために保存
        return fresh_value
    
    def _make_key(self, key: str) -> str:
        """キー名を統一（アプリ名を付けて他と区別）"""
        return f"{settings.PROJECT_NAME}:{key}"

# グローバルキャッシュ（どこからでも使える）
cache = CacheManager()

# 魔法のデコレーター（関数の結果を自動キャッシュ）
def cached(ttl: Optional[int] = None):
    """関数の結果を自動でキャッシュするデコレーター"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 引数からキャッシュキーを生成
            import hashlib
            args_str = str(args) + str(sorted(kwargs.items()))
            cache_key = f"{func.__name__}:{hashlib.md5(args_str.encode()).hexdigest()}"
            
            # キャッシュがあれば使う、なければ実行して保存
            return cache.get_or_set(cache_key, lambda: func(*args, **kwargs), ttl)
        return wrapper
    return decorator

# 使用例：重い計算を1回だけ実行
@cached(ttl=600)  # 10分間キャッシュ
def get_user_dashboard_data(user_id: int):
    """ユーザーダッシュボードの重いデータ取得（最初だけ時間かかる）"""
    print(f"重い計算実行中... ユーザー {user_id}")
    
    # 重い処理（データベース検索、集計など）
    # 2回目以降は瞬時に返ってくる！
    time.sleep(2)  # 2秒の重い処理をシミュレート
    
    return {
        "user_id": user_id,
        "total_projects": 15,
        "completed_tasks": 127,
        "team_members": 8
    }

# src/chapter05-saas-platform/backend/app/core/database_optimization.py（重要部分を抜粋）

from sqlalchemy import event, text
from sqlalchemy.engine import Engine
import time
import logging

class DatabaseOptimizer:
    """データベース最適化システム（図書館の司書さんみたいな仕組み）"""
    
    def __init__(self, engine):
        self.engine = engine
        self._setup_query_monitoring()  # クエリ監視を開始
    
    def _setup_query_monitoring(self):
        """遅いクエリを自動で見つける仕組み"""
        
        @event.listens_for(Engine, "before_cursor_execute")
        def receive_before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
            # クエリ開始時刻を記録
            context._query_start_time = time.time()

        @event.listens_for(Engine, "after_cursor_execute")
        def receive_after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
            # クエリ実行時間を計算
            total = time.time() - context._query_start_time
            
            # 1秒以上かかったクエリを警告（お客さんを待たせるレベル）
            if total > 1.0:
                logging.warning(
                    f"🐌 遅いクエリ発見！実行時間: {total:.2f}秒\n"
                    f"SQL: {statement}\n"
                    f"パラメータ: {parameters}"
                )
    
    def create_connection_pool(self):
        """コネクションプール設定（窓口カウンターの効率化）"""
        
        # データベース接続を使い回す仕組み（窓口の人数を調整）
        from sqlalchemy import create_engine
        from sqlalchemy.pool import QueuePool
        
        engine = create_engine(
            "postgresql://user:pass@localhost/db",
            
            # プール設定（銀行窓口の人数管理みたいな感じ）
            poolclass=QueuePool,
            pool_size=10,           # 常時待機する窓口数
            max_overflow=20,        # 混雑時に増やせる窓口数
            pool_timeout=30,        # 窓口待ちの最大時間（秒）
            pool_recycle=3600,      # 1時間で窓口担当者を交代
            
            # 接続オプション
            echo=False,             # SQLログ出力（開発時はTrue）
            future=True             # 新しいAPIを使用
        )
        
        return engine
    
    def setup_database_partitioning(self):
        """テーブル分割設定（大きな本棚を分割管理）"""
        
        # 日付ベースでテーブル分割（月ごとの帳簿みたいに分ける）
        partition_sql = """
        -- タスクテーブルを月別に分割
        CREATE TABLE tasks_y2024m01 PARTITION OF tasks
            FOR VALUES FROM ('2024-01-01') TO ('2024-02-01');
        
        CREATE TABLE tasks_y2024m02 PARTITION OF tasks  
            FOR VALUES FROM ('2024-02-01') TO ('2024-03-01');
        
        -- 古いパーティションの自動削除（古い帳簿の廃棄）
        CREATE OR REPLACE FUNCTION cleanup_old_partitions()
        RETURNS void AS $$
        DECLARE
            partition_name text;
        BEGIN
            -- 1年以上古いパーティションを削除
            FOR partition_name IN
                SELECT schemaname||'.'||tablename 
                FROM pg_tables 
                WHERE tablename LIKE 'tasks_y%' 
                AND tablename < 'tasks_y' || to_char(CURRENT_DATE - INTERVAL '1 year', 'YYYY"m"MM')
            LOOP
                EXECUTE 'DROP TABLE IF EXISTS ' || partition_name;
                RAISE NOTICE 'Dropped old partition: %', partition_name;
            END LOOP;
        END;
        $$ LANGUAGE plpgsql;
        """
        
        with self.engine.connect() as conn:
            conn.execute(text(partition_sql))
            conn.commit()

# src/chapter05-saas-platform/backend/app/core/load_balancer.py（実装例）

import random
import time
from typing import List, Dict, Optional, Any
from dataclasses import dataclass, field
from enum import Enum
import asyncio
import aiohttp

@dataclass
class ServerNode:
    """サーバーノード情報（レストランの各店舗）"""
    id: str
    host: str
    port: int
    weight: int = 1              # 処理能力の重み（大きな店舗は重み大）
    is_healthy: bool = True      # サーバーの健康状態
    current_connections: int = 0  # 現在の接続数
    last_health_check: float = field(default_factory=time.time)
    response_time: float = 0.0   # 平均応答時間

class LoadBalancingStrategy(Enum):
    """負荷分散方式"""
    ROUND_ROBIN = "round_robin"           # 順番に案内
    WEIGHTED_ROUND_ROBIN = "weighted"     # 能力に応じて案内  
    LEAST_CONNECTIONS = "least_conn"      # 空いてる店舗優先
    RANDOM = "random"                     # ランダム案内

class LoadBalancer:
    """ロードバランサー（チェーン店の案内係）"""
    
    def __init__(self, strategy: LoadBalancingStrategy = LoadBalancingStrategy.ROUND_ROBIN):
        self.servers: List[ServerNode] = []
        self.strategy = strategy
        self.current_index = 0  # Round Robin用のカウンター
        self.health_check_interval = 30  # 30秒ごとに健康診断
        
    def add_server(self, server: ServerNode):
        """サーバーを追加（新店舗オープン）"""
        self.servers.append(server)
        print(f"🏪 新店舗追加: {server.host}:{server.port} (重み: {server.weight})")
    
    def get_next_server(self) -> Optional[ServerNode]:
        """次のサーバーを選択（お客さんをどの店舗に案内するか）"""
        
        # 健康なサーバーだけフィルタリング
        healthy_servers = [s for s in self.servers if s.is_healthy]
        
        if not healthy_servers:
            print("⚠️ 利用可能な店舗がありません！")
            return None
        
        if self.strategy == LoadBalancingStrategy.ROUND_ROBIN:
            return self._round_robin_select(healthy_servers)
        elif self.strategy == LoadBalancingStrategy.WEIGHTED_ROUND_ROBIN:
            return self._weighted_round_robin_select(healthy_servers)
        elif self.strategy == LoadBalancingStrategy.LEAST_CONNECTIONS:
            return self._least_connections_select(healthy_servers)
        else:  # RANDOM
            return random.choice(healthy_servers)
    
    def _round_robin_select(self, servers: List[ServerNode]) -> ServerNode:
        """順番選択（順番に案内）"""
        if not servers:
            return None
            
        # 現在のインデックスを更新
        server = servers[self.current_index % len(servers)]
        self.current_index += 1
        
        print(f"🎯 Round Robin: {server.host}:{server.port} を選択")
        return server
    
    def _weighted_round_robin_select(self, servers: List[ServerNode]) -> ServerNode:
        """重み付き選択（大きな店舗により多くのお客さんを案内）"""
        
        # 重みの合計を計算
        total_weight = sum(server.weight for server in servers)
        
        # ランダムな数値を重みで選択
        random_value = random.randint(1, total_weight)
        current_weight = 0
        
        for server in servers:
            current_weight += server.weight
            if random_value <= current_weight:
                print(f"🎯 重み付き選択: {server.host}:{server.port} (重み: {server.weight})")
                return server
        
        # フォールバック
        return servers[0]
    
    def _least_connections_select(self, servers: List[ServerNode]) -> ServerNode:
        """最小接続選択（一番空いてる店舗に案内）"""
        
        # 接続数が最小のサーバーを選択
        least_busy_server = min(servers, key=lambda s: s.current_connections)
        
        print(f"🎯 最小接続: {least_busy_server.host}:{least_busy_server.port} "
              f"(接続数: {least_busy_server.current_connections})")
        
        return least_busy_server
    
    async def health_check_loop(self):
        """定期健康診断（各店舗の状況チェック）"""
        
        while True:
            print("🏥 サーバー健康診断を開始...")
            
            # 各サーバーの健康状態をチェック
            for server in self.servers:
                is_healthy = await self._check_server_health(server)
                
                if server.is_healthy != is_healthy:
                    # 状態が変わった場合の通知
                    status = "回復" if is_healthy else "ダウン"
                    print(f"📢 {server.host}:{server.port} が{status}しました")
                
                server.is_healthy = is_healthy
                server.last_health_check = time.time()
            
            # 健康な店舗数をレポート
            healthy_count = sum(1 for s in self.servers if s.is_healthy)
            print(f"📊 健康な店舗: {healthy_count}/{len(self.servers)}")
            
            # 次の健康診断まで待機
            await asyncio.sleep(self.health_check_interval)
    
    async def _check_server_health(self, server: ServerNode) -> bool:
        """個別サーバー健康診断（店舗の営業確認）"""
        
        try:
            start_time = time.time()
            
            # HTTPでサーバーの生存確認
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    f"http://{server.host}:{server.port}/health",
                    timeout=aiohttp.ClientTimeout(total=5)
                ) as response:
                    
                    # 応答時間を記録
                    server.response_time = time.time() - start_time
                    
                    # HTTPステータスが200番台なら健康
                    is_healthy = 200 <= response.status < 300
                    
                    if is_healthy:
                        print(f"✅ {server.host}:{server.port} は健康です (応答時間: {server.response_time:.2f}秒)")
                    else:
                        print(f"❌ {server.host}:{server.port} エラー応答: {response.status}")
                    
                    return is_healthy
                    
        except asyncio.TimeoutError:
            print(f"⏰ {server.host}:{server.port} タイムアウト")
            return False
        except Exception as e:
            print(f"💥 {server.host}:{server.port} 接続エラー: {e}")
            return False
    
    def get_load_balancer_stats(self) -> Dict[str, Any]:
        """ロードバランサーの統計情報"""
        
        total_servers = len(self.servers)
        healthy_servers = sum(1 for s in self.servers if s.is_healthy)
        total_connections = sum(s.current_connections for s in self.servers)
        avg_response_time = sum(s.response_time for s in self.servers) / total_servers if total_servers > 0 else 0
        
        return {
            "strategy": self.strategy.value,
            "total_servers": total_servers,
            "healthy_servers": healthy_servers,
            "total_connections": total_connections,
            "average_response_time": avg_response_time,
            "servers": [
                {
                    "id": s.id,
                    "host": f"{s.host}:{s.port}",
                    "weight": s.weight,
                    "is_healthy": s.is_healthy,
                    "connections": s.current_connections,
                    "response_time": s.response_time
                }
                for s in self.servers
            ]
        }

# 実際の使用例
async def setup_load_balancer():
    """ロードバランサーセットアップ例"""
    
    # ロードバランサーを作成
    lb = LoadBalancer(LoadBalancingStrategy.LEAST_CONNECTIONS)
    
    # サーバーを追加（チェーン店舗追加）
    lb.add_server(ServerNode("app1", "192.168.1.10", 8000, weight=1))
    lb.add_server(ServerNode("app2", "192.168.1.11", 8000, weight=2))  # 高性能サーバー
    lb.add_server(ServerNode("app3", "192.168.1.12", 8000, weight=1))
    
    # 健康診断を開始
    health_task = asyncio.create_task(lb.health_check_loop())
    
    return lb, health_task

# src/chapter05-saas-platform/backend/app/core/monitoring.py（監視システム）

import psutil
import time
from typing import Dict, Any, List
from dataclasses import dataclass
from datetime import datetime, timedelta
import asyncio
import json

@dataclass
class SystemMetrics:
    """システム指標（店舗の状況報告書）"""
    timestamp: datetime
    cpu_percent: float          # CPU使用率（コックさんの忙しさ）
    memory_percent: float       # メモリ使用率（冷蔵庫の満杯度）
    disk_percent: float         # ディスク使用率（倉庫の満杯度）
    network_io: Dict[str, int]  # ネットワークIO（お客さんの出入り）
    active_connections: int     # アクティブ接続数（店内のお客さん数）
    response_time: float        # 平均応答時間（注文から提供までの時間）

class MetricsCollector:
    """メトリクス収集システム（本部の情報収集部門）"""
    
    def __init__(self):
        self.metrics_history: List[SystemMetrics] = []
        self.collection_interval = 10  # 10秒ごとに収集
        self.retention_hours = 24      # 24時間分保持
        
    async def start_collection(self):
        """メトリクス収集開始（定期的な店舗巡回）"""
        print("📊 システム監視を開始します...")
        
        while True:
            try:
                # 現在のシステム状況を収集
                metrics = self._collect_current_metrics()
                
                # 履歴に追加
                self.metrics_history.append(metrics)
                
                # 古いデータを削除（24時間以上前）
                self._cleanup_old_metrics()
                
                # 異常検知
                await self._detect_anomalies(metrics)
                
                # 次の収集まで待機
                await asyncio.sleep(self.collection_interval)
                
            except Exception as e:
                print(f"❌ メトリクス収集エラー: {e}")
                await asyncio.sleep(5)  # エラー時は少し待つ
    
    def _collect_current_metrics(self) -> SystemMetrics:
        """現在のシステム指標を収集（店舗の現状調査）"""
        
        # CPU使用率（コックさんがどれだけ忙しいか）
        cpu_percent = psutil.cpu_percent(interval=1)
        
        # メモリ使用率（冷蔵庫の満杯度）
        memory = psutil.virtual_memory()
        memory_percent = memory.percent
        
        # ディスク使用率（倉庫の満杯度）
        disk = psutil.disk_usage('/')
        disk_percent = (disk.used / disk.total) * 100
        
        # ネットワークIO（お客さんの出入り状況）
        network = psutil.net_io_counters()
        network_io = {
            "bytes_sent": network.bytes_sent,
            "bytes_recv": network.bytes_recv,
            "packets_sent": network.packets_sent,
            "packets_recv": network.packets_recv
        }
        
        # アクティブ接続数（店内のお客さん数）
        active_connections = len(psutil.net_connections(kind='inet'))
        
        # 応答時間は別途測定（簡略化）
        response_time = self._measure_response_time()
        
        metrics = SystemMetrics(
            timestamp=datetime.utcnow(),
            cpu_percent=cpu_percent,
            memory_percent=memory_percent,
            disk_percent=disk_percent,
            network_io=network_io,
            active_connections=active_connections,
            response_time=response_time
        )
        
        # 収集した情報をログ出力
        print(f"📈 {metrics.timestamp.strftime('%H:%M:%S')}: "
              f"CPU:{cpu_percent:.1f}% "
              f"MEM:{memory_percent:.1f}% "
              f"接続:{active_connections}件")
        
        return metrics
    
    def _measure_response_time(self) -> float:
        """応答時間測定（注文から提供までの時間）"""
        # 実際の実装では、アプリケーションレベルで測定
        # ここでは簡略化
        return 0.1  # 100ms
    
    async def _detect_anomalies(self, metrics: SystemMetrics):
        """異常検知（問題の早期発見）"""
        
        warnings = []
        
        # CPU使用率が80%超過（コックさんが疲れ気味）
        if metrics.cpu_percent > 80:
            warnings.append(f"⚠️ CPU使用率が高いです: {metrics.cpu_percent:.1f}%")
        
        # メモリ使用率が85%超過（冷蔵庫がほぼ満杯）
        if metrics.memory_percent > 85:
            warnings.append(f"⚠️ メモリ使用率が高いです: {metrics.memory_percent:.1f}%")
        
        # ディスク使用率が90%超過（倉庫がほぼ満杯）
        if metrics.disk_percent > 90:
            warnings.append(f"⚠️ ディスク使用率が高いです: {metrics.disk_percent:.1f}%")
        
        # 応答時間が1秒超過（お客さんを待たせすぎ）
        if metrics.response_time > 1.0:
            warnings.append(f"⚠️ 応答時間が遅いです: {metrics.response_time:.2f}秒")
        
        # 警告がある場合はアラート送信
        if warnings:
            await self._send_alert(warnings)
    
    async def _send_alert(self, warnings: List[str]):
        """アラート送信（緊急事態の通知）"""
        
        alert_message = "🚨 システム警告:\n" + "\n".join(warnings)
        print(alert_message)
        
        # 実際の実装では以下のような通知を送信:
        # - Slack通知
        # - メール通知
        # - PagerDuty等のインシデント管理システム
        # - SMS通知（重要な障害の場合）
        
        # 例: Slack通知（実装例）
        # await self._send_slack_notification(alert_message)
    
    def _cleanup_old_metrics(self):
        """古いメトリクスデータの削除（古い資料の廃棄）"""
        
        cutoff_time = datetime.utcnow() - timedelta(hours=self.retention_hours)
        
        # 24時間より古いデータを削除
        self.metrics_history = [
            m for m in self.metrics_history 
            if m.timestamp > cutoff_time
        ]
    
    def get_metrics_summary(self, hours: int = 1) -> Dict[str, Any]:
        """指定時間のメトリクス集計（期間レポート）"""
        
        since_time = datetime.utcnow() - timedelta(hours=hours)
        recent_metrics = [
            m for m in self.metrics_history 
            if m.timestamp > since_time
        ]
        
        if not recent_metrics:
            return {"error": "No metrics available"}
        
        # 平均値、最大値、最小値を計算
        cpu_values = [m.cpu_percent for m in recent_metrics]
        memory_values = [m.memory_percent for m in recent_metrics]
        response_times = [m.response_time for m in recent_metrics]
        
        return {
            "period_hours": hours,
            "data_points": len(recent_metrics),
            "cpu": {
                "avg": sum(cpu_values) / len(cpu_values),
                "max": max(cpu_values),
                "min": min(cpu_values)
            },
            "memory": {
                "avg": sum(memory_values) / len(memory_values),
                "max": max(memory_values),
                "min": min(memory_values)
            },
            "response_time": {
                "avg": sum(response_times) / len(response_times),
                "max": max(response_times),
                "min": min(response_times)
            },
            "peak_connections": max(m.active_connections for m in recent_metrics)
        }

class AlertManager:
    """アラート管理システム（緊急事態管理部門）"""
    
    def __init__(self):
        self.alert_rules = {
            "cpu_critical": {"threshold": 90, "severity": "critical"},
            "memory_critical": {"threshold": 95, "severity": "critical"},
            "disk_critical": {"threshold": 95, "severity": "critical"},
            "response_time_warning": {"threshold": 2.0, "severity": "warning"}
        }
        self.alert_history = []
    
    async def process_metrics(self, metrics: SystemMetrics):
        """メトリクスからアラートをチェック"""
        
        alerts = []
        
        # CPU使用率チェック
        if metrics.cpu_percent >= self.alert_rules["cpu_critical"]["threshold"]:
            alerts.append({
                "rule": "cpu_critical",
                "message": f"CPU使用率が危険レベル: {metrics.cpu_percent:.1f}%",
                "severity": "critical",
                "timestamp": metrics.timestamp
            })
        
        # メモリ使用率チェック
        if metrics.memory_percent >= self.alert_rules["memory_critical"]["threshold"]:
            alerts.append({
                "rule": "memory_critical", 
                "message": f"メモリ使用率が危険レベル: {metrics.memory_percent:.1f}%",
                "severity": "critical",
                "timestamp": metrics.timestamp
            })
        
        # 各アラートを処理
        for alert in alerts:
            await self._handle_alert(alert)
    
    async def _handle_alert(self, alert: Dict[str, Any]):
        """個別アラート処理"""
        
        # アラート履歴に記録
        self.alert_history.append(alert)
        
        # 重要度に応じた処理
        if alert["severity"] == "critical":
            print(f"🚨 【緊急】{alert['message']}")
            # 即座に管理者に通知
            await self._send_critical_notification(alert)
        else:
            print(f"⚠️ 【警告】{alert['message']}")
            # 通常の警告通知
            await self._send_warning_notification(alert)
    
    async def _send_critical_notification(self, alert):
        """緊急通知送信"""
        # SMS、電話、Slack即座通知など
        pass
    
    async def _send_warning_notification(self, alert):
        """警告通知送信"""
        # メール、Slack通知など
        pass

# 実際の使用例
async def setup_monitoring():
    """監視システムセットアップ"""
    
    collector = MetricsCollector()
    alert_manager = AlertManager()
    
    # 監視開始
    monitor_task = asyncio.create_task(collector.start_collection())
    
    return collector, alert_manager, monitor_task

# src/chapter05-saas-platform/backend/app/core/alerting.py（アラートシステム）

import asyncio
import aiohttp
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from typing import Dict, Any, List, Optional
from datetime import datetime, timedelta
from dataclasses import dataclass
from enum import Enum
import json

class AlertSeverity(Enum):
    """アラートの重要度（緊急度ランク）"""
    INFO = "info"         # 情報（お知らせ程度）
    WARNING = "warning"   # 警告（注意が必要）
    CRITICAL = "critical" # 緊急（すぐ対応必要）
    FATAL = "fatal"       # 致命的（システム停止レベル）

@dataclass
class Alert:
    """アラート情報（緊急事態報告書）"""
    id: str
    title: str
    message: str
    severity: AlertSeverity
    timestamp: datetime
    source: str           # どのシステムからの警告か
    metadata: Dict[str, Any] = None

class NotificationChannel:
    """通知チャンネル（連絡方法）"""
    
    async def send_slack_notification(self, alert: Alert, webhook_url: str):
        """Slack通知（チャット通知）"""
        
        # 重要度に応じて色を変更
        color_map = {
            AlertSeverity.INFO: "#36a64f",      # 緑
            AlertSeverity.WARNING: "#ff9500",   # オレンジ
            AlertSeverity.CRITICAL: "#ff0000",  # 赤
            AlertSeverity.FATAL: "#8B0000"      # 暗赤
        }
        
        # 重要度に応じて絵文字を変更
        emoji_map = {
            AlertSeverity.INFO: "ℹ️",
            AlertSeverity.WARNING: "⚠️", 
            AlertSeverity.CRITICAL: "🚨",
            AlertSeverity.FATAL: "💀"
        }
        
        payload = {
            "attachments": [
                {
                    "color": color_map[alert.severity],
                    "title": f"{emoji_map[alert.severity]} {alert.title}",
                    "text": alert.message,
                    "fields": [
                        {
                            "title": "重要度",
                            "value": alert.severity.value.upper(),
                            "short": True
                        },
                        {
                            "title": "発生時刻",
                            "value": alert.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
                            "short": True
                        },
                        {
                            "title": "発生源",
                            "value": alert.source,
                            "short": True
                        }
                    ],
                    "footer": "SaaS Platform Monitoring",
                    "ts": alert.timestamp.timestamp()
                }
            ]
        }
        
        try:
            async with aiohttp.ClientSession() as session:
                async with session.post(webhook_url, json=payload) as response:
                    if response.status == 200:
                        print(f"✅ Slack通知送信成功: {alert.title}")
                    else:
                        print(f"❌ Slack通知送信失敗: {response.status}")
                        
        except Exception as e:
            print(f"💥 Slack通知エラー: {e}")
    
    async def send_email_notification(self, alert: Alert, email_config: Dict[str, str]):
        """メール通知（メール通知）"""
        
        try:
            # メール作成
            msg = MIMEMultipart()
            msg['From'] = email_config['from_email']
            msg['To'] = email_config['to_email']
            msg['Subject'] = f"[{alert.severity.value.upper()}] {alert.title}"
            
            # HTML本文作成
            html_body = f"""
            <html>
            <body>
                <h2 style="color: {'red' if alert.severity in [AlertSeverity.CRITICAL, AlertSeverity.FATAL] else 'orange'};">
                    システム警告
                </h2>
                
                <table style="border-collapse: collapse; width: 100%;">
                    <tr>
                        <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold;">タイトル</td>
                        <td style="border: 1px solid #ddd; padding: 8px;">{alert.title}</td>
                    </tr>
                    <tr>
                        <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold;">重要度</td>
                        <td style="border: 1px solid #ddd; padding: 8px;">{alert.severity.value.upper()}</td>
                    </tr>
                    <tr>
                        <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold;">発生時刻</td>
                        <td style="border: 1px solid #ddd; padding: 8px;">{alert.timestamp.strftime("%Y-%m-%d %H:%M:%S")}</td>
                    </tr>
                    <tr>
                        <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold;">発生源</td>
                        <td style="border: 1px solid #ddd; padding: 8px;">{alert.source}</td>
                    </tr>
                </table>
                
                <h3>詳細メッセージ</h3>
                <p>{alert.message}</p>
                
                <hr>
                <p><small>このメールは自動送信されました。</small></p>
            </body>
            </html>
            """
            
            msg.attach(MIMEText(html_body, 'html'))
            
            # SMTP送信
            server = smtplib.SMTP(email_config['smtp_server'], email_config['smtp_port'])
            server.starttls()
            server.login(email_config['username'], email_config['password'])
            server.send_message(msg)
            server.quit()
            
            print(f"✅ メール通知送信成功: {alert.title}")
            
        except Exception as e:
            print(f"💥 メール通知エラー: {e}")

class LogManager:
    """ログ管理システム（お店の日報管理）"""
    
    def __init__(self, log_level: str = "INFO"):
        self.log_level = log_level
        self.log_buffer = []  # メモリ内ログバッファ
        
    def log(self, level: str, message: str, extra_data: Dict[str, Any] = None):
        """ログ記録（日報への記録）"""
        
        log_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "level": level,
            "message": message,
            "extra_data": extra_data or {}
        }
        
        # メモリバッファに追加
        self.log_buffer.append(log_entry)
        
        # コンソール出力（開発時）
        timestamp_str = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp_str}] {level}: {message}")
        
        # ファイルに書き込み（実際の実装では）
        # self._write_to_file(log_entry)
        
        # 長期保存用にデータベースに保存（実際の実装では）
        # await self._save_to_database(log_entry)
    
    def info(self, message: str, **kwargs):
        """情報ログ"""
        self.log("INFO", message, kwargs)
    
    def warning(self, message: str, **kwargs):
        """警告ログ"""
        self.log("WARNING", message, kwargs)
    
    def error(self, message: str, **kwargs):
        """エラーログ"""
        self.log("ERROR", message, kwargs)
    
    def critical(self, message: str, **kwargs):
        """緊急ログ"""
        self.log("CRITICAL", message, kwargs)
    
    def get_recent_logs(self, hours: int = 1, level: Optional[str] = None) -> List[Dict[str, Any]]:
        """最近のログ取得（期間指定で日報確認）"""
        
        since_time = datetime.utcnow() - timedelta(hours=hours)
        
        filtered_logs = []
        for log_entry in self.log_buffer:
            log_time = datetime.fromisoformat(log_entry["timestamp"])
            
            # 時間範囲チェック
            if log_time < since_time:
                continue
            
            # レベルフィルター
            if level and log_entry["level"] != level:
                continue
            
            filtered_logs.append(log_entry)
        
        return filtered_logs

class AlertingSystem:
    """統合アラートシステム（緊急事態対応本部）"""
    
    def __init__(self):
        self.notification_channel = NotificationChannel()
        self.log_manager = LogManager()
        self.alert_history = []
        self.suppression_rules = {}  # アラート抑制ルール
        
    async def send_alert(
        self, 
        title: str, 
        message: str, 
        severity: AlertSeverity,
        source: str,
        slack_webhook: Optional[str] = None,
        email_config: Optional[Dict[str, str]] = None
    ):
        """アラート送信（緊急事態の発報）"""
        
        # アラート作成
        alert = Alert(
            id=f"{source}_{datetime.utcnow().timestamp()}",
            title=title,
            message=message,
            severity=severity,
            timestamp=datetime.utcnow(),
            source=source
        )
        
        # アラート抑制チェック（同じ警告の連発を防ぐ）
        if self._should_suppress_alert(alert):
            self.log_manager.info(f"アラート抑制: {alert.title}")
            return
        
        # アラート履歴に記録
        self.alert_history.append(alert)
        
        # ログに記録
        self.log_manager.log(
            level=severity.value.upper(),
            message=f"アラート発生: {title}",
            extra_data={"alert_id": alert.id, "source": source}
        )
        
        # 通知送信
        notifications = []
        
        if slack_webhook:
            notifications.append(
                self.notification_channel.send_slack_notification(alert, slack_webhook)
            )
        
        if email_config:
            notifications.append(
                self.notification_channel.send_email_notification(alert, email_config)
            )
        
        # 複数通知を並行実行
        if notifications:
            await asyncio.gather(*notifications, return_exceptions=True)
    
    def _should_suppress_alert(self, alert: Alert) -> bool:
        """アラート抑制判定（同じ警告の連発防止）"""
        
        # 過去5分間に同じタイプのアラートがあったら抑制
        five_minutes_ago = datetime.utcnow() - timedelta(minutes=5)
        
        for past_alert in self.alert_history:
            if (past_alert.timestamp > five_minutes_ago and 
                past_alert.title == alert.title and
                past_alert.source == alert.source):
                return True
        
        return False
    
    def get_alert_summary(self, hours: int = 24) -> Dict[str, Any]:
        """アラート集計（期間レポート）"""
        
        since_time = datetime.utcnow() - timedelta(hours=hours)
        recent_alerts = [
            alert for alert in self.alert_history 
            if alert.timestamp > since_time
        ]
        
        # 重要度別集計
        severity_counts = {}
        for severity in AlertSeverity:
            severity_counts[severity.value] = len([
                a for a in recent_alerts 
                if a.severity == severity
            ])
        
        # 発生源別集計
        source_counts = {}
        for alert in recent_alerts:
            source_counts[alert.source] = source_counts.get(alert.source, 0) + 1
        
        return {
            "period_hours": hours,
            "total_alerts": len(recent_alerts),
            "severity_breakdown": severity_counts,
            "source_breakdown": source_counts,
            "recent_alerts": [
                {
                    "title": alert.title,
                    "severity": alert.severity.value,
                    "timestamp": alert.timestamp.isoformat(),
                    "source": alert.source
                }
                for alert in recent_alerts[-10:]  # 最新10件
            ]
        }

# 実際の使用例
async def setup_alerting():
    """アラートシステムセットアップ"""
    
    alerting = AlertingSystem()
    
    # テスト警告送信
    await alerting.send_alert(
        title="CPU使用率が高いです",
        message="CPU使用率が85%を超えました。システムの負荷を確認してください。",
        severity=AlertSeverity.WARNING,
        source="monitoring_system",
        slack_webhook="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
    )
    
    return alerting

# app/core/database_optimization.py
from sqlalchemy import event, text
from sqlalchemy.engine import Engine
from sqlalchemy.pool import QueuePool
import time
import logging

from app.core.config import settings

# スロークエリ監視
@event.listens_for(Engine, "before_cursor_execute")
def receive_before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
    context._query_start_time = time.time()

@event.listens_for(Engine, "after_cursor_execute")
def receive_after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
    total = time.time() - context._query_start_time
    
    # 1秒以上のクエリを警告
    if total > 1.0:
        logging.warning(
            f"Slow query: {total:.2f}s\n"
            f"Statement: {statement}\n"
            f"Parameters: {parameters}"
        )

class DatabaseOptimizer:
    def __init__(self, engine):
        self.engine = engine
    
    def get_connection_pool_status(self):
        """コネクションプール状態取得"""
        pool = self.engine.pool
        return {
            "size": pool.size(),
            "checked_in": pool.checkedin(),
            "checked_out": pool.checkedout(),
            "overflow": pool.overflow(),
            "status": f"{pool.checkedout()}/{pool.size() + pool.overflow()}"
        }
    
    def analyze_query_performance(self, query: str, limit: int = 10):
        """クエリパフォーマンス分析"""
        with self.engine.connect() as conn:
            # EXPLAIN ANALYZE実行
            explain_query = f"EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) {query}"
            result = conn.execute(text(explain_query))
            explain_data = result.fetchone()[0]
            
            return {
                "execution_time": explain_data[0]["Execution Time"],
                "planning_time": explain_data[0]["Planning Time"],
                "plan": explain_data[0]["Plan"]
            }
    
    def get_database_statistics(self):
        """データベース統計情報取得"""
        with self.engine.connect() as conn:
            # テーブルサイズ
            table_sizes = conn.execute(text("""
                SELECT 
                    schemaname,
                    tablename,
                    pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) as size,
                    pg_total_relation_size(schemaname||'.'||tablename) as size_bytes
                FROM pg_tables 
                WHERE schemaname = 'public'
                ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC;
            """)).fetchall()
            
            # インデックス効率
            index_usage = conn.execute(text("""
                SELECT 
                    schemaname,
                    tablename,
                    indexname,
                    idx_scan as index_scans,
                    idx_tup_read as tuples_read,
                    idx_tup_fetch as tuples_fetched
                FROM pg_stat_user_indexes 
                ORDER BY idx_scan DESC;
            """)).fetchall()
            
            # 未使用インデックス
            unused_indexes = conn.execute(text("""
                SELECT 
                    schemaname,
                    tablename,
                    indexname,
                    pg_size_pretty(pg_relation_size(indexrelid)) as size
                FROM pg_stat_user_indexes 
                WHERE idx_scan = 0
                AND schemaname = 'public';
            """)).fetchall()
            
            return {
                "table_sizes": [dict(row._mapping) for row in table_sizes],
                "index_usage": [dict(row._mapping) for row in index_usage],
                "unused_indexes": [dict(row._mapping) for row in unused_indexes]
            }

# パーティショニング実装例
def create_audit_log_partition(year: int, month: int):
    """監査ログパーティション作成"""
    partition_name = f"audit_logs_y{year}m{month:02d}"
    start_date = f"{year}-{month:02d}-01"
    
    if month == 12:
        end_date = f"{year + 1}-01-01"
    else:
        end_date = f"{year}-{month + 1:02d}-01"
    
    create_partition_sql = f"""
    CREATE TABLE IF NOT EXISTS {partition_name} 
    PARTITION OF audit_logs 
    FOR VALUES FROM ('{start_date}') TO ('{end_date}');
    
    CREATE INDEX IF NOT EXISTS {partition_name}_created_at_idx 
    ON {partition_name} (created_at);
    
    CREATE INDEX IF NOT EXISTS {partition_name}_user_id_idx 
    ON {partition_name} (user_id);
    """
    
    return create_partition_sql

# app/core/load_balancer.py
from typing import List, Dict, Any
import random
import time
from dataclasses import dataclass
from enum import Enum

class HealthStatus(Enum):
    HEALTHY = "healthy"
    UNHEALTHY = "unhealthy"
    DEGRADED = "degraded"

@dataclass
class ServerInstance:
    id: str
    host: str
    port: int
    weight: int = 1
    current_connections: int = 0
    max_connections: int = 100
    status: HealthStatus = HealthStatus.HEALTHY
    last_health_check: float = 0
    response_time: float = 0

class LoadBalancer:
    def __init__(self):
        self.servers: List[ServerInstance] = []
        self.algorithm = "weighted_round_robin"
        self.current_index = 0
    
    def add_server(self, server: ServerInstance):
        """サーバー追加"""
        self.servers.append(server)
    
    def remove_server(self, server_id: str):
        """サーバー削除"""
        self.servers = [s for s in self.servers if s.id != server_id]
    
    def get_healthy_servers(self) -> List[ServerInstance]:
        """健全なサーバー一覧取得"""
        return [s for s in self.servers if s.status == HealthStatus.HEALTHY]
    
    def select_server(self) -> ServerInstance:
        """サーバー選択"""
        healthy_servers = self.get_healthy_servers()
        
        if not healthy_servers:
            raise Exception("No healthy servers available")
        
        if self.algorithm == "round_robin":
            return self._round_robin_selection(healthy_servers)
        elif self.algorithm == "weighted_round_robin":
            return self._weighted_round_robin_selection(healthy_servers)
        elif self.algorithm == "least_connections":
            return self._least_connections_selection(healthy_servers)
        else:
            return random.choice(healthy_servers)
    
    def _round_robin_selection(self, servers: List[ServerInstance]) -> ServerInstance:
        """ラウンドロビン選択"""
        server = servers[self.current_index % len(servers)]
        self.current_index += 1
        return server
    
    def _weighted_round_robin_selection(self, servers: List[ServerInstance]) -> ServerInstance:
        """重み付きラウンドロビン選択"""
        total_weight = sum(s.weight for s in servers)
        rand_weight = random.randint(1, total_weight)
        
        current_weight = 0
        for server in servers:
            current_weight += server.weight
            if rand_weight <= current_weight:
                return server
        
        return servers[0]  # フォールバック
    
    def _least_connections_selection(self, servers: List[ServerInstance]) -> ServerInstance:
        """最少コネクション選択"""
        return min(servers, key=lambda s: s.current_connections)
    
    async def health_check(self):
        """ヘルスチェック実行"""
        for server in self.servers:
            try:
                # HTTPヘルスチェック実行
                start_time = time.time()
                is_healthy = await self._check_server_health(server)
                response_time = time.time() - start_time
                
                server.response_time = response_time
                server.last_health_check = time.time()
                
                if is_healthy:
                    if response_time > 5.0:  # 5秒以上は劣化
                        server.status = HealthStatus.DEGRADED
                    else:
                        server.status = HealthStatus.HEALTHY
                else:
                    server.status = HealthStatus.UNHEALTHY
                    
            except Exception:
                server.status = HealthStatus.UNHEALTHY
    
    async def _check_server_health(self, server: ServerInstance) -> bool:
        """個別サーバーヘルスチェック"""
        import httpx
        
        try:
            async with httpx.AsyncClient(timeout=5.0) as client:
                response = await client.get(f"http://{server.host}:{server.port}/health")
                return response.status_code == 200
        except:
            return False

# 使用例
load_balancer = LoadBalancer()

# app/core/metrics.py
import time
import psutil
from typing import Dict, Any, List
from dataclasses import dataclass, asdict
from datetime import datetime
import asyncio

@dataclass
class SystemMetrics:
    timestamp: datetime
    cpu_percent: float
    memory_percent: float
    memory_used_mb: float
    disk_usage_percent: float
    network_io: Dict[str, int]
    process_count: int

@dataclass
class ApplicationMetrics:
    timestamp: datetime
    active_connections: int
    request_count: int
    error_count: int
    avg_response_time: float
    cache_hit_ratio: float
    database_connections: int

class MetricsCollector:
    def __init__(self):
        self.system_metrics_history: List[SystemMetrics] = []
        self.app_metrics_history: List[ApplicationMetrics] = []
        self.max_history_size = 1000
        
        # カウンター
        self.request_count = 0
        self.error_count = 0
        self.response_times: List[float] = []
    
    def collect_system_metrics(self) -> SystemMetrics:
        """システムメトリクス収集"""
        memory = psutil.virtual_memory()
        disk = psutil.disk_usage('/')
        network = psutil.net_io_counters()
        
        metrics = SystemMetrics(
            timestamp=datetime.utcnow(),
            cpu_percent=psutil.cpu_percent(interval=1),
            memory_percent=memory.percent,
            memory_used_mb=memory.used / 1024 / 1024,
            disk_usage_percent=disk.percent,
            network_io={
                "bytes_sent": network.bytes_sent,
                "bytes_recv": network.bytes_recv
            },
            process_count=len(psutil.pids())
        )
        
        # 履歴保存
        self.system_metrics_history.append(metrics)
        if len(self.system_metrics_history) > self.max_history_size:
            self.system_metrics_history.pop(0)
        
        return metrics
    
    def collect_application_metrics(self) -> ApplicationMetrics:
        """アプリケーションメトリクス収集"""
        from app.core.database import engine
        from app.core.cache import cache
        
        # データベース接続数
        db_connections = 0
        if hasattr(engine.pool, 'checkedout'):
            db_connections = engine.pool.checkedout()
        
        # レスポンス時間平均
        avg_response_time = 0
        if self.response_times:
            avg_response_time = sum(self.response_times) / len(self.response_times)
            self.response_times = self.response_times[-100:]  # 直近100件のみ保持
        
        # キャッシュヒット率
        cache_hit_ratio = 0
        try:
            cache_info = cache.redis_client.info('stats')
            hits = cache_info.get('keyspace_hits', 0)
            misses = cache_info.get('keyspace_misses', 0)
            if hits + misses > 0:
                cache_hit_ratio = hits / (hits + misses) * 100
        except:
            pass
        
        metrics = ApplicationMetrics(
            timestamp=datetime.utcnow(),
            active_connections=0,  # FastAPIから取得
            request_count=self.request_count,
            error_count=self.error_count,
            avg_response_time=avg_response_time,
            cache_hit_ratio=cache_hit_ratio,
            database_connections=db_connections
        )
        
        self.app_metrics_history.append(metrics)
        if len(self.app_metrics_history) > self.max_history_size:
            self.app_metrics_history.pop(0)
        
        return metrics
    
    def record_request(self, response_time: float, is_error: bool = False):
        """リクエスト記録"""
        self.request_count += 1
        self.response_times.append(response_time)
        
        if is_error:
            self.error_count += 1
    
    def get_summary(self) -> Dict[str, Any]:
        """メトリクス要約取得"""
        if not self.system_metrics_history or not self.app_metrics_history:
            return {}
        
        recent_system = self.system_metrics_history[-10:]  # 直近10件
        recent_app = self.app_metrics_history[-10:]
        
        return {
            "system": {
                "avg_cpu": sum(m.cpu_percent for m in recent_system) / len(recent_system),
                "avg_memory": sum(m.memory_percent for m in recent_system) / len(recent_system),
                "current_memory_mb": recent_system[-1].memory_used_mb,
                "disk_usage": recent_system[-1].disk_usage_percent
            },
            "application": {
                "total_requests": self.request_count,
                "total_errors": self.error_count,
                "error_rate": (self.error_count / self.request_count * 100) if self.request_count > 0 else 0,
                "avg_response_time": recent_app[-1].avg_response_time,
                "cache_hit_ratio": recent_app[-1].cache_hit_ratio,
                "db_connections": recent_app[-1].database_connections
            },
            "timestamp": datetime.utcnow().isoformat()
        }

# グローバルメトリクスコレクター
metrics_collector = MetricsCollector()

# ミドルウェア
from fastapi import Request, Response
from starlette.middleware.base import BaseHTTPMiddleware
import time

class MetricsMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        start_time = time.time()
        
        try:
            response = await call_next(request)
            
            # リクエスト記録
            response_time = time.time() - start_time
            is_error = response.status_code >= 400
            metrics_collector.record_request(response_time, is_error)
            
            # レスポンスヘッダーに追加
            response.headers["X-Response-Time"] = f"{response_time:.3f}"
            
            return response
            
        except Exception as e:
            response_time = time.time() - start_time
            metrics_collector.record_request(response_time, True)
            raise

# app/core/logging_config.py
import logging
import logging.handlers
import json
from datetime import datetime
from typing import Dict, Any
import traceback

from app.core.config import settings

class JSONFormatter(logging.Formatter):
    """JSON形式ログフォーマッター"""
    
    def format(self, record):
        log_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "level": record.levelname,
            "logger": record.name,
            "message": record.getMessage(),
            "module": record.module,
            "function": record.funcName,
            "line": record.lineno
        }
        
        # 例外情報追加
        if record.exc_info:
            log_entry["exception"] = {
                "type": record.exc_info[0].__name__,
                "message": str(record.exc_info[1]),
                "traceback": traceback.format_exception(*record.exc_info)
            }
        
        # 追加フィールド
        if hasattr(record, 'user_id'):
            log_entry["user_id"] = record.user_id
        
        if hasattr(record, 'organization_id'):
            log_entry["organization_id"] = record.organization_id
        
        if hasattr(record, 'request_id'):
            log_entry["request_id"] = record.request_id
        
        return json.dumps(log_entry)

def setup_logging():
    """ログ設定初期化"""
    
    # ルートロガー設定
    root_logger = logging.getLogger()
    root_logger.setLevel(getattr(logging, settings.LOG_LEVEL))
    
    # 既存ハンドラー削除
    for handler in root_logger.handlers[:]:
        root_logger.removeHandler(handler)
    
    # コンソールハンドラー
    console_handler = logging.StreamHandler()
    console_handler.setFormatter(JSONFormatter())
    root_logger.addHandler(console_handler)
    
    # ファイルハンドラー（本番環境）
    if not settings.DEBUG:
        file_handler = logging.handlers.RotatingFileHandler(
            "app.log",
            maxBytes=10*1024*1024,  # 10MB
            backupCount=5
        )
        file_handler.setFormatter(JSONFormatter())
        root_logger.addHandler(file_handler)
    
    # 外部ログ収集（例：Datadog）
    if hasattr(settings, 'DATADOG_API_KEY'):
        datadog_handler = DatadogHandler(settings.DATADOG_API_KEY)
        root_logger.addHandler(datadog_handler)

class StructuredLogger:
    """構造化ログヘルパー"""
    
    def __init__(self, name: str):
        self.logger = logging.getLogger(name)
    
    def info(self, message: str, **kwargs):
        self._log(logging.INFO, message, **kwargs)
    
    def warning(self, message: str, **kwargs):
        self._log(logging.WARNING, message, **kwargs)
    
    def error(self, message: str, **kwargs):
        self._log(logging.ERROR, message, **kwargs)
    
    def _log(self, level: int, message: str, **kwargs):
        extra = {k: v for k, v in kwargs.items() if k not in ['exc_info']}
        self.logger.log(level, message, extra=extra, exc_info=kwargs.get('exc_info'))

# アプリケーションロガー
app_logger = StructuredLogger("saas_platform")

# 使用例
def log_user_action(user_id: int, action: str, details: Dict[str, Any]):
    app_logger.info(
        f"User action: {action}",
        user_id=user_id,
        action=action,
        details=details
    )

# app/core/alerting.py
from typing import Dict, Any, List, Callable
from enum import Enum
from dataclasses import dataclass
from datetime import datetime, timedelta
import asyncio

class AlertSeverity(Enum):
    INFO = "info"
    WARNING = "warning"
    ERROR = "error"
    CRITICAL = "critical"

@dataclass
class Alert:
    id: str
    title: str
    description: str
    severity: AlertSeverity
    source: str
    timestamp: datetime
    metadata: Dict[str, Any]
    resolved: bool = False
    resolved_at: datetime = None

class AlertRule:
    def __init__(
        self,
        name: str,
        condition: Callable[[Dict[str, Any]], bool],
        severity: AlertSeverity,
        description: str,
        cooldown_minutes: int = 15
    ):
        self.name = name
        self.condition = condition
        self.severity = severity
        self.description = description
        self.cooldown = timedelta(minutes=cooldown_minutes)
        self.last_triggered = None
    
    def should_trigger(self, metrics: Dict[str, Any]) -> bool:
        """アラート発火条件チェック"""
        # クールダウン期間中は発火しない
        if self.last_triggered and datetime.utcnow() - self.last_triggered < self.cooldown:
            return False
        
        return self.condition(metrics)
    
    def trigger(self) -> Alert:
        """アラート発火"""
        self.last_triggered = datetime.utcnow()
        
        return Alert(
            id=f"{self.name}_{int(self.last_triggered.timestamp())}",
            title=f"Alert: {self.name}",
            description=self.description,
            severity=self.severity,
            source="system_monitor",
            timestamp=self.last_triggered,
            metadata={"rule": self.name}
        )

class AlertManager:
    def __init__(self):
        self.rules: List[AlertRule] = []
        self.active_alerts: Dict[str, Alert] = {}
        self.alert_handlers: List[Callable[[Alert], None]] = []
        
        # デフォルトルール設定
        self._setup_default_rules()
    
    def add_rule(self, rule: AlertRule):
        """アラートルール追加"""
        self.rules.append(rule)
    
    def add_handler(self, handler: Callable[[Alert], None]):
        """アラートハンドラー追加"""
        self.alert_handlers.append(handler)
    
    async def check_alerts(self, metrics: Dict[str, Any]):
        """アラートチェック実行"""
        for rule in self.rules:
            if rule.should_trigger(metrics):
                alert = rule.trigger()
                await self._handle_alert(alert)
    
    async def _handle_alert(self, alert: Alert):
        """アラート処理"""
        self.active_alerts[alert.id] = alert
        
        # 各ハンドラーで処理
        for handler in self.alert_handlers:
            try:
                await self._run_handler(handler, alert)
            except Exception as e:
                app_logger.error(f"Alert handler error: {e}", alert_id=alert.id)
    
    async def _run_handler(self, handler: Callable, alert: Alert):
        """ハンドラー実行"""
        if asyncio.iscoroutinefunction(handler):
            await handler(alert)
        else:
            handler(alert)
    
    def resolve_alert(self, alert_id: str):
        """アラート解決"""
        if alert_id in self.active_alerts:
            alert = self.active_alerts[alert_id]
            alert.resolved = True
            alert.resolved_at = datetime.utcnow()
            del self.active_alerts[alert_id]
    
    def _setup_default_rules(self):
        """デフォルトアラートルール設定"""
        
        # CPU使用率アラート
        self.add_rule(AlertRule(
            name="high_cpu_usage",
            condition=lambda m: m.get("system", {}).get("avg_cpu", 0) > 80,
            severity=AlertSeverity.WARNING,
            description="CPU使用率が80%を超えています"
        ))
        
        # メモリ使用率アラート
        self.add_rule(AlertRule(
            name="high_memory_usage",
            condition=lambda m: m.get("system", {}).get("avg_memory", 0) > 85,
            severity=AlertSeverity.ERROR,
            description="メモリ使用率が85%を超えています"
        ))
        
        # エラー率アラート
        self.add_rule(AlertRule(
            name="high_error_rate",
            condition=lambda m: m.get("application", {}).get("error_rate", 0) > 5,
            severity=AlertSeverity.ERROR,
            description="エラー率が5%を超えています"
        ))
        
        # レスポンス時間アラート
        self.add_rule(AlertRule(
            name="slow_response_time",
            condition=lambda m: m.get("application", {}).get("avg_response_time", 0) > 2.0,
            severity=AlertSeverity.WARNING,
            description="平均レスポンス時間が2秒を超えています"
        ))

# Slack通知ハンドラー
async def slack_alert_handler(alert: Alert):
    """Slack通知送信"""
    import httpx
    
    webhook_url = settings.SLACK_WEBHOOK_URL
    if not webhook_url:
        return
    
    color_map = {
        AlertSeverity.INFO: "#36a64f",
        AlertSeverity.WARNING: "#ff9900", 
        AlertSeverity.ERROR: "#ff0000",
        AlertSeverity.CRITICAL: "#8b0000"
    }
    
    message = {
        "attachments": [{
            "color": color_map.get(alert.severity, "#36a64f"),
            "title": alert.title,
            "text": alert.description,
            "fields": [
                {"title": "Severity", "value": alert.severity.value, "short": True},
                {"title": "Source", "value": alert.source, "short": True},
                {"title": "Time", "value": alert.timestamp.isoformat(), "short": False}
            ]
        }]
    }
    
    async with httpx.AsyncClient() as client:
        await client.post(webhook_url, json=message)

# グローバルアラートマネージャー
alert_manager = AlertManager()
alert_manager.add_handler(slack_alert_handler)