以下是nodejs-profiling技能的中文翻译内容：

name: nodejs-profiling description: 针对Node.js特定性能分析和优化的专家技能。使用V8 CPU分析器，分析堆快照，配置clinic.js工具（Doctor, Flame, Bubbleprof），调试事件循环阻塞，分析异步钩子性能，并优化V8 JIT编译。 allowed-tools: Bash(*) 读写编辑Glob Grep WebFetch metadata: author: babysitter-sdk version: “1.0.0” category: 运行时性能分析 backlog-id: SK-018

nodejs-profiling

你是nodejs-profiling - 一个专门针对Node.js运行时性能分析和优化的专家技能。这个技能提供了分析Node.js应用程序性能的专家能力，包括CPU性能分析、内存分析、事件循环调试和V8优化。

概览

这个技能使得AI驱动的Node.js性能分析成为可能，包括：

• 使用V8内置分析器进行热点路径识别
• 分析堆快照以查找内存泄漏
• 配置clinic.js工具（Doctor, Flame, Bubbleprof）
• 调试事件循环阻塞和延迟
• 使用async_hooks分析异步操作性能
• 优化V8 JIT编译
• 分析原生插件

先决条件

• Node.js 16+（推荐18+或20+）
• npm/yarn用于包管理
• clinic.js: npm install -g clinic
• 可选：0x用于火焰图，heapdump用于快照

能力

1. V8 CPU分析

使用V8内置分析器分析CPU使用情况：

// cpu-profile.js - 程序化CPU分析
const v8Profiler = require('v8-profiler-next');
const fs = require('fs');

// 开始分析
v8Profiler.setGenerateType(1); // 生成调用树
v8Profiler.startProfiling('cpu-profile', true);

// 运行你的工作负载
await runWorkload();

// 停止并保存分析结果
const profile = v8Profiler.stopProfiling('cpu-profile');
const profileData = profile.export();

fs.writeFileSync('cpu-profile.cpuprofile', JSON.stringify(profileData));
profile.delete();

console.log('CPU分析结果已保存至cpu-profile.cpuprofile');

# 使用Node.js内置分析器
node --prof app.js
node --prof-process isolate-0x*.log > processed.txt

# 生成V8日志以供分析
node --trace-opt --trace-deopt app.js 2>&1 | grep -E "(opt|deopt)"

# 使用inspector进行Chrome DevTools分析
node --inspect app.js
# 然后在Chrome中打开chrome://inspect

2. 堆快照分析

捕获并分析堆快照：

// heap-analysis.js
const v8 = require('v8');
const fs = require('fs');

// 拍摄堆快照
function takeHeapSnapshot(filename) {
  const snapshotStream = v8.writeHeapSnapshot(filename);
  console.log(`堆快照已写入${snapshotStream}`);
  return snapshotStream;
}

// 内存使用跟踪
function trackMemory() {
  const usage = process.memoryUsage();
  return {
    heapUsed: `${(usage.heapUsed / 1024 / 1024).toFixed(2)} MB`,
    heapTotal: `${(usage.heapTotal / 1024 / 1024).toFixed(2)} MB`,
    external: `${(usage.external / 1024 / 1024).toFixed(2)} MB`,
    rss: `${(usage.rss / 1024 / 1024).toFixed(2)} MB`,
    arrayBuffers: `${(usage.arrayBuffers / 1024 / 1024).toFixed(2)} MB`
  };
}

// 堆统计信息
function getHeapStats() {
  const stats = v8.getHeapStatistics();
  return {
    totalHeapSize: `${(stats.total_heap_size / 1024 / 1024).toFixed(2)} MB`,
    usedHeapSize: `${(stats.used_heap_size / 1024 / 1024).toFixed(2)} MB`,
    heapSizeLimit: `${(stats.heap_size_limit / 1024 / 1024).toFixed(2)} MB`,
    mallocedMemory: `${(stats.malloced_memory / 1024 / 1024).toFixed(2)} MB`,
    peakMallocedMemory: `${(stats.peak_malloced_memory / 1024 / 1024).toFixed(2)} MB`
  };
}

// 触发垃圾回收（需要--expose-gc标志）
function forceGC() {
  if (global.gc) {
    global.gc();
    console.log('触发垃圾回收');
  } else {
    console.warn('使用--expose-gc运行以启用手动GC');
  }
}

3. Clinic.js工具

使用clinic.js套件进行全面分析：

# Clinic Doctor - 整体健康检查
clinic doctor -- node app.js
# 生成：.clinic/xxx.clinic-doctor

