Node.js 性能分析与排查

// 典型场景：复杂计算、数据处理
app.get('/analyze', async (req, res) => {
  // ❌ 同步循环计算，会阻塞事件循环
  let result = 0;
  for (let i = 0; i < 100000000; i++) {
    result += Math.sqrt(i);
  }
  res.json({ result });
});

// 典型场景：缓存无限增长、事件监听器未清理
const cache = new Map();

// ❌ 缓存无限增长
function getData(key) {
  if (!cache.has(key)) {
    const data = fetchFromDB(key);
    cache.set(key, data); // 永远不清理
  }
  return cache.get(key);
}

// 典型场景：同步文件读写、阻塞的第三方调用
const fs = require('fs');

app.get('/read-file', (req, res) => {
  // ❌ 同步读取，阻塞事件循环
  const content = fs.readFileSync('./large-file.txt', 'utf-8');
  res.send(content);
});

// Node.js 内置的性能钩子
const { PerformanceObserver, performance } = require('perf_hooks');

// 测量代码执行时间
performance.mark('start');

// 模拟业务逻辑
doSomething();

performance.mark('end');

// 创建测量
performance.measure('doSomething', 'start', 'end');

// 观察测量结果
const observer = new PerformanceObserver((list) => {
  const entry = list.getEntries()[0];
  console.log(`${entry.name}: ${entry.duration}ms`);
});

observer.observe({ entryTypes: ['measure'] });

# 安装
npm install -g 0x

# 运行并生成火焰图
0x server.js

# 访问 http://localhost:3000 查看交互式火焰图

# 安装
npm install -g clinic

# 三种诊断模式
clinic doctor      # 诊断模式 - 检测常见问题
clinic flame       # 火焰图 - CPU 性能分析  
clinic bubbleprof  # 气泡图 - 异步 I/O 可视化

# 使用示例
clinic doctor -- node server.js

# 完成后会生成报告文件
# 用浏览器打开查看

// 生成堆快照
const v8 = require('v8');
const fs = require('fs');

app.get('/debug/heap-snapshot', (req, res) => {
  const snapshot = v8.writeHeapSnapshot();
  res.json({ snapshot: snapshot.filename });
});

// 监控内存使用
setInterval(() => {
  const used = process.memoryUsage();
  console.log({
    heapUsed: Math.round(used.heapUsed / 1024 / 1024) + 'MB',
    heapTotal: Math.round(used.heapTotal / 1024 / 1024) + 'MB',
    rss: Math.round(used.rss / 1024 / 1024) + 'MB',
    external: Math.round(used.external / 1024 / 1024) + 'MB'
  });
}, 10000);

# 1. 找到 Node.js 进程
ps aux | grep node

# 2. 使用 top 查看 CPU 使用
top -p <pid>

# 3. 使用 0x 生成火焰图
0x --on-port=3000 node server.js

# 4. 访问触发问题的接口后，查看火焰图

// ❌ 问题：递归调用没有终止条件
function fibonacci(n) {
  return fibonacci(n - 1) + fibonacci(n - 2); // 指数级增长
}

// ✅ 修复：使用循环或缓存
function fibonacci(n) {
  if (n <= 1) return n;
  
  let a = 0, b = 1;
  for (let i = 2; i <= n; i++) {
    [a, b] = [b, a + b];
  }
  return b;
}

// 或者使用缓存
const memo = new Map();
function fibonacciMemo(n) {
  if (memo.has(n)) return memo.get(n);
  if (n <= 1) return n;
  
  const result = fibonacciMemo(n - 1) + fibonacciMemo(n - 2);
  memo.set(n, result);
  return result;
}

# 1. 使用 clinic doctor 检测
clinic doctor -- node server.js

# 2. 触发问题操作后 Ctrl+C 查看建议

# 3. 使用 heapdump 生成快照对比
curl http://localhost:3000/debug/heap-snapshot
# 用 Chrome DevTools 对比两个快照

// ❌ 问题：事件监听器未清理
const EventEmitter = require('events');
class MyService extends EventEmitter {}

const service = new MyService();

// 每次请求都添加新的监听器
app.get('/subscribe', (req, res) => {
  service.on('event', () => {
    console.log('收到事件');
  });
  res.send('已订阅');
});

// ✅ 修复：使用 once 或手动清理
app.get('/subscribe', (req, res) => {
  service.once('event', () => {  // 只触发一次
    console.log('收到事件');
  });
  res.send('已订阅');
});

# 使用 clinic bubbleprof 可视化异步操作
clinic bubbleprof -- node server.js

# 访问触发问题的接口，查看气泡图

