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.