urllib 4.3.1 → 4.5.0-beta.1

package/src/HttpClient.ts

@@ -9,7 +9,6 @@ import {
   gunzipSync,
   brotliDecompressSync,
 } from 'node:zlib';
-import { Blob } from 'node:buffer';
 import { Readable, pipeline } from 'node:stream';
 import { pipeline as pipelinePromise } from 'node:stream/promises';
 import { basename } from 'node:path';
@@ -19,13 +18,13 @@ import { performance } from 'node:perf_hooks';
 import querystring from 'node:querystring';
 import { setTimeout as sleep } from 'node:timers/promises';
 import {
-  FormData,
   request as undiciRequest,
   Dispatcher,
   Agent,
   getGlobalDispatcher,
   Pool,
 } from 'undici';
+import { FormData } from './FormData.js';
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import undiciSymbols from 'undici/lib/core/symbols.js';
@@ -37,7 +36,7 @@ import { HttpAgent, CheckAddressFunction } from './HttpAgent.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 } from './utils.js';
+import { parseJSON, digestAuthHeader, globalId, performanceTime, isReadable, updateSocketInfo } from './utils.js';
 import symbols from './symbols.js';
 import { initDiagnosticsChannel } from './diagnosticsChannel.js';
 import { HttpClientConnectTimeoutError, HttpClientRequestTimeoutError } from './HttpClientError.js';
@@ -47,7 +46,31 @@ 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>;
 
-const PROTO_RE = /^https?:\/\//i;
+export const PROTO_RE = /^https?:\/\//i;
+
+export interface UndiciTimingInfo {
+  startTime: number;
+  redirectStartTime: number;
+  redirectEndTime: number;
+  postRedirectStartTime: number;
+  finalServiceWorkerStartTime: number;
+  finalNetworkResponseStartTime: number;
+  finalNetworkRequestStartTime: number;
+  endTime: number;
+  encodedBodySize: number;
+  decodedBodySize: number;
+  finalConnectionTimingInfo: {
+    domainLookupStartTime: number;
+    domainLookupEndTime: number;
+    connectionStartTime: number;
+    connectionEndTime: number;
+    secureConnectionStartTime: number;
+    // ALPNNegotiatedProtocol: undefined
+  };
+}
+
+// keep typo compatibility
+export interface UnidiciTimingInfo extends UndiciTimingInfo {}
 
 function noop() {
   // noop
@@ -92,28 +115,6 @@ export type ClientOptions = {
   },
 };
 
-// https://github.com/octet-stream/form-data
-class BlobFromStream {
-  #stream;
-  #type;
-  constructor(stream: Readable, type: string) {
-    this.#stream = stream;
-    this.#type = type;
-  }
-
-  stream() {
-    return this.#stream;
-  }
-
-  get type(): string {
-    return this.#type;
-  }
-
-  get [Symbol.toStringTag]() {
-    return 'Blob';
-  }
-}
-
 export const VERSION = 'VERSION';
 // 'node-urllib/4.0.0 Node.js/18.19.0 (darwin; x64)'
 export const HEADER_USER_AGENT =
@@ -135,11 +136,15 @@ export type RequestContext = {
   retries: number;
   socketErrorRetries: number;
   requestStartTime?: number;
+  redirects: number;
+  history: string[];
 };
 
