urllib 3.16.1 → 3.17.1

package/src/cjs/Request.d.ts

@@ -67,11 +67,16 @@ export type RequestOptions = {
     headers?: IncomingHttpHeaders;
     /**
      * Request timeout in milliseconds for connecting phase and response receiving phase.
-     * Defaults to exports.
-     * TIMEOUT, both are 5s. You can use timeout: 5000 to tell urllib use same timeout on two phase or set them seperately such as
+     * Defaults is `5000`, both are 5 seconds. You can use timeout: 5000 to tell urllib use same timeout on two phase or set them separately such as
      * timeout: [3000, 5000], which will set connecting timeout to 3s and response 5s.
      */
     timeout?: number | number[];
+    /**
+     * Default is `4000`,  4 seconds - The timeout after which a socket without active requests will time out.
+     * Monitors time between activity on a connected socket.
+     * This value may be overridden by *keep-alive* hints from the server. See [MDN: HTTP - Headers - Keep-Alive directives](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Keep-Alive#directives) for more details.
+     */
+    keepAliveTimeout?: number;
     /**
      * username:password used in HTTP Basic Authorization.
      * Alias to `headers.authorization = xxx`
@@ -89,7 +94,7 @@ export type RequestOptions = {
     formatRedirectUrl?: (a: any, b: any) => void;
     /** Before request hook, you can change every thing here. */
     beforeRequest?: (...args: any[]) => void;
-    /** Accept `gzip, br` response content and auto decode it, default is false. */
+    /** Accept `gzip, br` response content and auto decode it, default is `true`. */
     compressed?: boolean;
     /**
      * @deprecated
@@ -97,11 +102,11 @@ export type RequestOptions = {
      * */
     gzip?: boolean;
     /**
-     * Enable timing or not, default is false.
+     * Enable timing or not, default is `true`.
      * */
     timing?: boolean;
     /**
-     * Auto retry times on 5xx response, default is 0. Don't work on streaming request
+     * Auto retry times on 5xx response, default is `0`. Don't work on streaming request
      * It's not supported by using retry and writeStream, because the retry request can't stop the stream which is consuming.
      **/
     retry?: number;
@@ -112,6 +117,11 @@ export type RequestOptions = {
      * It will retry when status >= 500 by default. Request error is not included.
      */
     isRetry?: (response: HttpClientResponse) => boolean;
+    /**
+     * Auto retry times on socket error, default is `1`. Don't work on streaming request
+     * It's not supported by using retry and writeStream, because the retry request can't stop the stream which is consuming.
+     **/
+    socketErrorRetry?: number;
     /** Default: `null` */
     opaque?: unknown;
     /**
@@ -132,3 +142,10 @@ export type RequestOptions = {
     /** Default: `64 KiB` */
     highWaterMark?: number;
 };
+export type RequestMeta = {
+    requestId: number;
+    url: string;
+    args: RequestOptions;
+    ctx?: unknown;
+    retries: number;
+};

package/src/cjs/Response.d.ts

@@ -13,6 +13,8 @@ export type SocketInfo = {
     bytesRead: number;
     handledRequests: number;
     handledResponses: number;
+    connectedTime?: Date;
+    lastRequestEndTime?: Date;
 };
 /**
  * https://eggjs.org/en/core/httpclient.html#timing-boolean
@@ -37,6 +39,8 @@ export type RawResponseWithMeta = Readable & {
     rt: number;
     keepAliveSocket: boolean;
     requestUrls: string[];
+    retries: number;
+    socketErrorRetries: number;
 };
 export type HttpClientResponse<T = any> = {
     opaque: unknown;

package/src/cjs/diagnosticsChannel.js

@@ -21,6 +21,25 @@ let initedDiagnosticsChannel = false;
 // server --> client
 // undici:request:headers => { request, response }
 //   -> undici:request:trailers => { request, trailers }
+function subscribe(name, listener) {
+    if (typeof node_diagnostics_channel_1.default.subscribe === 'function') {
+        node_diagnostics_channel_1.default.subscribe(name, listener);
+    }
+    else {
+        // TODO: support Node.js 14, will be removed on the next major version
+        node_diagnostics_channel_1.default.channel(name).subscribe(listener);
+    }
+}
+function formatSocket(socket) {
+    if (!socket)
+        return socket;
+    return {
+        localAddress: socket[symbols_1.default.kSocketLocalAddress],
+        localPort: socket[symbols_1.default.kSocketLocalPort],
+        remoteAddress: socket.remoteAddress,
+        remotePort: socket.remotePort,
+    };
+}
 function initDiagnosticsChannel() {
     // makre sure init global DiagnosticsChannel once
     if (initedDiagnosticsChannel)
@@ -29,7 +48,7 @@ function initDiagnosticsChannel() {
     let kHandler;
     // This message is published when a new outgoing request is created.
     // Note: a request is only loosely completed to a given socket.
-    node_diagnostics_channel_1.default.channel('undici:request:create').subscribe((message, name) => {
+    subscribe('undici:request:create', (message, name) => {
         const { request } = message;
         if (!kHandler) {
             const symbols = Object.getOwnPropertySymbols(request);
@@ -52,16 +71,20 @@ function initDiagnosticsChannel() {
     // diagnosticsChannel.channel('undici:client:beforeConnect')
     // diagnosticsChannel.channel('undici:client:connectError')
     // This message is published after a connection is established.
-    node_diagnostics_channel_1.default.channel('undici:client:connected').subscribe((message, name) => {
+    subscribe('undici:client:connected', (message, name) => {
         const { socket } = message;
         socket[symbols_1.default.kSocketId] = (0, utils_1.globalId)('UndiciSocket');
         socket[symbols_1.default.kSocketStartTime] = node_perf_hooks_1.performance.now();
+        socket[symbols_1.default.kSocketConnectedTime] = new Date();
         socket[symbols_1.default.kHandledRequests] = 0;
         socket[symbols_1.default.kHandledResponses] = 0;
-        debug('[%s] Socket#%d connected', name, socket[symbols_1.default.kSocketId]);
+        // copy local address to symbol, avoid them be reset after request error throw
+        socket[symbols_1.default.kSocketLocalAddress] = socket.localAddress;
+        socket[symbols_1.default.kSocketLocalPort] = socket.localPort;
+        debug('[%s] Socket#%d connected (sock: %o)', name, socket[symbols_1.default.kSocketId], formatSocket(socket));
     });
     // This message is published right before the first byte of the request is written to the socket.
-    node_diagnostics_channel_1.default.channel('undici:client:sendHeaders').subscribe((message, name) => {
+    subscribe('undici:client:sendHeaders', (message, name) => {
         const { request, socket } = message;
         if (!kHandler)
             return;
@@ -71,7 +94,7 @@ function initDiagnosticsChannel() {
         socket[symbols_1.default.kHandledRequests]++;
         // attach socket to opaque
         opaque[symbols_1.default.kRequestSocket] = socket;
-        debug('[%s] Request#%d send headers on Socket#%d (handled %d requests)', name, opaque[symbols_1.default.kRequestId], socket[symbols_1.default.kSocketId], socket[symbols_1.default.kHandledRequests]);
+        debug('[%s] Request#%d send headers on Socket#%d (handled %d requests, sock: %o)', name, opaque[symbols_1.default.kRequestId], socket[symbols_1.default.kSocketId], socket[symbols_1.default.kHandledRequests], formatSocket(socket));
         if (!opaque[symbols_1.default.kEnableRequestTiming])
             return;
         opaque[symbols_1.default.kRequestTiming].requestHeadersSent = (0, utils_1.performanceTime)(opaque[symbols_1.default.kRequestStartTime]);
@@ -82,7 +105,7 @@ function initDiagnosticsChannel() {
                 (0, utils_1.performanceTime)(opaque[symbols_1.default.kRequestStartTime], socket[symbols_1.default.kSocketStartTime]);
         }
     });
-    node_diagnostics_channel_1.default.channel('undici:request:bodySent').subscribe((message, name) => {
+    subscribe('undici:request:bodySent', (message, name) => {
         const { request } = message;
         if (!kHandler)
             return;
@@ -95,7 +118,7 @@ function initDiagnosticsChannel() {
         opaque[symbols_1.default.kRequestTiming].requestSent = (0, utils_1.performanceTime)(opaque[symbols_1.default.kRequestStartTime]);
     });
     // This message is published after the response headers have been received, i.e. the response has been completed.
-    node_diagnostics_channel_1.default.channel('undici:request:headers').subscribe((message, name) => {
+    subscribe('undici:request:headers', (message, name) => {
         const { request, response } = message;
         if (!kHandler)
             return;
@@ -105,13 +128,13 @@ function initDiagnosticsChannel() {
         // get socket from opaque
         const socket = opaque[symbols_1.default.kRequestSocket];
         socket[symbols_1.default.kHandledResponses]++;
-        debug('[%s] Request#%d get %s response headers on Socket#%d (handled %d responses)', name, opaque[symbols_1.default.kRequestId], response.statusCode, socket[symbols_1.default.kSocketId], socket[symbols_1.default.kHandledResponses]);
+        debug('[%s] Request#%d get %s response headers on Socket#%d (handled %d responses, sock: %o)', name, opaque[symbols_1.default.kRequestId], response.statusCode, socket[symbols_1.default.kSocketId], socket[symbols_1.default.kHandledResponses], formatSocket(socket));
         if (!opaque[symbols_1.default.kEnableRequestTiming])
             return;
         opaque[symbols_1.default.kRequestTiming].waiting = (0, utils_1.performanceTime)(opaque[symbols_1.default.kRequestStartTime]);
     });
     // This message is published after the response body and trailers have been received, i.e. the response has been completed.
-    node_diagnostics_channel_1.default.channel('undici:request:trailers').subscribe((message, name) => {
+    subscribe('undici:request:trailers', (message, name) => {
         const { request } = message;
         if (!kHandler)
             return;
@@ -123,6 +146,15 @@ function initDiagnosticsChannel() {
             return;
         opaque[symbols_1.default.kRequestTiming].contentDownload = (0, utils_1.performanceTime)(opaque[symbols_1.default.kRequestStartTime]);
     });
-    // diagnosticsChannel.channel('undici:request:error')
+    // This message is published if the request is going to error, but it has not errored yet.
+    // subscribe('undici:request:error', (message, name) => {
+    //   const { request, error } = message as DiagnosticsChannel.RequestErrorMessage;
+    //   const opaque = request[kHandler]?.opts?.opaque;
+    //   if (!opaque || !opaque[symbols.kRequestId]) return;
+    //   const socket = opaque[symbols.kRequestSocket];
+    //   debug('[%s] Request#%d error on Socket#%d (handled %d responses, sock: %o), error: %o',
+    //     name, opaque[symbols.kRequestId], socket[symbols.kSocketId], socket[symbols.kHandledResponses],
+    //     formatSocket(socket), error);
+    // });
 }
 exports.initDiagnosticsChannel = initDiagnosticsChannel;

package/src/cjs/index.d.ts

@@ -2,7 +2,7 @@ import { RequestOptions, RequestURL } from './Request';
 export declare function request<T = any>(url: RequestURL, options?: RequestOptions): Promise<import("./Response").HttpClientResponse<T>>;
 export declare function curl<T = any>(url: RequestURL, options?: RequestOptions): Promise<import("./Response").HttpClientResponse<T>>;
 export { MockAgent, ProxyAgent, Agent, Dispatcher, setGlobalDispatcher, getGlobalDispatcher, } from 'undici';
-export { HttpClient, HttpClient as HttpClient2, HEADER_USER_AGENT as USER_AGENT } from './HttpClient';
+export { HttpClient, HttpClient as HttpClient2, HEADER_USER_AGENT as USER_AGENT, RequestDiagnosticsMessage, ResponseDiagnosticsMessage, } from './HttpClient';
 export { RequestOptions, RequestOptions as RequestOptions2, RequestURL, HttpMethod, FixJSONCtlCharsHandler, FixJSONCtlChars, } from './Request';
 export { SocketInfo, Timing, RawResponseWithMeta, HttpClientResponse } from './Response';
 declare const _default: {

package/src/cjs/symbols.d.ts

@@ -1,6 +1,10 @@
 declare const _default: {
     kSocketId: symbol;
     kSocketStartTime: symbol;
+    kSocketConnectedTime: symbol;
+    kSocketRequestEndTime: symbol;
+    kSocketLocalAddress: symbol;
+    kSocketLocalPort: symbol;
     kHandledRequests: symbol;
     kHandledResponses: symbol;
     kRequestSocket: symbol;

package/src/cjs/symbols.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     kSocketId: Symbol('socket id'),
     kSocketStartTime: Symbol('socket start time'),
+    kSocketConnectedTime: Symbol('socket connected time'),
+    kSocketRequestEndTime: Symbol('socket request end time'),
+    kSocketLocalAddress: Symbol('socket local address'),
+    kSocketLocalPort: Symbol('socket local port'),
     kHandledRequests: Symbol('handled requests per socket'),
     kHandledResponses: Symbol('handled responses per socket'),
     kRequestSocket: Symbol('request on the socket'),

package/src/diagnosticsChannel.ts

@@ -1,6 +1,7 @@
 import diagnosticsChannel from 'node:diagnostics_channel';
 import { performance } from 'node:perf_hooks';
 import { debuglog } from 'node:util';
+import { Socket } from 'node:net';
 import { DiagnosticsChannel } from 'undici';
 import symbols from './symbols';
 import { globalId, performanceTime } from './utils';
@@ -17,6 +18,26 @@ let initedDiagnosticsChannel = false;
 // server --> client
 // undici:request:headers => { request, response }
 //   -> undici:request:trailers => { request, trailers }
+
+function subscribe(name: string, listener: (message: unknown, channelName: string | symbol) => void) {
+  if (typeof diagnosticsChannel.subscribe === 'function') {
+    diagnosticsChannel.subscribe(name, listener);
+  } else {
+    // TODO: support Node.js 14, will be removed on the next major version
+    diagnosticsChannel.channel(name).subscribe(listener);
+  }
+}
+
+function formatSocket(socket: Socket) {
+  if (!socket) return socket;
+  return {
+    localAddress: socket[symbols.kSocketLocalAddress],
+    localPort: socket[symbols.kSocketLocalPort],
+    remoteAddress: socket.remoteAddress,
+    remotePort: socket.remotePort,
+  };
+}
+
 export function initDiagnosticsChannel() {
   // makre sure init global DiagnosticsChannel once
   if (initedDiagnosticsChannel) return;
@@ -25,7 +46,7 @@ export function initDiagnosticsChannel() {
   let kHandler: symbol;
   // This message is published when a new outgoing request is created.
   // Note: a request is only loosely completed to a given socket.
-  diagnosticsChannel.channel('undici:request:create').subscribe((message, name) => {
+  subscribe('undici:request:create', (message, name) => {
     const { request } = message as DiagnosticsChannel.RequestCreateMessage;
     if (!kHandler) {
       const symbols = Object.getOwnPropertySymbols(request);
@@ -48,17 +69,21 @@ export function initDiagnosticsChannel() {
   // diagnosticsChannel.channel('undici:client:beforeConnect')
   // diagnosticsChannel.channel('undici:client:connectError')
   // This message is published after a connection is established.
-  diagnosticsChannel.channel('undici:client:connected').subscribe((message, name) => {
+  subscribe('undici:client:connected', (message, name) => {
     const { socket } = message as DiagnosticsChannel.ClientConnectedMessage;
     socket[symbols.kSocketId] = globalId('UndiciSocket');
     socket[symbols.kSocketStartTime] = performance.now();
+    socket[symbols.kSocketConnectedTime] = new Date();
     socket[symbols.kHandledRequests] = 0;
     socket[symbols.kHandledResponses] = 0;
-    debug('[%s] Socket#%d connected', name, socket[symbols.kSocketId]);
+    // copy local address to symbol, avoid them be reset after request error throw
+    socket[symbols.kSocketLocalAddress] = socket.localAddress;
+    socket[symbols.kSocketLocalPort] = socket.localPort;
+    debug('[%s] Socket#%d connected (sock: %o)', name, socket[symbols.kSocketId], formatSocket(socket));
   });
 
   // This message is published right before the first byte of the request is written to the socket.
-  diagnosticsChannel.channel('undici:client:sendHeaders').subscribe((message, name) => {
+  subscribe('undici:client:sendHeaders', (message, name) => {
     const { request, socket } = message as DiagnosticsChannel.ClientSendHeadersMessage;
     if (!kHandler) return;
     const opaque = request[kHandler]?.opts?.opaque;
@@ -67,8 +92,9 @@ export function initDiagnosticsChannel() {
     socket[symbols.kHandledRequests]++;
     // attach socket to opaque
     opaque[symbols.kRequestSocket] = socket;
-    debug('[%s] Request#%d send headers on Socket#%d (handled %d requests)',
-      name, opaque[symbols.kRequestId], socket[symbols.kSocketId], socket[symbols.kHandledRequests]);
+    debug('[%s] Request#%d send headers on Socket#%d (handled %d requests, sock: %o)',
+      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]);
@@ -80,7 +106,7 @@ export function initDiagnosticsChannel() {
     }
   });
 
-  diagnosticsChannel.channel('undici:request:bodySent').subscribe((message, name) => {
+  subscribe('undici:request:bodySent', (message, name) => {
     const { request } = message as DiagnosticsChannel.RequestBodySentMessage;
     if (!kHandler) return;
     const opaque = request[kHandler]?.opts?.opaque;
@@ -92,7 +118,7 @@ export function initDiagnosticsChannel() {
   });
 
   // This message is published after the response headers have been received, i.e. the response has been completed.
-  diagnosticsChannel.channel('undici:request:headers').subscribe((message, name) => {
+  subscribe('undici:request:headers', (message, name) => {
     const { request, response } = message as DiagnosticsChannel.RequestHeadersMessage;
     if (!kHandler) return;
     const opaque = request[kHandler]?.opts?.opaque;
@@ -101,15 +127,16 @@ export function initDiagnosticsChannel() {
     // get socket from opaque
     const socket = opaque[symbols.kRequestSocket];
     socket[symbols.kHandledResponses]++;
-    debug('[%s] Request#%d get %s response headers on Socket#%d (handled %d responses)',
-      name, opaque[symbols.kRequestId], response.statusCode, socket[symbols.kSocketId], socket[symbols.kHandledResponses]);
+    debug('[%s] Request#%d get %s response headers on Socket#%d (handled %d responses, sock: %o)',
+      name, opaque[symbols.kRequestId], response.statusCode, socket[symbols.kSocketId], socket[symbols.kHandledResponses],
+      formatSocket(socket));
 
     if (!opaque[symbols.kEnableRequestTiming]) return;
     opaque[symbols.kRequestTiming].waiting = performanceTime(opaque[symbols.kRequestStartTime]);
   });
 
   // This message is published after the response body and trailers have been received, i.e. the response has been completed.
-  diagnosticsChannel.channel('undici:request:trailers').subscribe((message, name) => {
+  subscribe('undici:request:trailers', (message, name) => {
     const { request } = message as DiagnosticsChannel.RequestTrailersMessage;
     if (!kHandler) return;
     const opaque = request[kHandler]?.opts?.opaque;
@@ -120,5 +147,15 @@ export function initDiagnosticsChannel() {
     if (!opaque[symbols.kEnableRequestTiming]) return;
     opaque[symbols.kRequestTiming].contentDownload = performanceTime(opaque[symbols.kRequestStartTime]);
   });
-  // diagnosticsChannel.channel('undici:request:error')
+
+  // This message is published if the request is going to error, but it has not errored yet.
+  // subscribe('undici:request:error', (message, name) => {
+  //   const { request, error } = message as DiagnosticsChannel.RequestErrorMessage;
+  //   const opaque = request[kHandler]?.opts?.opaque;
+  //   if (!opaque || !opaque[symbols.kRequestId]) return;
+  //   const socket = opaque[symbols.kRequestSocket];
+  //   debug('[%s] Request#%d error on Socket#%d (handled %d responses, sock: %o), error: %o',
+  //     name, opaque[symbols.kRequestId], socket[symbols.kSocketId], socket[symbols.kHandledResponses],
+  //     formatSocket(socket), error);
+  // });
 }

package/src/esm/HttpClient.d.ts

@@ -4,8 +4,8 @@
 import { EventEmitter } from 'node:events';
 import { LookupFunction } from 'node:net';
 import { CheckAddressFunction } from './HttpAgent';
-import { RequestURL, RequestOptions } from './Request';
-import { HttpClientResponse } from './Response';
+import { RequestURL, RequestOptions, RequestMeta } from './Request';
+import { RawResponseWithMeta, HttpClientResponse } from './Response';
 export type ClientOptions = {
     defaultArgs?: RequestOptions;
     /**
@@ -37,6 +37,14 @@ export type ClientOptions = {
     };
 };
 export declare const HEADER_USER_AGENT: string;
+export type RequestDiagnosticsMessage = {
+    request: RequestMeta;
+};
+export type ResponseDiagnosticsMessage = {
+    request: RequestMeta;
+    response: RawResponseWithMeta;
+    error?: Error;
+};
 export declare class HttpClient extends EventEmitter {
     #private;
     constructor(clientOptions?: ClientOptions);

package/src/esm/HttpClient.js

@@ -1,3 +1,4 @@
+import diagnosticsChannel from 'node:diagnostics_channel';
 import { EventEmitter } from 'node:events';
 import { STATUS_CODES } from 'node:http';
 import { debuglog } from 'node:util';
@@ -63,7 +64,7 @@ class HttpClientRequestTimeoutError extends Error {
         Error.captureStackTrace(this, this.constructor);
     }
 }
-export const HEADER_USER_AGENT = createUserAgent('node-urllib', '3.16.1');
+export const HEADER_USER_AGENT = createUserAgent('node-urllib', '3.17.1');
 function getFileName(stream) {
     const filePath = stream.path;
     if (filePath) {
@@ -74,6 +75,10 @@ function getFileName(stream) {
 function defaultIsRetry(response) {
     return response.status >= 500;
 }
+const channels = {
+    request: diagnosticsChannel.channel('urllib:request'),
+    response: diagnosticsChannel.channel('urllib:response'),
+};
 export class HttpClient extends EventEmitter {
     #defaultArgs;
     #dispatcher;
@@ -120,6 +125,8 @@ export class HttpClient extends EventEmitter {
         const headers = {};
         const args = {
             retry: 0,
+            socketErrorRetry: 1,
+            timing: true,
             ...this.#defaultArgs,
             ...options,
             // keep method and headers exists on args for request event handler to easy use
@@ -128,9 +135,13 @@ export class HttpClient extends EventEmitter {
         };
         requestContext = {
             retries: 0,
+            socketErrorRetries: 0,
             ...requestContext,
         };
-        const requestStartTime = performance.now();
+        if (!requestContext.requestStartTime) {
+            requestContext.requestStartTime = performance.now();
+        }
+        const requestStartTime = requestContext.requestStartTime;
         // https://developer.chrome.com/docs/devtools/network/reference/?utm_source=devtools#timing-explanation
         const timing = {
             // socket assigned
@@ -190,6 +201,8 @@ export class HttpClient extends EventEmitter {
             requestUrls: [],
             timing,
             socket: socketInfo,
+            retries: requestContext.retries,
+            socketErrorRetries: requestContext.socketErrorRetries,
         };
         let headersTimeout = 5000;
         let bodyTimeout = 5000;
@@ -234,9 +247,17 @@ export class HttpClient extends EventEmitter {
         if (requestContext.retries > 0) {
             headers['x-urllib-retry'] = `${requestContext.retries}/${args.retry}`;
         }
+        if (requestContext.socketErrorRetries > 0) {
+            headers['x-urllib-retry-on-socket-error'] = `${requestContext.socketErrorRetries}/${args.socketErrorRetry}`;
+        }
         if (args.auth && !headers.authorization) {
             headers.authorization = `Basic ${Buffer.from(args.auth).toString('base64')}`;
         }
+        // streaming request should disable socketErrorRetry and retry
+        let isStreamingRequest = false;
+        if (args.dataType === 'stream' || args.writeStream) {
+            isStreamingRequest = true;
+        }
         try {
             const requestOptions = {
                 method,
@@ -264,10 +285,12 @@ export class HttpClient extends EventEmitter {
                 if (isReadable(args.stream) && !(args.stream instanceof Readable)) {
                     debug('Request#%d convert old style stream to Readable', requestId);
                     args.stream = new Readable().wrap(args.stream);
+                    isStreamingRequest = true;
                 }
                 else if (args.stream instanceof FormStream) {
                     debug('Request#%d convert formstream to Readable', requestId);
                     args.stream = new Readable().wrap(args.stream);
+                    isStreamingRequest = true;
                 }
                 args.content = args.stream;
             }
@@ -315,6 +338,7 @@ export class HttpClient extends EventEmitter {
                     else if (file instanceof Readable || isReadable(file)) {
                         const fileName = getFileName(file) || `streamfile${index}`;
                         formData.append(field, new BlobFromStream(file, mime.lookup(fileName) || ''), fileName);
+                        isStreamingRequest = true;
                     }
                 }
                 if (FormDataNative) {
@@ -340,6 +364,7 @@ export class HttpClient extends EventEmitter {
                     else if (typeof args.content === 'string' && !headers['content-type']) {
                         headers['content-type'] = 'text/plain;charset=UTF-8';
                     }
+                    isStreamingRequest = isReadable(args.content);
                 }
             }
             else if (args.data) {
@@ -359,6 +384,7 @@ export class HttpClient extends EventEmitter {
                 else {
                     if (isStringOrBufferOrReadable) {
                         requestOptions.body = args.data;
+                        isStreamingRequest = isReadable(args.data);
                     }
                     else {
                         if (args.contentType === 'json'
@@ -376,8 +402,15 @@ export class HttpClient extends EventEmitter {
                     }
                 }
             }
-            debug('Request#%d %s %s, headers: %j, headersTimeout: %s, bodyTimeout: %s', requestId, requestOptions.method, requestUrl.href, headers, headersTimeout, bodyTimeout);
+            if (isStreamingRequest) {
+                args.retry = 0;
+                args.socketErrorRetry = 0;
+            }
+            debug('Request#%d %s %s, headers: %j, headersTimeout: %s, bodyTimeout: %s, isStreamingRequest: %s', requestId, requestOptions.method, requestUrl.href, headers, headersTimeout, bodyTimeout, isStreamingRequest);
             requestOptions.headers = headers;
+            channels.request.publish({
+                request: reqMeta,
+            });
             if (this.listenerCount('request') > 0) {
                 this.emit('request', reqMeta);
             }
@@ -422,8 +455,6 @@ export class HttpClient extends EventEmitter {
             }
             let data = null;
             if (args.dataType === 'stream') {
-                // streaming mode will disable retry
-                args.retry = 0;
                 // only auto decompress on request args.compressed = true
                 if (args.compressed === true && isCompressedContent) {
                     // gzip or br
@@ -435,8 +466,6 @@ export class HttpClient extends EventEmitter {
                 }
             }
             else if (args.writeStream) {
-                // streaming mode will disable retry
-                args.retry = 0;
                 if (args.compressed === true && isCompressedContent) {
                     const decoder = contentEncoding === 'gzip' ? createGunzip() : createBrotliDecompress();
                     await pipelinePromise(response.body, decoder, args.writeStream);
@@ -496,6 +525,10 @@ export class HttpClient extends EventEmitter {
                     return await this.#requestInternal(url, options, requestContext);
                 }
             }
+            channels.response.publish({
+                request: reqMeta,
+                response: res,
+            });
             if (this.listenerCount('response') > 0) {
                 this.emit('response', {
                     requestId,
@@ -519,16 +552,33 @@ export class HttpClient extends EventEmitter {
             else if (err.name === 'BodyTimeoutError') {
                 err = new HttpClientRequestTimeoutError(bodyTimeout, { cause: e });
             }
+            else if (err.code === 'UND_ERR_SOCKET' || err.code === 'ECONNRESET') {
+                // auto retry on socket error, https://github.com/node-modules/urllib/issues/454
+                if (args.socketErrorRetry > 0 && requestContext.socketErrorRetries < args.socketErrorRetry) {
+                    requestContext.socketErrorRetries++;
+                    return await this.#requestInternal(url, options, requestContext);
+                }
+            }
             err.opaque = orginalOpaque;
             err.status = res.status;
             err.headers = res.headers;
             err.res = res;
+            if (err.socket) {
+                // store rawSocket
+                err._rawSocket = err.socket;
+            }
+            err.socket = socketInfo;
             // make sure requestUrls not empty
             if (res.requestUrls.length === 0) {
                 res.requestUrls.push(requestUrl.href);
             }
             res.rt = performanceTime(requestStartTime);
             this.#updateSocketInfo(socketInfo, internalOpaque);
+            channels.response.publish({
+                request: reqMeta,
+                response: res,
+                error: err,
+            });
             if (this.listenerCount('response') > 0) {
                 this.emit('response', {
                     requestId,
@@ -550,13 +600,16 @@ export class HttpClient extends EventEmitter {
             socketInfo.id = socket[symbols.kSocketId];
             socketInfo.handledRequests = socket[symbols.kHandledRequests];
             socketInfo.handledResponses = socket[symbols.kHandledResponses];
-            socketInfo.localAddress = socket.localAddress;
-            socketInfo.localPort = socket.localPort;
+            socketInfo.localAddress = socket[symbols.kSocketLocalAddress];
+            socketInfo.localPort = socket[symbols.kSocketLocalPort];
             socketInfo.remoteAddress = socket.remoteAddress;
             socketInfo.remotePort = socket.remotePort;
             socketInfo.remoteFamily = socket.remoteFamily;
             socketInfo.bytesRead = socket.bytesRead;
             socketInfo.bytesWritten = socket.bytesWritten;
+            socketInfo.connectedTime = socket[symbols.kSocketConnectedTime];
+            socketInfo.lastRequestEndTime = socket[symbols.kSocketRequestEndTime];
+            socket[symbols.kSocketRequestEndTime] = new Date();
         }
     }
 }