Heap snapshot for memory leaks in Node.js - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a heap snapshot in Node.js?

A heap snapshot is a detailed record of the memory used by a Node.js application at a specific time. It shows all objects in memory and their relationships, helping to find memory leaks.

beginner

How do you take a heap snapshot using Chrome DevTools with Node.js?

You start your Node.js app with the --inspect flag, open Chrome DevTools, connect to the Node process, go to the Memory tab, and click 'Take heap snapshot'.

intermediate

Why are heap snapshots useful for finding memory leaks?

Heap snapshots show which objects stay in memory longer than expected. By comparing snapshots over time, you can spot objects that should be gone but are still kept, indicating leaks.

intermediate

What does the 'Retainers' view in a heap snapshot show?

The 'Retainers' view shows what other objects are keeping a selected object in memory. This helps find why an object is not being removed and causing a memory leak.

beginner

Name one common cause of memory leaks visible in heap snapshots.

One common cause is forgotten event listeners or timers that keep references to objects, preventing garbage collection.

What flag do you use to enable debugging for heap snapshots in Node.js?

A --memory-check

B --debug

C --inspect

D --heap-snapshot

The --inspect flag enables the Node.js process to be debugged and connected to Chrome DevTools for heap snapshots.

Which Chrome DevTools tab do you use to take a heap snapshot?

A Console

B Memory

C Sources

D Network

The Memory tab in Chrome DevTools is used to take heap snapshots and analyze memory usage.

What does a heap snapshot NOT show?

A Retainers of objects

B References between objects

C Objects in memory

D CPU usage

Heap snapshots focus on memory, not CPU usage.

If an object is still in memory but should be gone, what might this indicate?

A A memory leak

B Garbage collection is working fine

C The app is idle

D The object is a primitive type

Objects that stay in memory unexpectedly often indicate a memory leak.

What is a common cause of memory leaks visible in heap snapshots?

A Forgotten event listeners

B Unused variables

C Fast CPU speed

D Small heap size

Forgotten event listeners keep references alive, causing memory leaks.

Explain how to take and use a heap snapshot to find memory leaks in a Node.js app.

Think about the steps from starting the app to analyzing objects in memory.

Describe what information a heap snapshot provides and why it is helpful for debugging memory issues.

Focus on what you see in the snapshot and how it helps find leaks.

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