# Clinic Flame - CPU火焰图
clinic flame -- node app.js
# 生成：.clinic/xxx.clinic-flame

# Clinic Bubbleprof - 异步操作可视化
clinic bubbleprof -- node app.js
# 生成：.clinic/xxx.clinic-bubbleprof

# Clinic Heap Profiler - 内存分析
clinic heapprofiler -- node app.js
# 生成：.clinic/xxx.clinic-heapprofiler

# 用特定工作负载运行
clinic flame --autocannon [ /api/users -- -c 10 -d 30 ] -- node app.js

# 分析特定端点
clinic bubbleprof --autocannon [ /api/slow-endpoint -c 5 -d 60 ] -- node server.js

// 程序化使用clinic
const ClinicDoctor = require('@clinic/doctor');
const doctor = new ClinicDoctor();

doctor.collect(['node', 'app.js'], (err, filepath) => {
  if (err) throw err;

  doctor.visualize(filepath, filepath + '.html', (err) => {
    if (err) throw err;
    console.log(`报告：${filepath}.html`);
  });
});

4. 事件循环分析

调试事件循环阻塞和延迟：

// event-loop-monitor.js
const { monitorEventLoopDelay } = require('perf_hooks');

// 为事件循环延迟创建直方图
const h = monitorEventLoopDelay({ resolution: 20 });
h.enable();

// 定期报告
setInterval(() => {
  console.log('事件循环延迟：');
  console.log(`  最小值：${h.min / 1e6} ms`);
  console.log(`  最大值：${h.max / 1e6} ms`);
  console.log(`  平均值：${h.mean / 1e6} ms`);
  console.log(`  P50：${h.percentile(50) / 1e6} ms`);
  console.log(`  P99：${h.percentile(99) / 1e6} ms`);
  h.reset();
}, 5000);

// 检测阻塞操作
const blocked = require('blocked-at');
blocked((time, stack, { type, resource }) => {
  console.warn(`事件循环阻塞${time}ms`);
  console.warn(`类型：${type}`);
  console.warn(`堆栈：
${stack.join('
')}`);
}, { threshold: 100, resourcesCap: 100 });

// 异步操作计时
const async_hooks = require('async_hooks');
const { performance, PerformanceObserver } = require('perf_hooks');

// 跟踪异步操作持续时间
const asyncTiming = new Map();

const hook = async_hooks.createHook({
  init(asyncId, type, triggerAsyncId) {
    asyncTiming.set(asyncId, {
      type,
      start: performance.now(),
      triggerAsyncId
    });
  },
  destroy(asyncId) {
    const timing = asyncTiming.get(asyncId);
    if (timing) {
      const duration = performance.now() - timing.start;
      if (duration > 100) { // 记录慢操作
        console.log(`慢异步：${timing.type}耗时${duration.toFixed(2)}ms`);
      }
      asyncTiming.delete(asyncId);
    }
  }
});

hook.enable();

5. 火焰图生成

生成CPU分析的火焰图：

# 使用0x
npm install -g 0x
0x -o app.js
# 在浏览器中打开火焰图

# 使用perf和FlameGraph（Linux）
perf record -F 99 -g -- node app.js
perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > flame.svg

# 使用node --perf-basic-prof
node --perf-basic-prof app.js &
perf record -F 99 -p $! -g -- sleep 30
perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > flame.svg

6. V8优化分析

分析V8 JIT优化：

# 跟踪优化和去优化
node --trace-opt --trace-deopt app.js 2>&1 | tee opt.log

# 分析内联缓存
node --trace-ic app.js 2>&1 | tee ic.log

# 检查隐藏类转换
node --allow-natives-syntax -e "
  function Point(x, y) { this.x = x; this.y = y; }
  const p = new Point(1, 2);
  %DebugPrint(p);
  %HaveSameMap(new Point(1,2), p);
"

# 详细的V8标志
node --v8-options | grep -i "optimize"

// 优化提示（仅限调试）
function optimizedFunction(a, b) {
  // 这个函数应该被优化
  return a + b;
}

// 检查函数是否被优化（需要--allow-natives-syntax）
// %OptimizeFunctionOnNextCall(optimizedFunction);
// optimizedFunction(1, 2);
// console.log(%GetOptimizationStatus(optimizedFunction));

7. 内存泄漏检测

检测和诊断内存泄漏：

// leak-detector.js
const memwatch = require('@airbnb/node-memwatch');

// 检测泄漏趋势
memwatch.on('leak', (info) => {
  console.error('检测到内存泄漏：');
  console.error(JSON.stringify(info, null, 2));
});

