http: cut per-request work on the server hot path

Avoid building req.headers for Host, Expect, and body-header
checks by scanning rawHeaders without allocating lowercased
names. Cache status lines, the Date header, and Keep-Alive
header pairs. Reuse the connection's pending-data and finish
listeners instead of binding fresh functions per request.

Intern HTTP header names in the parser so repeated tokens
such as Host and Connection share one V8 string.

Signed-off-by: Yagiz Nizipli <yagiz@nizipli.com>
Assisted-by: a closed-source coding agent

Author: anonrig

lib/_http_incoming.js

@@ -63,16 +63,15 @@ function IncomingMessage(socket) {
     return deprecateInstantiation(IncomingMessage, 'DEP0195', socket);
   }
 
-  let streamOptions;
+  Readable.call(this);
 
   if (socket) {
-    streamOptions = {
-      highWaterMark: socket.readableHighWaterMark,
-    };
+    const hwm = socket.readableHighWaterMark;
+    if (this._readableState.highWaterMark !== hwm) {
+      this._readableState.highWaterMark = hwm;
+    }
   }
 
-  Readable.call(this, streamOptions);
-
   this._readableState.readingMore = true;
 
   this.socket = socket;
@@ -530,6 +529,70 @@ IncomingMessage.prototype._dump = function _dump() {
   }
 };
 
