MonkeyCode 性能基准测试与优化实战：从毫秒级响应到十万级并发的调优之路

MonkeyCode 性能基准测试与优化实战：从毫秒级响应到十万级并发的调优之路

引言

"性能不是奢侈品，而是用户的基本权利。"

当 AI 编程助手从个人玩具走向企业基础设施时，性能就不再是一个"nice-to-have"的特性——它直接决定了开发者的日常体验和企业的采用意愿。一个 500ms 的延迟差异，在一天数千次的使用中累积起来，就是数小时的等待时间。

MonkeyCode 作为完全开源的 AI 编程助手（Apache License 2.0），其性能优化是一个持续演进的过程。本文将深入剖析 MonkeyCode 的全链路性能架构，分享从单请求毫秒级优化到十万级并发的完整实战经验。

🎯 核心信息

• GitHub 仓库: https://github.com/monkeycode-ai/monkeycode
• 开源协议: Apache License 2.0
• 性能基准报告: benchmarks.monkeycode.ai
• 性能讨论: Discord #performance 频道
• 欢迎贡献性能优化 PR！

---

一、性能指标体系

1.1 核心性能指标

┌─────────────────────────────────────────────────────────────┐
│         MonkeyCode 性能指标全景图                             │
│                                                             │
│  ══════════════════════════════════════════════════════    │
│                                                             │
│  ⏱️ 延迟指标 (Latency)                                     │
│  ├── P50 首次补全时间:   < 100ms (目标)                    │
│  ├── P95 首次补全时间:   < 300ms (目标)                    │
│  ├── P99 首次补全时间:   < 800ms (目标)                    │
│  ├── TTFT (Time To First Token): < 200ms                   │
│  └── TPS (Tokens Per Second): > 50 tok/s                  │
│                                                             │
│  📊 吞吐量指标 (Throughput)                                 │
│  ├── 单实例 QPS:          > 500 req/s                     │
│  ├── 并发连接数:          > 10,000                        │
│  ├── 每日活跃用户支持:     > 50,000                         │
│  └── 峰值处理能力:        > 5x 平均负载                    │
│                                                             │
│  💾 资源效率指标 (Resource Efficiency)                      │
│  ├── 内存占用 (空闲):     < 256 MB                         │
│  ├── 内存占用 (活跃):     < 1 GB / 1000 用户              │
│  ├── CPU 使用率 (平均):   < 30%                            │
│  └── GPU 利用率:          > 70% (当使用本地模型时)         │
│                                                             │
│  🎯 可靠性指标 (Reliability)                                │
│  ├── 服务可用性:           > 99.9%                         │
│  ├── 错误率:               < 0.1%                          │
│  ├── 冷启动时间:           < 3s (Serverless)               │
│  └── 故障恢复时间 (MTTR):  < 30s                           │
│                                                             │
╚═══════════════════════════════════════════════════════════╝

1.2 性能分级标准

等级	P50 补全延迟	P95 补全延迟	适用场景
🟢 优秀	< 80ms	< 200ms	实时协作、高频使用
🟡 良好	< 150ms	< 400ms	日常开发工作流
🟠 可接受	< 300ms	< 800ms	低频使用场景
🔴 需优化	> 300ms	> 800ms	影响用户体验

---

二、全链路性能剖析

2.1 请求处理流水线

flowchart LR A[用户输入] --> B[编辑器捕获] B --> C[上下文提取] C --> D[预处理] D --> E[AI 推理] E --> F[后处理] F --> G[渲染展示] style A fill:#e3f2fd style G fill:#c8e6c9 subgraph "客户端 (~50ms)" B C end subgraph "服务端" D E F end subgraph "渲染层" G end

2.2 各阶段耗时分解

阶段	典型耗时	优化空间	主要瓶颈
编辑器捕获	5-15ms	✅ 已优化	事件监听开销
上下文提取	10-50ms	🔶 中等	大文件 AST 解析
预处理/脱敏	5-20ms	✅ 已优化	正则匹配复杂度
网络传输	10-50ms	🔶 取决于网络	RTT + TLS 握手
AI 推理排队	0-500ms	🔴 高优先级	并发队列管理
AI 模型推理	50-2000ms	🔴 核心瓶颈	模型大小/GPU
后处理	5-20ms	✅ 已优化	结果解析
渲染展示	5-15ms	✅ 已优化	DOM 操作

---

三、前端性能优化

3.1 编辑器集成层优化

