Heap snapshot for memory leaks in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What does a heap snapshot primarily show in Node.js?

When you take a heap snapshot in Node.js, what is the main information it provides?

A The list of all running event loop callbacks

B The CPU usage statistics of the Node.js process

C A detailed view of memory allocations and object references at a point in time

D The network requests currently open by the application

💡 Hint

Think about what 'heap' means in programming memory terms.

A heap snapshot captures the memory allocations and how objects reference each other at a specific moment. It helps identify memory leaks by showing what is still in memory.

❓ component_behavior

intermediate

What happens when you compare two heap snapshots in Node.js?

You take two heap snapshots at different times during your Node.js app run. What useful information can you get by comparing them?

A You find the exact line of code causing a syntax error

B You get the CPU usage difference between the two times

C You get a list of all functions executed between the snapshots

D You can see which objects have increased in number or size, indicating possible leaks

💡 Hint

Think about what memory leaks look like over time.

Comparing heap snapshots shows growth in objects or retained memory, which helps identify leaks by highlighting what is not being freed.

🔧 Debug

advanced

Why does this heap snapshot show many detached DOM nodes in a Node.js app using jsdom?

You use jsdom in your Node.js app and take a heap snapshot. It shows many detached DOM nodes still in memory. What is the most likely cause?

A Event listeners or references to DOM nodes are not removed, preventing garbage collection

B Heap snapshots cannot capture DOM nodes, so this is a false positive

C The Node.js version does not support garbage collection

D The app is running out of CPU, causing memory to freeze

💡 Hint

Think about what keeps objects alive in memory.

If event listeners or variables still reference DOM nodes, they cannot be freed, causing detached nodes to accumulate in memory.

📝 Syntax

advanced

Which code snippet correctly triggers a heap snapshot in Node.js using the inspector module?

Choose the correct code to programmatically take a heap snapshot in Node.js.

Node.js

const inspector = require('inspector');
const session = new inspector.Session();
session.connect();
// Take heap snapshot here

A session.takeHeapSnapshot(() => { console.log('Snapshot taken'); });

B session.post('HeapProfiler.takeHeapSnapshot', null, (err, res) => { if (err) console.error(err); else console.log('Snapshot taken'); });

C inspector.takeHeapSnapshot(() => { console.log('Snapshot taken'); });

D session.post('Heap.takeSnapshot', () => { console.log('Snapshot taken'); });

💡 Hint

Check the exact method name and parameters for the inspector session.

The correct method is session.post with 'HeapProfiler.takeHeapSnapshot' as the command. Other options use wrong method names or calls.

❓ state_output

expert

What is the output of this Node.js heap snapshot analysis code snippet?

Given the following code snippet that analyzes a heap snapshot JSON, what will be the value of leakedObjectsCount?

Node.js

const snapshot = {
  nodes: [
    { id: 1, type: 'Object', retainedSize: 100 },
    { id: 2, type: 'Object', retainedSize: 0 },
    { id: 3, type: 'Object', retainedSize: 50 },
    { id: 4, type: 'String', retainedSize: 0 }
  ]
};

const leakedObjectsCount = snapshot.nodes.filter(n => n.type === 'Object' && n.retainedSize > 0).length;

A 2

B 3

C 1

D 4

💡 Hint

Count only objects with retainedSize greater than zero.

Only nodes with type 'Object' and retainedSize > 0 are counted. Nodes 1 and 3 meet this condition, so count is 2.

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