urllib 4.8.2 → 4.9.1

package/src/HttpClient.ts

@@ -1,53 +1,46 @@
 import diagnosticsChannel from 'node:diagnostics_channel';
+import type { Channel } from 'node:diagnostics_channel';
 import { EventEmitter } from 'node:events';
-import { LookupFunction } from 'node:net';
+import { createReadStream } from 'node:fs';
 import { STATUS_CODES } from 'node:http';
-import { debuglog } from 'node:util';
-import {
-  createGunzip,
-  createBrotliDecompress,
-  gunzipSync,
-  brotliDecompressSync,
-} from 'node:zlib';
-import { Readable, pipeline } from 'node:stream';
-import { pipeline as pipelinePromise } from 'node:stream/promises';
+import type { LookupFunction } from 'node:net';
 import { basename } from 'node:path';
-import { createReadStream } from 'node:fs';
-import { format as urlFormat } from 'node:url';
 import { performance } from 'node:perf_hooks';
 import querystring from 'node:querystring';
+import { Readable, pipeline } from 'node:stream';
+import { pipeline as pipelinePromise } from 'node:stream/promises';
 import { setTimeout as sleep } from 'node:timers/promises';
-import {
-  request as undiciRequest,
-  Dispatcher,
-  Agent,
-  getGlobalDispatcher,
-  Pool,
-} from 'undici';
+import { format as urlFormat } from 'node:url';
+import { debuglog } from 'node:util';
+import { createGunzip, createBrotliDecompress, gunzipSync, brotliDecompressSync } from 'node:zlib';
+
+// Compatible with old style formstream
+import FormStream from 'formstream';
+import mime from 'mime-types';
+import qs from 'qs';
+import { request as undiciRequest, Dispatcher, Agent, getGlobalDispatcher, Pool } from 'undici';
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import undiciSymbols from 'undici/lib/core/symbols.js';
-import mime from 'mime-types';
-import qs from 'qs';
-// Compatible with old style formstream
-import FormStream from 'formstream';
+
+import { initDiagnosticsChannel } from './diagnosticsChannel.js';
+import type { FetchOpaque } from './FetchOpaqueInterceptor.js';
 import { FormData } from './FormData.js';
-import { HttpAgent, CheckAddressFunction } from './HttpAgent.js';
+import { HttpAgent } from './HttpAgent.js';
+import type { CheckAddressFunction } from './HttpAgent.js';
+import { HttpClientConnectTimeoutError, HttpClientRequestTimeoutError } from './HttpClientError.js';
 import type { IncomingHttpHeaders } from './IncomingHttpHeaders.js';
-import { RequestURL, RequestOptions, HttpMethod, RequestMeta } from './Request.js';
-import { RawResponseWithMeta, HttpClientResponse, SocketInfo } from './Response.js';
-import { parseJSON, digestAuthHeader, globalId, performanceTime, isReadable, updateSocketInfo } from './utils.js';
+import type { RequestURL, RequestOptions, HttpMethod, RequestMeta } from './Request.js';
+import type { RawResponseWithMeta, HttpClientResponse, SocketInfo } from './Response.js';
 import symbols from './symbols.js';
-import { initDiagnosticsChannel } from './diagnosticsChannel.js';
-import { HttpClientConnectTimeoutError, HttpClientRequestTimeoutError } from './HttpClientError.js';
-import { FetchOpaque } from './FetchOpaqueInterceptor.js';
+import { parseJSON, digestAuthHeader, globalId, performanceTime, isReadable, updateSocketInfo } from './utils.js';
 
 type Exists<T> = T extends undefined ? never : T;
 type UndiciRequestOption = Exists<Parameters<typeof undiciRequest>[1]>;
 type PropertyShouldBe<T, K extends keyof T, V> = Omit<T, K> & { [P in K]: V };
 type IUndiciRequestOption = PropertyShouldBe<UndiciRequestOption, 'headers', IncomingHttpHeaders>;
 