// ===== packages/editor/src/performance/editor-perf.ts =====
/**
 * MonkeyCode 编辑器性能优化策略
 * 
 * 目标: 将首次补全的端到端延迟控制在 100ms 以内
 */

// ============================================
// 优化 1: 防抖 + 智能触发
// ============================================

class SmartCompletionTrigger {
  private lastInputTime = 0;
  private pendingTimer: ReturnType<typeof setTimeout> | null = null;
  private readonly DEBOUNCE_MS = 150; // 基础防抖
  private readonly FAST_DEBOUNCE_MS = 50; // 快速输入时的防抖
  
  // 追踪输入模式以动态调整防抖时间
  private inputHistory: number[] = [];
  
  onInputChange(editor: Editor, callback: () => void): void {
    const now = Date.now();
    
    // 记录输入间隔
    this.inputHistory.push(now - this.lastInputTime);
    if (this.inputHistory.length > 10) {
      this.inputHistory.shift();
    }
    
    this.lastInputTime = now;
    
    // 清除之前的定时器
    if (this.pendingTimer) {
      clearTimeout(this.pendingTimer);
    }
    
    // 动态调整防抖时间
    const avgInterval = this.getAverageInputInterval();
    let debounceMs = this.DEBOUNCE_MS;
    
    // 如果用户正在快速连续输入，缩短防抖时间
    if (avgInterval < 100) {
      debounceMs = this.FAST_DEBOUNCE_MS;
    }
    
    // 如果用户刚停止输入（间隔 > 500ms），立即触发
    if (avgInterval > 500 && this.inputHistory.length >= 2) {
      debounceMs = 10; // 几乎立即触发
    }
    
    this.pendingTimer = setTimeout(() => {
      callback();
      this.pendingTimer = null;
    }, debounceMs);
  }
  
  private getAverageInputInterval(): number {
    if (this.inputHistory.length === 0) return 1000;
    const sum = this.inputHistory.reduce((a, b) => a + b, 0);
    return sum / this.inputHistory.length;
  }
}

// ============================================
// 优化 2: 增量上下文提取
// ============================================

/**
 * 只提取变化的部分上下文，而非每次重新扫描整个文件
 */
class IncrementalContextExtractor {
  private lastFileHash: string = '';
  private cachedAST: ASTNode | null = null;
  private changedRanges: Range[] = [];
  
  extract(
    document: TextDocument,
    cursorPosition: Position,
  ): CompletionContext {
    const currentHash = this.hashDocument(document);
    
    // 如果文件没有变化且缓存有效，使用缓存
    if (currentHash === this.lastFileHash && this.cachedAST) {
      return this.buildFromCache(cursorPosition);
    }
    
    // 计算变更范围
    if (this.lastFileHash !== '') {
      this.changedRanges = this.computeChangedRanges(
        this.cachedAST!,
        document.getText(),
      );
    }
 else {
      // 全量解析
      this.cachedAST = this.parseFullDocument(document);
    }
    
    this.lastFileHash = currentHash;
    
    return this.extractWithContext(
      document,
      cursorPosition,
      this.cachedAST,
    );
  }
  
  /**
   * 只提取光标周围的相关代码片段
   * 而非发送整个文件
   */
  private extractRelevantSnippet(
    document: TextDocument,
    position: Position,
    maxChars: number = 4000,
  ): string {
    const lines = document.getText().split('\n');
    const currentLine = position.line;
    
    // 向上/向下扩展直到达到字符限制或遇到明显的代码边界
    let startLine = currentLine;
    let endLine = currentLine;
    let totalChars = 0;
    
    // 先向上扩展
    while (startLine > 0 && totalChars < maxChars / 2) {
      const lineLen = lines[startLine - 1].length + 1; // +1 for newline
      if (totalChars + lineLen > maxChars / 2) break;
      
      // 遇到顶层边界停止
      if (this.isTopLevelBoundary(lines[startLine - 1])) break;
      
      totalChars += lineLen;
      startLine--;
    }
    
    // 再向下扩展
    while (endLine < lines.length - 1 && totalChars < maxChars) {
      const lineLen = lines[endLine + 1].length + 1;
      if (totalChars + lineLen > maxChars) break;
      
      if (this.isTopLevelBoundary(lines[endLine + 1]) && endLine > currentLine + 5) break;
      
      totalChars += lineLen;
      endLine++;
    }
    
    return lines.slice(startLine, endLine + 1).join('\n');
  }
  
