Heap snapshot for memory leaks in Node.js - Step-by-Step Execution

Concept Flow - Heap snapshot for memory leaks

Start Node.js app

↓

Trigger memory usage

↓

Take heap snapshot

↓

Analyze snapshot

↓

Identify retained objects

↓

Find memory leaks

↓

Fix leaks and retest

Shows the steps to capture and analyze a heap snapshot to find memory leaks in a Node.js app.

Execution Sample

Node.js

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

const snapshotStream = v8.getHeapSnapshot();
snapshotStream.pipe(fs.createWriteStream('heap.heapsnapshot'));

This code takes a heap snapshot and saves it to a file for later analysis.

Execution Table

Step	Action	Memory State	Snapshot File	Result
1	Start Node.js app	Memory usage normal	No	App running
2	Allocate objects	Memory usage increases	No	Objects created
3	Take heap snapshot	Memory usage frozen at point	heap.heapsnapshot created	Snapshot saved
4	Analyze snapshot	Memory usage unchanged	heap.heapsnapshot read	Objects and retainers listed
5	Identify retained objects	Memory usage unchanged	heap.heapsnapshot analyzed	Potential leaks found
6	Fix leaks	Memory usage decreases	No	Leaks fixed
7	Retake snapshot	Memory usage stable	New snapshot created	No leaks detected
8	End	Memory usage stable	No	Process ends

💡 Process ends after confirming no memory leaks remain.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 6	Final
memoryUsage	Low	High (objects allocated)	Frozen (snapshot taken)	Lower (leaks fixed)	Stable
snapshotFile	None	None	heap.heapsnapshot	None	None
leaksFound	No	No	Yes	No	No

Key Moments - 3 Insights

Why does memory usage freeze when taking a heap snapshot?

Because the snapshot captures the exact memory state at that moment, freezing it for analysis as shown in execution_table step 3.

How do we know if a memory leak exists from the snapshot?

By analyzing retained objects that should have been freed but are still referenced, as shown in execution_table step 5.

Why retake the snapshot after fixing leaks?

To confirm that memory usage is stable and leaks are gone, as shown in execution_table step 7.

Visual Quiz - 3 Questions

Look at the execution table, at which step is the heap snapshot file created?

A Step 5

B Step 2

C Step 3

D Step 7

💡 Hint

Check the 'Snapshot File' column in the execution_table rows.

According to variable_tracker, what happens to memoryUsage after fixing leaks?

A It stays high

B It decreases

C It increases

D It becomes unstable

💡 Hint

Look at the 'memoryUsage' row values after Step 6 in variable_tracker.

If no leaks are found, which variable in variable_tracker remains 'No' throughout?

A leaksFound

B memoryUsage

C snapshotFile

D None

💡 Hint

Check the 'leaksFound' row in variable_tracker for its values.

Concept Snapshot

Heap snapshot captures the exact memory state of a Node.js app.
Use v8.getHeapSnapshot() to create a snapshot stream.
Save snapshot to a file for offline analysis.
Analyze retained objects to find memory leaks.
Fix leaks and retake snapshots to confirm fixes.

Full Transcript

Heap snapshots help find memory leaks in Node.js apps by capturing memory state at a moment. The process starts by running the app and allocating objects. Then, a heap snapshot is taken using v8.getHeapSnapshot(), saving memory data to a file. This snapshot freezes memory usage for detailed analysis. Developers analyze the snapshot to find objects still retained in memory that should be freed, indicating leaks. After fixing leaks, another snapshot is taken to confirm memory stability. Variables like memoryUsage and leaksFound track the process. This method helps keep Node.js apps efficient and leak-free.

Practice

1. What is the main purpose of taking a heap snapshot in Node.js?

easy

A. To monitor network requests

B. To speed up the execution of code

C. To compile the Node.js application

D. To see what objects are currently in memory

Solution

1. Step 1: Understand heap snapshot concept

   A heap snapshot captures the objects currently stored in memory at a specific time.

2. Step 2: Identify the purpose of heap snapshots

   They help detect memory leaks by showing which objects remain in memory longer than expected.

3. Final Answer:

   To see what objects are currently in memory -> Option D

4. Quick Check:

   Heap snapshot = current memory objects [OK]

Hint: Heap snapshots show memory objects at a moment [OK]

Common Mistakes:

• Thinking heap snapshots speed up code
• Confusing heap snapshots with network monitoring
• Assuming heap snapshots compile code