+// Case-insensitive ASCII compare against an already-lowercased name.
+// Avoids allocating a lowercased copy of every header name.
+function asciiEqualIgnoreCase(a, lower) {
+  const len = lower.length;
+  if (a.length !== len)
+    return false;
+  if (a === lower)
+    return true;
+  for (let i = 0; i < len; i++) {
+    let c = a.charCodeAt(i);
+    if (c >= 65 && c <= 90)
+      c += 32;
+    if (c !== lower.charCodeAt(i))
+      return false;
+  }
+  return true;
+}
+
+function hasRawHeader(msg, lowerName) {
+  const rawHeaders = msg.rawHeaders;
+  const count = msg[kHeadersCount];
+  for (let i = 0; i < count; i += 2) {
+    if (asciiEqualIgnoreCase(rawHeaders[i], lowerName))
+      return true;
+  }
+  return false;
+}
+
+function getRawHeader(msg, lowerName, joinDuplicates) {
+  const rawHeaders = msg.rawHeaders;
+  const count = msg[kHeadersCount];
+  let result;
+  for (let i = 0; i < count; i += 2) {
+    if (!asciiEqualIgnoreCase(rawHeaders[i], lowerName))
+      continue;
+    const value = rawHeaders[i + 1];
+    if (result === undefined) {
+      result = value;
+      if (!joinDuplicates)
+        return result;
+    } else {
+      result += ', ' + value;
+    }
+  }
+  return result;
+}
+
+function hasBodyHeaders(msg) {
+  const rawHeaders = msg.rawHeaders;
+  const count = msg[kHeadersCount];
+  for (let i = 0; i < count; i += 2) {
+    const key = rawHeaders[i];
+    const length = key.length;
+    if (length === 14) {
+      if (asciiEqualIgnoreCase(key, 'content-length'))
+        return true;
+    } else if (length === 17) {
+      if (asciiEqualIgnoreCase(key, 'transfer-encoding'))
+        return true;
+    }
+  }
+  return false;
+}
+
 function onError(self, error, cb) {
   // This is to keep backward compatible behavior.
   // An error is emitted only if there are listeners attached to the event.
@@ -543,6 +606,9 @@ function onError(self, error, cb) {
 module.exports = {
   IncomingMessage,
   kDetachAbortSignal,
+  hasRawHeader,
+  getRawHeader,
+  hasBodyHeaders,
   readStart,
   readStop,
 };

lib/_http_outgoing.js

@@ -38,7 +38,7 @@ const { getDefaultHighWaterMark } = require('internal/streams/state');
 const assert = require('internal/assert');
 const EE = require('events');
 const Stream = require('stream');
-const { kOutHeaders, utcDate, kNeedDrain } = require('internal/http');
+const { kOutHeaders, utcDateHeader, kNeedDrain } = require('internal/http');
 const { Buffer } = require('buffer');
 const {
   _checkIsHttpToken: checkIsHttpToken,
@@ -89,6 +89,11 @@ const kChunkedLength = Symbol('kChunkedLength');
 const kUniqueHeaders = Symbol('kUniqueHeaders');
 const kBytesWritten = Symbol('kBytesWritten');
 const kErrored = Symbol('errored');
+const kLenientCache = Symbol('kLenientCache');
+
+let keepAliveTimeoutCache = -1;
+let keepAliveMaxCache = -1;
+let keepAliveHeaderCache = '';
 const kWritableFinished = Symbol('kWritableFinished');
 const kEndCallbacks = Symbol('kEndCallbacks');
 const kFlushError = Symbol('kFlushError');
@@ -169,6 +174,7 @@ function OutgoingMessage(options) {
   this[kFlushError] = null;
   this[kHighWaterMark] = options?.highWaterMark ?? getDefaultHighWaterMark();
   this[kRejectNonStandardBodyWrites] = options?.rejectNonStandardBodyWrites ?? false;
+  this[kLenientCache] = null;
 }
 ObjectSetPrototypeOf(OutgoingMessage.prototype, Stream.prototype);
 ObjectSetPrototypeOf(OutgoingMessage, Stream);
@@ -178,27 +184,34 @@ ObjectSetPrototypeOf(OutgoingMessage, Stream);
 // For ServerResponse: checks the server's httpValidation or insecureHTTPParser
 // Falls back to global --insecure-http-parser flag.
 OutgoingMessage.prototype._isLenientHeaderValidation = function() {
+  // Options cannot change for the lifetime of a message after headers
+  // are stored: compute the lookup chain only once.
+  this[kLenientCache] ??= isLenientHeaderValidation(this);
+  return this[kLenientCache];
+};
+
+function isLenientHeaderValidation(msg) {
   // New httpValidation option takes priority (ClientRequest case)
-  if (this.httpValidation !== undefined) {
-    return this.httpValidation !== 'strict';
+  if (msg.httpValidation !== undefined) {
+    return msg.httpValidation !== 'strict';
   }
   // ServerResponse: check server's httpValidation option
-  const serverHttpValidation = this.req?.socket?.server?.httpValidation;
+  const serverHttpValidation = msg.req?.socket?.server?.httpValidation;
   if (serverHttpValidation !== undefined) {
     return serverHttpValidation !== 'strict';
   }
   // Legacy insecureHTTPParser - ClientRequest has it directly
-  if (typeof this.insecureHTTPParser === 'boolean') {
-    return this.insecureHTTPParser;
+  if (typeof msg.insecureHTTPParser === 'boolean') {
+    return msg.insecureHTTPParser;
   }
   // ServerResponse can access via req.socket.server
-  const serverOption = this.req?.socket?.server?.insecureHTTPParser;
+  const serverOption = msg.req?.socket?.server?.insecureHTTPParser;
   if (typeof serverOption === 'boolean') {
     return serverOption;
   }
   // Fall back to global option
   return isLenient();
-};
+}
 
 ObjectDefineProperty(OutgoingMessage.prototype, 'errored', {
   __proto__: null,
@@ -472,7 +485,7 @@ function _storeHeader(firstLine, headers) {
     trailer: false,
     header: firstLine,
   };
-  const lenient = this._isLenientHeaderValidation();
+  const lenient = headers ? this._isLenientHeaderValidation() : false;
 
   if (headers) {
     if (headers === this[kOutHeaders]) {
@@ -508,7 +521,7 @@ function _storeHeader(firstLine, headers) {
 
   // Date header
   if (this.sendDate && !state.date) {
-    header += 'Date: ' + utcDate() + '\r\n';
+    header += utcDateHeader();
   }
 
   // Force the connection to close when the response is a 204 No Content or
@@ -541,14 +554,21 @@ function _storeHeader(firstLine, headers) {
     if (shouldSendKeepAlive && this.maxRequestsOnConnectionReached) {
       header += 'Connection: close\r\n';
     } else if (shouldSendKeepAlive) {
-      header += 'Connection: keep-alive\r\n';
       if (this._keepAliveTimeout && this._defaultKeepAlive) {
-        const timeoutSeconds = MathFloor(this._keepAliveTimeout / 1000);
-        let max = '';
-        if (~~this._maxRequestsPerSocket > 0) {
-          max = `, max=${this._maxRequestsPerSocket}`;
+        // Identical for every response of a given server: cache the last
+        // rendered Connection + Keep-Alive pair.
+        const timeout = this._keepAliveTimeout;
+        const max = ~~this._maxRequestsPerSocket;
+        if (timeout !== keepAliveTimeoutCache || max !== keepAliveMaxCache) {
+          keepAliveTimeoutCache = timeout;
+          keepAliveMaxCache = max;
+          keepAliveHeaderCache = 'Connection: keep-alive\r\n' +
+            `Keep-Alive: timeout=${MathFloor(timeout / 1000)}` +
+            (max > 0 ? `, max=${max}` : '') + '\r\n';
         }
-        header += `Keep-Alive: timeout=${timeoutSeconds}${max}\r\n`;
+        header += keepAliveHeaderCache;
+      } else {
+        header += 'Connection: keep-alive\r\n';
       }
     } else {
       this._last = true;
@@ -639,10 +659,38 @@ function storeHeader(self, state, key, value, validate, lenient) {
   matchHeader(self, state, key, value);
 }
 
+function lowerOutgoingHeaderName(field) {
+  switch (field) {
+    case 'Connection':
+    case 'connection':
+      return 'connection';
+    case 'Content-Length':
+    case 'content-length':
+      return 'content-length';
+    case 'Transfer-Encoding':
+    case 'transfer-encoding':
+      return 'transfer-encoding';
+    case 'Date':
+    case 'date':
+      return 'date';
+    case 'Expect':
+    case 'expect':
+      return 'expect';
+    case 'Trailer':
+    case 'trailer':
+      return 'trailer';
+    case 'Keep-Alive':
+    case 'keep-alive':
+      return 'keep-alive';
+    default:
+      return field.toLowerCase();
+  }
+}
+
 function matchHeader(self, state, field, value) {
   if (field.length < 4 || field.length > 17)
     return;
-  field = field.toLowerCase();
+  field = lowerOutgoingHeaderName(field);
   switch (field) {
     case 'connection':
       state.connection = true;