Heap snapshot for memory leaks in Node.js - Mini Project: Build & Apply

Heap Snapshot for Memory Leaks in Node.js

📖 Scenario: You are working on a Node.js server application that sometimes uses too much memory. You want to find out if there are memory leaks by taking a heap snapshot. This helps you see what objects stay in memory longer than they should.

🎯 Goal: Build a simple Node.js script that creates a heap snapshot file to analyze memory usage and detect leaks.

📋 What You'll Learn

Create a Node.js script that imports the inspector module

Start a new inspector session

Take a heap snapshot and save it to a file named heap.heapsnapshot

Close the inspector session after the snapshot is saved

💡 Why This Matters

🌍 Real World

Heap snapshots help developers find memory leaks by showing what objects remain in memory. This is useful for improving app performance and stability.

💼 Career

Understanding how to capture and analyze heap snapshots is valuable for Node.js backend developers and performance engineers to diagnose memory issues.

1

Import the inspector module and start a session

Write code to import the inspector module and create a new inspector.Session() instance called session. Then call session.connect() to start the session.

Node.js

// Import inspector and start a session
// Your code here

Hint

Use require('inspector') to import the module. Then create a session with new inspector.Session() and connect it.

2

Create a writable stream for the heap snapshot file

Add code to import the fs module and create a writable stream called writeStream that writes to a file named heap.heapsnapshot.

Node.js

const inspector = require('inspector');
const session = new inspector.Session();
session.connect();

// Import fs and create writeStream for 'heap.heapsnapshot'
// Your code here

Hint

Use require('fs') to import the file system module. Then use fs.createWriteStream('heap.heapsnapshot') to create the stream.

3

Take the heap snapshot and pipe data to the file

Use session.on('HeapProfiler.addHeapSnapshotChunk') to listen for snapshot data chunks. In the callback, write each chunk to writeStream. Then call session.post('HeapProfiler.takeHeapSnapshot') to start the snapshot.

Node.js

const inspector = require('inspector');
const session = new inspector.Session();
session.connect();

const fs = require('fs');
const writeStream = fs.createWriteStream('heap.heapsnapshot');

// Listen for snapshot chunks and write to file
// Start taking heap snapshot
// Your code here

Hint

Listen for 'HeapProfiler.addHeapSnapshotChunk' events and write each chunk to the file. Then call session.post('HeapProfiler.takeHeapSnapshot') to start.

4

Close the write stream and disconnect session after snapshot

Add a listener for 'HeapProfiler.reportHeapSnapshotProgress' event. When done === true, close writeStream and call session.disconnect() to end the session.

Node.js

const inspector = require('inspector');
const session = new inspector.Session();
session.connect();

const fs = require('fs');
const writeStream = fs.createWriteStream('heap.heapsnapshot');

session.on('HeapProfiler.addHeapSnapshotChunk', (m) => {
  writeStream.write(m.params.chunk);
});

session.post('HeapProfiler.takeHeapSnapshot');

// Close stream and disconnect session when snapshot is done
// Your code here

Hint

Use the 'HeapProfiler.reportHeapSnapshotProgress' event to detect when the snapshot is done. Then close the file and disconnect the session.

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