from opentelemetry import trace
from opentelemetry.semconv.ai import GenAiAttributes

tracer = trace.get_tracer("agent-runtime")

with tracer.start_as_current_span("llm.invoke") as span:
    span.set_attribute("gen_ai.request.model", "gpt-5.6")
    span.set_attribute("gen_ai.request.max_tokens", 4096)
    span.set_attribute("gen_ai.response.token_count", 847)
    span.set_attribute("gen_ai.response.completion_tokens", 612)
    span.set_attribute("gen_ai.tool.name", "sales_api")
    span.set_attribute("gen_ai.tool.type", "function")
    span.set_attribute("gen_ai.agent.id", "assistant-v3")
    span.set_attribute("gen_ai.agent.turn", 2)

from opentelemetry import trace
from opentelemetry.propagate import inject
import json, time

tracer = trace.get_tracer("agent-runtime")
tracer_provider = trace.get_tracer_provider()

def handle_user_request(user_input: str, session_id: str):
    """Agent 入口：处理用户请求"""
    with tracer.start_as_current_span(
        "agent.run",
        attributes={
            "session.id": session_id,
            "agent.name": "customer-support-agent",
            "agent.version": "3.2.0"
        }
    ) as root_span:
        # 第一步：LLM 分析用户意图
        tools_to_call = llm_analyze_intent(user_input)
        
        for tool_name, params in tools_to_call:
            # 每个工具调用是一个子 Span
            with tracer.start_as_current_span(
                f"tool.invoke.{tool_name}",
                attributes={
                    "gen_ai.tool.name": tool_name,
                    "gen_ai.tool.type": "function",
                    "tool.params": json.dumps(params)
                }
            ) as tool_span:
                if tool_name == "crm_top_customers":
                    result = crm_top_customers(params)
                    tool_span.set_attribute("tool.result.count", len(result))
                    # 工具的 HTTP 调用作为孙 Span
                    with tracer.start_as_current_span("http.request") as http_span:
                        http_span.set_attribute("http.method", "GET")
                        http_span.set_attribute("http.url", "https://crm.internal/api/top-customers")
                        http_span.set_attribute("http.status_code", 200)
                elif tool_name == "order_status":
                    result = order_status(params)
                    tool_span.set_attribute("tool.result.orders", len(result))
                elif tool_name == "contract_search":
                    with tracer.start_as_current_span("vector_search.query") as query_span:
                        query_span.set_attribute("retriever.top_k", 3)
                        query_span.set_attribute("retriever.score_threshold", 0.7)
                        result = vector_search(params)
        
        # 最终 LLM 生成回答
        with tracer.start_as_current_span("llm.final_response") as final_span:
            response = llm_generate(tools_to_call, result)
            final_span.set_attribute("gen_ai.response.token_count", response.token_count)
            final_span.set_attribute("gen_ai.response.finish_reason", response.finish_reason)
        
        root_span.set_attribute("agent.total_tools", len(tools_to_call))
        root_span.set_attribute("agent.total_latency_ms", int(time.time() * 1000 - start_ms))
        
        return response

from langfuse import Langfuse
from langfuse.decorators import observe, langfuse_context

langfuse = Langfuse(
    public_key="pk-...",
    secret_key="sk-...",
    host="https://cloud.langfuse.com"
)

@observe()
def agent_process(user_input: str):
    # LangFuse 自动捕获 LLM 调用、token、延迟
    langfuse_context.update_current_observation(
        input=user_input,
        session_id="sess_abc123",
        metadata={"agent_version": "3.2.0"}
    )
    
    # LLM 调用
    response = openai.chat.completions.create(
        model="gpt-5.6",
        messages=[...]
    )
    
    # 手动标记 token
    langfuse_context.score_current_observation(
        name="response_quality",
        value=4,  # 人工评分或自动评分
        comment="正确回答了客户问题"
    )
    
    return response

# 查询 token 消耗
traces = langfuse.fetch_traces(
    session_id="sess_abc123"
)
for t in traces:
    print(f"Total tokens: {t.total_tokens}")
    print(f"Cost: ${t.total_cost:.4f}")