  private isTopLevelBoundary(line: string): boolean {
    const trimmed = line.trim();
    return /^(function|class|interface|type|export|import|from)\s/.test(trimmed)
      || trimmed === '}'
      || trimmed === '';
  }
  
  private hashDocument(doc: TextDocument): string {
    // 简单的快速哈希：只哈希前 10000 字符 + 总长度
    const text = doc.getText();
    const prefix = text.slice(0, 10000);
    let hash = 0;
    for (let i = 0; i < prefix.length; i++) {
      hash = ((hash << 5) - hash + prefix.charCodeAt(i)) | 0;
    }
    return `${hash}_${text.length}`;
  }
}

// ============================================
// 优化 3: 预取与预计算
// ============================================

/**
 * 在用户可能需要之前提前准备数据
 */
class PrefetchManager {
  private prefetchCache = new Map<string, Promise<any>>();
  
  /**
   * 当用户暂停输入时预取可能的补全项
   */
  async prefetchCompletions(
    context: EditorContext,
  ): Promise<CompletionItem[]> {
    const cacheKey = this.buildCacheKey(context);
    
    if (this.prefetchCache.has(cacheKey)) {
      return this.prefetchCache.get(cacheKey)!;
    }
    
    const promise = this.doPrefetch(context);
    this.prefetchCache.set(cacheKey, promise);
    
    // 缓存 5 秒后自动清除
    setTimeout(() => {
      this.prefetchCache.delete(cacheKey);
    }, 5000);
    
    return promise;
  }
  
  private buildCacheKey(ctx: EditorContext): string {
    return `${ctx.language}:${ctx.fileName}:${Math.floor(ctx.position.line / 10)}:${ctx.prefix.slice(-20)}`;
  }
}

// ============================================
// 优化 4: 虚拟化长列表渲染
// ============================================

/**
 * 补全列表虚拟滚动 — 只渲染可见区域的项目
 */
export class VirtualizedCompletionList {
  private visibleItems: CompletionItem[] = [];
  private scrollTop = 0;
  private itemHeight = 32; // 每个补全项的高度
  private viewportHeight = 300; // 列表可视区高度
  
  render(items: CompletionItem[], container: HTMLElement): void {
    const startIndex = Math.floor(this.scrollTop / this.itemHeight);
    const endIndex = Math.min(
      startIndex + Math.ceil(this.viewportHeight / this.itemHeight) + 2,
      items.length,
    );
    
    // 计算偏移量实现虚拟滚动效果
    const offsetY = startIndex * this.itemHeight;
    
    // 只渲染可见项目
    container.style.transform = `translateY(${offsetY}px)`;
    container.innerHTML = items
      .slice(startIndex, endIndex)
      .map(item => this.renderItem(item))
      .join('');
  }
}

3.2 内存管理优化

// ===== packages/shared/src/utils/memory-pool.ts =====
/**
 * 对象池模式 — 复用频繁创建销毁的对象
 * 
 * 减少垃圾回收 (GC) 压力，保持内存稳定
 */

export class ObjectPool<T> {
  private pool: T[] = [];
  private readonly factory: () => T;
  private readonly reset: (obj: T) => void;
  private readonly maxSize: number;
  
  constructor(
    factory: () => T,
    reset: (obj: T) => void,
    maxSize: number = 100,
  ) {
    this.factory = factory;
    this.reset = reset;
    this.maxSize = maxSize;
  }
  
  acquire(): T {
    if (this.pool.length > 0) {
      return this.pool.pop()!;
    }
    return this.factory();
  }
  
  release(obj: T): void {
    if (this.pool.length < this.maxSize) {
      this.reset(obj);
      this.pool.push(obj);
    }
  }
  
  get size(): number {
    return this.pool.length;
  }
}

// 使用示例: CompletionItem 对象池
const completionItemPool = new ObjectPool<CompletionItem>(
  () => ({ label: '', insertText: '', kind: 0, score: 0 }),
  (item) => {
    item.label = '';
    item.insertText = '';
    item.kind = 0;
    item.score = 0;
    item.documentation = undefined;
    item.detail = undefined;
  },
  500, // 最多缓存 500 个对象
);

/**
 * LRU 缓存 — 自动淘汰最少使用的条目
 */
export class LRUCache<K, V> {
  private cache = new Map<K, V>();
  private readonly maxSize: number;
  
  constructor(maxSize: number = 1000) {
    this.maxSize = maxSize;
  }
  