// 跟踪堆差异
let lastHeapDiff = null;

memwatch.on('stats', (stats) => {
  console.log('GC发生：');
  console.log(`  堆使用量：${(stats.used_heap_size / 1024 / 1024).toFixed(2)} MB`);

  if (lastHeapDiff) {
    const diff = new memwatch.HeapDiff();
    // ...运行一些代码...
    const changes = diff.end();
    console.log('堆变化：', JSON.stringify(changes.change, null, 2));
  }
});

// 程序化堆差异
function findLeaks() {
  const hd = new memwatch.HeapDiff();

  // 运行疑似泄漏代码
  suspectedLeakyFunction();

  const diff = hd.end();
  return diff.change.details.filter(d =>
    d.size_bytes > 10000 && d['+'] > d['-']
  );
}

8. 性能测量API

使用内置的性能API：

// performance-monitoring.js
const {
  performance,
  PerformanceObserver,
  createHistogram
} = require('perf_hooks');

// 测量特定操作
performance.mark('operation-start');
await performOperation();
performance.mark('operation-end');
performance.measure('operation', 'operation-start', 'operation-end');

// 观察测量结果
const obs = new PerformanceObserver((list) => {
  const entries = list.getEntries();
  entries.forEach((entry) => {
    console.log(`${entry.name}: ${entry.duration.toFixed(2)}ms`);
  });
});
obs.observe({ entryTypes: ['measure', 'function'] });

// 为重复测量创建直方图
const histogram = createHistogram();

function timedOperation() {
  const start = process.hrtime.bigint();
  // ...操作...
  const duration = Number(process.hrtime.bigint() - start);
  histogram.record(duration);
}

// 报告直方图
console.log({
  min: histogram.min,
  max: histogram.max,
  mean: histogram.mean,
  p50: histogram.percentile(50),
  p99: histogram.percentile(99)
});

MCP服务器集成

这个技能可以利用以下MCP服务器：

服务器	描述	用例
clinic.js	Node.js性能分析套件	全面分析
Sentry MCP	错误跟踪	性能相关性
OpenTelemetry	分布式跟踪	生产性能分析

最佳实践

性能分析

1. 在类似生产的环境中进行性能分析 - 结果因环境而异
2. 测量前预热 - JIT需要时间来优化
3. 多次运行 - 考虑统计显著性
4. 关注热点路径 - 优化重要的部分

内存

1. 定期拍摄堆快照 - 随时间比较
2. 观察趋势 - 慢泄漏难以发现
3. 用生产数据大小进行测试 - 泄漏随着数据规模而变化
4. 使用弱引用 - 用于缓存和监听器

事件循环

1. 避免同步操作 - 使用异步替代品
2. 批量CPU工作 - 使用setImmediate来让出
3. 工作线程 - 用于CPU密集型工作
4. 在生产中监控 - 使用perf_hooks

流程集成

这个技能与以下流程集成：

• cpu-profiling-investigation.js - CPU性能分析工作流
• memory-profiling-analysis.js - 内存分析
• memory-leak-detection.js - 泄漏检测

输出格式

执行操作时，提供结构化输出：

{
  "operation": "profile-cpu",
  "status": "completed",
  "duration": "30s",
  "profile": {
    "samples": 15420,
    "topFunctions": [
      {
        "name": "processRequest",
        "selfTime": "2340ms",
        "totalTime": "8920ms",
        "percentage": "28.5%",
        "file": "handlers.js:45"
      },
      {
        "name": "serializeResponse",
        "selfTime": "1890ms",
        "totalTime": "2100ms",
        "percentage": "22.1%",
        "file": "serializer.js:12"
      }
    ],
    "eventLoopDelay": {
      "mean": "2.3ms",
      "p99": "15.8ms",
      "max": "45.2ms"
    }
  },
  "recommendations": [
    {
      "function": "processRequest",
      "issue": "JSON解析中的高CPU时间",
      "suggestion": "考虑为大型负载使用流式JSON解析器"
    }
  ],
  "artifacts": ["cpu-profile.cpuprofile", "flame.svg"]
}

错误处理

常见问题

错误	原因	解决方案
无法拍摄堆快照	OOM条件	增加内存限制
分析器已启动	多个分析会话	停止现有的分析器
事件循环阻塞	同步操作	使用异步替代品
高GC时间	内存压力	减少分配，增加堆

约束

• 性能分析增加开销 - 避免在生产中使用
• 堆快照暂停进程
• 事件循环监控开销极小
• V8标志仅限调试使用