第4周：生产化、部署、面试准备 - 完整概览#

// internal/observability/tracer.go
import (
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/exporters/jaeger"
	"go.opentelemetry.io/otel/sdk/trace"
)

func InitTracer() (*trace.TracerProvider, error) {
	exporter, err := jaeger.New(
		jaeger.WithAgentHost("localhost"),
		jaeger.WithAgentPort("6831"),
	)
	if err != nil {
		return nil, err
	}
	
	tp := trace.NewTracerProvider(
		trace.WithBatcher(exporter),
	)
	otel.SetTracerProvider(tp)
	
	return tp, nil
}

// 在handler中使用
func (h *Handler) ChatHandler(w http.ResponseWriter, r *http.Request) {
	ctx, span := tracer.Start(r.Context(), "chat_handler")
	defer span.End()
	
	span.SetAttributes(
		attribute.String("request_id", requestID),
		attribute.String("user_id", userID),
	)
	
	// Retrieval span
	retrievalCtx, retrievalSpan := tracer.Start(ctx, "retrieval")
	chunks, _ := ragEngine.Search(retrievalCtx, query)
	retrievalSpan.SetAttributes(
		attribute.Int("chunk_count", len(chunks)),
	)
	retrievalSpan.End()
	
	// LLM span
	llmCtx, llmSpan := tracer.Start(ctx, "llm_generation")
	answer, _ := llmClient.Generate(llmCtx, request)
	llmSpan.SetAttributes(
		attribute.Int("input_tokens", tokens.Input),
		attribute.Int("output_tokens", tokens.Output),
	)
	llmSpan.End()
}

// internal/observability/metrics.go
import (
	"go.opentelemetry.io/otel/metric"
	"go.opentelemetry.io/otel/exporters/prometheus"
)

type Metrics struct {
	requestCount     metric.Int64Counter
	requestLatency   metric.Float64Histogram
	llmLatency       metric.Float64Histogram
	toolFailureRate  metric.Float64Gauge
	retrievalHitRate metric.Float64Gauge
	citationRate     metric.Float64Gauge
	approvalRate     metric.Float64Gauge
	evalPassRate     metric.Float64Gauge
}

func (m *Metrics) RecordRequest(duration time.Duration) {
	m.requestCount.Add(context.Background(), 1)
	m.requestLatency.Record(context.Background(), duration.Milliseconds())
}

func (m *Metrics) RecordLLMLatency(duration time.Duration) {
	m.llmLatency.Record(context.Background(), duration.Milliseconds())
}

// Prometheus导出
exporter, _ := prometheus.New()
provider := metric.NewMeterProvider(metric.WithReader(exporter))

// cmd/eval/main.go
package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"time"
)

type EvalSuite struct {
	Cases []EvalCase `json:"cases"`
}

type EvalCase struct {
	ID         string   `json:"id"`
	Input      string   `json:"input"`
	Expected   string   `json:"expected"`
	Sources    []string `json:"expected_sources"`
	MustCite   bool     `json:"must_cite"`
}

type EvalReport struct {
	Timestamp       time.Time
	TotalCases      int
	PassedCases     int
	FailedCases     int
	PassRate        float32
	AverageLatency  time.Duration
	DetailedResults []CaseResult
}

func main() {
	datasetPath := flag.String("dataset", "evals/dataset.jsonl", "Path to eval dataset")
	outputPath := flag.String("output", "eval-report.md", "Output report path")
	flag.Parse()
	
	// 1. 加载eval dataset
	cases := loadDataset(*datasetPath)
	
	// 2. 运行eval
	results := runEval(cases)
	
	// 3. 生成报告
	report := generateReport(results)
	
	// 4. 输出为Markdown（易于CI展示）
	writeMarkdownReport(*outputPath, report)
	
	// 5. 根据通过率决定CI pass/fail
	if report.PassRate < 0.80 {
		fmt.Printf("FAILED: Pass rate %.2f%% is below threshold 80%%\n", report.PassRate*100)
		os.Exit(1)
	}
	
	fmt.Printf("PASSED: Pass rate %.2f%%\n", report.PassRate*100)
	os.Exit(0)
}

func generateReport(results []CaseResult) *EvalReport {
	passed := 0
	for _, r := range results {
		if r.Passed {
			passed++
		}
	}
	
	return &EvalReport{
		Timestamp:      time.Now(),
		TotalCases:     len(results),
		PassedCases:    passed,
		FailedCases:    len(results) - passed,
		PassRate:       float32(passed) / float32(len(results)),
		DetailedResults: results,
	}
}

func writeMarkdownReport(path string, report *EvalReport) {
	md := fmt.Sprintf(`# Eval Report

Generated: %s

## Summary
- **Total Cases**: %d
- **Passed**: %d
- **Failed**: %d
- **Pass Rate**: %.2f%%
- **Average Latency**: %v

## Detailed Results

| Case ID | Input | Status | Latency |
|---------|-------|--------|---------|
`,
		report.Timestamp.Format(time.RFC3339),
		report.TotalCases,
		report.PassedCases,
		report.FailedCases,
		report.PassRate*100,
		report.AverageLatency,
	)
	
	for _, r := range report.DetailedResults {
		status := "✅ PASS"
		if !r.Passed {
			status = "❌ FAIL"
		}
		md += fmt.Sprintf("| %s | %s | %s | %v |\n",
			r.CaseID, r.Input[:30]+"...", status, r.Latency)
	}
	
	os.WriteFile(path, []byte(md), 0644)
}