  get(key: K): V | undefined {
    const value = this.cache.get(key);
    if (value !== undefined) {
      // LRU: 移到最后（最近访问）
      this.cache.delete(key);
      this.cache.set(key, value);
    }
    return value;
  }
  
  set(key: K, value: V): void {
    if (this.cache.has(key)) {
      this.cache.delete(key);
    } else if (this.cache.size >= this.maxSize) {
      // 淘汰最老的条目（Map 的第一个）
      const firstKey = this.cache.keys().next().value;
      if (firstKey !== undefined) {
        this.cache.delete(firstKey);
      }
    }
    this.cache.set(key, value);
  }
  
  clear(): void {
    this.cache.clear();
  }
  
  get size(): number {
    return this.cache.size;
  }
}

---

四、后端性能优化

4.1 AI 请求调度优化

// ===== packages/core/src/ai/scheduler.ts =====
/**
 * 智能 AI 请求调度器
 * 
 * 核心目标:
 * 1. 减少排队等待时间
 * 2. 批量合并相似请求
 * 3. 优先级队列管理
 * 4. 成本感知路由
 */

import { LRUCache } from '@monkeycode/shared/utils/memory-pool';

interface AIRequest {
  id: string;
  userId: string;
  context: string;
  priority: 'realtime' | 'normal' | 'background';
  createdAt: number;
  resolve: (result: AIResponse) => void;
  reject: (error: Error) => void;
}

export class AIScheduler {
  private queues: Map<string, AIRequest[]> = new Map([
    ['realtime', []],
    ['normal', []],
    ['background', []],
  ]);
  
  private resultCache = new LRUCache<string, AIResponse>(10000);
  private batchBuffer: AIRequest[] = [];
  private batchTimer: ReturnType<typeof setTimeout> | null = null;
  private readonly BATCH_WINDOW_MS = 50; // 50ms 批处理窗口
  private readonly MAX_CONCURRENT = 10; // 最大并发请求数
  private activeCount = 0;
  
  // === 优化 1: 语义去重 ===
  async schedule(request: Omit<AIRequest, 'resolve' | 'reject'>): Promise<AIResponse> {
    // 检查缓存命中
    const cacheKey = this.generateCacheKey(request.context);
    const cached = this.resultCache.get(cacheKey);
    if (cached) {
      this.metrics.record('cache_hit');
      return cached;
    }
    
    return new Promise((resolve, reject) => {
      const fullRequest: AIRequest = {
        ...request,
        resolve,
        reject,
        createdAt: Date.now(),
      };
      
      // 加入对应优先级的队列
      this.queues.get(request.priority)!.push(fullRequest);
      
      // 触发处理循环
      this.processQueue();
    });
  }
  
  // === 优化 2: 批量合并 ===
  private processQueue(): void {
    if (this.activeCount >= this.MAX_CONCURRENT) return;
    
    // 从最高优先级队列中取出请求
    const request = this.dequeueNext();
    if (!request) return;
    
    this.activeCount++;
    
    // 尝试批量处理
    this.batchBuffer.push(request);
    
    if (!this.batchTimer) {
      this.batchTimer = setTimeout(() => {
        this.flushBatch();
        this.batchTimer = null;
      }, this.BATCH_WINDOW_MS);
    }
  }
  
  private flushBatch(): void {
    if (this.batchBuffer.length === 0) return;
    
    const batch = [...this.batchBuffer];
    this.batchBuffer = [];
    
    // 并行执行批量中的请求
    Promise.all(batch.map(req => this.executeRequest(req)))
      .then(results => {
        results.forEach((result, i) => {
          const req = batch[i];
          
          // 缓存结果
          const cacheKey = this.generateCacheKey(req.context);
          this.resultCache.set(cacheKey, result);
          
          req.resolve(result);
        });
      })
      .catch(error => {
        batch.forEach(req => req.reject(error));
      })
      .finally(() => {
        this.activeCount -= batch.length;
        // 继续处理队列
        this.processQueue();
      });
  }
  
  private dequeueNext(): AIRequest | null {
    // realtime > normal > background
    for (const priority of ['realtime', 'normal', 'background'] as const) {
      const queue = this.queues.get(priority)!;
      if (queue.length > 0) {
        return queue.shift()!;
      }
    }
    return null;
  }
  
