Node.js Performance Profiling: Finding and Fixing Bottlenecks

Performance profiling helps identify bottlenecks in your Node.js applications.

CPU Profiling#

Using Chrome DevTools#

# Start with inspector
node --inspect app.js

# Or attach to running process
node --inspect=9229 app.js

Open chrome://inspect and click "inspect" to access DevTools.

Programmatic Profiling#

const { Session } = require('inspector');
const fs = require('fs');

const session = new Session();
session.connect();

// Start profiling
session.post('Profiler.enable');
session.post('Profiler.start');

// Your code runs here...

// Stop and save
session.post('Profiler.stop', (err, { profile }) => {
  fs.writeFileSync('profile.cpuprofile', JSON.stringify(profile));
});

Using clinic.js#

npm install -g clinic

# CPU profiling
clinic doctor -- node app.js

# Flame graphs
clinic flame -- node app.js

# Event loop analysis
clinic bubbleprof -- node app.js

Memory Profiling#

Heap Snapshots#

const v8 = require('v8');
const fs = require('fs');

function takeHeapSnapshot() {
  const snapshotStream = v8.writeHeapSnapshot();
  console.log(`Heap snapshot written to ${snapshotStream}`);
}

// Take snapshot on signal
process.on('SIGUSR2', takeHeapSnapshot);

Detecting Memory Leaks#

// Track memory usage
setInterval(() => {
  const usage = process.memoryUsage();
  console.log({
    heapUsed: Math.round(usage.heapUsed / 1024 / 1024) + 'MB',
    heapTotal: Math.round(usage.heapTotal / 1024 / 1024) + 'MB',
    external: Math.round(usage.external / 1024 / 1024) + 'MB',
  });
}, 5000);

Common Memory Leaks#

// ❌ Growing array (leak)
const cache = [];
function addToCache(item) {
  cache.push(item); // Never cleaned up
}

// ✅ Fixed with LRU cache
const LRU = require('lru-cache');
const cache = new LRU({ max: 500 });

// ❌ Event listener leak
function handleRequest(req, res) {
  emitter.on('data', handler); // Never removed
}

// ✅ Fixed with cleanup
function handleRequest(req, res) {
  const handler = (data) => res.write(data);
  emitter.on('data', handler);
  res.on('close', () => emitter.off('data', handler));
}

// ❌ Closure retaining references
function createHandler(largeData) {
  return () => {
    console.log(largeData.id); // Retains entire largeData
  };
}

// ✅ Fixed by extracting needed values
function createHandler(largeData) {
  const id = largeData.id;
  return () => {
    console.log(id); // Only retains id
  };
}

Event Loop Monitoring#

const { monitorEventLoopDelay } = require('perf_hooks');

const histogram = monitorEventLoopDelay({ resolution: 20 });
histogram.enable();

setInterval(() => {
  console.log({
    min: histogram.min / 1e6,
    max: histogram.max / 1e6,
    mean: histogram.mean / 1e6,
    percentile99: histogram.percentile(99) / 1e6,
  });
  histogram.reset();
}, 5000);

Async Operations#

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

// Measure async operations
async function measureAsync(name, fn) {
  const start = performance.now();
  try {
    return await fn();
  } finally {
    const duration = performance.now() - start;
    console.log(`${name}: ${duration.toFixed(2)}ms`);
  }
}

// Usage
await measureAsync('database-query', async () => {
  return db.users.findMany();
});

Optimization Techniques#

Avoid Blocking the Event Loop#

// ❌ Blocking
function processLargeArray(items) {
  return items.map(item => heavyComputation(item));
}

// ✅ Non-blocking with batching
async function processLargeArray(items) {
  const results = [];
  const BATCH_SIZE = 100;

  for (let i = 0; i < items.length; i += BATCH_SIZE) {
    const batch = items.slice(i, i + BATCH_SIZE);
    results.push(...batch.map(heavyComputation));

    // Yield to event loop
    await new Promise(resolve => setImmediate(resolve));
  }

  return results;
}

Use Worker Threads for CPU-Intensive Work#

const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
  function runWorker(data) {
    return new Promise((resolve, reject) => {
      const worker = new Worker(__filename, { workerData: data });
      worker.on('message', resolve);
      worker.on('error', reject);
    });
  }

  // Use worker for heavy computation
  const result = await runWorker({ numbers: largeArray });
} else {
  const { workerData } = require('worker_threads');
  const result = heavyComputation(workerData);
  parentPort.postMessage(result);
}

Connection Pooling#

// Use connection pools
const { Pool } = require('pg');

const pool = new Pool({
  max: 20,
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});

// Reuse connections
const result = await pool.query('SELECT * FROM users');

Monitoring in Production#

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

// Collect default metrics
client.collectDefaultMetrics();

// Custom metrics
const httpDuration = new client.Histogram({
  name: 'http_request_duration_seconds',
  help: 'HTTP request duration',
  labelNames: ['method', 'route', 'status'],
});

app.use((req, res, next) => {
  const end = httpDuration.startTimer();
  res.on('finish', () => {
    end({ method: req.method, route: req.route?.path, status: res.statusCode });
  });
  next();
});

Profile regularly, monitor in production, and optimize based on real data rather than assumptions.

Share this article