-const channels = {
+export const channels = {
   request: diagnosticsChannel.channel('urllib:request'),
   response: diagnosticsChannel.channel('urllib:response'),
+  fetchRequest: diagnosticsChannel.channel('urllib:fetch:request'),
+  fetchResponse: diagnosticsChannel.channel('urllib:fetch:response'),
 };
 
 export type RequestDiagnosticsMessage = {
@@ -167,6 +172,15 @@ export interface PoolStat {
   size: number;
 }
 
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Redirections
+const RedirectStatusCodes = [
+  301, // Moved Permanently
+  302, // Found
+  303, // See Other
+  307, // Temporary Redirect
+  308, // Permanent Redirect
+];
+
 export class HttpClient extends EventEmitter {
   #defaultArgs?: RequestOptions;
   #dispatcher?: Dispatcher;
@@ -271,11 +285,14 @@ export class HttpClient extends EventEmitter {
     requestContext = {
       retries: 0,
       socketErrorRetries: 0,
+      redirects: 0,
+      history: [],
       ...requestContext,
     };
     if (!requestContext.requestStartTime) {
       requestContext.requestStartTime = performance.now();
     }
+    requestContext.history.push(requestUrl.href);
     const requestStartTime = requestContext.requestStartTime;
 
     // https://developer.chrome.com/docs/devtools/network/reference/?utm_source=devtools#timing-explanation
@@ -335,7 +352,7 @@ export class HttpClient extends EventEmitter {
       aborted: false,
       rt: 0,
       keepAliveSocket: true,
-      requestUrls: [],
+      requestUrls: requestContext.history,
       timing,
       socket: socketInfo,
       retries: requestContext.retries,
@@ -396,10 +413,13 @@ export class HttpClient extends EventEmitter {
       isStreamingRequest = true;
     }
 
+    let maxRedirects = args.maxRedirects ?? 10;
+
     try {
       const requestOptions: IUndiciRequestOption = {
         method,
-        maxRedirections: args.maxRedirects ?? 10,
+        // disable undici auto redirect handler
+        maxRedirections: 0,
         headersTimeout,
         headers,
         bodyTimeout,
@@ -414,7 +434,7 @@ export class HttpClient extends EventEmitter {
         requestOptions.reset = args.reset;
       }
       if (args.followRedirect === false) {
-        requestOptions.maxRedirections = 0;
+        maxRedirects = 0;
       }
 
       const isGETOrHEAD = requestOptions.method === 'GET' || requestOptions.method === 'HEAD';
@@ -464,21 +484,28 @@ export class HttpClient extends EventEmitter {
           }
         }
         for (const [ index, [ field, file, customFileName ]] of uploadFiles.entries()) {
+          let fileName = '';
+          let value: any;
           if (typeof file === 'string') {
-            // FIXME: support non-ascii filename
-            // const fileName = encodeURIComponent(basename(file));
-            // formData.append(field, await fileFromPath(file, `utf-8''${fileName}`, { type: mime.lookup(fileName) || '' }));
-            const fileName = basename(file);
-            const fileReadable = createReadStream(file);
-            formData.append(field, new BlobFromStream(fileReadable, mime.lookup(fileName) || ''), fileName);
+            fileName = basename(file);
+            value = createReadStream(file);
           } else if (Buffer.isBuffer(file)) {
-            formData.append(field, new Blob([ file ]), customFileName || `bufferfile${index}`);
+            fileName = customFileName || `bufferfile${index}`;
+            value = file;
           } else if (file instanceof Readable || isReadable(file as any)) {
-            const fileName = getFileName(file) || customFileName || `streamfile${index}`;
-            formData.append(field, new BlobFromStream(file, mime.lookup(fileName) || ''), fileName);
+            fileName = getFileName(file) || customFileName || `streamfile${index}`;
             isStreamingRequest = true;
+            value = file;
           }
+          const mimeType = mime.lookup(fileName) || '';
+          formData.append(field, value, {
+            filename: fileName,
+            contentType: mimeType,
+          });
+          debug('formData append field: %s, mimeType: %s, fileName: %s',
+            field, mimeType, fileName);
         }
+        Object.assign(headers, formData.getHeaders());
         requestOptions.body = formData;
       } else if (args.content) {
         if (!isGETOrHEAD) {
@@ -535,8 +562,8 @@ export class HttpClient extends EventEmitter {
         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);
+      debug('Request#%d %s %s, headers: %j, headersTimeout: %s, bodyTimeout: %s, isStreamingRequest: %s, maxRedirections: %s, redirects: %s',
+        requestId, requestOptions.method, requestUrl.href, headers, headersTimeout, bodyTimeout, isStreamingRequest, maxRedirects, requestContext.redirects);
       requestOptions.headers = headers;
       channels.request.publish({
         request: reqMeta,
@@ -567,18 +594,6 @@ export class HttpClient extends EventEmitter {
           response = await undiciRequest(requestUrl, requestOptions as UndiciRequestOption);
         }
       }
-
-      const context = response.context as { history: URL[] };
-      let lastUrl = '';
-      if (context?.history) {
-        for (const urlObject of context?.history) {
-          res.requestUrls.push(urlObject.href);
-          lastUrl = urlObject.href;
-        }
-      } else {
-        res.requestUrls.push(requestUrl.href);
-        lastUrl = requestUrl.href;
-      }
       const contentEncoding = response.headers['content-encoding'];
       const isCompressedContent = contentEncoding === 'gzip' || contentEncoding === 'br';
 
@@ -589,6 +604,19 @@ export class HttpClient extends EventEmitter {
         res.size = parseInt(res.headers['content-length']);
       }
 
+      // https://developer.mozilla.org/en-US/docs/Web/HTTP/Redirections
+      if (RedirectStatusCodes.includes(res.statusCode) && maxRedirects > 0 && requestContext.redirects < maxRedirects && !isStreamingRequest) {
+        if (res.headers.location) {
+          requestContext.redirects++;
+          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 data: any = null;
       if (args.dataType === 'stream') {
         // only auto decompress on request args.compressed = true
@@ -631,7 +659,7 @@ export class HttpClient extends EventEmitter {
       }
       res.rt = performanceTime(requestStartTime);
       // get real socket info from internalOpaque
-      this.#updateSocketInfo(socketInfo, internalOpaque);
+      updateSocketInfo(socketInfo, internalOpaque);
 
       const clientResponse: HttpClientResponse = {
         opaque: originalOpaque,
@@ -640,12 +668,15 @@ export class HttpClient extends EventEmitter {
         statusCode: res.status,
         statusText: res.statusText,
         headers: res.headers,
-        url: lastUrl,
-        redirected: res.requestUrls.length > 1,
+        url: requestUrl.href,
+        redirected: requestContext.history.length > 1,
         requestUrls: res.requestUrls,
         res,
       };
 
+      debug('Request#%d got response, status: %s, headers: %j, timing: %j',
+        requestId, res.status, res.headers, res.timing);
+
       if (args.retry > 0 && requestContext.retries < args.retry) {
         const isRetry = args.isRetry ?? defaultIsRetry;
         if (isRetry(clientResponse)) {
@@ -657,8 +688,6 @@ export class HttpClient extends EventEmitter {
         }
       }
 
-      debug('Request#%d got response, status: %s, headers: %j, timing: %j',
-        requestId, res.status, res.headers, res.timing);
       channels.response.publish({
         request: reqMeta,
         response: res,
@@ -678,7 +707,8 @@ export class HttpClient extends EventEmitter {
 
       return clientResponse;
     } catch (rawError: any) {
-      debug('Request#%d throw error: %s', requestId, rawError);
+      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 });
@@ -690,6 +720,8 @@ 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);
           return await this.#requestInternal(url, options, requestContext);
         }
       }
@@ -702,12 +734,8 @@ export class HttpClient extends EventEmitter {
         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, rawError);
+      updateSocketInfo(socketInfo, internalOpaque, rawError);
 
       channels.response.publish({
         request: reqMeta,
@@ -729,40 +757,4 @@ export class HttpClient extends EventEmitter {
       throw err;
     }
   }
-
-  #updateSocketInfo(socketInfo: SocketInfo, internalOpaque: any, err?: any) {
-    const socket = internalOpaque[symbols.kRequestSocket] ?? err?.[symbols.kErrorSocket];
-    if (socket) {
-      socketInfo.id = socket[symbols.kSocketId];
-      socketInfo.handledRequests = socket[symbols.kHandledRequests];
-      socketInfo.handledResponses = socket[symbols.kHandledResponses];
-      if (socket[symbols.kSocketLocalAddress]) {
-        socketInfo.localAddress = socket[symbols.kSocketLocalAddress];
-        socketInfo.localPort = socket[symbols.kSocketLocalPort];
-      }
-      if (socket.remoteAddress) {
-        socketInfo.remoteAddress = socket.remoteAddress;
-        socketInfo.remotePort = socket.remotePort;
-        socketInfo.remoteFamily = socket.remoteFamily;
-      }
-      socketInfo.bytesRead = socket.bytesRead;
-      socketInfo.bytesWritten = socket.bytesWritten;
-      if (socket[symbols.kSocketConnectErrorTime]) {
-        socketInfo.connectErrorTime = socket[symbols.kSocketConnectErrorTime];
-        if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
-          socketInfo.attemptedRemoteAddresses = socket.autoSelectFamilyAttemptedAddresses;
-        }
-        socketInfo.connectProtocol = socket[symbols.kSocketConnectProtocol];
-        socketInfo.connectHost = socket[symbols.kSocketConnectHost];
-        socketInfo.connectPort = socket[symbols.kSocketConnectPort];
-      }
-      if (socket[symbols.kSocketConnectedTime]) {
-        socketInfo.connectedTime = socket[symbols.kSocketConnectedTime];
-      }
-      if (socket[symbols.kSocketRequestEndTime]) {
-        socketInfo.lastRequestEndTime = socket[symbols.kSocketRequestEndTime];
-      }
-      socket[symbols.kSocketRequestEndTime] = new Date();
-    }
-  }
 }

package/src/Request.ts

@@ -3,6 +3,7 @@ import type { EventEmitter } from 'node:events';
 import type { Dispatcher } from 'undici';
 import type { IncomingHttpHeaders } from './IncomingHttpHeaders.js';
 import type { HttpClientResponse } from './Response.js';
+import { Request } from 'undici';
 
 export type HttpMethod = Dispatcher.HttpMethod;
 
@@ -161,3 +162,8 @@ export type RequestMeta = {
   ctx?: unknown;
   retries: number;
 };
+
+export type FetchMeta = {
+  requestId: number;
+  request: Request,
+};

package/src/diagnosticsChannel.ts

@@ -143,7 +143,10 @@ export function initDiagnosticsChannel() {
   subscribe('undici:client:sendHeaders', (message, name) => {
     const { request, socket } = message as DiagnosticsChannel.ClientSendHeadersMessage & { socket: SocketExtend };
     const opaque = getRequestOpaque(request, kHandler);
-    if (!opaque || !opaque[symbols.kRequestId]) return;
+    if (!opaque || !opaque[symbols.kRequestId]) {
+      debug('[%s] opaque not found', name);
+      return;
+    }
 
     (socket[symbols.kHandledRequests] as number)++;
     // attach socket to opaque
@@ -165,7 +168,10 @@ export function initDiagnosticsChannel() {
   subscribe('undici:request:bodySent', (message, name) => {
     const { request } = message as DiagnosticsChannel.RequestBodySentMessage;
     const opaque = getRequestOpaque(request, kHandler);
-    if (!opaque || !opaque[symbols.kRequestId]) return;
+    if (!opaque || !opaque[symbols.kRequestId]) {
+      debug('[%s] opaque not found', name);
+      return;
+    }
 
     debug('[%s] Request#%d send body', name, opaque[symbols.kRequestId]);
     if (!opaque[symbols.kEnableRequestTiming]) return;
@@ -176,7 +182,10 @@ export function initDiagnosticsChannel() {
   subscribe('undici:request:headers', (message, name) => {
     const { request, response } = message as DiagnosticsChannel.RequestHeadersMessage;
     const opaque = getRequestOpaque(request, kHandler);
-    if (!opaque || !opaque[symbols.kRequestId]) return;
+    if (!opaque || !opaque[symbols.kRequestId]) {
+      debug('[%s] opaque not found', name);
+      return;
+    }
 
     // get socket from opaque
     const socket = opaque[symbols.kRequestSocket];
@@ -199,6 +208,7 @@ export function initDiagnosticsChannel() {
     const { request } = message as DiagnosticsChannel.RequestTrailersMessage;
     const opaque = getRequestOpaque(request, kHandler);
     if (!opaque || !opaque[symbols.kRequestId]) {
+      debug('[%s] opaque not found', name);
       return;
     }
 

package/src/fetch.ts

@@ -0,0 +1,263 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import {
+  fetch as UndiciFetch,
+  RequestInfo,
+  RequestInit,
+  Request,
+  Response,
+  Agent,
+  getGlobalDispatcher,
+  Pool,
+} from 'undici';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import undiciSymbols from 'undici/lib/core/symbols.js';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import { getResponseState } from 'undici/lib/web/fetch/response.js';
+import {
+  channels,
+  ClientOptions,
+  PoolStat,
+  RequestDiagnosticsMessage,
+  ResponseDiagnosticsMessage,
+  UndiciTimingInfo,
+} from './HttpClient.js';
+import {
+  HttpAgent,
+  HttpAgentOptions,
+} from './HttpAgent.js';
+import { initDiagnosticsChannel } from './diagnosticsChannel.js';
+import { convertHeader, globalId, performanceTime, updateSocketInfo } from './utils.js';
+import symbols from './symbols.js';
+import {
+  FetchMeta,
+  HttpMethod,
+  RequestMeta,
+} from './Request.js';
+import { FetchOpaque, fetchOpaqueInterceptor } from './FetchOpaqueInterceptor.js';
+import { RawResponseWithMeta, SocketInfo } from './Response.js';
+import { IncomingHttpHeaders } from './IncomingHttpHeaders.js';
+
+export interface UrllibRequestInit extends RequestInit {
+  // default is true
+  timing?: boolean;
+}
+
+export type FetchDiagnosticsMessage = {
+  fetch: FetchMeta;
+};
+
+export type FetchResponseDiagnosticsMessage = {
+  fetch: FetchMeta;
+  timingInfo?: UndiciTimingInfo;
+  response?: Response;
+  error?: Error;
+};
+
+export class FetchFactory {
+  static #dispatcher: Agent;
+  static #opaqueLocalStorage = new AsyncLocalStorage<FetchOpaque>();
+
+  static getDispatcher() {
+    return FetchFactory.#dispatcher ?? getGlobalDispatcher();
+  }
+
+  static setDispatcher(dispatcher: Agent) {
+    FetchFactory.#dispatcher = dispatcher;
+  }
+
+  static setClientOptions(clientOptions: ClientOptions) {
+    let dispatcherOption: Agent.Options = {
+      interceptors: {
+        Agent: [
+          fetchOpaqueInterceptor({
+            opaqueLocalStorage: FetchFactory.#opaqueLocalStorage,
+          }),
+        ],
+        Client: [],
+      },
+    };
+    let dispatcherClazz: new (options: Agent.Options) => Agent = Agent;
+    if (clientOptions?.lookup || clientOptions?.checkAddress) {
+      dispatcherOption = {
+        ...dispatcherOption,
+        lookup: clientOptions.lookup,
+        checkAddress: clientOptions.checkAddress,
+        connect: clientOptions.connect,
+        allowH2: clientOptions.allowH2,
+      } as HttpAgentOptions;
+      dispatcherClazz = HttpAgent as unknown as new (options: Agent.Options) => Agent;
+    } else if (clientOptions?.connect) {
+      dispatcherOption = {
+        ...dispatcherOption,
+        connect: clientOptions.connect,
+        allowH2: clientOptions.allowH2,
+      } as HttpAgentOptions;
+      dispatcherClazz = Agent;
+    } else if (clientOptions?.allowH2) {
+      // Support HTTP2
+      dispatcherOption = {
+        ...dispatcherOption,
+        allowH2: clientOptions.allowH2,
+      } as HttpAgentOptions;
+      dispatcherClazz = Agent;
+    }
+    FetchFactory.#dispatcher = new dispatcherClazz(dispatcherOption);
+    initDiagnosticsChannel();
+  }
+
+  static getDispatcherPoolStats() {
+    const agent = FetchFactory.getDispatcher();
+    // origin => Pool Instance
+    const clients: Map<string, WeakRef<Pool>> | undefined = Reflect.get(agent, undiciSymbols.kClients);
+    const poolStatsMap: Record<string, PoolStat> = {};
+    if (!clients) {
+      return poolStatsMap;
+    }
+    for (const [ key, ref ] of clients) {
+      const pool = typeof ref.deref === 'function' ? ref.deref() : ref as unknown as Pool;
+      const stats = pool?.stats;
+      if (!stats) continue;
+      poolStatsMap[key] = {
+        connected: stats.connected,
+        free: stats.free,
+        pending: stats.pending,
+        queued: stats.queued,
+        running: stats.running,
+        size: stats.size,
+      } satisfies PoolStat;
+    }
+    return poolStatsMap;
+  }
+
+  static async fetch(input: RequestInfo, init?: UrllibRequestInit): Promise<Response> {
+    const requestStartTime = performance.now();
+    init = init ?? {};
+    init.dispatcher = init.dispatcher ?? FetchFactory.#dispatcher;
+    const request = new Request(input, init);
+    const requestId = globalId('HttpClientRequest');
+    // https://developer.chrome.com/docs/devtools/network/reference/?utm_source=devtools#timing-explanation
+    const timing = {
+      // socket assigned
+      queuing: 0,
+      // dns lookup time
+      // dnslookup: 0,
+      // socket connected
+      connected: 0,
+      // request headers sent
+      requestHeadersSent: 0,
+      // request sent, including headers and body
+      requestSent: 0,
+      // Time to first byte (TTFB), the response headers have been received
+      waiting: 0,
+      // the response body and trailers have been received
+      contentDownload: 0,
+    };
+
+    // using opaque to diagnostics channel, binding request and socket
+    const internalOpaque = {
+      [symbols.kRequestId]: requestId,
+      [symbols.kRequestStartTime]: requestStartTime,
+      [symbols.kEnableRequestTiming]: !!(init.timing ?? true),
+      [symbols.kRequestTiming]: timing,
+      // [symbols.kRequestOriginalOpaque]: originalOpaque,
+    } as FetchOpaque;
+    const reqMeta: RequestMeta = {
+      requestId,
+      url: request.url,
+      args: {
+        method: request.method as HttpMethod,
+        type: request.method as HttpMethod,
+        data: request.body,
+        headers: convertHeader(request.headers),
+      },
+      retries: 0,
+    };
+    const fetchMeta: FetchMeta = {
+      requestId,
+      request,
+    };
+    const socketInfo: SocketInfo = {
+      id: 0,
+      localAddress: '',
+      localPort: 0,
+      remoteAddress: '',
+      remotePort: 0,
+      remoteFamily: '',
+      bytesWritten: 0,
+      bytesRead: 0,
+      handledRequests: 0,
+      handledResponses: 0,
+    };
+    channels.request.publish({
+      request: reqMeta,
+    } as RequestDiagnosticsMessage);
+    channels.fetchRequest.publish({
+      fetch: fetchMeta,
+    } as FetchDiagnosticsMessage);
+
+    let res: Response;
+    // keep urllib createCallbackResponse style
+    const resHeaders: IncomingHttpHeaders = {};
+    const urllibResponse = {
+      status: -1,
+      statusCode: -1,
+      statusText: '',
+      statusMessage: '',
+      headers: resHeaders,
+      size: 0,
+      aborted: false,
+      rt: 0,
+      keepAliveSocket: true,
+      requestUrls: [
+        request.url,
+      ],
+      timing,
+      socket: socketInfo,
+      retries: 0,
+      socketErrorRetries: 0,
+    } as any as RawResponseWithMeta;
+    try {
+      await FetchFactory.#opaqueLocalStorage.run(internalOpaque, async () => {
+        res = await UndiciFetch(input, init);
+      });
+    } catch (e: any) {
+      channels.response.publish({
+        fetch: fetchMeta,
+        error: e,
+      } as FetchResponseDiagnosticsMessage);
+      channels.fetchResponse.publish({
+        request: reqMeta,
+        response: urllibResponse,
+        error: e,
+      } as ResponseDiagnosticsMessage);
+      throw e;
+    }
+
+    // get undici internal response
+    const state = getResponseState(res!);
+    updateSocketInfo(socketInfo, internalOpaque /* , rawError */);
+
+    urllibResponse.headers = convertHeader(res!.headers);
+    urllibResponse.status = urllibResponse.statusCode = res!.status;
+    urllibResponse!.statusMessage = res!.statusText;
+    if (urllibResponse.headers['content-length']) {
+      urllibResponse.size = parseInt(urllibResponse.headers['content-length']);
+    }
+    urllibResponse.rt = performanceTime(requestStartTime);
+
+    channels.fetchResponse.publish({
+      fetch: fetchMeta,
+      timingInfo: state.timingInfo,
+      response: res!,
+    } as FetchResponseDiagnosticsMessage);
+    channels.response.publish({
+      request: reqMeta,
+      response: urllibResponse,
+    } as ResponseDiagnosticsMessage);
+    return res!;
+  }
+}
+
+export const fetch = FetchFactory.fetch;