Performance analysis tools

The Importance of Performance Analysis Tools in Node.js

The performance of Node.js applications directly impacts user experience and system stability. Performance analysis tools help developers identify bottlenecks, optimize code, and reduce resource consumption. From CPU usage to memory leaks, from event loop delays to asynchronous operation tracing, these tools cover all aspects of performance monitoring.

Built-in Performance Analysis Tools

Node.js comes with various performance analysis tools that can be used without installing third-party modules.

process.memoryUsage()

This method returns the memory usage of the Node.js process:

const memoryUsage = process.memoryUsage();
console.log({
  rss: `${Math.round(memoryUsage.rss / 1024 / 1024)} MB`, // Resident Set Size
  heapTotal: `${Math.round(memoryUsage.heapTotal / 1024 / 1024)} MB`, // Total heap memory
  heapUsed: `${Math.round(memoryUsage.heapUsed / 1024 / 1024)} MB`, // Used heap memory
  external: `${Math.round(memoryUsage.external / 1024 / 1024)} MB` // Memory used by C++ objects
});

--inspect Flag

Adding the --inspect flag when starting a Node.js application enables the Chrome DevTools protocol:

node --inspect app.js

Then, in the Chrome browser, visit chrome://inspect to connect to the Node.js process for CPU and memory analysis.

Third-Party Performance Analysis Tools

Clinic.js

Clinic.js is a suite of performance diagnostic tools developed by NearForm, consisting of three main components:

1. Doctor: Quickly identifies performance issues
2. Bubbleprof: Visualizes asynchronous operation flows
3. Flame: Generates flame graphs for CPU usage analysis

Installation and usage example:

npm install -g clinic
clinic doctor -- node app.js

0x

The 0x tool generates flame graphs to help analyze performance bottlenecks:

npx 0x app.js

After testing, it generates an HTML file showing function call stacks and CPU time consumption.

Memory Leak Detection

heapdump Module

heapdump can generate heap snapshots at runtime:

const heapdump = require('heapdump');

// Manually generate a heap snapshot
heapdump.writeSnapshot('/tmp/' + Date.now() + '.heapsnapshot');

// Automatically generate when memory usage exceeds a threshold
setInterval(() => {
  const memoryUsage = process.memoryUsage();
  if (memoryUsage.heapUsed > 500 * 1024 * 1024) { // 500MB threshold
    heapdump.writeSnapshot();
  }
}, 1000);

memwatch-next

This module monitors memory leaks:

const memwatch = require('memwatch-next');

memwatch.on('leak', (info) => {
  console.log('Memory leak detected:', info);
});

Event Loop Monitoring

loopbench

Monitors event loop latency:

const loopbench = require('loopbench')();

console.log(`Current latency: ${loopbench.delay}ms`);
console.log(`Overloaded: ${loopbench.overLimit}`);

loopbench.on('load', () => {
  console.log('Event loop overloaded');
});

toobusy-js

Prevents new requests when event loop latency is too high:

const toobusy = require('toobusy-js');

app.use((req, res, next) => {
  if (toobusy()) {
    res.status(503).send("Server too busy");
  } else {
    next();
  }
});

Performance Benchmarking

benchmark.js

Compares code performance:

const Benchmark = require('benchmark');
const suite = new Benchmark.Suite;

suite.add('RegExp#test', () => {
  /o/.test('Hello World!');
})
.add('String#indexOf', () => {
  'Hello World!'.indexOf('o') > -1;
})
.on('cycle', (event) => {
  console.log(String(event.target));
})
.run();

autocannon

HTTP benchmarking tool:

npx autocannon -c 100 -d 20 http://localhost:3000

This command simulates 100 concurrent connections for a 20-second load test.

Distributed System Performance Analysis

Node.js Performance Hooks

The perf_hooks module provides performance measurement APIs:

const { performance, PerformanceObserver } = require('perf_hooks');

const obs = new PerformanceObserver((items) => {
  console.log(items.getEntries()[0].duration);
  performance.clearMarks();
});
obs.observe({ entryTypes: ['measure'] });

performance.mark('A');
doSomeLongOperation();
performance.mark('B');
performance.measure('A to B', 'A', 'B');

OpenTelemetry

Distributed tracing tool:

const { NodeTracerProvider } = require('@opentelemetry/node');
const { SimpleSpanProcessor } = require('@opentelemetry/tracing');
const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');

const provider = new NodeTracerProvider();
provider.addSpanProcessor(
  new SimpleSpanProcessor(
    new JaegerExporter({
      serviceName: 'my-service'
    })
  )
);
provider.register();

Real-Time Performance Monitoring

Prometheus + Grafana

Use Prometheus to collect metrics and Grafana to display them:

const client = require('prom-client');
const collectDefaultMetrics = client.collectDefaultMetrics;

collectDefaultMetrics({ timeout: 5000 });

app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

PM2 Monitoring

PM2 has built-in monitoring features:

pm2 monit
pm2 dashboard

Advanced Analysis Techniques

V8 Code Optimization Analysis

Check if a function is optimized by V8:

const v8 = require('v8');

function someFunction() {
  // Function implementation
}

console.log(v8.getOptimizationStatus(someFunction));
// 1 = Function is optimized
// 2 = Function is not optimized
// 3 = Function is always optimized
// 4 = Function is never optimized
// 5 = Function may be optimized
// 6 = Module contains functions that are never optimized

Disabling Optimization for Debugging

Sometimes optimization needs to be disabled to debug performance issues:

node --trace-opt --trace-deopt app.js

Performance Analysis Best Practices

1. Establish performance baselines: Record current performance metrics before optimization
2. Change one variable at a time: Avoid modifying multiple factors simultaneously
3. Analyze in production: Performance in development may differ from production
4. Long-term monitoring: Performance issues may emerge over time
5. Focus on critical paths: Prioritize optimizing the most impactful parts

Common Performance Problem Patterns

Synchronous Blocking Operations

// Avoid
const data = fs.readFileSync('large-file.json');

// Recommended
const data = await fs.promises.readFile('large-file.json');

Memory Leak Example

const leaks = [];

app.get('/leak', (req, res) => {
  const largeObject = new Array(1000000).fill('*');
  leaks.push(largeObject); // Memory leak
  res.send('OK');
});

Event Listener Leaks

const EventEmitter = require('events');
const emitter = new EventEmitter();

function listener() {}

setInterval(() => {
  emitter.on('event', listener); // Repeatedly adding listeners
}, 100);

Node.js Version Differences

Performance characteristics may vary across Node.js versions:

• Node.js 12+: Improved heap analysis APIs
• Node.js 14+: Better async stack traces
• Node.js 16+: Enhanced V8 engine performance
• Node.js 18+: Experimental performance hooks enhancements

Performance Analysis Tool Selection Strategy

1. Quick diagnosis: Use Clinic.js Doctor
2. In-depth CPU analysis: Use 0x or Flame
3. Memory issues: Use heapdump and Chrome DevTools
4. Production environment: Use Prometheus + Grafana
5. Distributed systems: Use OpenTelemetry