Why Does Your Node.js Service Leak Memory? A Deep Dive into V8 Generator Bugs and Fixes

Background

Developers often encounter Node.js services whose memory usage continuously rises after deployment, a classic sign of a memory leak that can degrade performance or cause crashes if left unchecked.

Why Memory Leaks Occur

In C, memory must be allocated with malloc and released with free, making manual management error‑prone. Node.js relies on V8’s automatic memory management, which allocates objects and runs a garbage collector (GC) to reclaim unused memory. However, developers may mistakenly assume that GC eliminates all leaks, leading to hidden memory growth.

Investigation

Heap Snapshot Comparison

Start the application and generate an initial heap snapshot (Snapshot A).

Execute operations that are suspected of causing leaks.

After memory growth, generate a second heap snapshot (Snapshot B).

Load both snapshots in Chrome DevTools and compare them to identify objects that continuously increase.

Example code used for the demonstration:

class Person { constructor(name) { this.name = name; } }
let persons = [];
function leak() { const bob = new Person('bob'); persons.push(bob); }
// Pseudo‑code to generate snapshots before and after calling leak()
genHeapSnapshot(); // Snapshot A
leak();
genHeapSnapshot(); // Snapshot B

Analysis of the snapshots shows that after leak() runs, a new Person object and its name string appear, confirming the leak source.

MAT (Memory Analyzer Tool)

MAT builds a dominator tree from a heap snapshot and flags objects whose retained size exceeds a configurable threshold (default 20% of total memory). The tool then reveals the dominator chain leading to the leaked objects.

class Person {}
let persons = [];
let women = [];
function leak() {
  const bob = new Person();
  const steve = new Person();
  const lily = new Person();
  persons.push(bob, steve, lily);
  women.push(lily);
}
leak();
genHeapSnapshot(); // Analyze with MAT

Common Leak Scenarios

Implicit global variables (e.g., forgetting var/let/const).

Unreleased listeners or caches that remain referenced.

Closures that capture variables indefinitely.

Useful Tools

heapdump

Generates heap snapshots via API or signal.

var heapdump = require('heapdump');
heapdump.writeSnapshot('/var/local/' + Date.now() + '.heapsnapshot');

v8-profiler

Creates CPU profiles, heap snapshots, and allocation profiles.

const v8Profiler = require('v8-profiler-next');
const title = 'my-profile';
v8Profiler.startProfiling(title, true);
setTimeout(() => {
  const profile = v8Profiler.stopProfiling(title);
  profile.export((err, result) => {
    require('fs').writeFileSync(`${title}.cpuprofile`, result);
    profile.delete();
  });
}, 5 * 60 * 1000);

Chrome Inspector

Run Node with --inspect to connect Chrome DevTools. node --inspect=0.0.0.0:9229 app.js Open chrome://inspect/ to debug, capture CPU profiles, and take heap snapshots.

Solution

The leak was traced to a V8 bug affecting versions 11.0.0‑12.15.x when generators are used (e.g., async/await compiled to generators). The problem can be solved by either removing generator usage or upgrading Node.js to version 12.16 or newer. After upgrading, memory consumption stabilizes and the leak disappears.

Conclusion

Even with automatic garbage collection, memory leaks can still arise in JavaScript runtimes. Developers should stay vigilant, understand common leak patterns, and employ snapshot comparison, MAT, or profiling tools to diagnose and fix leaks promptly.