# 容量予測モデル
成長予測:
  現在のトラフィック: 1000 req/s
  月次成長率: 15%
  
  6ヶ月後予測: 1000 × (1.15^6) = 2313 req/s
  必要インスタンス数: ceil(2313 / 100) = 24台
  
  バッファ込み: 24 × 1.3 = 32台

from opentelemetry import trace, metrics
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader

# Tracing設定
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

# Span Processorの設定
span_processor = BatchSpanProcessor(
    OTLPSpanExporter(
        endpoint="https://api.honeycomb.io/v1/traces",
        headers={"x-honeycomb-team": "your-api-key"}
    )
)
trace.get_tracer_provider().add_span_processor(span_processor)

# Metricsの設定
metric_reader = PeriodicExportingMetricReader(
    exporter=OTLPMetricExporter(
        endpoint="https://api.honeycomb.io/v1/metrics",
        headers={"x-honeycomb-team": "your-api-key"}
    ),
    export_interval_millis=30000
)
metrics.set_meter_provider(MeterProvider(metric_readers=[metric_reader]))
meter = metrics.get_meter(__name__)

# カスタムメトリクス
request_counter = meter.create_counter(
    "requests_total",
    description="Total number of requests",
    unit="1",
)

response_time_histogram = meter.create_histogram(
    "request_duration_seconds",
    description="Request duration in seconds",
    unit="s",
)

# 使用例
@tracer.start_as_current_span("process_request")
def process_request(request_id):
    with tracer.start_as_current_span("database_query") as span:
        span.set_attribute("request.id", request_id)
        span.set_attribute("db.operation", "select")
        
        # メトリクス記録
        request_counter.add(1, {"endpoint": "/api/users", "method": "GET"})
        
        # 処理時間の記録
        import time
        start_time = time.time()
        
        # 実際の処理
        result = fetch_user_data(request_id)
        
        duration = time.time() - start_time
        response_time_histogram.record(duration, {"endpoint": "/api/users"})
        
        return result

import jaeger_client
from jaeger_client import Config

def initialize_tracer(service_name):
    config = Config(
        config={
            'sampler': {
                'type': 'const',
                'param': 1,
            },
            'logging': True,
            'reporter': {
                'log_spans': True,
                'batch_size': 1,
                'queue_size': 100,
                'local_agent': {
                    'reporting_host': 'jaeger-agent',
                    'reporting_port': 6831,
                }
            }
        },
        service_name=service_name,
        validate=True,
    )
    return config.initialize_tracer()

tracer = initialize_tracer('user-service')

def get_user_profile(user_id):
    with tracer.start_span('get_user_profile') as span:
        span.set_tag('user.id', user_id)
        span.set_tag('span.kind', 'server')
        
        # 子スパンでデータベース操作
        with tracer.start_span('database_query', child_of=span) as db_span:
            db_span.set_tag('db.type', 'postgresql')
            db_span.set_tag('db.statement', 'SELECT * FROM users WHERE id = %s')
            
            user_data = database.query_user(user_id)
            
            if user_data:
                db_span.set_tag('db.rows_affected', 1)
            else:
                db_span.set_tag('error', True)
                span.set_tag('error', True)
                
        return user_data

import random
import time
from typing import List, Dict
from dataclasses import dataclass
from kubernetes import client, config

@dataclass
class ChaosExperiment:
    name: str
    target_service: str
    failure_type: str
    duration_seconds: int
    success_criteria: Dict[str, float]