-export const PROTO_RE = /^https?:\/\//i;
+export const PROTO_RE: RegExp = /^https?:\/\//i;
 
 export interface UndiciTimingInfo {
   startTime: number;
@@ -73,7 +66,7 @@ export interface UndiciTimingInfo {
 // keep typo compatibility
 export interface UnidiciTimingInfo extends UndiciTimingInfo {}
 
-function noop() {
+function noop(): void {
   // noop
 }
 
@@ -88,23 +81,23 @@ export type ClientOptions = {
    */
   lookup?: LookupFunction;
   /**
-    * check request address to protect from SSRF and similar attacks.
-    * It receive two arguments(ip and family) and should return true or false to identified the address is legal or not.
-    * It rely on lookup and have the same version requirement.
-    */
+   * check request address to protect from SSRF and similar attacks.
+   * It receive two arguments(ip and family) and should return true or false to identified the address is legal or not.
+   * It rely on lookup and have the same version requirement.
+   */
   checkAddress?: CheckAddressFunction;
   connect?: {
     key?: string | Buffer;
     /**
-    * A string or Buffer containing the certificate key of the client in PEM format.
-    * Notes: This is necessary only if using the client certificate authentication
-    */
+     * A string or Buffer containing the certificate key of the client in PEM format.
+     * Notes: This is necessary only if using the client certificate authentication
+     */
     cert?: string | Buffer;
     /**
-    * If `true`, the server certificate is verified against the list of supplied CAs.
-    * An 'error' event is emitted if verification fails.
-    * Default: `true`
-    */
+     * If `true`, the server certificate is verified against the list of supplied CAs.
+     * An 'error' event is emitted if verification fails.
+     * Default: `true`
+     */
     rejectUnauthorized?: boolean;
     /**
      * socketPath string | null (optional) - Default: null - An IPC endpoint, either Unix domain socket or Windows named pipe
@@ -114,15 +107,14 @@ export type ClientOptions = {
      * connect timeout, default is 10000ms
      */
     timeout?: number;
-  },
+  };
 };
 
-export const VERSION = 'VERSION';
+export const VERSION: string = 'VERSION';
 // 'node-urllib/4.0.0 Node.js/18.19.0 (darwin; x64)'
-export const HEADER_USER_AGENT =
-  `node-urllib/${VERSION} Node.js/${process.version.substring(1)} (${process.platform}; ${process.arch})`;
+export const HEADER_USER_AGENT: string = `node-urllib/${VERSION} Node.js/${process.version.substring(1)} (${process.platform}; ${process.arch})`;
 
-function getFileName(stream: Readable) {
+function getFileName(stream: Readable): string {
   const filePath: string = (stream as any).path;
   if (filePath) {
     return basename(filePath);
@@ -130,7 +122,7 @@ function getFileName(stream: Readable) {
   return '';
 }
 
-function defaultIsRetry(response: HttpClientResponse) {
+function defaultIsRetry(response: HttpClientResponse): boolean {
   return response.status >= 500;
 }
 
@@ -142,7 +134,12 @@ export type RequestContext = {
   history: string[];
 };
 
-export const channels = {
+export const channels: {
+  request: Channel;
+  response: Channel;
+  fetchRequest: Channel;
+  fetchResponse: Channel;
+} = {
   request: diagnosticsChannel.channel('urllib:request'),
   response: diagnosticsChannel.channel('urllib:response'),
   fetchRequest: diagnosticsChannel.channel('urllib:fetch:request'),
@@ -187,6 +184,12 @@ const RedirectStatusCodes = [
   308, // Permanent Redirect
 ];
 
+// Credential-bearing headers that must not be forwarded across an origin
+// boundary when following a redirect, to avoid leaking them to a third party.
+// Matches the WHATWG Fetch spec and undici's RedirectHandler.
+// https://fetch.spec.whatwg.org/#http-redirect-fetch
+const CrossOriginSensitiveHeaders = new Set(['authorization', 'cookie', 'proxy-authorization']);
+
 export class HttpClient extends EventEmitter {
   #defaultArgs?: RequestOptions;
   #dispatcher?: Dispatcher;
@@ -215,15 +218,15 @@ export class HttpClient extends EventEmitter {
     initDiagnosticsChannel();
   }
 
-  getDispatcher() {
+  getDispatcher(): Dispatcher {
     return this.#dispatcher ?? getGlobalDispatcher();
   }
 
-  setDispatcher(dispatcher: Dispatcher) {
+  setDispatcher(dispatcher: Dispatcher): void {
     this.#dispatcher = dispatcher;
   }
 
-  getDispatcherPoolStats() {
+  getDispatcherPoolStats(): Record<string, PoolStat> {
     const agent = this.getDispatcher();
     // origin => Pool Instance
     const clients: Map<string, WeakRef<Pool>> | undefined = Reflect.get(agent, undiciSymbols.kClients);
@@ -231,8 +234,8 @@ export class HttpClient extends EventEmitter {
     if (!clients) {
       return poolStatsMap;
     }
-    for (const [ key, ref ] of clients) {
-      const pool = (typeof ref.deref === 'function' ? ref.deref() : ref) as unknown as (Pool & { dispatcher: Pool });
+    for (const [key, ref] of clients) {
+      const pool = (typeof ref.deref === 'function' ? ref.deref() : ref) as unknown as Pool & { dispatcher: Pool };
       // NOTE: pool become to { dispatcher: Pool } in undici@v7
       const stats = pool?.stats ?? pool?.dispatcher?.stats;
       if (!stats) continue;
@@ -249,16 +252,20 @@ export class HttpClient extends EventEmitter {
     return poolStatsMap;
   }
 
-  async request<T = any>(url: RequestURL, options?: RequestOptions) {
+  async request<T = any>(url: RequestURL, options?: RequestOptions): Promise<HttpClientResponse<T>> {
     return await this.#requestInternal<T>(url, options);
   }
 
   // alias to request, keep compatible with urllib@2 HttpClient.curl
-  async curl<T = any>(url: RequestURL, options?: RequestOptions) {
+  async curl<T = any>(url: RequestURL, options?: RequestOptions): Promise<HttpClientResponse<T>> {
     return await this.request<T>(url, options);
   }
 
-  async #requestInternal<T>(url: RequestURL, options?: RequestOptions, requestContext?: RequestContext): Promise<HttpClientResponse<T>> {
+  async #requestInternal<T>(
+    url: RequestURL,
+    options?: RequestOptions,
+    requestContext?: RequestContext,
+  ): Promise<HttpClientResponse<T>> {
     const requestId = globalId('HttpClientRequest');
     let requestUrl: URL;
     if (typeof url === 'string') {
@@ -472,20 +479,20 @@ export class HttpClient extends EventEmitter {
         const formData = new FormData();
         const uploadFiles: [string, string | Readable | Buffer, string?][] = [];
         if (Array.isArray(args.files)) {
-          for (const [ index, file ] of args.files.entries()) {
+          for (const [index, file] of args.files.entries()) {
             const field = index === 0 ? 'file' : `file${index}`;
-            uploadFiles.push([ field, file ]);
+            uploadFiles.push([field, file]);
           }
         } else if (args.files instanceof Readable || isReadable(args.files as any)) {
-          uploadFiles.push([ 'file', args.files as Readable ]);
+          uploadFiles.push(['file', args.files as Readable]);
         } else if (typeof args.files === 'string' || Buffer.isBuffer(args.files)) {
-          uploadFiles.push([ 'file', args.files ]);
+          uploadFiles.push(['file', args.files]);
         } else if (typeof args.files === 'object') {
           const files = args.files as Record<string, string | Readable | Buffer>;
           for (const field in files) {
             // set custom fileName
             const file = files[field];
-            uploadFiles.push([ field, file, field ]);
+            uploadFiles.push([field, file, field]);
           }
         }
         // set normal fields first
@@ -494,7 +501,7 @@ export class HttpClient extends EventEmitter {
             formData.append(field, args.data[field]);
           }
         }
-        for (const [ index, [ field, file, customFileName ]] of uploadFiles.entries()) {
+        for (const [index, [field, file, customFileName]] of uploadFiles.entries()) {
           let fileName = '';
           let value: any;
           if (typeof file === 'string') {
@@ -513,8 +520,7 @@ export class HttpClient extends EventEmitter {
             filename: fileName,
             contentType: mimeType,
           });
-          debug('formData append field: %s, mimeType: %s, fileName: %s',
-            field, mimeType, fileName);
+          debug('formData append field: %s, mimeType: %s, fileName: %s', field, mimeType, fileName);
         }
         Object.assign(headers, formData.getHeaders());
         requestOptions.body = formData;
@@ -530,9 +536,8 @@ export class HttpClient extends EventEmitter {
           isStreamingRequest = isReadable(args.content);
         }
       } else if (args.data) {
-        const isStringOrBufferOrReadable = typeof args.data === 'string'
-          || Buffer.isBuffer(args.data)
-          || isReadable(args.data);
+        const isStringOrBufferOrReadable =
+          typeof args.data === 'string' || Buffer.isBuffer(args.data) || isReadable(args.data);
         if (isGETOrHEAD) {
           if (!isStringOrBufferOrReadable) {
             let query: string;
@@ -550,9 +555,11 @@ export class HttpClient extends EventEmitter {
             requestOptions.body = args.data;
             isStreamingRequest = isReadable(args.data);
           } else {
-            if (args.contentType === 'json'
-              || args.contentType === 'application/json'
-              || headers['content-type']?.startsWith('application/json')) {
+            if (
+              args.contentType === 'json' ||
+              args.contentType === 'application/json' ||
+              headers['content-type']?.startsWith('application/json')
+            ) {
               requestOptions.body = JSON.stringify(args.data);
               if (!headers['content-type']) {
                 headers['content-type'] = 'application/json';
@@ -578,8 +585,19 @@ export class HttpClient extends EventEmitter {
         args.socketErrorRetry = 0;
       }
 
-      debug('Request#%d %s %s, headers: %j, headersTimeout: %s, bodyTimeout: %s, isStreamingRequest: %s, isStreamingResponse: %s, maxRedirections: %s, redirects: %s',
-        requestId, requestOptions.method, requestUrl.href, headers, headersTimeout, bodyTimeout, isStreamingRequest, isStreamingResponse, maxRedirects, requestContext.redirects);
+      debug(
+        'Request#%d %s %s, headers: %j, headersTimeout: %s, bodyTimeout: %s, isStreamingRequest: %s, isStreamingResponse: %s, maxRedirections: %s, redirects: %s',
+        requestId,
+        requestOptions.method,
+        requestUrl.href,
+        headers,
+        headersTimeout,
+        bodyTimeout,
+        isStreamingRequest,
+        isStreamingResponse,
+        maxRedirects,
+        requestContext.redirects,
+      );
       requestOptions.headers = headers;
       channels.request.publish({
         request: reqMeta,
@@ -589,17 +607,25 @@ export class HttpClient extends EventEmitter {
       }
 
       let response = await undiciRequest(requestUrl, requestOptions as UndiciRequestOption);
-      if (response.statusCode === 401 && (response.headers['www-authenticate'] || response.headers['x-www-authenticate']) &&
-        !requestOptions.headers.authorization && args.digestAuth) {
+      if (
+        response.statusCode === 401 &&
+        (response.headers['www-authenticate'] || response.headers['x-www-authenticate']) &&
+        !requestOptions.headers.authorization &&
+        args.digestAuth
+      ) {
         // handle digest auth
         const authenticateHeaders = response.headers['www-authenticate'] ?? response.headers['x-www-authenticate'];
         const authenticate = Array.isArray(authenticateHeaders)
-          ? authenticateHeaders.find(authHeader => authHeader.startsWith('Digest '))
+          ? authenticateHeaders.find((authHeader) => authHeader.startsWith('Digest '))
           : authenticateHeaders;
         if (authenticate && authenticate.startsWith('Digest ')) {
           debug('Request#%d %s: got digest auth header WWW-Authenticate: %s', requestId, requestUrl.href, authenticate);
-          requestOptions.headers.authorization = digestAuthHeader(requestOptions.method!,
-            `${requestUrl.pathname}${requestUrl.search}`, authenticate, args.digestAuth);
+          requestOptions.headers.authorization = digestAuthHeader(
+            requestOptions.method!,
+            `${requestUrl.pathname}${requestUrl.search}`,
+            authenticate,
+            args.digestAuth,
+          );
           debug('Request#%d %s: auth with digest header: %s', requestId, url, requestOptions.headers.authorization);
           if (Array.isArray(response.headers['set-cookie'])) {
             // FIXME: merge exists cookie header
@@ -627,9 +653,31 @@ export class HttpClient extends EventEmitter {
           const nextUrl = new URL(res.headers.location, requestUrl.href);
           // Ensure the response is consumed
           await response.body.arrayBuffer();
-          debug('Request#%d got response, status: %s, headers: %j, timing: %j, redirect to %s',
-            requestId, res.status, res.headers, res.timing, nextUrl.href);
-          return await this.#requestInternal(nextUrl.href, options, requestContext);
+          let redirectOptions = options;
+          // Do not forward credential-bearing headers to a different origin.
+          if (nextUrl.origin !== requestUrl.origin) {
+            const cleanedHeaders: IncomingHttpHeaders = {};
+            if (options?.headers) {
+              for (const name in options.headers) {
+                if (!CrossOriginSensitiveHeaders.has(name.toLowerCase())) {
+                  cleanedHeaders[name] = options.headers[name];
+                }
+              }
+            }
+            // Clone so the caller's options object is never mutated, and drop
+            // credentials so they are not re-applied on the new origin,
+            // including Basic/digest auth inherited from the client's defaultArgs.
+            redirectOptions = { ...options, headers: cleanedHeaders, auth: undefined, digestAuth: undefined };
+          }
+          debug(
+            'Request#%d got response, status: %s, headers: %j, timing: %j, redirect to %s',
+            requestId,
+            res.status,
+            res.headers,
+            res.timing,
+            nextUrl.href,
+          );
+          return await this.#requestInternal(nextUrl.href, redirectOptions, requestContext);
         }
       }
 
@@ -690,8 +738,14 @@ export class HttpClient extends EventEmitter {
         res,
       };
 
-      debug('Request#%d got response, status: %s, headers: %j, timing: %j, socket: %j',
-        requestId, res.status, res.headers, res.timing, res.socket);
+      debug(
+        'Request#%d got response, status: %s, headers: %j, timing: %j, socket: %j',
+        requestId,
+        res.status,
+        res.headers,
+        res.timing,
+        res.socket,
+      );
 
       if (args.retry > 0 && requestContext.retries < args.retry) {
         const isRetry = args.isRetry ?? defaultIsRetry;
@@ -723,8 +777,13 @@ export class HttpClient extends EventEmitter {
 
       return clientResponse;
     } catch (rawError: any) {
-      debug('Request#%d throw error: %s, socketErrorRetry: %s, socketErrorRetries: %s',
-        requestId, rawError, args.socketErrorRetry, requestContext.socketErrorRetries);
+      debug(
+        'Request#%d throw error: %s, socketErrorRetry: %s, socketErrorRetries: %s',
+        requestId,
+        rawError,
+        args.socketErrorRetry,
+        requestContext.socketErrorRetries,
+      );
       let err = rawError;
       if (err.name === 'HeadersTimeoutError') {
         err = new HttpClientRequestTimeoutError(headersTimeout, { cause: err });
@@ -738,8 +797,11 @@ export class HttpClient extends EventEmitter {
         // auto retry on socket error, https://github.com/node-modules/urllib/issues/454
         if (args.socketErrorRetry > 0 && requestContext.socketErrorRetries < args.socketErrorRetry) {
           requestContext.socketErrorRetries++;
-          debug('Request#%d retry on socket error, socketErrorRetries: %d',
-            requestId, requestContext.socketErrorRetries);
+          debug(
+            'Request#%d retry on socket error, socketErrorRetries: %d',
+            requestId,
+            requestContext.socketErrorRetries,
+          );
           return await this.#requestInternal(url, options, requestContext);
         }
       }

package/src/HttpClientError.ts

@@ -1,5 +1,5 @@
-import type { RawResponseWithMeta, SocketInfo } from './Response.js';
 import type { IncomingHttpHeaders } from './IncomingHttpHeaders.js';
+import type { RawResponseWithMeta, SocketInfo } from './Response.js';
 
 // need to support ES2021
 interface ErrorOptions {

package/src/IncomingHttpHeaders.ts

@@ -1,6 +1,7 @@
-import type { Except } from 'type-fest';
 import type { IncomingHttpHeaders as HTTPIncomingHttpHeaders } from 'node:http';
 
+import type { Except } from 'type-fest';
+
 // fix set-cookie type define https://github.com/nodejs/undici/pull/1893
 export interface IncomingHttpHeaders extends Except<HTTPIncomingHttpHeaders, 'set-cookie'> {
   'set-cookie'?: string | string[];

package/src/Request.ts

@@ -1,9 +1,11 @@
-import type { Readable, Writable } from 'node:stream';
 import type { EventEmitter } from 'node:events';
+import type { Readable, Writable } from 'node:stream';
+
 import type { Dispatcher } from 'undici';
+import { Request } from 'undici';
+
 import type { IncomingHttpHeaders } from './IncomingHttpHeaders.js';
 import type { HttpClientResponse } from './Response.js';
-import { Request } from 'undici';
 
 export type HttpMethod = Dispatcher.HttpMethod;
 
@@ -36,10 +38,16 @@ export type RequestOptions = {
    */
   writeStream?: Writable;
   /**
-    * The files will send with multipart/form-data format, base on formstream.
-    * If method not set, will use POST method by default.
-    */
-  files?: Array<Readable | Buffer | string> | Record<string, Readable | Buffer | string> | Readable | Buffer | string | object;
+   * The files will send with multipart/form-data format, base on formstream.
+   * If method not set, will use POST method by default.
+   */
+  files?:
+    | Array<Readable | Buffer | string>
+    | Record<string, Readable | Buffer | string>
+    | Readable
+    | Buffer
+    | string
+    | object;
   /** Type of request data, could be 'json'. If it's 'json', will auto set Content-Type: 'application/json' header. */
   contentType?: string;
   /**
@@ -165,5 +173,5 @@ export type RequestMeta = {
 
 export type FetchMeta = {
   requestId: number;
-  request: Request,
+  request: Request;
 };

package/src/Response.ts

@@ -1,4 +1,5 @@
 import type { Readable } from 'node:stream';
+
 import type { IncomingHttpHeaders } from './IncomingHttpHeaders.js';
 
 export type SocketInfo = {

package/src/diagnosticsChannel.ts

@@ -1,8 +1,10 @@
 import diagnosticsChannel from 'node:diagnostics_channel';
+import { Socket } from 'node:net';
 import { performance } from 'node:perf_hooks';
 import { debuglog } from 'node:util';
-import { Socket } from 'node:net';
-import { DiagnosticsChannel } from 'undici';
+
+import type { DiagnosticsChannel } from 'undici';
+
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import symbols from './symbols.js';
@@ -54,7 +56,7 @@ function formatSocket(socket: SocketExtend) {
 
 // make sure error contains socket info
 const destroySocket = Socket.prototype.destroy;
-Socket.prototype.destroy = function(err?: any) {
+Socket.prototype.destroy = function (err?: any) {
   if (err) {
     Object.defineProperty(err, symbols.kErrorSocket, {
       // don't show on console log
@@ -80,7 +82,7 @@ function getRequestOpaque(request: DiagnosticsChannel.Request, kHandler?: symbol
   return handler?.opts?.opaque ?? handler?.opaque;
 }
 
-export function initDiagnosticsChannel() {
+export function initDiagnosticsChannel(): void {
   // make sure init global DiagnosticsChannel once
   if (initedDiagnosticsChannel) return;
   initedDiagnosticsChannel = true;
@@ -104,14 +106,24 @@ export function initDiagnosticsChannel() {
     if (!opaque || !opaque[symbols.kRequestId]) return;
 
     Reflect.set(request, symbols.kRequestInternalOpaque, opaque);
-    debug('[%s] Request#%d %s %s, path: %s, headers: %j',
-      name, opaque[symbols.kRequestId], request.method, request.origin, request.path, request.headers);
+    debug(
+      '[%s] Request#%d %s %s, path: %s, headers: %j',
+      name,
+      opaque[symbols.kRequestId],
+      request.method,
+      request.origin,
+      request.path,
+      request.headers,
+    );
     if (!opaque[symbols.kEnableRequestTiming]) return;
     opaque[symbols.kRequestTiming].queuing = performanceTime(opaque[symbols.kRequestStartTime]);
   });
 
   subscribe('undici:client:connectError', (message, name) => {
-    const { error, connectParams, socket } = message as DiagnosticsChannel.ClientConnectErrorMessage & { error: any, socket: SocketExtend };
+    const { error, connectParams, socket } = message as DiagnosticsChannel.ClientConnectErrorMessage & {
+      error: any;
+      socket: SocketExtend;
+    };
     let sock = socket;
     if (!sock && error[symbols.kErrorSocket]) {
       sock = error[symbols.kErrorSocket];
@@ -129,11 +141,16 @@ export function initDiagnosticsChannel() {
       sock[symbols.kSocketConnectProtocol] = connectParams.protocol;
       sock[symbols.kSocketConnectHost] = connectParams.host;
       sock[symbols.kSocketConnectPort] = connectParams.port;
-      debug('[%s] Socket#%d connectError, connectParams: %j, error: %s, (sock: %j)',
-        name, sock[symbols.kSocketId], connectParams, (error as Error).message, formatSocket(sock));
+      debug(
+        '[%s] Socket#%d connectError, connectParams: %j, error: %s, (sock: %j)',
+        name,
+        sock[symbols.kSocketId],
+        connectParams,
+        (error as Error).message,
+        formatSocket(sock),
+      );
     } else {
-      debug('[%s] connectError, connectParams: %j, error: %o',
-        name, connectParams, error);
+      debug('[%s] connectError, connectParams: %j, error: %o', name, connectParams, error);
     }
   });
 
@@ -166,17 +183,24 @@ export function initDiagnosticsChannel() {
     (socket[symbols.kHandledRequests] as number)++;
     // attach socket to opaque
     opaque[symbols.kRequestSocket] = socket;
-    debug('[%s] Request#%d send headers on Socket#%d (handled %d requests, sock: %j)',
-      name, opaque[symbols.kRequestId], socket[symbols.kSocketId], socket[symbols.kHandledRequests],
-      formatSocket(socket));
+    debug(
+      '[%s] Request#%d send headers on Socket#%d (handled %d requests, sock: %j)',
+      name,
+      opaque[symbols.kRequestId],
+      socket[symbols.kSocketId],
+      socket[symbols.kHandledRequests],
+      formatSocket(socket),
+    );
 
     if (!opaque[symbols.kEnableRequestTiming]) return;
     opaque[symbols.kRequestTiming].requestHeadersSent = performanceTime(opaque[symbols.kRequestStartTime]);
     // first socket need to calculate the connected time
     if (socket[symbols.kHandledRequests] === 1) {
       // kSocketStartTime - kRequestStartTime = connected time
-      opaque[symbols.kRequestTiming].connected =
-        performanceTime(opaque[symbols.kRequestStartTime], socket[symbols.kSocketStartTime] as number);
+      opaque[symbols.kRequestTiming].connected = performanceTime(
+        opaque[symbols.kRequestStartTime],
+        socket[symbols.kSocketStartTime] as number,
+      );
     }
   });
 
@@ -206,12 +230,22 @@ export function initDiagnosticsChannel() {
     const socket = opaque[symbols.kRequestSocket];
     if (socket) {
       socket[symbols.kHandledResponses]++;
-      debug('[%s] Request#%d get %s response headers on Socket#%d (handled %d responses, sock: %j)',
-        name, opaque[symbols.kRequestId], response.statusCode, socket[symbols.kSocketId], socket[symbols.kHandledResponses],
-        formatSocket(socket));
+      debug(
+        '[%s] Request#%d get %s response headers on Socket#%d (handled %d responses, sock: %j)',
+        name,
+        opaque[symbols.kRequestId],
+        response.statusCode,
+        socket[symbols.kSocketId],
+        socket[symbols.kHandledResponses],
+        formatSocket(socket),
+      );
     } else {
-      debug('[%s] Request#%d get %s response headers on Unknown Socket',
-        name, opaque[symbols.kRequestId], response.statusCode);
+      debug(
+        '[%s] Request#%d get %s response headers on Unknown Socket',
+        name,
+        opaque[symbols.kRequestId],
+        response.statusCode,
+      );
     }
 
     if (!opaque[symbols.kEnableRequestTiming]) return;