rezo 1.0.18 → 1.0.20

package/dist/adapters/http.cjs

@@ -20,6 +20,100 @@ const { isSameDomain, RezoPerformance } = require('../utils/tools.cjs');
 const { getGlobalDNSCache } = require('../cache/dns-cache.cjs');
 const { ResponseCache } = require('../cache/response-cache.cjs');
 const dns = require("dns");
+const debugLog = {
+  requestStart: (config, url, method) => {
+    if (config.debug) {
+      console.log(`
+[Rezo Debug] ─────────────────────────────────────`);
+      console.log(`[Rezo Debug] ${method} ${url}`);
+      console.log(`[Rezo Debug] Request ID: ${config.requestId}`);
+      if (config.originalRequest?.headers) {
+        const headers = config.originalRequest.headers instanceof RezoHeaders ? config.originalRequest.headers.toObject() : config.originalRequest.headers;
+        console.log(`[Rezo Debug] Request Headers:`, JSON.stringify(headers, null, 2));
+      }
+      if (config.proxy && typeof config.proxy === "object") {
+        console.log(`[Rezo Debug] Proxy: ${config.proxy.protocol}://${config.proxy.host}:${config.proxy.port}`);
+      } else if (config.proxy && typeof config.proxy === "string") {
+        console.log(`[Rezo Debug] Proxy: ${config.proxy}`);
+      }
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] → ${method} ${url}`);
+    }
+  },
+  redirect: (config, fromUrl, toUrl, statusCode, method) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Redirect ${statusCode}: ${fromUrl}`);
+      console.log(`[Rezo Debug]        → ${toUrl} (${method})`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ↳ ${statusCode} → ${toUrl}`);
+    }
+  },
+  retry: (config, attempt, maxRetries, statusCode, delay) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Retry ${attempt}/${maxRetries} after status ${statusCode}${delay > 0 ? ` (waiting ${delay}ms)` : ""}`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ⟳ Retry ${attempt}/${maxRetries} (status ${statusCode})`);
+    }
+  },
+  maxRetries: (config, maxRetries) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Max retries (${maxRetries}) reached, throwing error`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ✗ Max retries reached`);
+    }
+  },
+  response: (config, status, statusText, duration) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response: ${status} ${statusText} (${duration.toFixed(2)}ms)`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] ✓ ${status} ${statusText}`);
+    }
+  },
+  responseHeaders: (config, headers) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response Headers:`, JSON.stringify(headers, null, 2));
+    }
+  },
+  cookies: (config, cookieCount) => {
+    if (config.debug && cookieCount > 0) {
+      console.log(`[Rezo Debug] Cookies received: ${cookieCount}`);
+    }
+  },
+  timing: (config, timing) => {
+    if (config.debug) {
+      const parts = [];
+      if (timing.dns)
+        parts.push(`DNS: ${timing.dns.toFixed(2)}ms`);
+      if (timing.connect)
+        parts.push(`Connect: ${timing.connect.toFixed(2)}ms`);
+      if (timing.tls)
+        parts.push(`TLS: ${timing.tls.toFixed(2)}ms`);
+      if (timing.ttfb)
+        parts.push(`TTFB: ${timing.ttfb.toFixed(2)}ms`);
+      if (timing.total)
+        parts.push(`Total: ${timing.total.toFixed(2)}ms`);
+      if (parts.length > 0) {
+        console.log(`[Rezo Debug] Timing: ${parts.join(" | ")}`);
+      }
+    }
+  },
+  complete: (config, finalUrl, redirectCount, duration) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Complete: ${finalUrl}`);
+      if (redirectCount > 0) {
+        console.log(`[Rezo Debug] Redirects: ${redirectCount}`);
+      }
+      console.log(`[Rezo Debug] Total Duration: ${duration.toFixed(2)}ms`);
+      console.log(`[Rezo Debug] ─────────────────────────────────────
+`);
+    }
+  }
+};
 const responseCacheInstances = new Map;
 function getCacheConfigKey(option) {
   if (option === true)
@@ -246,6 +340,8 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
   config.setSignal();
   const timeoutClearInstanse = config.timeoutClearInstanse;
   delete config.timeoutClearInstanse;
+  const requestUrl = fetchOptions.fullUrl ? String(fetchOptions.fullUrl) : "";
+  debugLog.requestStart(config, requestUrl, fetchOptions.method || "GET");
   const eventEmitter = streamResult || downloadResult || uploadResult;
   if (eventEmitter) {
     eventEmitter.emit("initiated");
@@ -284,17 +380,14 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
               throw response;
             }
             if (maxRetries <= retries) {
-              if (config.debug) {
-                console.log(`Max retries (${maxRetries}) reached, throwing the last error`);
-              }
+              debugLog.maxRetries(config, maxRetries);
               throw response;
             }
             retries++;
-            if (config.debug) {
-              console.log(`Request failed with status code ${responseStatusCode}, retrying...${retryDelay > 0 ? " in " + (incrementDelay ? retryDelay * retries : retryDelay) + "ms" : ""}`);
-            }
+            const currentDelay = incrementDelay ? retryDelay * retries : retryDelay;
+            debugLog.retry(config, retries, maxRetries, responseStatusCode, currentDelay);
             if (retryDelay > 0) {
-              await new Promise((resolve) => setTimeout(resolve, incrementDelay ? retryDelay * retries : retryDelay));
+              await new Promise((resolve) => setTimeout(resolve, currentDelay));
             }
           }
           config.retryAttempts++;
@@ -302,6 +395,16 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
         continue;
       }
       if (statusOnNext === "success") {
+        const totalDuration = performance.now() - timing.startTime;
+        debugLog.response(config, response.status, response.statusText, totalDuration);
+        if (response.headers) {
+          const headersObj = response.headers instanceof RezoHeaders ? response.headers.toObject() : response.headers;
+          debugLog.responseHeaders(config, headersObj);
+        }
+        if (response.cookies?.array) {
+          debugLog.cookies(config, response.cookies.array.length);
+        }
+        debugLog.complete(config, response.finalUrl || requestUrl, config.redirectCount, totalDuration);
         return response;
       }
       if (statusOnNext === "redirect") {
@@ -363,8 +466,8 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
         addedOptions.customHeaders = customHeaders;
         addedOptions.fullUrl = fetchOptions.fullUrl;
         delete options.params;
+        const fromUrl = fetchOptions.fullUrl;
         fetchOptions.fullUrl = location;
-        let commented = false;
         if (typeof onRedirect === "object" && onRedirect.redirect) {
           const method = onRedirect.method || fetchOptions.method;
           config.method = method;
@@ -375,26 +478,16 @@ async function executeHttp1Request(fetchOptions, config, options, perform, fs, s
           } else if (onRedirect.body) {
             options.body = onRedirect.body;
           }
-          if (config.debug) {
-            commented = true;
-            console.log(`
-Redirecting to: ${fetchOptions.fullUrl} using ${method} method`);
-          }
+          debugLog.redirect(config, fromUrl, fetchOptions.fullUrl, redirectCode, method);
           if (onRedirect.setHeaders) {
             addedOptions.customHeaders = onRedirect.setHeaders;
           }
         } else if (response.status === 301 || response.status === 302 || response.status === 303) {
-          if (config.debug) {
-            commented = true;
-            console.log(`
-Redirecting to: ${fetchOptions.fullUrl} using GET method`);
-          }
+          debugLog.redirect(config, fromUrl, fetchOptions.fullUrl, redirectCode, "GET");
           options.method = "GET";
           delete options.body;
-        } else
-          commented = false;
-        if (config.debug && !commented) {
-          console.log(`Redirecting to: ${fetchOptions.fullUrl}`);
+        } else {
+          debugLog.redirect(config, fromUrl, fetchOptions.fullUrl, redirectCode, fetchOptions.method);
         }
         const __ = prepareHTTPOptions(fetchOptions, config.cookieJar, addedOptions, config);
         fetchOptions = __.fetchOptions;
@@ -414,11 +507,10 @@ Redirecting to: ${fetchOptions.fullUrl} using GET method`);
               duration: perform.now()
             });
             perform.reset();