// internal/cost/cost_tracker.go
type CostTracker struct {
	embeddingCostPer1KTokens float64  // $0.00002
	llmCostPerToken          float64  // varies by model
	totalCost                float64
	tokenUsage               int
}

func (ct *CostTracker) TrackEmbedding(tokenCount int) {
	cost := float64(tokenCount) / 1000.0 * ct.embeddingCostPer1KTokens
	ct.totalCost += cost
	ct.tokenUsage += tokenCount
}

func (ct *CostTracker) TrackLLM(inputTokens, outputTokens int) {
	// GPT-4-turbo: $0.01 per 1K input, $0.03 per 1K output
	inputCost := float64(inputTokens) / 1000.0 * 0.01
	outputCost := float64(outputTokens) / 1000.0 * 0.03
	ct.totalCost += inputCost + outputCost
	ct.tokenUsage += inputTokens + outputTokens
}

// internal/cache/cache_strategies.go
type CacheStrategy string

const (
	CacheEmbedding    CacheStrategy = "embedding"    // 缓存embedding结果
	CacheRetrieval    CacheStrategy = "retrieval"    // 缓存RAG检索结果
	CacheLLMSafeAnswer CacheStrategy = "llm_safe"     // 缓存确定的答案
)

type CacheManager struct {
	redis *redis.Client
	ttl   map[CacheStrategy]time.Duration
}

// 1. Embedding缓存
func (cm *CacheManager) GetOrComputeEmbedding(ctx context.Context, text string) ([]float32, error) {
	cacheKey := fmt.Sprintf("embedding:%s", hashText(text))
	
	// 先查缓存
	if cached, err := cm.redis.Get(ctx, cacheKey).Result(); err == nil {
		var embedding []float32
		json.Unmarshal([]byte(cached), &embedding)
		return embedding, nil
	}
	
	// 调OpenAI
	embedding, _ := embeddingClient.Embed(ctx, text)
	
	// 缓存1周
	cm.redis.Set(ctx, cacheKey, marshalJSON(embedding), 7*24*time.Hour)
	
	return embedding, nil
}

// 2. Retrieval缓存 - 相同query返回缓存结果
func (cm *CacheManager) GetOrSearch(ctx context.Context, query string, topK int) ([]Chunk, error) {
	cacheKey := fmt.Sprintf("retrieval:%s:%d", query, topK)
	
	if cached, err := cm.redis.Get(ctx, cacheKey).Result(); err == nil {
		var chunks []Chunk
		json.Unmarshal([]byte(cached), &chunks)
		return chunks, nil
	}
	
	chunks, _ := retriever.Search(ctx, query, topK)
	
	// 缓存1小时
	cm.redis.Set(ctx, cacheKey, marshalJSON(chunks), 1*time.Hour)
	
	return chunks, nil
}

// 3. Safe Answer缓存 - 对于high-confidence答案
type SafeAnswer struct {
	Query      string
	Answer     string
	Confidence string
	CreatedAt  time.Time
}

func (cm *CacheManager) TryGetSafeAnswer(ctx context.Context, query string) (*SafeAnswer, error) {
	cacheKey := fmt.Sprintf("answer:%s", query)
	
	if cached, err := cm.redis.Get(ctx, cacheKey).Result(); err == nil {
		var ans SafeAnswer
		json.Unmarshal([]byte(cached), &ans)
		
		// 只返回最近一天的答案
		if time.Since(ans.CreatedAt) < 24*time.Hour {
			return &ans, nil
		}
	}
	
	return nil, nil
}

// 成本-质量权衡
type ModelStrategy struct {
	RouterModel     string  // 分类用，小且快
	RetrievalModel  string  // Rerank用，小且快
	GenerationModel string  // 答案生成，大且准
}

// 设想：用GPT-4 turbo只给 high-risk 问题
// 用GPT-4O mini给routine问题
func (h *Handler) ChatHandler(w http.ResponseWriter, r *http.Request) {
	userInput := getInput(r)
	
	// 1. 先用小模型分类
	classification, _ := smallLLMClient.Classify(context.Background(), userInput)
	
	if classification.IsHighRisk {
		// 用大模型
		answer, _ := largeLLMClient.Generate(context.Background(), request)
	} else {
		// 用小模型，省钱
		answer, _ := smallLLMClient.Generate(context.Background(), request)
	}
}

// docs/failure-modes.md structure

## 线上常见故障模式

### 1. LLM Timeout
**Symptom**: 请求返回504，用户看到"Service Unavailable"
**Root Cause**: OpenAI API超时（可能网络慢、queue长）
**Detection**: 
  - Metrics: LLM latency > threshold
  - Alert: p99 latency > 30s
**Mitigation**:
  - Day 6: Retry with exponential backoff
  - Day 25: Fallback to smaller model
  - Day 22: circuit breaker pattern
  
Code:
```go
if isOpenAITimeout(err) {
    // 降级到本地模型或小模型
    answer, _ = fallbackLLMClient.Generate(ctx, request)
}