How to make Express 2x faster

[andrehrferreira]

Hello friends of the community, how are you?

First of all, I always like to make it clear that I simply love the Express project. I have been using it in my projects for over 8 years. Therefore, this post seeks to help improve the project even more. I recently opened an inquiry regarding the performance of Express compared to other HTTP server options available. The focus on the release of version 5 was mentioned first. I fully agree that there are several priority issues in the project. However, on my own initiative, I began to study the codes more deeply to try to understand what causes Express to have a lower performance than Fasfity or Koa, for example. So I started a reinterpretation by implementing the same Express functions in a new project. In my specific case, my focus is on integrating Vite functionalities into my HTTP server and creating other layers of abstraction such as decorators. However, using Express as a base, during the development of this project I realized that the biggest performance problem that Express faces is related to the use of 'Object.defineProperty', I'll explain why.

Both Koa and Fastify use an approach of creating a new Request and Response object, defining getters and applying the objects generated by HTTP and HTTP2 from nodejs as a 'raw', assigning them as a simple property, through the getters retrieving the necessary data such as headers, body, params and queries, Express assigns getters dynamically in both the request and response using the "defineGetter" function, I understand that the way it was done takes advantage of the entire structure of original properties and functions, but the processing cost to dynamically add these getters is very high, even using Reflect.defineProperty as an alternative there is still a delay that considerably reduces the amount of requests that Express can process per second.

To make it clearer, I'll leave a simple test comparing the two approaches:

For the test I am using my personal computer a Core i9 10980XE, with 256GB DDR4, Sansung NVME SSD, on Windows 10, using WLS from Ubuntu 22.04, Node in version 20.17.0, Autocannon in version 7.15.0

autocannon -w 8 -d 10 -c 1024 http://localhost:3000

Object Define Property

const http = require('http');

const server = http.createServer((req, res) => {
  
  Object.defineProperty(req, 'xhr', {
    configurable: true,
    enumerable: true,
    get: function () {
        var val = this.headers["X-Requested-With"] || '';
        return val.toLowerCase() === 'xmlhttprequest';
    }
  });
  
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ xhr: req.xhr }));
});

server.listen(3000, () => {
  console.log('Server with Object.defineProperty is running on http://localhost:3000');
});

Result:

Stat	1%	2.5%	50%	97.5%	Avg	Stdev	Min
Req/Sec	18,447	18,447	21,551	23,135	21,518.4	1,202.72	18,441
Bytes/Sec	3.43 MB	3.43 MB	4.01 MB	4.3 MB	4 MB	224 kB	3.43 MB

Object Create

const http = require('http');

const request = {
    get xhr() {
        var val = this.req.headers["X-Requested-With"] || '';
        return val.toLowerCase() === 'xmlhttprequest';
    }
}

const server = http.createServer((req, res) => {
    let obj = Object.create(request);
    obj.req = req;
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ xhr: obj.xhr }));
});

server.listen(3001, () => {
  console.log('Server with Object.create is running on http://localhost:3001');
});

Result:

Stat	1%	2.5%	50%	97.5%	Avg	Stdev	Min
Req/Sec	20,447	20,447	25,359	26,383	24,836.8	1,658.27	20,440
Bytes/Sec	3.8 MB	3.8 MB	4.72 MB	4.91 MB	4.62 MB	309 kB	3.8 MB

Note that in the examples above we are defining only 1 getter in the request, but this action occurs several times in both the request and the response, greatly reducing the number of requests per second that Express can serve. With this change, Express will have the same performance as Koa and Fastify. Basically, I know because I have already tested it by basically rewriting the request/response with the same functions currently present. I did not send a PR for the change because I was waiting for version 5 to be officially available to check if this point was changed. However, checking the version code I found that it is apparently the same as version 4.

I hope I have helped improve the project, and if you want my help to change the code I am available, see you later =)

[cesco69]

@andrehrferreira v5 is available https://www.npmjs.com/package/express/v/5.0.0

defineGetter still in version 5
https://github.com/expressjs/express/blob/5.0/lib/request.js#L509

[andrehrferreira]

@cesco69 Yes, I checked earlier before posting, I will wait for the project maintainers to respond to the post to see if I implement the resolution and send it to them or if they will make the change themselves.

[cesco69]

And also... While Object.defineProperty() provides flexibility, it adds overhead compared to directly setting properties on an object. Consider directly adding values to the request object instead of defining getters for every property, particularly if these values won't change during a request's lifecycle.

req.secure = req.protocol === 'https';

instead of

defineGetter(req, 'secure', function secure(){
  return this.protocol === 'https';
});

[tjdav]

Would it be beneficial to extend the res properties using the Object.create second argument?

https://github.com/expressjs/express/blob/344b022fc7ed95cf07b46e097935e61151fd585f/lib/request.js#L30

for example

var req = Object.create(http.IncomingMessage.prototype, {
  xhr: {
    configurable: true,
    enumerable: true,
    get () {
      var val = this.req.headers["X-Requested-With"] || '';
      return val.toLowerCase() === 'xmlhttprequest';
    }
  }
})