-            if (config.debug) {
-              console.log(`Request failed with status code ${response.status}, retrying...${retryDelay > 0 ? " in " + (incrementDelay ? retryDelay * retries : retryDelay) + "ms" : ""}`);
-            }
+            const currentDelay = incrementDelay ? retryDelay * retries : retryDelay;
+            debugLog.retry(config, retries, maxRetries, response.status, currentDelay);
             if (retryDelay > 0) {
-              await new Promise((resolve) => setTimeout(resolve, incrementDelay ? retryDelay * retries : retryDelay));
+              await new Promise((resolve) => setTimeout(resolve, currentDelay));
             }
             continue;
           }
@@ -464,9 +556,9 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
       const requestOptions = buildHTTPOptions(fetchOptions, isSecure, url);
       try {
         const req = httpModule.request(requestOptions, async (res) => {
-          if (!config.timing.ttfbMs) {
+          if (!timing.firstByteTime) {
             timing.firstByteTime = performance.now();
-            config.timing.ttfbMs = timing.firstByteTime - timing.startTime;
+            config.timing.responseStart = timing.firstByteTime;
           }
           const { statusCode, statusMessage, headers, httpVersion, socket } = res;
           const { remoteAddress, remotePort, localAddress, localPort } = socket;
@@ -496,8 +588,8 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
               contentLength: contentLength ? parseInt(contentLength, 10) : undefined,
               cookies: cookieArray,
               timing: {
-                firstByte: config.timing.ttfbMs,
-                total: performance.now() - timing.startTime
+                firstByte: config.timing.responseStart - config.timing.startTime,
+                total: performance.now() - config.timing.startTime
               }
             };
             eventEmitter.emit("headers", headersEvent);
@@ -582,14 +674,7 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
                 finalUrl: url.toString(),
                 cookies: config.cookieJar?.cookies() || { array: [], map: {} },
                 urls: [url.toString()],
-                timing: {
-                  total: config.timing.durationMs || 0,
-                  dns: config.timing.dnsMs,
-                  tcp: config.timing.tcpMs,
-                  tls: config.timing.tlsMs,
-                  firstByte: config.timing.ttfbMs,
-                  download: config.timing.transferMs
-                },
+                timing: getTimingDurations(config),
                 config: sanitizeConfig(config)
               };
               streamResult.emit("done", streamFinishEvent);
@@ -646,14 +731,10 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
                 fileName: filename,
                 fileSize: contentLengthCounter,
                 timing: {
-                  total: config.timing.durationMs || 0,
-                  dns: config.timing.dnsMs,
-                  tcp: config.timing.tcpMs,
-                  tls: config.timing.tlsMs,
-                  firstByte: config.timing.ttfbMs,
-                  download: config.timing.transferMs || 0
+                  ...getTimingDurations(config),
+                  download: getTimingDurations(config).download || 0
                 },
-                averageSpeed: config.timing.transferMs ? contentLengthCounter / config.timing.transferMs * 1000 : 0,
+                averageSpeed: getTimingDurations(config).download ? contentLengthCounter / getTimingDurations(config).download * 1000 : 0,
                 config: sanitizeConfig(config)
               };
               downloadResult.emit("finish", finishEvent);
@@ -746,16 +827,16 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
                   uploadSize: config.transfer.requestSize || 0,
                   fileName: uploadResult.fileName,
                   timing: {
-                    total: config.timing.durationMs || 0,
-                    dns: config.timing.dnsMs,
-                    tcp: config.timing.tcpMs,
-                    tls: config.timing.tlsMs,
-                    upload: config.timing.ttfbMs || 0,
-                    waiting: config.timing.ttfbMs && config.timing.transferMs ? config.timing.transferMs - config.timing.ttfbMs : 0,
-                    download: config.timing.transferMs
+                    total: getTimingDurations(config).total,
+                    dns: getTimingDurations(config).dns,
+                    tcp: getTimingDurations(config).tcp,
+                    tls: getTimingDurations(config).tls,
+                    upload: getTimingDurations(config).firstByte || 0,
+                    waiting: getTimingDurations(config).download > 0 && getTimingDurations(config).firstByte > 0 ? getTimingDurations(config).download - getTimingDurations(config).firstByte : 0,
+                    download: getTimingDurations(config).download
                   },
-                  averageUploadSpeed: config.timing.ttfbMs && config.transfer.requestSize ? config.transfer.requestSize / config.timing.ttfbMs * 1000 : 0,
-                  averageDownloadSpeed: config.timing.transferMs ? contentLengthCounter / config.timing.transferMs * 1000 : 0,
+                  averageUploadSpeed: getTimingDurations(config).firstByte && config.transfer.requestSize ? config.transfer.requestSize / getTimingDurations(config).firstByte * 1000 : 0,
+                  averageDownloadSpeed: getTimingDurations(config).download ? contentLengthCounter / getTimingDurations(config).download * 1000 : 0,
                   config: sanitizeConfig(config)
                 };
                 uploadResult.emit("finish", uploadFinishEvent);