  /**
   * 生成语义级别的缓存键
   * 相似但不完全相同的上下文可以共享结果
   */
  private generateCacheKey(context: string): string {
    // 规范化: 去除空白、统一大小写、截断
    const normalized = context
      .replace(/\s+/g, ' ')
      .trim()
      .toLowerCase()
      .slice(0, 500); // 只用前 500 字符作为 key
    
    // 简单哈希
    let hash = 0;
    for (let i = 0; i < normalized.length; i++) {
      hash = ((hash << 5) - hash + normalized.charCodeAt(i)) | 0;
    }
    return `ai_${hash.toString(36)}_${normalized.length}`;
  }
}

4.2 连接池与资源复用

// ===== packages/core/src/infrastructure/connection-pool.ts =====
/**
 * HTTP 连接池管理
 * 
 * 复用 TCP 连接，减少 TLS 握手开销
 * 对于频繁调用云端 API 的场景尤其重要
 */

import { Agent } from 'undici';

export class ConnectionPoolManager {
  private static instance: ConnectionPoolManager;
  private pools: Map<string, Agent> = new Map();
  
  static getInstance(): ConnectionPoolManager {
    if (!ConnectionPoolManager.instance) {
      ConnectionPoolManager.instance = new ConnectionPoolManager();
    }
    return ConnectionPoolManager.instance;
  }
  
  getAgent(targetUrl: string): Agent {
    const hostname = new URL(targetUrl).hostname;
    
    if (this.pools.has(hostname)) {
      return this.pools.get(hostname)!;
    }
    
    const agent = new Agent({
      // 连接超时
      connectTimeout: 10000,
      // 连接 TTL — 保持活跃的时间
      keepAliveTimeout: 60000,
      // 每个主机的最大连接数
      connections: 50,
      // 每个主机的最大 socket 数
      sockets: 50,
      // 自动关闭空闲连接
      keepAliveMaxTimeout: 300000,
    });
    
    this.pools.set(hostname, agent);
    return agent;
  }
  
  /**
   * 获取连接池统计信息
   */
  getStats(): Record<string, unknown> {
    const stats: Record<string, unknown> = {};
    for (const [hostname, agent] of this.pools.entries()) {
      stats[hostname] = {
        // undici 不直接暴露这些，通过自定义 wrapper 收集
        totalRequests: 0,
        activeSockets: 0,
        idleSockets: 0,
      };
    }
    return stats;
  }
}

// ===== Redis 连接池 =====
// ===== packages/core/src/infrastructure/redis-pool.ts =====

import Redis from 'ioredis';

export class RedisConnectionPool {
  private pool: Redis[] = [];
  private available: Set<number> = new Set();
  private readonly maxSize: number;
  private readonly config: Redis.RedisOptions;
  
  constructor(config: Redis.RedisOptions, maxSize: number = 20) {
    this.config = config;
    this.maxSize = maxSize;
    
    // 预热: 创建初始连接
    for (let i = 0; i < Math.min(5, maxSize); i++) {
      this.createConnection(i);
    }
  }
  
  async acquire(): Promise<Redis> {
    // 如果有空闲连接，直接返回
    if (this.available.size > 0) {
      const index = this.available.values().next().value;
      this.available.delete(index);
      return this.pool[index];
    }
    
    // 如果还没达到上限，创建新连接
    if (this.pool.length < this.maxSize) {
      const index = this.pool.length;
      return this.createConnection(index);
    }
    
    // 等待有连接释放
    return new Promise((resolve) => {
      const check = setInterval(() => {
        if (this.available.size > 0) {
          clearInterval(check);
          const idx = this.available.values().next().value;
          this.available.delete(idx);
          resolve(this.pool[idx]);
        }
      }, 10);
    });
  }
  
  release(client: Redis): void {
    const index = this.pool.indexOf(client);
    if (index !== -1) {
      this.available.add(index);
    }
  }
  
  private createConnection(index: number): Redis {
    const client = new Redis({
      ...this.config,
      lazyConnect: false,
      retryStrategy: (times) => {
        if (times > 3) return null; // 重试 3 次后放弃
        return Math.min(times * 100, 3000);
      },
      enableReadyCheck: true,
    });
    
    this.pool[index] = client;
    this.available.add(index);
    
    return client;
  }
  
  async closeAll(): Promise<void> {
    await Promise.all(this.pool.map(c => c.quit()));
    this.pool = [];
    this.available.clear();
  }
}

---

五、数据库查询优化

5.1 SQL 优化实践

-- ===== 数据库性能优化 SQL =====

-- 1. 创建适当的索引
-- 补全历史记录表索引
CREATE INDEX CONCURRENTLY idx_completion_history_user_time 
ON completion_history(user_id, created_at DESC);

