Node.js requires proper tools for debugging and profiling.

Debugging and profiling are essential processes for finding and fixing errors, measuring and optimizing performance, and ensuring the quality and efficiency of your Node.js applications.

But there are many tools available for debugging and profiling Node.js applications, so how do you choose the best ones for your needs?

Well, that’s where this article comes in. Let’s look at the top 5 Node.js tools for debugging and profiling.

1. Node.js Built-in Debugger

Node.js Built-in Debugger is a simple and effective tool that comes with Node.js itself. You can use it to inspect your code, set breakpoints, and watch variables. To use it, you just need to run your Node.js application with the --inspect flag and connect to it with Chrome DevTools or the Node debugging client.

Pricing: The Node.js Built-in Debugger is free to use, as it is part of the Node.js platform. You can download Node.js from its official website.

To set up and use the Node.js Built-in Debugger, you can follow these steps:

Step 01

Create a Node.js app or use an existing one. For this example, I will use a simple app that prints “Hello, world!” and then throws an error. Save it as app.js in your project folder.

// app.js
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello, world!');
  throw new Error('Oops!');
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

Step 02

Open a terminal and navigate to your project folder. Then, run your app with the below command.

node --inspect app.js

This will start your app and enable the debugger. You should see a message like this in the terminal:

Debugger listening on ws://127.0.0.1:9229/uuid-here
For help, see: https://nodejs.org/en/docs/inspector
Hello, world!

Step 03

Open another terminal and run the command node inspect 127.0.0.1:9229/uuid-here, replacing the uuid-here part with the actual UUID from the previous message. This will connect to the debugger and pause the execution of your app. You should see a prompt like this:

< Debugger listening on ws://127.0.0.1:9229/uuid-here
< For help, see: https://nodejs.org/en/docs/inspector
connecting to 127.0.0.1:9229/uuid-here ... ok
break in app.js:1
> 1 console.log('Hello, world!');
  2
  3 throw new Error('Oops!');
debug>

Step 04

At the debug prompt, you can use various commands to control the execution of your app and inspect its state. You can use commands like n, c, s, o, repl, watch, list, setBreakpoint, etc. to control and inspect your app. Let’s use the n command to step to the next line. You should see the output of the console.log statement and the current line updated to the throw statement.

debug> n
Hello, world!
break in app.js:3
  1 console.log('Hello, world!');
  2
> 3 throw new Error('Oops!');
  4
debug>

Step 05

Next, let’s use the c command to continue the execution until the next breakpoint or the end of the app.

debug> c
break in internal/errors.js:259
 257     }
 258   }
>259   return ${prefix}${this.message} ;
 260 };
 261
Watchers:
  0: Error = function Error() { [native code] }

Step 06

Finally, use the quit command to exit the debugger.

debug> quit
< undefined

These are the basic steps to debug your Node.js app using the Node.js Built-in Debugger.

2. WebStorm

WebStorm is a powerful and versatile IDE for Node.js development, with a built-in debugger that supports Node.js core and popular frameworks. You can use it to debug your Node.js application with a graphical interface, edit code on the fly, and use various features like code completion, refactoring, testing, and more. You can download WebStorm from its official website.

Pricing: WebStorm has different pricing and licensing options. The current prices are as follows:

• For individuals: $69 for the first year, $55 for the second year, and $41 for the third year onwards.
• For organizations: $159 per user for the first year, $127 for the second year, and $95 for the third year onwards.
• For students and teachers: Free.
• For open-source projects: Free for qualified projects.

To set up and use WebStorm for debugging your Node.js app, you can follow these steps:

Step 01

Create or open a project with your app file. For this example, I will use a simple app that prints “Hello, world!” and then throws an error.

Step 02

Go to **Run | Edit Configurations** from the menu bar or click the **Edit Configurations** button on the toolbar. In the dialog that opens, click the **Add** button and select **Node.js** from the list. This will create a new Node.js run/debug configuration for your app.

Step 03

In the **Node.js** configuration dialog, set the name, interpreter, file, parameters, and environmentvariables for your app. Click OKto save the configuration and see it on the toolbar.

Step 04

Start debugging your app and use the debug toolbar and tabs to control and inspect your app. You can also evaluate expressions in the editor or the **Debug Console** tab by hovering over them or typing them.

3. Node.js Built-in Profiler

Node.js Built-in Profiler is a command-line tool included with Node.js that helps developers identify performance issues in their applications. It generates output in the form of a V8 log file that can be analyzed to gain insights into the functions called during the profiling session and their execution times

Pricing: Node.js Built-in Profiler is free to use, as it is part of the Node.js program.