class ChaosMonkey:
    def __init__(self, monitoring_client):
        self.monitoring = monitoring_client
        self.k8s_client = client.AppsV1Api()
        
    def execute_experiment(self, experiment: ChaosExperiment):
        """カオス実験を実行し、監視データを収集"""
        
        # 実験開始前のベースライン収集
        baseline_metrics = self.collect_baseline_metrics(experiment.target_service)
        
        # 実験開始ログ
        self.monitoring.log_event({
            "event_type": "chaos_experiment_start",
            "experiment_name": experiment.name,
            "target_service": experiment.target_service,
            "failure_type": experiment.failure_type
        })
        
        try:
            # 障害の注入
            self.inject_failure(experiment)
            
            # 実験期間中の監視
            experiment_metrics = self.monitor_during_experiment(
                experiment.target_service, 
                experiment.duration_seconds
            )
            
            # 成功基準の評価
            success = self.evaluate_success_criteria(
                experiment_metrics, 
                experiment.success_criteria
            )
            
            # 結果の記録
            self.record_experiment_result(experiment, success, experiment_metrics)
            
        finally:
            # 障害の除去
            self.remove_failure(experiment)
            
            # 実験終了ログ
            self.monitoring.log_event({
                "event_type": "chaos_experiment_end",
                "experiment_name": experiment.name,
                "success": success
            })
    
    def inject_failure(self, experiment: ChaosExperiment):
        """障害を注入"""
        if experiment.failure_type == "pod_kill":
            self.kill_random_pods(experiment.target_service)
        elif experiment.failure_type == "network_latency":
            self.inject_network_latency(experiment.target_service)
        elif experiment.failure_type == "memory_stress":
            self.inject_memory_stress(experiment.target_service)
    
    def kill_random_pods(self, service_name: str):
        """ランダムにポッドを削除"""
        pods = self.k8s_client.list_namespaced_pod(
            namespace="default",
            label_selector=f"app={service_name}"
        )
        
        if pods.items:
            target_pod = random.choice(pods.items)
            self.k8s_client.delete_namespaced_pod(
                name=target_pod.metadata.name,
                namespace="default"
            )
    
    def monitor_during_experiment(self, service_name: str, duration: int) -> Dict:
        """実験期間中のメトリクス収集"""
        metrics = {
            "error_rate": [],
            "response_time": [],
            "throughput": []
        }
        
        start_time = time.time()
        while time.time() - start_time < duration:
            current_metrics = self.monitoring.get_service_metrics(service_name)
            
            metrics["error_rate"].append(current_metrics.get("error_rate", 0))
            metrics["response_time"].append(current_metrics.get("response_time", 0))
            metrics["throughput"].append(current_metrics.get("throughput", 0))
            
            time.sleep(10)  # 10秒間隔で収集
        
        return metrics
    
    def evaluate_success_criteria(self, metrics: Dict, criteria: Dict) -> bool:
        """成功基準の評価"""
        avg_error_rate = sum(metrics["error_rate"]) / len(metrics["error_rate"])
        avg_response_time = sum(metrics["response_time"]) / len(metrics["response_time"])
        
        # 基準を満たしているかチェック
        if avg_error_rate > criteria.get("max_error_rate", 0.05):
            return False
        if avg_response_time > criteria.get("max_response_time", 1.0):
            return False
            
        return True

# 使用例
chaos_monkey = ChaosMonkey(monitoring_client)

experiment = ChaosExperiment(
    name="user-service-resilience-test",
    target_service="user-service",
    failure_type="pod_kill",
    duration_seconds=300,
    success_criteria={
        "max_error_rate": 0.05,  # 5%以下
        "max_response_time": 2.0  # 2秒以下
    }
)

chaos_monkey.execute_experiment(experiment)

import numpy as np
from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import StandardScaler
from typing import List, Dict, Tuple

class AnomalyDetector:
    def __init__(self, contamination=0.1):
        self.model = IsolationForest(contamination=contamination, random_state=42)
        self.scaler = StandardScaler()
        self.feature_names = []
        
    def train(self, training_data: List[Dict]):
        """正常時のデータでモデルを学習"""
        features = self.extract_features(training_data)
        scaled_features = self.scaler.fit_transform(features)
        self.model.fit(scaled_features)
        
    def detect_anomalies(self, current_data: List[Dict]) -> List[Tuple[int, float]]:
        """異常を検出"""
        features = self.extract_features(current_data)
        scaled_features = self.scaler.transform(features)
        
        # 異常度スコアを計算
        anomaly_scores = self.model.decision_function(scaled_features)
        predictions = self.model.predict(scaled_features)
        
        anomalies = []
        for i, (score, prediction) in enumerate(zip(anomaly_scores, predictions)):
            if prediction == -1:  # 異常と判定
                anomalies.append((i, score))
                
        return anomalies
    
    def extract_features(self, data: List[Dict]) -> np.ndarray:
        """メトリクスからフィーチャを抽出"""
        if not self.feature_names:
            # 初回実行時にフィーチャ名を設定
            self.feature_names = [
                'cpu_usage', 'memory_usage', 'disk_usage',
                'network_in', 'network_out', 'request_count',
                'error_rate', 'response_time'
            ]
        
        features = []
        for record in data:
            feature_vector = [
                record.get(name, 0) for name in self.feature_names
            ]
            features.append(feature_vector)
            
        return np.array(features)

# 使用例
detector = AnomalyDetector()

# 正常時のデータでトレーニング
normal_data = [
    {"cpu_usage": 45, "memory_usage": 60, "response_time": 200},
    {"cpu_usage": 50, "memory_usage": 65, "response_time": 180},
    # ... 正常時のデータ
]

detector.train(normal_data)

# 現在のデータで異常検出
current_data = [
    {"cpu_usage": 95, "memory_usage": 90, "response_time": 2000},  # 異常
    {"cpu_usage": 48, "memory_usage": 62, "response_time": 190},   # 正常
]

anomalies = detector.detect_anomalies(current_data)
for index, score in anomalies:
    print(f"異常を検出: データ#{index}, 異常度スコア: {score:.3f}")