2. Which Node.js module provides the getHeapSnapshot() method to create heap snapshots?

easy

A. fs

B. v8

C. http

D. os

Solution

1. Step 1: Recall Node.js modules for memory tools

   The v8 module provides access to V8 engine features including heap snapshots.

2. Step 2: Match method to module

   The getHeapSnapshot() method is part of the v8 module, not fs, http, or os.

3. Final Answer:

   v8 -> Option B

4. Quick Check:

   Heap snapshot method = v8 module [OK]

Hint: Heap snapshot method is in v8 module [OK]

Common Mistakes:

• Choosing fs for file operations only
• Confusing http with memory tools
• Selecting os which handles system info

3. Consider this Node.js code snippet:

import { writeFileSync } from 'fs';
import { getHeapSnapshot } from 'v8';

const snapshotStream = getHeapSnapshot();
const chunks = [];
snapshotStream.on('data', chunk => chunks.push(chunk));
snapshotStream.on('end', () => {
  writeFileSync('heap.heapsnapshot', Buffer.concat(chunks));
  console.log('Snapshot saved');
});

What will this code do when run?

medium

A. Create an empty file named 'heap.heapsnapshot' only

B. Throw an error because getHeapSnapshot is not a function

C. Save a heap snapshot file and print 'Snapshot saved'

D. Print 'Snapshot saved' without creating any file

Solution

1. Step 1: Analyze getHeapSnapshot usage

   The getHeapSnapshot() returns a readable stream of the heap snapshot data.

2. Step 2: Understand stream data handling

   The code collects data chunks from the stream, concatenates them, and writes to 'heap.heapsnapshot'. Then it logs confirmation.

3. Final Answer:

   Save a heap snapshot file and print 'Snapshot saved' -> Option C

4. Quick Check:

   Heap snapshot stream saved to file [OK]

Hint: getHeapSnapshot returns stream; collect and save it [OK]

Common Mistakes:

• Assuming getHeapSnapshot returns a buffer directly
• Expecting no file creation
• Thinking it throws an error

4. You wrote this code to save a heap snapshot but it never finishes and the file is empty:

import { writeFileSync } from 'fs';
import { getHeapSnapshot } from 'v8';

const snapshotStream = getHeapSnapshot();
snapshotStream.on('data', chunk => {
  writeFileSync('heap.heapsnapshot', chunk);
});
console.log('Snapshot saved');

What is the main problem?

medium

A. writeFileSync overwrites file on each data event, so file ends empty

B. getHeapSnapshot does not return a stream

C. Missing 'end' event handler to finalize file writing

D. writeFileSync cannot write buffers

Solution

1. Step 1: Examine file writing inside 'data' event

   Calling writeFileSync inside 'data' overwrites the file each time a chunk arrives.

2. Step 2: Understand effect on file content

   Because of overwriting, only the last chunk remains, or file may appear empty if last chunk is empty.

3. Final Answer:

   writeFileSync overwrites file on each data event, so file ends empty -> Option A

4. Quick Check:

   File overwritten repeatedly in data event [OK]

Hint: Write all chunks after stream ends, not during data event [OK]

Common Mistakes:

• Assuming getHeapSnapshot is not a stream
• Ignoring need for 'end' event
• Thinking writeFileSync can't write buffers

5. You want to detect a memory leak in your Node.js app by comparing heap snapshots over time. Which approach is best?

hard

A. Take multiple heap snapshots at intervals and compare retained objects

B. Only take one snapshot at app start and analyze it

C. Use console.log to print all objects in memory continuously

D. Restart the app frequently to clear memory

Solution

1. Step 1: Understand memory leak detection

   Memory leaks show as objects that remain in memory longer than expected, growing over time.

2. Step 2: Use heap snapshots over time

   Taking snapshots at intervals lets you compare and find objects that accumulate, indicating leaks.

3. Step 3: Evaluate other options

   One snapshot can't show growth; console.log is impractical; restarting hides leaks instead of detecting.

4. Final Answer:

   Take multiple heap snapshots at intervals and compare retained objects -> Option A

5. Quick Check:

   Compare snapshots over time to find leaks [OK]

Hint: Compare snapshots over time to spot leaks [OK]

Common Mistakes:

• Relying on a single snapshot
• Using console.log for memory objects
• Restarting app to avoid leaks instead of fixing