Fix socket reuse timing phases preservation

We also inline a dependency so we can fix it.

Fixes #2425

Author: sindresorhus

package.json

@@ -52,7 +52,6 @@
 	],
 	"dependencies": {
 		"@sindresorhus/is": "^7.0.1",
-		"@szmarczak/http-timer": "^5.0.1",
 		"byte-counter": "^0.1.0",
 		"cacheable-lookup": "^7.0.0",
 		"cacheable-request": "^13.0.12",

source/core/diagnostics-channel.ts

@@ -1,6 +1,6 @@
 import {randomUUID} from 'node:crypto';
 import diagnosticsChannel from 'node:diagnostics_channel';
-import type {Timings} from '@szmarczak/http-timer';
+import type {Timings} from './utils/timer.js';
 import type {RequestError} from './errors.js';
 
 const channels = {

source/core/errors.ts

@@ -1,5 +1,5 @@
 import is from '@sindresorhus/is';
-import type {Timings} from '@szmarczak/http-timer';
+import type {Timings} from './utils/timer.js';
 import type Options from './options.js';
 import type {TimeoutError as TimedOutTimeoutError} from './timed-out.js';
 import type {PlainResponse, Response} from './response.js';

source/core/index.ts

@@ -4,7 +4,6 @@ import {Duplex, type Readable} from 'node:stream';
 import http, {ServerResponse, type ClientRequest, type RequestOptions} from 'node:http';
 import type {Socket} from 'node:net';
 import {byteLength} from 'byte-counter';
-import timer, {type ClientRequestWithTimings, type Timings, type IncomingMessageWithTimings} from '@szmarczak/http-timer';
 import CacheableRequest, {
 	CacheError as CacheableCacheError,
 	type CacheableRequestFunction,
@@ -16,6 +15,7 @@ import type KeyvType from 'keyv';
 import is, {isBuffer} from '@sindresorhus/is';
 import {FormDataEncoder, isFormData as isFormDataLike} from 'form-data-encoder';
 import type ResponseLike from 'responselike';
+import timer, {type ClientRequestWithTimings, type Timings, type IncomingMessageWithTimings} from './utils/timer.js';
 import getBodySize from './utils/get-body-size.js';
 import isFormData from './utils/is-form-data.js';
 import proxyEvents from './utils/proxy-events.js';
@@ -828,29 +828,6 @@ export default class Request extends Duplex implements RequestEvents<Request> {
 			isFromCache: typedResponse.isFromCache,
 		});
 
-		// Workaround for http-timer bug: when connecting to an IP address (no DNS lookup),
-		// http-timer sets lookup = connect instead of lookup = socket, resulting in
-		// dns = lookup - socket being a small positive number instead of 0.
-		// See https://github.com/sindresorhus/got/issues/2279
-		const {timings} = response;
-		if (timings?.lookup !== undefined && timings.socket !== undefined && timings.connect !== undefined && timings.lookup === timings.connect && timings.phases.dns !== 0) {
-			// Fix the DNS phase to be 0 and set lookup to socket time
-			timings.phases.dns = 0;
-			timings.lookup = timings.socket;
-			// Recalculate TCP time to be the full time from socket to connect
-			timings.phases.tcp = timings.connect - timings.socket;
-		}
-
-		// Workaround for http-timer limitation with HTTP/2:
-		// When using HTTP/2, the socket is a proxy that http-timer discards,
-		// so lookup, connect, and secureConnect events are never captured.
-		// This results in phases.request being NaN (undefined - undefined).
-		// Set it to undefined to be consistent with other unavailable timings.
-		// See https://github.com/sindresorhus/got/issues/1958
-		if (timings && Number.isNaN(timings.phases.request)) {
-			timings.phases.request = undefined;
-		}
-
 		response.once('error', (error: Error) => {
 			this._aborted = true;
 

source/core/options.ts

@@ -21,8 +21,8 @@ import {isFormData, type FormDataLike} from 'form-data-encoder';
 import type {KeyvStoreAdapter} from 'keyv';
 import type KeyvType from 'keyv';
 import type ResponseLike from 'responselike';
-import type {IncomingMessageWithTimings} from '@szmarczak/http-timer';
 import type {CancelableRequest} from '../as-promise/types.js';
+import type {IncomingMessageWithTimings} from './utils/timer.js';
 import parseLinkHeader from './parse-link-header.js';
 import type {PlainResponse, Response} from './response.js';
 import type {RequestError} from './errors.js';

source/core/response.ts

@@ -1,5 +1,5 @@
 import type {Buffer} from 'node:buffer';
-import type {IncomingMessageWithTimings, Timings} from '@szmarczak/http-timer';
+import type {IncomingMessageWithTimings, Timings} from './utils/timer.js';
 import {RequestError} from './errors.js';
 import type {ParseJsonFunction, ResponseType} from './options.js';
 import type Request from './index.js';

source/core/utils/defer-to-connect.ts

@@ -0,0 +1,56 @@
+import type {Socket} from 'node:net';
+import type {TLSSocket} from 'node:tls';
+
+type Listeners = {
+	connect?: () => void;
+	secureConnect?: () => void;
+	close?: (hadError: boolean) => void;
+};
+
+function isTlsSocket(socket: Socket | TLSSocket): socket is TLSSocket {
+	return 'encrypted' in socket;
+}
+
+const deferToConnect = (socket: TLSSocket | Socket, fn: Listeners | (() => void)): void => {
+	let listeners: Listeners;
+	if (typeof fn === 'function') {
+		const connect = fn;
+		listeners = {connect};
+	} else {
+		listeners = fn;
+	}
+
+	const hasConnectListener = typeof listeners.connect === 'function';
+	const hasSecureConnectListener = typeof listeners.secureConnect === 'function';
+	const hasCloseListener = typeof listeners.close === 'function';
+
+	const onConnect = () => {
+		if (hasConnectListener) {
+			listeners.connect!();
+		}
+
+		if (isTlsSocket(socket) && hasSecureConnectListener) {
+			if (socket.authorized) {
+				listeners.secureConnect!();
+			} else {
+				// Wait for secureConnect event (even if authorization fails, we need the timing)
+				socket.once('secureConnect', listeners.secureConnect!);
+			}
+		}
+
+		if (hasCloseListener) {
+			socket.once('close', listeners.close!);
+		}
+	};
+
+	if (socket.writable && !socket.connecting) {
+		onConnect();
+	} else if (socket.connecting) {
+		socket.once('connect', onConnect);
+	} else if (socket.destroyed && hasCloseListener) {
+		const hadError = '_hadError' in socket ? Boolean((socket as any)._hadError) : false;
+		listeners.close!(hadError);
+	}
+};
+
+export default deferToConnect;

source/core/utils/timer.ts

@@ -0,0 +1,225 @@
+import {errorMonitor} from 'node:events';
+import {types} from 'node:util';
+import type {ClientRequest, IncomingMessage} from 'node:http';
+import type {Socket} from 'node:net';
+import deferToConnect from './defer-to-connect.js';
+
+export type Timings = {
+	start: number;
+	socket?: number;
+	lookup?: number;
+	connect?: number;
+	secureConnect?: number;
+	upload?: number;
+	response?: number;
+	end?: number;
+	error?: number;
+	abort?: number;
+	phases: {
+		wait?: number;
+		dns?: number;
+		tcp?: number;
+		tls?: number;
+		request?: number;
+		firstByte?: number;
+		download?: number;
+		total?: number;
+	};
+};
+
+export type ClientRequestWithTimings = ClientRequest & {
+	timings?: Timings;
+};
+
+export type IncomingMessageWithTimings = IncomingMessage & {
+	timings?: Timings;
+};
+
+type SocketWithConnectionTimings = Socket & {
+	__initial_connection_timings__?: {
+		dnsPhase: number;
+		tcpPhase: number;
+		tlsPhase?: number;
+	};
+};
+
+const timer = (request: ClientRequestWithTimings): Timings => {
+	if (request.timings) {
+		return request.timings;
+	}
+
+	const timings: Timings = {
+		start: Date.now(),
+		socket: undefined,
+		lookup: undefined,
+		connect: undefined,
+		secureConnect: undefined,
+		upload: undefined,
+		response: undefined,
+		end: undefined,
+		error: undefined,
+		abort: undefined,
+		phases: {
+			wait: undefined,
+			dns: undefined,
+			tcp: undefined,
+			tls: undefined,
+			request: undefined,
+			firstByte: undefined,
+			download: undefined,
+			total: undefined,
+		},
+	};
+
+	request.timings = timings;
+
+	const handleError = (origin: ClientRequest | IncomingMessage) => {
+		origin.once(errorMonitor, () => {
+			timings.error = Date.now();
+			timings.phases.total = timings.error - timings.start;
+		});
+	};
+
+	handleError(request);
+
+	const onAbort = () => {
+		timings.abort = Date.now();
+		timings.phases.total = timings.abort - timings.start;
+	};
+
+	request.prependOnceListener('abort', onAbort);
+
+	const onSocket = (socket: SocketWithConnectionTimings) => {
+		timings.socket = Date.now();
+		timings.phases.wait = timings.socket - timings.start;
+
+		if (types.isProxy(socket)) {
+			// HTTP/2: The socket is a proxy, so connection events won't fire.
+			// We can't measure connection timings, so leave them undefined.
+			// This prevents NaN in phases.request calculation.
+			return;
+		}
+
+		// Check if socket is already connected (reused from connection pool)
+		const socketAlreadyConnected = socket.writable && !socket.connecting;
+
+		if (socketAlreadyConnected) {
+			// Socket reuse detected: the socket was already connected from a previous request.
+			// For reused sockets, set all connection timestamps to socket time since no new
+			// connection was made for THIS request. But preserve phase durations from the
+			// original connection so they're not lost.
+			timings.lookup = timings.socket;
+			timings.connect = timings.socket;
+
+			if (socket.__initial_connection_timings__) {
+				// Restore the phase timings from the initial connection
+				timings.phases.dns = socket.__initial_connection_timings__.dnsPhase;
+				timings.phases.tcp = socket.__initial_connection_timings__.tcpPhase;
+				timings.phases.tls = socket.__initial_connection_timings__.tlsPhase;
+
+				// Set secureConnect timestamp if there was TLS
+				if (timings.phases.tls !== undefined) {
+					timings.secureConnect = timings.socket;
+				}
+			} else {
+				// Socket reused but no initial timings stored (e.g., from external code)
+				// Set phases to 0
+				timings.phases.dns = 0;
+				timings.phases.tcp = 0;
+			}
+
+			return;
+		}
+
+		const lookupListener = () => {
+			timings.lookup = Date.now();
+			timings.phases.dns = timings.lookup - timings.socket!;
+		};
+
+		socket.prependOnceListener('lookup', lookupListener);
+
+		deferToConnect(socket, {
+			connect() {
+				timings.connect = Date.now();
+				if (timings.lookup === undefined) {
+					// No DNS lookup occurred (e.g., connecting to an IP address directly)
+					// Set lookup to socket time (no time elapsed for DNS)
+					socket.removeListener('lookup', lookupListener);
+					timings.lookup = timings.socket!;
+					timings.phases.dns = 0;
+				}
+
+				timings.phases.tcp = timings.connect - timings.lookup;
+
+				// Store connection phase timings on socket for potential reuse
+				if (!socket.__initial_connection_timings__) {
+					socket.__initial_connection_timings__ = {
+						dnsPhase: timings.phases.dns!,
+						// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript can't prove this is defined due to callback structure
+						tcpPhase: timings.phases.tcp!,
+					};
+				}
+			},
+			secureConnect() {
+				timings.secureConnect = Date.now();
+				timings.phases.tls = timings.secureConnect - timings.connect!;
+
+				// Update stored timings with TLS phase timing
+				if (socket.__initial_connection_timings__) {
+					socket.__initial_connection_timings__.tlsPhase = timings.phases.tls;
+				}
+			},
+		});
+	};
+
+	if (request.socket) {
+		onSocket(request.socket as SocketWithConnectionTimings);
+	} else {
+		request.prependOnceListener('socket', onSocket as (socket: Socket) => void);
+	}
+
+	const onUpload = () => {
+		timings.upload = Date.now();
+
+		// Calculate request phase if we have connection timings
+		const secureOrConnect = timings.secureConnect ?? timings.connect;
+		if (secureOrConnect !== undefined) {
+			timings.phases.request = timings.upload - secureOrConnect;
+		}
+		// If both are undefined (HTTP/2), phases.request stays undefined (not NaN)
+	};
+
+	if (request.writableFinished) {
+		onUpload();
+	} else {
+		request.prependOnceListener('finish', onUpload);
+	}
+
+	request.prependOnceListener('response', (response: IncomingMessageWithTimings) => {
+		timings.response = Date.now();
+		timings.phases.firstByte = timings.response - timings.upload!;
+
+		response.timings = timings;
+		handleError(response);
+
+		response.prependOnceListener('end', () => {
+			request.off('abort', onAbort);
+			response.off('aborted', onAbort);
+
+			if (timings.phases.total !== undefined) {
+				// Aborted or errored
+				return;
+			}
+
+			timings.end = Date.now();
+			timings.phases.download = timings.end - timings.response!;
+			timings.phases.total = timings.end - timings.start;
+		});
+
+		response.prependOnceListener('aborted', onAbort);
+	});
+
+	return timings;
+};
+
+export default timer;