CPU profiling basics in Node.js - Step-by-Step Execution

Concept Flow - CPU profiling basics

Start Node.js app

↓

Enable CPU profiler

↓

Run workload

↓

Collect CPU profile data

↓

Analyze profile

↓

Identify slow functions

↓

Optimize code

↓

Repeat profiling if needed

This flow shows how CPU profiling works: start the app, enable profiling, run code, collect data, analyze to find slow parts, then optimize.

Execution Sample

Node.js

import * as inspector from 'node:inspector';

const session = new inspector.Session();

inspector.open(9229);

await session.connect();

await session.post('Profiler.enable');
await session.post('Profiler.start');

// run code

const { profile } = await session.post('Profiler.stop');

console.log(profile);

This code starts the CPU profiler, runs some code, stops profiling, and logs the collected CPU profile data.

Execution Table

Step	Action	Profiler State	CPU Usage Data	Output
1	Start Node.js app	Profiler inactive	No data	App running
2	Enable CPU profiler	Profiler active	Collecting data	Profiler started
3	Run workload	Profiler active	Recording CPU samples	Workload executing
4	Stop CPU profiler	Profiler inactive	Final CPU profile collected	Profile data ready
5	Analyze profile	Profiler inactive	Profile data analyzed	Identified slow functions
6	Optimize code	Profiler inactive	No data change	Code improved
7	Repeat profiling if needed	Profiler active	New data collected	Cycle continues

💡 Profiling stops when profiler is disabled or app ends

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
profilerState	inactive	active	inactive	inactive	inactive
cpuProfileData	none	collecting	collected	analyzed	analyzed

Key Moments - 3 Insights

Why does the profilerState change from active to inactive after stopping?

Because stopping the profiler disables data collection, so profilerState changes to inactive as shown in execution_table step 4.

What does cpuProfileData contain after stopping the profiler?

It contains the full CPU usage profile collected during the workload, ready for analysis as shown in execution_table step 4.

Why do we need to repeat profiling after optimizing code?

To verify if the optimizations improved performance by collecting new CPU data, as shown in execution_table step 7.

Visual Quiz - 3 Questions

Look at the execution_table, what is the profilerState at Step 3?

A inactive

B active

C starting

D stopped

💡 Hint

Check the 'Profiler State' column at Step 3 in the execution_table.

At which step does the CPU profile data become fully collected?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'CPU Usage Data' column to find when data collection finishes.

If we skip Step 6 (Optimize code), what happens at Step 7?

A New profile data will still be collected

B Profiler will remain inactive

C No new data will be collected

D App will crash

💡 Hint

Step 7 shows profiler active and new data collected regardless of optimization.

Concept Snapshot

CPU Profiling Basics in Node.js:
- Start profiler before workload
- Run code to collect CPU samples
- Stop profiler to get profile data
- Analyze to find slow functions
- Optimize code and repeat profiling
Use node:inspector Profiler API for control.

Full Transcript

CPU profiling in Node.js involves starting the profiler before running your code, collecting CPU usage data during execution, then stopping the profiler to get the full profile. This profile shows which functions use the most CPU time. You analyze this data to find slow parts of your code. After optimizing those parts, you can profile again to check improvements. The profiler state changes from inactive to active when started, and back to inactive when stopped. CPU profile data is collected only while the profiler is active. This process helps improve app performance by focusing on real CPU usage.

Practice

1. What is the main purpose of CPU profiling in Node.js?

easy

A. To debug syntax errors in the code

B. To check the memory usage of the application

C. To monitor network requests

D. To find which parts of the code use the most CPU time

Solution

1. Step 1: Understand CPU profiling goal

   CPU profiling tracks where the CPU spends time during app execution.

2. Step 2: Compare options to profiling purpose

   Only To find which parts of the code use the most CPU time matches CPU time usage; others relate to memory, network, or syntax.

3. Final Answer:

   To find which parts of the code use the most CPU time -> Option D

4. Quick Check:

   CPU profiling = find CPU time hotspots [OK]

Hint: CPU profiling shows where CPU time is spent [OK]

Common Mistakes:

• Confusing CPU profiling with memory profiling
• Thinking it tracks network or syntax errors
• Assuming it shows all app performance issues

2. Which command correctly starts CPU profiling in Node.js?

easy

A. node --profile app.js

B. node --cpu-profile app.js

C. node --prof app.js

D. node --profile-cpu app.js

Solution

1. Step 1: Recall Node.js CPU profiling command

   The correct flag to start CPU profiling is --prof.

2. Step 2: Check each option's correctness

   Only node --prof app.js uses --prof, others are invalid flags.

3. Final Answer:

   node --prof app.js -> Option C

4. Quick Check:

   Use --prof to start CPU profiling [OK]

Hint: Use --prof flag to enable CPU profiling [OK]

Common Mistakes:

• Using incorrect flags like --profile or --cpu-profile
• Confusing profiling with debugging flags
• Omitting the --prof flag entirely

3. Given this command sequence:
node --prof app.js
Then running:
node --prof-process isolate-0x12345-v8.log
What is the output of --prof-process?

medium

A. The original JavaScript source code

B. A readable report showing CPU time spent in functions

C. A list of all files loaded by Node.js

D. An error message about missing files

Solution

1. Step 1: Understand purpose of --prof-process

   This command processes the raw CPU profile log into a readable report.

2. Step 2: Match output to options

   The output is a report showing CPU time spent per function, not source code or file lists.

3. Final Answer:

   A readable report showing CPU time spent in functions -> Option B

4. Quick Check:

   --prof-process = readable CPU time report [OK]

Hint: Use --prof-process to get readable CPU report [OK]

Common Mistakes:

• Expecting source code output from --prof-process
• Thinking it lists loaded files
• Confusing it with error output

4. You ran node --prof app.js but no log file was created. What is a likely cause?

medium

A. The app.js script exited too quickly before profiling started

B. You forgot to run node --prof-process first

C. You used --prof with an unsupported Node.js version

D. The log file is created only if you add --cpu-prof

Solution

1. Step 1: Understand profiling log creation

   The log file is created when the app runs with --prof and exits normally.

2. Step 2: Analyze why no log appears

   If the app exits too fast, profiling may not start or finish, so no log is saved.

3. Final Answer:

   The app.js script exited too quickly before profiling started -> Option A

4. Quick Check:

   App must run long enough to create profile log [OK]

Hint: App must run fully to generate profile log [OK]

Common Mistakes:

• Thinking --prof-process creates the log file
• Assuming --cpu-prof is required for logs
• Blaming Node.js version without checking

5. You want to find which function in your Node.js app uses the most CPU time. You run node --prof app.js and get a log file. What is the correct next step to analyze this data?

hard

A. Run node --prof-process on the log file to get a readable CPU profile report

B. Open the log file in a text editor and search for function names manually

C. Run node --inspect to debug the app instead

D. Restart the app without profiling to compare performance

Solution

1. Step 1: Understand how to analyze CPU profile logs

   The raw log file is not human-friendly; it needs processing.

2. Step 2: Use the correct tool for analysis

   Running node --prof-process on the log file converts it into a readable report showing CPU usage per function.

3. Final Answer:

   Run node --prof-process on the log file to get a readable CPU profile report -> Option A

4. Quick Check:

   Use --prof-process to analyze CPU profile logs [OK]

Hint: Process logs with --prof-process for readable CPU report [OK]

Common Mistakes:

• Trying to read raw logs manually
• Confusing profiling with debugging
• Restarting app without analyzing logs