CPU profiling basics in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What does CPU profiling in Node.js primarily measure?

CPU profiling helps developers understand what aspect of their Node.js application?

A The number of network requests made by the application

B The amount of memory used by variables during execution

C The size of the application bundle after build

D The time spent executing JavaScript functions on the CPU

💡 Hint

Think about what 'CPU' relates to in a computer.

CPU profiling tracks how much time the processor spends running each function in your code. It helps find slow parts.

❓ component_behavior

intermediate

What output will this Node.js CPU profiling code produce?

Consider this code snippet that uses the built-in profiler API. What will be the main content of the output file?

Node.js

import { writeFileSync } from 'node:fs';
import { performance } from 'node:perf_hooks';

const start = performance.now();

function busyLoop() {
  let sum = 0;
  for (let i = 0; i < 1e7; i++) {
    sum += i;
  }
  return sum;
}

const result = busyLoop();
const end = performance.now();

writeFileSync('profile.cpuprofile', JSON.stringify({ start, end, result }));

A An empty file because no profiling was started

B A JSON file containing start time, end time, and the sum result from busyLoop

C A text file listing all functions called during execution with timestamps

D A binary file with CPU usage statistics for each function call

💡 Hint

Look at what is being written to the file.

This code writes a JSON object with timing and result data, not a CPU profile trace.

📝 Syntax

advanced

Which option correctly starts and stops CPU profiling using Node.js inspector module?

Choose the code snippet that properly starts CPU profiling, runs a function, then stops profiling and saves the data.

A

import inspector from 'node:inspector';
const session = new inspector.Session();
session.connect();
session.post('Profiler.start');
// run code
session.post('Profiler.stop', (err, { profile }) => {
  console.log(profile);
  session.disconnect();
});

B

import inspector from 'node:inspector';
const session = new inspector.Session();
session.post('Profiler.start');
session.connect();
// run code
session.post('Profiler.stop', (err, { profile }) => {
  console.log(profile);
  session.disconnect();
});

C

import inspector from 'node:inspector';
const session = new inspector.Session();
session.connect();
// run code
session.post('Profiler.start');
session.post('Profiler.stop', (err, { profile }) => {
  console.log(profile);
  session.disconnect();
});

D

import inspector from 'node:inspector';
const session = new inspector.Session();
session.connect();
session.post('Profiler.stop');
// run code
session.post('Profiler.start', (err, { profile }) => {
  console.log(profile);
  session.disconnect();
});

💡 Hint

Remember to connect the session before starting profiling.

You must connect the inspector session before calling Profiler.start. Then after running code, call Profiler.stop to get the profile.

🔧 Debug

advanced

Why does this CPU profiling code fail to capture any profile data?

Given this code snippet, why is the CPU profile empty after running?

Node.js

import inspector from 'node:inspector';
const session = new inspector.Session();
session.connect();
session.post('Profiler.start');
// no code executed here
session.post('Profiler.stop', (err, { profile }) => {
  console.log(profile);
  session.disconnect();
});

A Because Profiler.stop callback is missing error handling, causing silent failure

B Because session.connect() was called too early, it should be after Profiler.start

C Because no CPU-intensive code ran between start and stop, profile is empty

D Because the inspector module does not support CPU profiling in Node.js

💡 Hint

Think about what profiling measures and what code runs between start and stop.

Profiling captures CPU usage during the time between start and stop. If no code runs, profile is empty.

❓ state_output

expert

What is the value of 'profile.nodes.length' after this profiling session?

This code profiles a function that calls two other functions. How many nodes will the profile contain?

Node.js

import inspector from 'node:inspector';
const session = new inspector.Session();
session.connect();

function a() { for(let i=0; i<1000; i++) {} }
function b() { for(let i=0; i<500; i++) {} }
function main() { a(); b(); }

(async () => {
  await new Promise(resolve => {
    session.post('Profiler.start', () => {
      main();
      session.post('Profiler.stop', (err, { profile }) => {
        console.log(profile.nodes.length);
        session.disconnect();
        resolve();
      });
    });
  });
})();

A 4

B 3

C 2

D 1

💡 Hint

Each function call creates a node plus the root node.

The profile includes nodes for the root, main, a, and b functions, totaling 4 nodes.