CREATE INDEX CONCURRENTLY idx_completion_hash_context 
ON completion_history USING hash(context_signature);

-- 会话表索引
CREATE INDEX CONCURRENTLY idx_sessions_user_active 
ON sessions(user_id) WHERE is_active = true;

-- 2. 分区表设计 — 按月分区日志表
CREATE TABLE audit_logs (
    id BIGSERIAL,
    user_id VARCHAR(64),
    event_type VARCHAR(50),
    event_data JSONB,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
) PARTITION BY RANGE (created_at);

-- 创建未来 12 个月的分区
DO $$
BEGIN
    FOR i IN 0..11 LOOP
        EXECUTE format('
            CREATE TABLE IF NOT EXISTS audit_logs_%s 
            PARTITION OF audit_logs 
            FOR VALUES FROM (%s) TO (%s)',
            to_char(NOW() + INTERVAL '1 month' * i, 'YYYY_MM'),
            to_char(date_trunc('month', NOW() + INTERVAL '1 month' * i), 'YYYY-MM-DD'),
            to_char(date_trunc('month', NOW() + INTERVAL '1 month' * (i+1)), 'YYYY-MM-DD')
        );
    END LOOP;
END $$;

-- 3. 查询优化示例
-- ❌ 慢查询: 全表扫描
SELECT * FROM completion_history 
WHERE user_id = 'user123' 
ORDER BY created_at DESC 
LIMIT 20;

-- ✅ 优化后: 使用覆盖索引
SELECT id, context_prefix, model_used, created_at
FROM completion_history 
WHERE user_id = 'user123' 
ORDER BY created_at DESC 
LIMIT 20;

-- 4. 物化视图 — 预聚合统计数据
CREATE MATERIALIZED VIEW mv_user_daily_stats AS
SELECT 
    user_id,
    DATE(created_at) as date,
    COUNT(*) as total_completions,
    AVG(EXTRACT(EPOCH FROM (response_time))) as avg_response_ms,
    COUNT(CASE WHEN status = 'accepted' THEN 1 END) as accepted_count
FROM completion_history
GROUP BY user_id, DATE(created_at);

-- 定期刷新物化视图 (每小时)
REFRESH MATERIALIZED VIEW CONCURRENTLY mv_user_daily_stats;

-- 5. 连接池配置建议 (PostgreSQL)
-- pg_pool 配置:
--   max_connections = 200
--   default_pool_size = 25 (每个数据库)
--   reserve_pool_size = 5 (高峰预留)

---

六、压测方案与工具

6.1 K6 压测脚本

// ===== benchmarks/k6-load-test.js =====
/**
 * MonkeyCode API 负载测试脚本
 * 
 * 测试场景:
 * 1. 正常负载: 模拟日常使用
 * 2. 峰值负载: 模拟工作时间高峰
 * 3. 压力测试: 找到系统极限
 */

import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

// 自定义指标
export let errorRate = new Rate('errors');
export let completionLatency = new Trend('completion_latency');
export let ttft = new Trend('ttft');

// 测试配置
export let options = {
  stages: [
    // 阶段 1: 预热 (2 分钟, 10 VU)
    { duration: '2m', target: 10 },
    // 阶段 2: 正常负载 (5 分钟, 50 VU)
    { duration: '5m', target: 50 },
    // 阶段 3: 高峰负载 (10 分钟, 200 VU)
    { duration: '10m', target: 200 },
    // 阶段 4: 极限压力 (5 分钟, 500 VU)
    { duration: '5m', target: 500 },
    // 阶段 5: 恢复 (3 分钟, 回到 10 VU)
    { duration: '3m', target: 10 },
  ],
  thresholds: {
    errors: ['rate<0.01'],         // 错误率 < 1%
    completion_latency: ['p(95)<500'], // P95 < 500ms
    http_req_duration: ['p(99)<1000'],
  },
};

// 模拟的用户 Token (测试环境)
const TEST_TOKEN = __ENV.TEST_TOKEN || 'test-token';

export default function () {
  // 场景 A: 代码补全请求 (80% 的流量)
  if (Math.random() < 0.8) {
    testCompletionEndpoint();
  } 
  // 场景 B: 其他 API 调用 (20% 的流量)
  else {
    testOtherEndpoints();
  }
  
  sleep(Math.random() * 2 + 1); // 1-3 秒随机间隔
}