from langsmith import Client, traceable

client = Client()

@traceable(run_type="chain")
def agent_chain(user_input: str):
    # LangSmith 的 trace 自动记录每一步
    intent = analyze_intent(user_input)
    result = execute_tools(intent)
    return result

# 运行评估
results = client.evaluate(
    dataset_id="customer-support-dataset",
    targets=[agent_chain],
    evaluators=[response_correctness, hallucination_check]
)

import statistics
from collections import deque

class AgentBaseline:
    def __init__(self, window_size: int = 1000):
        self.window_size = window_size
        self.tool_count = deque(maxlen=window_size)
        self.latency_p50 = deque(maxlen=window_size)
        self.error_rate = deque(maxlen=window_size)
        self.chain_depth = deque(maxlen=window_size)
    
    def record(self, trace_data: dict):
        self.tool_count.append(trace_data["tool_count"])
        self.latency_p50.append(trace_data["latency_ms"])
        self.error_rate.append(trace_data["has_error"])
        self.chain_depth.append(trace_data.get("chain_depth", 1))
    
    def get_baseline(self) -> dict:
        return {
            "tool_count_avg": statistics.mean(self.tool_count),
            "tool_count_std": statistics.stdev(self.tool_count),
            "latency_p50": statistics.median(self.latency_p50),
            "error_rate": sum(self.error_rate) / len(self.error_rate),
            "chain_depth_p95": sorted(self.chain_depth)[
                int(len(self.chain_depth) * 0.95)
            ]
        }
    
    def is_anomalous(self, trace: dict) -> bool:
        bl = self.get_baseline()
        if trace["tool_count"] > bl["tool_count_avg"] + 3 * bl["tool_count_std"]:
            return True  # 工具调用数远超正常
        if trace["error_rate"] > bl["error_rate"] * 3 and bl["error_rate"] > 0.01:
            return True  # 错误率突增 3 倍
        return False

import numpy as np
from scipy import stats

class SPCAnomalyDetector:
    def __init__(self, window_hours: int = 24):
        self.window = window_hours
        self.hourly_metrics = {}  # {hour: [tool_call_counts]}
    
    def update(self, hour: str, tool_calls: int, latency: float):
        if hour not in self.hourly_metrics:
            self.hourly_metrics[hour] = []
        self.hourly_metrics[hour].append({
            "tool_calls": tool_calls,
            "latency": latency
        })
    
    def detect(self, current_hour: str) -> list:
        """返回当前小时的所有异常信号"""
        alerts = []
        recent_hours = list(self.hourly_metrics.keys())[-24:]  # 最近 24h
        
        all_tool_calls = []
        all_latency = []
        for h in recent_hours:
            for m in self.hourly_metrics[h]:
                all_tool_calls.append(m["tool_calls"])
                all_latency.append(m["latency"])
        
        if len(all_tool_calls) < 50:
            return []  # 数据不足
        
        # Z-score 异常检测
        current_data = self.hourly_metrics.get(current_hour, [])
        for m in current_data:
            z_tool = (m["tool_calls"] - np.mean(all_tool_calls)) / np.std(all_tool_calls)
            z_latency = (m["latency"] - np.mean(all_latency)) / np.std(all_latency)
            
            if abs(z_tool) > 3:
                alerts.append(f"工具调用数异常（z={z_tool:.1f}）: {m['tool_calls']}")
            if abs(z_latency) > 3:
                alerts.append(f"延迟异常（z={z_latency:.1f}）: {m['latency']}ms")
        
        return alerts

-- 找出今天所有「绕圈子」的 Agent 请求
SELECT session_id, tool_count, 
       arrayStringConcat(tool_names, ' -> ') as tool_chain
FROM agent_traces
WHERE toDate(timestamp) = today()
  AND tool_count > 8
  AND tool_names[tool_count] = tool_names[1]  -- 最后调用的工具和第一个相同
ORDER BY tool_count DESC
LIMIT 20;