urllib 3.19.3 → 3.21.0

package/src/HttpClientError.ts

@@ -0,0 +1,34 @@
+import type { RawResponseWithMeta, SocketInfo } from './Response.js';
+import type { IncomingHttpHeaders } from './IncomingHttpHeaders.js';
+
+// need to support ES2021
+interface ErrorOptions {
+  cause?: Error;
+}
+
+export class HttpClientRequestError extends Error {
+  status?: number;
+  headers?: IncomingHttpHeaders;
+  socket?: SocketInfo;
+  res?: RawResponseWithMeta;
+}
+
+export class HttpClientRequestTimeoutError extends HttpClientRequestError {
+  constructor(timeout: number, options: ErrorOptions) {
+    const message = `Request timeout for ${timeout} ms`;
+    super(message, options);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+export class HttpClientConnectTimeoutError extends HttpClientRequestError {
+  code: string;
+
+  constructor(message: string, code: string, options: ErrorOptions) {
+    super(message, options);
+    this.name = this.constructor.name;
+    this.code = code;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}

package/src/Response.ts

@@ -13,7 +13,12 @@ export type SocketInfo = {
   handledRequests: number;
   handledResponses: number;
   connectedTime?: Date;
+  connectErrorTime?: Date;
   lastRequestEndTime?: Date;
+  attemptedRemoteAddresses?: string[];
+  connectProtocol?: string;
+  connectHost?: string;
+  connectPort?: string;
 };
 
 /**

package/src/diagnosticsChannel.ts

@@ -35,9 +35,25 @@ function formatSocket(socket: Socket) {
     localPort: socket[symbols.kSocketLocalPort],
     remoteAddress: socket.remoteAddress,
     remotePort: socket.remotePort,
+    attemptedAddresses: socket.autoSelectFamilyAttemptedAddresses,
+    connecting: socket.connecting,
   };
 }
 
+// make sure error contains socket info
+const kDestroy = Symbol('kDestroy');
+Socket.prototype[kDestroy] = Socket.prototype.destroy;
+Socket.prototype.destroy = function(err?: any) {
+  if (err) {
+    Object.defineProperty(err, symbols.kErrorSocket, {
+      // don't show on console log
+      enumerable: false,
+      value: this,
+    });
+  }
+  return this[kDestroy](err);
+};
+
 export function initDiagnosticsChannel() {
   // makre sure init global DiagnosticsChannel once
   if (initedDiagnosticsChannel) return;
@@ -67,10 +83,37 @@ export function initDiagnosticsChannel() {
   });
 
   // diagnosticsChannel.channel('undici:client:beforeConnect')
-  // diagnosticsChannel.channel('undici:client:connectError')
+
+  subscribe('undici:client:connectError', (message, name) => {
+    const { error, connectParams } = message as DiagnosticsChannel.ClientConnectErrorMessage & { error: any };
+    let { socket } = message as DiagnosticsChannel.ClientConnectErrorMessage;
+    if (!socket && error[symbols.kErrorSocket]) {
+      socket = error[symbols.kErrorSocket];
+    }
+    if (socket) {
+      socket[symbols.kSocketId] = globalId('UndiciSocket');
+      socket[symbols.kSocketConnectErrorTime] = new Date();
+      socket[symbols.kHandledRequests] = 0;
+      socket[symbols.kHandledResponses] = 0;
+      // copy local address to symbol, avoid them be reset after request error throw
+      if (socket.localAddress) {
+        socket[symbols.kSocketLocalAddress] = socket.localAddress;
+        socket[symbols.kSocketLocalPort] = socket.localPort;
+      }
+      socket[symbols.kSocketConnectProtocol] = connectParams.protocol;
+      socket[symbols.kSocketConnectHost] = connectParams.host;
+      socket[symbols.kSocketConnectPort] = connectParams.port;
+      debug('[%s] Socket#%d connectError, connectParams: %o, error: %s, (sock: %o)',
+        name, socket[symbols.kSocketId], connectParams, (error as Error).message, formatSocket(socket));
+    } else {
+      debug('[%s] connectError, connectParams: %o, error: %o',
+        name, connectParams, error);
+    }
+  });
+
   // This message is published after a connection is established.
   subscribe('undici:client:connected', (message, name) => {
-    const { socket } = message as DiagnosticsChannel.ClientConnectedMessage;
+    const { socket, connectParams } = message as DiagnosticsChannel.ClientConnectedMessage;
     socket[symbols.kSocketId] = globalId('UndiciSocket');
     socket[symbols.kSocketStartTime] = performance.now();
     socket[symbols.kSocketConnectedTime] = new Date();
@@ -79,6 +122,9 @@ export function initDiagnosticsChannel() {
     // copy local address to symbol, avoid them be reset after request error throw
     socket[symbols.kSocketLocalAddress] = socket.localAddress;
     socket[symbols.kSocketLocalPort] = socket.localPort;
+    socket[symbols.kSocketConnectProtocol] = connectParams.protocol;
+    socket[symbols.kSocketConnectHost] = connectParams.host;
+    socket[symbols.kSocketConnectPort] = connectParams.port;
     debug('[%s] Socket#%d connected (sock: %o)', name, socket[symbols.kSocketId], formatSocket(socket));
   });
 

package/src/index.ts

@@ -4,6 +4,7 @@ import { RequestOptions, RequestURL } from './Request.js';
 
 let httpclient: HttpClient;
 const domainSocketHttpclients = new LRU(50);
+
 export async function request<T = any>(url: RequestURL, options?: RequestOptions) {
   if (options?.socketPath) {
     let domainSocketHttpclient = domainSocketHttpclients.get<HttpClient>(options.socketPath);
@@ -22,7 +23,7 @@ export async function request<T = any>(url: RequestURL, options?: RequestOptions
   return await httpclient.request<T>(url, options);
 }
 
-// export curl method is keep compatible with urlib.curl()
+// export curl method is keep compatible with urllib.curl()
 // ```ts
 // import * as urllib from 'urllib';
 // urllib.curl(url);
@@ -52,7 +53,7 @@ export {
 export {
   IncomingHttpHeaders,
 } from './IncomingHttpHeaders.js';
-
+export * from './HttpClientError.js';
 
 export default {
   request,

package/src/symbols.ts

@@ -2,9 +2,13 @@ export default {
   kSocketId: Symbol('socket id'),
   kSocketStartTime: Symbol('socket start time'),
   kSocketConnectedTime: Symbol('socket connected time'),
+  kSocketConnectErrorTime: Symbol('socket connectError time'),
   kSocketRequestEndTime: Symbol('socket request end time'),
   kSocketLocalAddress: Symbol('socket local address'),
   kSocketLocalPort: Symbol('socket local port'),
+  kSocketConnectHost: Symbol('socket connect params: host'),
+  kSocketConnectPort: Symbol('socket connect params: port'),
+  kSocketConnectProtocol: Symbol('socket connect params: protocol'),
   kHandledRequests: Symbol('handled requests per socket'),
   kHandledResponses: Symbol('handled responses per socket'),
   kRequestSocket: Symbol('request on the socket'),
@@ -13,4 +17,5 @@ export default {
   kEnableRequestTiming: Symbol('enable request timing or not'),
   kRequestTiming: Symbol('request timing'),
   kRequestOriginalOpaque: Symbol('request original opaque'),
+  kErrorSocket: Symbol('socket of error'),
 };