Let's create a folder called hello-server, initialize a package.json, and install Express and Jade:

$ mkdir hello-server
$ cd hello-server
$ npm init -y
$ npm install --save express jade  

Now we'll create our server.js file:

const express = require('express')
const path = require('path')
const app = express()

app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

app.get('/hello', (req, res) => {
  res.render('hello', { title: 'Express' });
})

app.listen(3000)

Next, we'll create the views folder:

$ mkdir views  

Now we create a file in views/hello.jade, with the following content:

doctype html
 html
   head
     title= title
     link(rel='stylesheet', href='/stylesheets/style.css')
   body
     h1= title

OK, now we're ready to profile the server and generate a flamegraph.

Instead of starting our server with the node binary, we use the globally installed 0x executable.

We start our server with the following command:

$ 0x server.js 

Now we can use the autocannon benchmarking tool to generate some server activity.

In another terminal window we use autocannon to generate load:

$ autocannon -c 100 http://localhost:3000/hello
 Running 10s test @ http://localhost:3000/hello
 100 connections with 1 pipelining factor

 Stat         Avg      Stdev    Max
 Latency (ms) 259.62   122.24   1267
 Req/Sec      380.37   104.36   448
 Bytes/Sec    131.4 kB 35.84 kB 155.65 kB

 40k requests in 10s, 1.45 MB read

When the benchmark finishes, we hit Ctrl + C in the server terminal. This will cause 0x to begin converting captured stacks into a flamegraph.

When the flamegraph has been generated a long URL will be printed to the terminal:

$ 0x server.js
file://path/to/profile-86501/flamegraph.html

The 0x tool has created a folder named profile-XXXX, where XXXX is the PID of the server process.

If we open the flamegraph.html file with Google Chrome we'll be presented with some controls, and a flamegraph resembling the following:

Functions that may be bottlenecks are displayed in darker shades of orange and red.

Hot spots at the bottom of the chart are usually less relevant to application and module developers, since they tend to relate to the inner workings of Node core. So if we ignore those, we can see that most of the hot areas appear within the two macro flames in the middle of the chart. A quick study of these show that many of the same functions appear within each--which means overall both stacks represent very similar logical paths.

The right-hand stack has a cluster of hot stacks some way up the main stack in the horizontal center of other diverging stacks.

Let's click near the illustrated frame (or the equivalent identified stack if our current flamegraph is slightly different). Upon clicking the frame, 0x allows us to delve deeper by unfolding the parent and child stacks to fill the screen, like so:

We should be able to see a pattern of darker orange stack frames, in each case the function is the same function appearing on line 48 of a walk.js file in one of our sub-dependencies.

We have located our bottleneck!