[nigrosimone]

Would it be beneficial to extend the res properties using the Object.create second argument?

https://github.com/expressjs/express/blob/344b022fc7ed95cf07b46e097935e61151fd585f/lib/request.js#L30

for example

var req = Object.create(http.IncomingMessage.prototype, {
  xhr: {
    configurable: true,
    enumerable: true,
    get () {
      var val = this.req.headers["X-Requested-With"] || '';
      return val.toLowerCase() === 'xmlhttprequest';
    }
  }
})

benchmark

defineGetter(req, 'xhr', function xhr(){
  var val = this.get('X-Requested-With') || '';
  return val.toLowerCase() === 'xmlhttprequest';
});

VS

req = Object.create(req, {
  xhr: {
    configurable: true,
    enumerable: true,
    get() {
      var val = this.req.headers["X-Requested-With"] || '';
      return val.toLowerCase() === 'xmlhttprequest';
    }
  }
});

RESULT
defineGetter: 950,260 ops/s
Object.create: 305,490 ops/s

defineGetter wins (3x FASTER)!

[andrehrferreira]

@tjdav From what I've seen, the problem is precisely extending based on the request that already has many parameters/functions. Object.create and Object.defineProperty probably perform some type of validation that ends up weighing down the process. That's why the alternative used by Koa and Fastify is to use req and res as a direct property and create getters by calling the property.

[nigrosimone]

@tjdav & @andrehrferreira

With Object.defineProperty the engine (Node/V8) has to handle the possibility of custom getters, setters, and property descriptors, which can prevent certain optimizations that would otherwise make property access faster.

For example, consider the difference between these two methods:

Direct assignment: 4,937,680 ops/s

const obj = {};
obj.prop = 42; 

Object.defineProperty: 1,191,010 ops/s

const obj = {};
Object.defineProperty(obj, 'prop', {
    value: 42,
    writable: true,
    enumerable: true,
    configurable: true
});

what I don't understand is why some functions have been assigned to the request with direct assignment (eg.: https://github.com/expressjs/express/blob/5.0/lib/request.js#L257) while others are with Object.defineProperty

see https://humanwhocodes.com/blog/2015/11/performance-implication-object-defineproperty/ and https://v8.dev/blog/fast-properties

Using direrect assignment make all a bit faster

[cesco69]

Hi, I have tried (in PR expressjs/express#6004) to extend the request

class Request extends http.IncomingMessage { 

}

ad set the getter without Object.defineProperty, eg.:

class Request extends http.IncomingMessage { 
  get query() {
    var queryparse = this.app.get('query parser fn');

    if (!queryparse) {
      // parsing is disabled
      return Object.create(null);
    }

    var querystring = parse(this).query;

    return queryparse(querystring);
  }
}

all 1227 tests passing

I'm on Windows and the express benchmark works only on linux. Can someone run this for me and show me if my PR improves performance?

[faulpeltz]

Run on Linux Mint 22, on a Ryzen 3900X, with Node 22.9.0
The default benchmark only runs for 3sec per run which gave very inconsistent results, this is with 30sec/run.
Compared versions:
left 3 columns: vanilla express from expressjs/express:master
right 2 columns: your patch commit 8e3c005

Unfortunately there were no significant changes:

Flame chart using flame with default settings and one 30sec run with 10 middleware, 100 conn

[andrehrferreira]

I'm testing my project using the same parameters and functions that exist in Express and the result is well balanced. I'll leave it here for reference. Obviously, it needs to be adapted to the reality of Express, which uses pure JavaScript.

https://github.com/andrehrferreira/cmmv-server/blob/main/packages/server/lib/request.ts

https://github.com/andrehrferreira/cmmv-server/blob/main/packages/server/lib/response.ts

It is not yet 100% implemented but preliminary results have been:

(index)	Framework	Reqs/s	Total Reqs	Transfer/s	Transfer Total	Latency
0	http	24635	246341	4.18 MB	41.82 MB	123 ms
1	fastify	23451	234531	3.58 MB	35.79 MB	110 ms
2	cmmv	21877	218783	3.34 MB	33.38 MB	116 ms
3	koa	21823	218223	3.64 MB	36.42 MB	111 ms
4	hapi	16244	162432	3.42 MB	34.23 MB	88 ms
5	express	6668	66677	1.51 MB	15.13 MB	83 ms

https://github.com/andrehrferreira/cmmv-server/blob/main/tools/benchmarks/benchmarks-allservers.js

[cesco69]

@andrehrferreira Wow! cmmv is really close to fastify!
@faulpeltz thanks!

[andrehrferreira]

@cesco69 I honestly want Express to solve the performance problem so I don't have to use my project, it's a lot of work, but since my focus is SEO and keeping the application's TTFB low, I need the request latency to be as low as possible.

[IamLizu]

Interesting, I was looking at router module the other day and I think using something smarter than a liner search approach for route matching might make it a little bit fast.

Maybe it could improve the benchmarks for requests handled per second but I am skeptical.

cc: @wesleytodd