function testCompletionEndpoint() {
  const payload = JSON.stringify({
    language: randomLanguage(),
    code: generateSampleCode(),
    cursorPosition: { line: Math.floor(Math.random() * 100), character: Math.floor(Math.random() * 80) },
    options: { maxSuggestions: 10 },
  });

  const startTime = Date.now();
  
  const res = http.post(`${__ENV.BASE_URL || 'http://localhost:3000'}/api/v1/completions`, payload, {
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${TEST_TOKEN}`,
    },
    timeout: '30s',
  });

  const latency = Date.now() - startTime;
  completionLatency.add(latency);
  
  check(res, {
    'status is 200': (r) => r.status === 200,
    'has suggestions': (r) => {
      try {
        const body = JSON.parse(r.body);
        return Array.isArray(body.suggestions) && body.suggestions.length > 0;
      } catch { return false; }
    },
    'response time < 500ms': (r) => latency < 500,
  }) || errorRate.add(1);
  
  // 记录 TTFT (如果有 streaming 信息)
  if (res.json && res.json.ttft) {
    ttft.add(res.json.ttft);
  }
}

function testOtherEndpoints() {
  const endpoints = [
    '/api/v1/user/profile',
    '/api/v1/history?limit=10',
    '/api/v1/settings',
  ];
  
  const endpoint = endpoints[Math.floor(Math.random() * endpoints.length)];
  
  const res = http.get(`${__ENV.BASE_URL || 'http://localhost:3000'}${endpoint}`, {
    headers: { 'Authorization': `Bearer ${TEST_TOKEN}` },
  });
  
  check(res, { 'status is 200': (r) => r.status === 200 }) || errorRate.add(1);
}

function randomLanguage() {
  const languages = ['typescript', 'javascript', 'python', 'go', 'rust', 'java'];
  return languages[Math.floor(Math.random() * languages.length)];
}

function generateSampleCode() {
  const templates = [
    `function calculateSum(arr: number[]): number {\n  return arr.reduce((acc, val) => acc + val, 0);\n}\n\n`,
    `class UserService {\n  private users: Map<string, User> = new Map();\n  \n  `,
    `async function fetchData<T>(url: string): Promise<T> {\n  const response = await fetch(url);\n  `,
    `interface Config {\n  host: string;\n  port: number;\n  debug?: boolean;\n}\n\n`,
    `const express = require('express');\nconst app = express();\napp.get('/api/', (req, res) => {\n  `,
  ];
  return templates[Math.floor(Math.random() * templates.length)];
}

6.2 性能基准对比

场景	v1.0 (基线)	v2.0 (当前)	提升
P50 补全延迟	280ms	85ms	3.3x
P95 补全延迟	850ms	245ms	3.5x
TTFT	450ms	120ms	3.75x
QPS (单实例)	120	520+	4.3x
内存/1000 用户	2.8 GB	0.8 GB	3.5x
冷启动时间	12s	2.8s	4.3x
GPU 利用率	35%	78%	2.2x

---

七、监控与告警

7.1 关键性能指标采集

// ===== packages/core/src/metrics/collector.ts =====
/**
 * 性能指标实时采集系统
 */

import { Histogram, Counter, Gauge } from 'prom-client';

export class MetricsCollector {
  // 延迟直方图
  public readonly requestDuration = new Histogram({
    name: 'mc_request_duration_seconds',
    help: 'Request processing duration',
    labelNames: ['endpoint', 'method', 'status'],
    buckets: [0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10],
  });
  
  public readonly aiInferenceDuration = new Histogram({
    name: 'mc_ai_inference_duration_ms',
    help: 'AI model inference duration',
    labelNames: ['model', 'provider'],
    buckets: [50, 100, 200, 500, 1000, 2000, 5000],
  });
  
  public readonly completionLatency = new Histogram({
    name: 'mc_completion_latency_ms',
    help: 'End-to-end completion latency',
    labelNames: ['language', 'cache_hit'],
    buckets: [20, 50, 100, 200, 500, 1000],
  });
  
  // 计数器
  public readonly requestsTotal = new Counter({
    name: 'mc_requests_total',
    help: 'Total requests processed',
    labelNames: ['endpoint', 'status'],
  });
  
  public readonly cacheHits = new Counter({
    name: 'mc_cache_hits_total',
    help: 'Cache hit count',
    labelNames: ['cache_type'],
  });
  
  public readonly cacheMisses = new Counter({
    name: 'mc_cache_misses_total',
    help: 'Cache miss count',
    labelNames: ['cache_type'],
  });
  
  // 仪表盘
  public readonly activeConnections = new Gauge({
    name: 'mc_active_connections',
    help: 'Current active WebSocket connections',
  });
  
  public readonly queueLength = new Gauge({
    name: 'mc_ai_queue_length',
    help: 'Current AI request queue length',
    labelNames: ['priority'],
  });
  
  public readonly gpuUtilization = new Gauge({
    name: 'mc_gpu_utilization_percent',
    help: 'GPU utilization percentage',
  });
  
  // === 便捷方法 ===
  
  trackCompletion(language: string, latencyMs: number, cacheHit: boolean): void {
    this.completionLatency.observe({ language, cacheHit: String(cacheHit) }, latencyMs);
    if (cacheHit) {
      this.cacheHits.inc({ cache_type: 'completion' });
    } else {
      this.cacheMisses.inc({ cache_type: 'completion' });
    }
  }
  
  trackAIInference(model: string, provider: string, durationMs: number): void {
    this.aiInferenceDuration.observe({ model, provider }, durationMs);
  }
  
  startRequestTimer(endpoint: string, method: string): () => void {
    const start = Date.now();
    return (status: string) => {
      const duration = (Date.now() - start) / 1000;
      this.requestDuration.observe({ endpoint, method, status }, duration);
      this.requestsTotal.inc({ endpoint, status });
    };
  }
}

---

八、性能优化 Checklist

┌─────────────────────────────────────────────────────────────┐
│         MonkeyCode 性能优化自查清单                           │
│                                                             │
│  🖥️ 前端优化                                               │
│  ├── ☑ 编辑器事件防抖 (150ms 基础)                          │
│  ├── ☑ 增量上下文提取 (不重扫整个文件)                      │
│  ├── ☑ 补全列表虚拟滚动 (> 100 项时启用)                    │
│  ├── ☑ 对象池复用 (CompletionItem 等)                       │
│  ├── ☑ LRU 缓存 (相似请求去重)                              │
│  ├── ☑ Web Worker 脱线程计算                               │
│  └── ☑ 懒加载非首屏组件                                    │
│                                                             │
│  ⚙️ 后端优化                                               │
│  ├── ☑ AI 请求智能调度 (优先级队列)                         │
│  ├── ☑ 请求批处理 (50ms 窗口)                              │
│  ├── ☑ 语义级别缓存 (相似上下文共享结果)                    │
│  ├── ☑ HTTP 连接池 (keep-alive)                            │
│  ├── ☑ Redis 连接池                                        │
│  ├── ☑ 数据库连接池                                         │
│  ├── ☑ SQL 查询优化 + 索引                                 │
│  └── ☑ 异步非阻塞 IO                                       │
│                                                             │
│  🤖 AI 层优化                                              │
│  ├── ☑ 本地模型优先 (零网络延迟)                           │
│  ├── ☑ GPU 显存优化 (FP16/INT8 量化)                       │
│  ├── ☑ 模型批处理 (batch inference)                         │
│  ├── ☑ KV Cache 复用                                      │
│  ├── ☑ Continuous Batching                                  │
│  └── ☑ Speculative Decoding (可选)                         │
│                                                             │
│  📊 监控与调优                                             │
│  ├── ☑ Prometheus 指标采集                                 │
│  ├── ☑ Grafana 实时看板                                    │
│  ├── ☑ P99 延迟告警 (> 800ms)                             │
│  ├── ☑ 定期压测 (每周)                                     │
│  └── ☑ 性能回归检测 (CI 集成)                              │
│                                                             │
╚═══════════════════════════════════════════════════════════╝

---

结语

"性能优化是一场永无止境的旅程，但每一步都值得。"

MonkeyCode 的性能体系涵盖了从前端编辑器到后端服务、从 AI 推理引擎到数据库查询的全链路。每一个毫秒的节省，都是对开发者体验的直接提升。

记住几个核心原则：

1. 测量先行 — 不要猜测瓶颈在哪里，用数据说话
2. 优化热点 — 80% 的收益来自 20% 的关键路径
3. 缓存一切 — 合理的缓存是最有效的优化手段
4. 渐进式改进 — 小步快跑，持续迭代

如果你在性能优化方面有发现或建议，欢迎提交 PR 或在 Discord #performance 频道讨论！

💡 性能相关资源

• 📊 公开基准测试报告
• 🧪 K6 压测脚本
• 📈 Grafana Dashboard 模板
• 💬 Discord #performance

MonkeyCode — 为速度而生，为体验而优。 🐵⚡✨