@@ -794,17 +875,19 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
             socket.unref();
           }
           timing.dnsStart = performance.now();
+          config.timing.domainLookupStart = timing.dnsStart;
           socket.on("lookup", () => {
-            if (!config.timing.dnsMs) {
-              if (timing.dnsStart)
-                config.timing.dnsMs = performance.now() - timing.dnsStart;
+            if (!timing.dnsEnd) {
+              timing.dnsEnd = performance.now();
+              config.timing.domainLookupEnd = timing.dnsEnd;
               timing.tcpStart = performance.now();
+              config.timing.connectStart = timing.tcpStart;
             }
           });
           socket.on("secureConnect", () => {
-            if (!config.timing.tlsMs) {
-              if (timing.tlsStart && !config.timing.tlsMs)
-                config.timing.tlsMs = performance.now() - timing.tlsStart;
+            if (!timing.tlsEnd && timing.tlsStart) {
+              timing.tlsEnd = performance.now();
+              config.timing.connectEnd = timing.tlsEnd;
             }
             const tls = {
               cipher: socket.getCipher(),
@@ -828,11 +911,13 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
             };
           });
           socket.on("connect", () => {
-            if (!config.timing.tcpMs) {
-              if (timing.tcpStart)
-                config.timing.tcpMs = performance.now() - timing.tcpStart;
-              if (isSecure)
+            if (!timing.tcpEnd) {
+              timing.tcpEnd = performance.now();
+              config.timing.connectEnd = timing.tcpEnd;
+              if (isSecure) {
                 timing.tlsStart = performance.now();
+                config.timing.secureConnectionStart = timing.tlsStart;
+              }
             }
             const { remoteAddress, remotePort, localAddress, localPort, remoteFamily } = socket;
             if (remoteAddress && !config.network.remoteAddress) {
@@ -903,10 +988,15 @@ async function request(config, fetchOptions, requestCount, timing, _stats, respo
   });
 }
 function updateTiming(config, timing, contentLength, contentLengthCounter, rawHeaders) {
-  config.timing.endTimestamp = Date.now();
-  const elapsedMs = performance.now() - timing.startTime;
-  config.timing.durationMs = elapsedMs;
-  config.timing.transferMs = timing.firstByteTime ? performance.now() - timing.firstByteTime : elapsedMs;
+  const now = performance.now();
+  config.timing.domainLookupStart = timing.dnsStart || config.timing.startTime;
+  config.timing.domainLookupEnd = timing.dnsEnd || timing.dnsStart || config.timing.startTime;
+  config.timing.connectStart = timing.tcpStart || timing.dnsEnd || config.timing.startTime;
+  config.timing.secureConnectionStart = timing.tlsStart || 0;
+  config.timing.connectEnd = timing.tlsEnd || timing.tcpEnd || timing.tcpStart || config.timing.startTime;
+  config.timing.requestStart = timing.tlsEnd || timing.tcpEnd || config.timing.startTime;
+  config.timing.responseStart = timing.firstByteTime || config.timing.requestStart;
+  config.timing.responseEnd = now;
   const bodySize = parseInt(contentLength || "0", 10) || contentLengthCounter;
   config.transfer.bodySize = bodySize;
   let headerSize = 0;
@@ -939,6 +1029,17 @@ function updateTiming(config, timing, contentLength, contentLengthCounter, rawHe
     };
   }
 }
+function getTimingDurations(config) {
+  const t = config.timing;
+  return {
+    total: t.responseEnd - t.startTime,
+    dns: t.domainLookupEnd - t.domainLookupStart,
+    tcp: t.secureConnectionStart > 0 ? t.secureConnectionStart - t.connectStart : t.connectEnd - t.connectStart,
+    tls: t.secureConnectionStart > 0 ? t.connectEnd - t.secureConnectionStart : undefined,
+    firstByte: t.responseStart - t.startTime,
+    download: t.responseEnd - t.responseStart
+  };
+}
 let dnsCache = null;
 function createDNSLookup(cache) {
   return (hostname, optionsOrCallback, callbackOrUndefined) => {
@@ -1076,9 +1177,19 @@ async function setInitialConfig(config, fetchOptions, isSecure, url, httpModule,
       browser: false,
       ssl: isSecure
     };
-    const timestampToUse = actualTimestamp || Date.now();
-    config.timing = config.timing || { startTimestamp: timestampToUse, endTimestamp: 0, durationMs: 0 };
-    config.timing.startTimestamp = config.timing.startTimestamp || timestampToUse;
+    const startTime = performance.now();
+    config.timing = config.timing || {
+      startTime,
+      domainLookupStart: startTime,
+      domainLookupEnd: startTime,
+      connectStart: startTime,
+      secureConnectionStart: 0,
+      connectEnd: startTime,
+      requestStart: startTime,
+      responseStart: startTime,
+      responseEnd: startTime
+    };
+    config.timing.startTime = config.timing.startTime || startTime;
     config.maxRedirectsReached = false;
     config.responseCookies = {
       array: [],
@@ -1092,11 +1203,11 @@ async function setInitialConfig(config, fetchOptions, isSecure, url, httpModule,
     };
     config.retryAttempts = 0;
     config.errors = [];
-    config.debug = fetchOptions.debug || false;
+    config.debug = config.debug || fetchOptions.debug || false;
     config.requestId = generateRequestId();
     config.sessionId = fetchOptions.sessionId || generateSessionId();
     config.traceId = generateTraceId();
-    config.timestamp = config.timing.startTimestamp;
+    config.timestamp = Date.now();
     config.trackingData = {};
     config.transfer = {
       requestSize: 0,