Common memory leak patterns in Node.js - Performance & Optimization

Performance: Common memory leak patterns

HIGH IMPACT

This affects the server's memory usage over time, leading to slower response times and potential crashes.

Managing event listeners in a Node.js server

Node.js

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

function onRequest(data) {
  console.log('Request received:', data);
}

// Add listener once outside request handler
emitter.on('request', onRequest);

function handleRequest(data) {
  emitter.emit('request', data);
}

handleRequest('data1');
handleRequest('data2');

Listener is added once, preventing buildup and reducing memory usage.

📈 Performance GainMemory remains stable regardless of number of requests.

Managing event listeners in a Node.js server

Node.js

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

function onRequest(data) {
  console.log('Request received:', data);
}

// Adding listener on every request without removing
function handleRequest(data) {
  emitter.on('request', onRequest);
  emitter.emit('request', data);
}

// Simulate multiple requests
handleRequest('data1');
handleRequest('data2');

Listeners accumulate on the emitter without removal, causing memory to grow indefinitely.

📉 Performance CostMemory usage grows linearly with requests, leading to high memory consumption and possible crashes.

Performance Comparison

Pattern	Memory Usage	Garbage Collection	Server Responsiveness	Verdict
Adding event listeners repeatedly	Grows with requests	Increases GC frequency	Degrades over time	[X] Bad
Adding event listener once	Stable	Minimal GC impact	Consistent	[OK] Good
Unbounded global cache	Grows indefinitely	High GC overhead	Slows server	[X] Bad
Limited cache size	Stable	Low GC overhead	Stable performance	[OK] Good
Closure capturing large objects	High memory retained	GC delayed	Slower event loop	[X] Bad
Avoid closure capture	Memory freed quickly	Efficient GC	Responsive server	[OK] Good

Rendering Pipeline

Memory leaks in Node.js do not affect browser rendering but impact server responsiveness and stability by increasing memory pressure and garbage collection time.

→Memory Allocation

→Garbage Collection

→Event Loop Responsiveness

⚠️ BottleneckGarbage Collection slows down due to retained unused objects.

Optimization Tips

1Remove event listeners when no longer needed to prevent buildup.

2Limit cache sizes to avoid unbounded memory growth.

3Avoid capturing large objects in closures to allow garbage collection.

Performance Quiz - 3 Questions

What is a common cause of memory leaks related to event listeners in Node.js?

A Using global variables for configuration

B Using asynchronous functions

C Adding event listeners repeatedly without removing them

D Writing synchronous code

DevTools: Node.js --inspect with Chrome DevTools (Memory panel)

How to check: 1. Run Node.js with --inspect flag. 2. Open Chrome and navigate to chrome://inspect. 3. Connect to your Node.js process. 4. Use the Memory tab to take heap snapshots before and after operations. 5. Compare snapshots to find retained objects and leaks.

What to look for: Look for objects that grow in number or size over time without being released, indicating memory leaks.