To set up and use Node.js Built-in Profiler for profiling your Node.js app, you can follow these steps.

Step 01

Run your app with the --prof flag and the NODE_ENV=production variable. For example,

NODE_ENV=production node --prof app.js

This will start your app and generate a log file in the same folder, with a name like isolate-0x102801c00-v8.log.

Step 02

Put some load on your app by sending requests to it. You can use a tool like curl or ab (ApacheBench) to do this. For example,

curl -X GET "http://localhost:3000/"
ab -k -c 20 -n 250 "http://localhost:3000/"

This will send a GET request to your app using curl, and then send 250 concurrent requests using ab.

Step 03

Stop your app with Ctrl+C and process the log file with the --prof-process flag. For example,

node --prof-process isolate-0x102801c00-v8.log > profile.txt

This will create a profile.txt file in the same folder, with the processed data. This will show you something like this:

Statistical profiling result from isolate-0x102801c00-v8.log, (250 ticks, 0 unaccounted, 0 excluded).

[Shared libraries]:
   ticks  total  nonlib   name
      9    3.6%          /usr/lib/...
      2    0.8%          /usr/lib/...

4. Node Inspector

Node Inspector is a standalone debugger that provides a similar experience to Chrome DevTools. You can use it to debug and profile your Node.js application in a separate browser window, with features like real-time code editing, performance profiling, and more.

Pricing: Node Inspector is free to use, as it is an open-source and cross-platform software. You can install it using npm.

To set up and use Node Inspector for profiling your Node.js app, you can follow these steps:

Step 01

Install it globally with npm and start it with node-inspector command.

npm install -g node-inspector
node-inspector

This will launch Node Inspector and print a URL to access it in the browser. By default, it will be something like http://127.0.0.1:8080/?port=5858.

Step 02

Run your app with the --inspect flag and the same port number as Node Inspector.

node --inspect=5858 app.js

Open the Node Inspector URL in your browser and use the Profiles tab to record a CPU profile of your app.

Step 03

To profile your Node.js app, go to the Profiles tab and click the Start button. This will start recording a CPU profile of your app. Put some load on your app by sending requests to it. You can use a tool like curl or ab (ApacheBench) to do this.

curl -X GET "http://localhost:3000/"
ab -k -c 20 -n 250 "http://localhost:3000/"

Step 04

Stop the profiling by clicking the stop button and view the profile report to identify performance bottlenecks and hotspots in your code.

5. Visual Studio Code Debugger

Visual Studio Code Debugger is a feature-rich and user-friendly debugger that integrates with Visual Studio Code, a popular code editor. You can use it to debug your Node.js application with a graphical interface, edit code on the fly, and use various extensions.

Pricing: Visual Studio Code Debugger is free to use, as it is part of the Visual Studio Code editor, which is an open-source and cross-platform software.

To set up and use Visual Studio Code Debugger for debugging and profiling your Node.js app, you can follow these steps:

Step 01

Open Visual Studio Code and create a new project or open an existing one. For this example, I will use a simple Express app that prints “Hello, world!” and then throws an error. Save it in your project folder.

Go to the **Run and Debug** view by clicking the **Run and Debug** icon in the Activity Bar on the left side of Visual Studio Code. If running and debugging are not yet configured (no launch.json has been created), Visual Studio Code shows the Run start view.

Step 02

Click the **create a launch.json file** link in the Run Start view. Select **Node.js** as the environment. This will generate a launch.json file in the .vscode folder of your project, with some default settings. You can edit this file according to your needs. Here is an example of a launch.json file

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Launch Program",
      "skipFiles": ["<node_internals>/**"],
      "program": "${workspaceFolder}/app.js",
      // Enable profiling for this configuration
      "profile": true
    }
  ]
}

Step 03

Set a breakpoint in your code where you want to pause the execution. Then, start debugging your app and use the debug toolbar and tabs to control and inspect your app.

Step 04

End the debugging session and open the CPU profile file to see the performance of your app. For more information, see Debugging in Visual Studio Code.

Step 05

Visual Studio Code Debugger creates a CPU profile file in .vscode folder after debugging. The file shows a flame graph of the CPU usage of your app, with the functions and their times. You can use this information to identify performance bottlenecks and hotspots in your code. For more information, see Profiling Node.js apps here.

Wrapping Up

Debugging and profiling are essential for developing high-quality and high-performance Node.js applications.

Depending on your needs and preferences, you may find different tools more suitable and effective for your projects. Some of the factors you should consider when selecting a tool are its features, usability, and popularity.

By comparing and evaluating these factors, you can find the tool that meets your expectations and helps you troubleshoot and optimize your Node.js applications.