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.