Common memory leak patterns in Node.js - Step-by-Step Execution

Concept Flow - Common memory leak patterns

Start Node.js App

↓

Allocate Memory

↓

Memory Leak Pattern?

No→Normal Memory Release

Yes↓

Memory Not Freed

↓

Memory Usage Grows

↓

App Performance Drops

↓

Detect & Fix Leak

↓

Memory Stabilizes

↓

End or Continue Monitoring

This flow shows how a Node.js app allocates memory, may encounter leaks, causing memory growth and performance issues, then detection and fixing stabilizes memory.

Execution Sample

Node.js

const cache = {};
function addToCache(key, value) {
  cache[key] = value; // memory grows
}
addToCache('item1', 'data');
// cache never cleared, leak occurs

This code adds items to a cache object without removing them, causing memory to grow and leak.

Execution Table

Step	Action	Memory State	Leak Pattern Detected	Effect
1	Start app	Memory low	No	Normal operation
2	Add item1 to cache	Memory increases	Yes - Unbounded cache growth	Memory usage grows
3	Add item2 to cache	Memory increases more	Yes	Memory usage grows
4	No cache cleanup	Memory keeps growing	Yes	Performance degrades
5	Detect leak with profiler	Memory high	Yes	Leak identified
6	Fix: clear cache periodically	Memory stabilizes	No	Performance improves
7	App runs normally	Memory stable	No	Normal operation

💡 Memory stabilizes after fixing leak by clearing cache

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 6	Final
cache size	0	1	2	2 (no cleanup)	0 (cleared)	0

Key Moments - 3 Insights

Why does memory keep growing even if we stop adding new items?

Because the cache object is never cleared or items removed, memory holds references preventing garbage collection, as shown in steps 3 and 4 in the execution_table.

How do we know a memory leak is happening?

By observing memory usage growing steadily without dropping, and profiler tools detecting uncollected objects, as in step 5 of the execution_table.

What fixes the memory leak in this example?

Clearing the cache periodically releases references, allowing garbage collection, stabilizing memory as shown in step 6.

Visual Quiz - 3 Questions

Look at the execution_table, what is the cache size after step 3?

A 2

B 1

C 0

D 3

💡 Hint

Check variable_tracker row for 'cache size' after Step 3

At which step does the memory leak get detected?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

Look at execution_table column 'Leak Pattern Detected' for detection step

If we never clear the cache, what happens to memory usage?

A Memory stabilizes

B Memory decreases

C Memory keeps growing

D Memory usage resets

💡 Hint

Refer to execution_table steps 3 and 4 showing memory growth without cleanup

Concept Snapshot

Common memory leaks in Node.js happen when objects like caches or event listeners keep references and never release them.
This causes memory to grow and app performance to drop.
Detect leaks using profilers and fix by releasing references or clearing caches.
Always monitor memory usage in long-running Node.js apps.

Full Transcript

This visual execution shows how a Node.js app can leak memory by adding items to a cache object without removing them. The memory usage grows step-by-step as items accumulate. Without cleanup, memory keeps increasing causing performance issues. Using a profiler detects the leak. Fixing it by clearing the cache stabilizes memory. Variables like cache size track growth and cleanup. Key moments explain why memory grows without cleanup, how leaks are detected, and how fixing references stops leaks. Quiz questions test understanding of memory state at different steps and effects of cleanup.

Practice

1. Which of the following is a common cause of memory leaks in Node.js applications?

easy

A. Keeping references to objects that are no longer needed

B. Using asynchronous functions

C. Writing synchronous code

D. Using the latest Node.js version

Solution

1. Step 1: Understand what causes memory leaks

   Memory leaks happen when your program holds onto data it no longer needs, preventing the system from freeing memory.

2. Step 2: Identify the correct cause among options

   Keeping references to unused objects prevents garbage collection, causing leaks. Other options do not inherently cause leaks.

3. Final Answer:

   Keeping references to objects that are no longer needed -> Option A

4. Quick Check:

   Memory leaks = unused references [OK]

Hint: Memory leaks happen when unused data is still referenced [OK]

Common Mistakes:

