Node.js Memory Leak — Diagnosis & Fix Guide

Memory leaks in Node.js applications are among the most critical production issues. This guide outlines the end-to-end workflow — from initial detection to a confirmed fix.

🔍 Is It Really a Leak?

A memory leak is defined as a sustained, unbounded increase in heap usage.

Behaviors That Look Like Leaks But Are Normal:

• Warm-up Growth: Heap climbs for the first few minutes after boot, then plateaus (Normal JIT compilation & module load).
• In-Memory Caches: Intentional growth as items populate an unbounded cache (Expected behavior).
• Garbage Collection (GC) Sawtooth: Heap climbs between GC cycles, then drops sharply after collection (Healthy).

🛑 4 Most Common Causes

1. Retained EventEmitter Listeners

// ❌ LEAKS: 'finish' listener holds a reference to `context`
server.on('connection', (socket) => {
  const context = buildContext(socket);
  socket.on('data', (chunk) => process(chunk, context));
  // Missing: socket.on('close', () => cleanup())
});

Fix: Always unbind listeners when the target object is destroyed or closed.

2. Unbounded Maps or Sets Used as Caches

// ❌ LEAKS: Cache grows infinitely without eviction
const cache = new Map();
 
app.get('/item/:id', async (req, res) => {
  if (!cache.has(req.params.id)) {
    cache.set(req.params.id, await db.getItem(req.params.id));
  }
  res.json(cache.get(req.params.id));
});

Fix: Use a size-bounded LRU cache (lru-cache package) with max limits and TTL.

3. Timers (setInterval) Holding Object References

// ❌ LEAKS: Interval runs indefinitely, keeping references alive
function startPoller(callback) {
  const id = setInterval(callback, 1000);
}

Fix: Always return timer IDs and call clearInterval(id) when teardown occurs.

4. Closures Capturing Large Buffers

// ❌ LEAKS: Retains full 100 MB buffer in memory
function processLargeFile(buffer) {
  return {
    getFirst: () => buffer[0], // Closure captures full 100 MB buffer reference
  };
}

Fix: Extract only primitive values from large objects before forming closures.

🛠️ Step-by-Step Diagnostic Workflow

Step 1 — Confirm the Heap Growth Trend

Add memory logging to your application:

setInterval(() => {
  const m = process.memoryUsage();
  console.log(JSON.stringify({
    heapUsed: Math.round(m.heapUsed / 1024 / 1024) + ' MB',
    heapTotal: Math.round(m.heapTotal / 1024 / 1024) + ' MB',
    external: Math.round(m.external / 1024 / 1024) + ' MB',
  }));
}, 60_000);

Step 2 — Take Three Heap Snapshots

Launch Node with inspection enabled:

node --inspect src/server.js

In Chrome DevTools (chrome://inspect) → Memory:

1. Take Snapshot A (after warm-up).
2. Wait 30 minutes under load → Take Snapshot B.
3. Wait another 30 minutes under load → Take Snapshot C.

Step 3 — Isolate Accumulated Objects

In Snapshot C, filter by "Objects allocated between Snapshot A and B". Sort by Retained Size.

Step 4 — Trace the Retainer Chain

Inspect the leaked object in the Retainers panel to identify which parent reference prevents Garbage Collection.

🧰 Tooling Reference

Still stuck? Describe your memory leak and I will estimate how long it would take to diagnose and fix.