📊 指标体系

class PerformanceAnalyzer:
    def analyze(self, traces):
        """分析推理性能"""
        latencies = [t.duration for t in traces]
        
        analysis = {
            "p50_latency": np.percentile(latencies, 50),
            "p90_latency": np.percentile(latencies, 90),
            "p99_latency": np.percentile(latencies, 99),
            "throughput": len(traces) / sum(latencies),
            "error_rate": sum(1 for t in traces if t.status != 200) / len(traces),
            "cache_hit_rate": self.calculate_cache_hit(traces),
        }
        
        # 瓶颈分析
        bottlenecks = self.identify_bottlenecks(traces)
        analysis["bottlenecks"] = bottlenecks
        
        return analysis
    
    def identify_bottlenecks(self, traces):
        """识别性能瓶颈"""
        bottlenecks = []
        
        # 分析各阶段耗时
        prep_times = [t.prep_time for t in traces]
        inference_times = [t.inference_time for t in traces]
        postproc_times = [t.postproc_time for t in traces]
        
        avg_prep = np.mean(prep_times)
        avg_infer = np.mean(inference_times)
        avg_post = np.mean(postproc_times)
        
        if avg_prep > avg_infer * 0.3:
            bottlenecks.append("预处理瓶颈")
        if avg_post > avg_infer * 0.2:
            bottlenecks.append("后处理瓶颈")
        
        return bottlenecks

class QualityMonitor:
    def __init__(self, baseline_model):
        self.baseline = baseline_model
    
    def monitor(self, new_model, sample_requests):
        """监控模型质量"""
        results = []
        
        for req in sample_requests:
            baseline_resp = self.baseline.generate(req)
            new_resp = new_model.generate(req)
            
            comparison = self.compare_responses(
                baseline_resp, new_resp, req
            )
            results.append(comparison)
        
        quality_report = self.summarize(results)
        return quality_report
    
    def compare_responses(self, baseline, new_response, request):
        """对比模型输出"""
        return {
            "request": request,
            "similarity": self.cosine_similarity(baseline, new_response),
            "length_ratio": len(new_response) / len(baseline),
            "safety_score": self.safety_check(new_response),
            "factual_score": self.fact_check(new_response),
        }

class CostOptimizer:
    def optimize(self, usage_data):
        """优化推理成本"""
        
        strategies = []
        
        # 1. 缓存命中率低 → 增加缓存
        if usage_data.cache_hit_rate < 0.3:
            strategies.append("Increase cache size")
        
        # 2. 批量大小过小 → 增加批量
        if usage_data.avg_batch_size < 16:
            strategies.append("Increase batch size")
        
        # 3. 小模型性能不足 → 切换大模型
        if usage_data.small_model_quality < threshold:
            strategies.append("Upgrade model size")
        
        # 4. 空闲 GPU → 使用 spot instance
        if usage_data.idle_gpu_hours > 100:
            strategies.append("Use spot instances")
        
        return strategies

from opentelemetry import trace
from opentelemetry.metrics import get_meter

tracer = trace.get_tracer("ai-service")
meter = get_meter("ai-service")

# 定义指标
request_counter = meter.create_counter(
    "ai.request.total",
    description="Total AI requests"
)
latency_histogram = meter.create_histogram(
    "ai.request.latency",
    description="Request latency in ms"
)

@tracer.start_as_current_span("generate")
def generate_request(prompt):
    with tracer.start_as_current_span("model_inference") as span:
        response = model.generate(prompt)
        span.set_attribute("model.version", "1.0")
        span.set_attribute("tokens.count", len(response))
        return response