• Thinking async code always causes leaks
• Confusing synchronous code with leaks
• Assuming Node.js version causes leaks

2. Which syntax correctly removes an event listener in Node.js to help prevent memory leaks?

easy

A. emitter.deleteListener('event', callback);

B. emitter.off('event');

C. emitter.remove('event', callback);

D. emitter.removeListener('event', callback);

Solution

1. Step 1: Recall Node.js event listener removal syntax

   The correct method to remove a specific listener is removeListener(event, callback).

2. Step 2: Check each option's validity

   emitter.removeListener('event', callback); uses the correct method. emitter.off('event'); removes all listeners but omits the specific callback. Options A and C are not valid methods.

3. Final Answer:

   emitter.removeListener('event', callback); -> Option D

4. Quick Check:

   Correct method = removeListener(event, callback) [OK]

Hint: Use removeListener with event and callback to remove listeners [OK]

Common Mistakes:

• Using emitter.off without callback
• Using non-existent methods like remove or deleteListener
• Omitting the callback function

3. Consider this code snippet:

const cache = {};
function addToCache(key, value) {
  cache[key] = value;
}
addToCache('user1', {name: 'Alice'});
addToCache('user2', {name: 'Bob'});
console.log(Object.keys(cache).length);

What will be the output and what memory issue might this cause if keys are never removed?

medium

A. 0; No memory leak because cache is empty

B. 2; Memory leak due to unbounded cache growth

C. Error; Syntax error in code

D. Undefined; cache is not defined

Solution

1. Step 1: Analyze the code output

   The cache object stores two keys: 'user1' and 'user2'. Object.keys(cache).length returns 2.

2. Step 2: Identify memory issue

   Since keys are never removed, cache grows indefinitely, causing a memory leak.

3. Final Answer:

   2; Memory leak due to unbounded cache growth -> Option B

4. Quick Check:

   Cache size = 2, leak if keys never removed [OK]

Hint: Uncleared caches cause leaks; count keys to check size [OK]

Common Mistakes:

• Thinking cache is empty initially
• Assuming syntax error without checking code
• Confusing undefined with empty object

4. You have this code causing a memory leak:

const listeners = [];
function addListener(emitter, callback) {
  emitter.on('data', callback);
  listeners.push({emitter, callback});
}
// Later you forget to remove listeners

What is the best fix to prevent the leak?

medium

A. Remove listeners with emitter.removeListener and clear the listeners array

B. Do nothing; Node.js cleans up automatically

C. Replace emitter.on with emitter.once

D. Use global variables instead of arrays

Solution

1. Step 1: Identify cause of leak

   Listeners are added and stored in an array but never removed, causing memory to stay used.

2. Step 2: Apply fix to remove listeners and clear references

   Use emitter.removeListener with stored callbacks and clear the listeners array to free memory.

3. Final Answer:

   Remove listeners with emitter.removeListener and clear the listeners array -> Option A

4. Quick Check:

   Remove listeners + clear refs = fix leak [OK]

Hint: Always remove event listeners and clear stored references [OK]

Common Mistakes:

• Assuming Node.js auto-cleans listeners
• Using emitter.once without removing listeners
• Using global variables increases leaks

5. You have a Node.js app caching user sessions in a global object. Over time, memory usage grows unexpectedly. Which combined approach best prevents this memory leak?

hard

A. Use global variables for caching without cleanup

B. Store all sessions indefinitely to avoid losing data

C. Implement session expiration and remove expired sessions from cache regularly

D. Avoid using any caching to prevent leaks

Solution

1. Step 1: Understand the problem with indefinite caching

   Storing sessions forever causes the cache to grow without limit, leading to memory leaks.

2. Step 2: Apply session expiration and cleanup

   Removing expired sessions regularly frees memory and prevents leaks while keeping useful data.

3. Final Answer:

   Implement session expiration and remove expired sessions from cache regularly -> Option C

4. Quick Check:

   Expire and clean cache to prevent leaks [OK]

Hint: Expire and clear cached data regularly to avoid leaks [OK]

Common Mistakes:

• Keeping all data forever causes leaks
• Avoiding caching is not practical
• Using globals without cleanup worsens leaks