// ❌ 问题：串行查询
async function getUserWithOrders(userId) {
  const user = await db.users.find(userId);           // 100ms
  const orders = await db.orders.find({ userId });    // 100ms
  const address = await db.addresses.find(user.addressId); // 100ms
  
  return { user, orders, address };  // 总共 300ms
}

// ✅ 修复：并行查询
async function getUserWithOrders(userId) {
  const [user, orders, address] = await Promise.all([
    db.users.find(userId),
    db.orders.find({ userId }),
    user.addressId ? db.addresses.find(user.addressId) : null
  ]);
  
  return { user, orders, address };  // 总共 ~100ms
}

// 频繁创建/销毁的对象使用对象池
class ObjectPool {
  constructor(factory, size = 10) {
    this.factory = factory;
    this.pool = [];
    for (let i = 0; i < size; i++) {
      this.pool.push(factory());
    }
  }
  
  acquire() {
    return this.pool.pop() || this.factory();
  }
  
  release(obj) {
    if (this.pool.length < 100) {  // 限制池大小
      this.pool.push(obj);
    }
  }
}

// 使用示例：缓冲区池
const bufferPool = new ObjectPool(() => Buffer.alloc(4096), 50);

// 获取
const buf = bufferPool.acquire();
// 使用...

// 归还
bufferPool.release(buf);

// ❌ 启动时加载所有模块
const userService = require('./services/user');
const orderService = require('./services/order');
const productService = require('./services/product');
const analyticsService = require('./services/analytics');

// ✅ 按需加载
function getUserService() {
  return require('./services/user');
}

app.get('/users', (req, res) => {
  // 只有访问 /users 时才加载
  const userService = getUserService();
  userService.list().then(res.json.bind(res));
});

// ❌ 逐条插入
async function createUsers(users) {
  for (const user of users) {
    await db.users.create(user);  // N 次数据库往返
  }
}

// ✅ 批量插入
async function createUsersBatch(users) {
  await db.users.insertMany(users);  // 1 次数据库往返
}

// 或者分批处理大量数据
async function processLargeDataset(items, batchSize = 1000) {
  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    await processBatch(batch);
    
    // 让出事件循环
    await new Promise(resolve => setImmediate(resolve));
  }
}

// 内存缓存（适合小数据量）
const cache = new Map();
const CACHE_TTL = 5 * 60 * 1000; // 5分钟

function getCached(key) {
  const item = cache.get(key);
  if (item && Date.now() - item.timestamp < CACHE_TTL) {
    return item.value;
  }
  return null;
}

function setCache(key, value) {
  cache.set(key, { value, timestamp: Date.now() });
}

// Redis 缓存（适合分布式场景）
const redis = require('ioredis');
const redisClient = new redis(process.env.REDIS_URL);

async function getUser(id) {
  // 先查 Redis
  const cached = await redisClient.get(`user:${id}`);
  if (cached) {
    return JSON.parse(cached);
  }
  
  // 查数据库
  const user = await db.users.find(id);
  
  // 存入 Redis
  await redisClient.setex(`user:${id}`, 300, JSON.stringify(user));
  
  return user;
}

const os = require('os');

function getSystemMetrics() {
  const cpuUsage = process.cpuUsage();
  const memUsage = process.memoryUsage();
  const loadAvg = os.loadavg();
  
  return {
    cpu: {
      user: cpuUsage.user / 1000000, // 转换为秒
      system: cpuUsage.system / 1000000,
      load: loadAvg
    },
    memory: {
      heapUsed: Math.round(memUsage.heapUsed / 1024 / 1024),
      heapTotal: Math.round(memUsage.heapTotal / 1024 / 1024),
      rss: Math.round(memUsage.rss / 1024 / 1024),
      external: Math.round(memUsage.external / 1024 / 1024)
    },
    eventLoop: {
      lag: Math.round(process.uptime() * 1000 - Date.now())
    }
  };
}

// 暴露给监控系统
app.get('/metrics', (req, res) => {
  res.json(getSystemMetrics());
});

// 建议的告警阈值
const ALERTS = {
  cpu: {
    warning: 70,  // 持续 5 分钟 CPU 超过 70%
    critical: 90  // 超过 90% 立即告警
  },
  memory: {
    warning: 80,  // 内存使用超过 80%
    critical: 90  // 超过 90% 立即告警
  },
  responseTime: {
    p95: 1000,    // P95 响应时间超过 1 秒
    p99: 3000     // P99 响应时间超过 3 秒
  },
  errorRate: {
    warning: 1,   // 错误率超过 1%
    critical: 5   // 超过 5% 立即告警
  }
};