hyperttp 0.2.4 → 0.2.5

package/dist/Hyperttp/Core/HttpClientImproved.js

@@ -7,9 +7,10 @@ const RateLimiter_js_1 = require("./RateLimiter.js");
 const MetricsManager_js_1 = require("./MetricsManager.js");
 const RequestBuilder_js_1 = require("./RequestBuilder.js");
 const InterceptorManager_js_1 = require("./InterceptorManager.js");
-const ResponseTransformer_js_1 = require("./ResponseTransformer.js");
 const RequestExecutor_js_1 = require("./RequestExecutor.js");
-const index_js_1 = require("../../Types/index.js");
+const ResponseConverter_js_1 = require("./ResponseConverter.js");
+const errors_js_1 = require("../../Types/errors.js");
+const isProd = process.env.NODE_ENV === "production";
 /**
  * @class HttpClientImproved
  * @en High-performance HTTP client with built-in caching, queuing, rate limiting, and metrics.
@@ -17,134 +18,87 @@ const index_js_1 = require("../../Types/index.js");
  */
 class HttpClientImproved {
     agent;
-    options;
+    config;
     cache;
     queue;
     limiter;
     metricsManager;
     interceptors;
-    transformer;
     executor;
-    /**
-     * @en Internal map to track active requests for deduplication and cancellation.
-     * @ru Внутренняя карта для отслеживания активных запросов (дедупликация и отмена).
-     */
+    converter;
     inflight = new Map();
     defaultHeaders = {};
-    constructor(options) {
-        this.options = this.applyDefaultOptions(options);
+    cacheEnabled;
+    queueEnabled;
+    limiterEnabled;
+    metricsEnabled;
+    verboseEnabled;
+    constructor(config) {
+        this.config = this.applyDefaulthcoptions(config);
+        this.cacheEnabled = !!this.config.cache?.enabled;
+        this.queueEnabled = !!this.config.queue?.enabled;
+        this.limiterEnabled = !!this.config.rateLimit?.enabled;
+        this.metricsEnabled = this.config.metrics?.enabled ?? true;
+        this.verboseEnabled = !!this.config.verbose && !isProd;
         this.metricsManager = new MetricsManager_js_1.MetricsManager({
-            maxHistory: this.options.maxMetricsSize,
+            maxHistory: this.config.metrics?.maxHistory,
+        });
+        this.converter = new ResponseConverter_js_1.ResponseConverter({
+            maxBodySize: this.config.responseConverter?.maxBodySize,
+            parseHTML: this.config.responseConverter?.parseHTML,
+            htmlMode: this.config.responseConverter?.htmlMode,
+            charset: this.config.responseConverter?.charset,
         });
         this.interceptors = new InterceptorManager_js_1.InterceptorManager();
-        this.transformer = new ResponseTransformer_js_1.ResponseTransformer(this.options.maxResponseBytes, this.options.logger);
-        if (this.options.enableCache) {
+        if (this.cacheEnabled) {
             this.cache = new CacheManager_js_1.CacheManager({
-                cacheTTL: this.options.cacheTTL,
-                cacheMaxSize: this.options.cacheMaxSize,
+                cacheTTL: this.config.cache?.ttl,
+                cacheMaxSize: this.config.cache?.maxSize,
             });
         }
-        if (this.options.enableQueue) {
-            this.queue = new QueueManager_js_1.QueueManager(this.options.maxConcurrent ?? 500);
+        const concurrency = this.config.network?.maxConcurrent === 0
+            ? Infinity
+            : (this.config.network?.maxConcurrent ?? 500);
+        if (this.queueEnabled) {
+            this.queue = new QueueManager_js_1.QueueManager(concurrency);
         }
-        if (this.options.enableRateLimit) {
-            this.limiter = new RateLimiter_js_1.RateLimiter(this.options.rateLimit);
+        if (this.config.rateLimit?.enabled) {
+            this.limiter = new RateLimiter_js_1.RateLimiter(this.config.rateLimit);
         }
         this.agent = new undici_1.CookieAgent({
-            connections: 1000,
-            pipelining: 10,
-            keepAliveTimeout: 60000,
+            connections: concurrency,
+            pipelining: this.config.network?.pipelining ?? 10,
+            keepAliveTimeout: this.config.network?.keepAliveTimeout ?? 30000,
+            keepAliveMaxTimeout: this.config.network?.keepAliveTimeout ?? 30000,
             connect: {
                 ciphers: "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384",
+                rejectUnauthorized: !this.config.network?.rejectUnauthorized,
             },
-            // @ts-ignore
-            allowH2: this.options.allowHttp2 ?? false,
+            allowH2: this.config.network?.allowHttp2 ?? true,
         });
         this.executor = new RequestExecutor_js_1.RequestExecutor(this.agent, this.interceptors, {
-            timeout: this.options.timeout,
-            maxRetries: this.options.maxRetries,
-            followRedirects: this.options.followRedirects,
-            maxRedirects: this.options.maxRedirects,
-            retryOptions: this.options.retryOptions,
-            verbose: this.options.verbose,
-            logger: this.options.logger,
+            timeout: this.config.network?.timeout ?? 30000,
+            maxRetries: this.config.retry?.maxRetries ?? 3,
+            followRedirects: this.config.network?.followRedirects ?? true,
+            maxRedirects: this.config.network?.maxRedirects ?? 5,
+            retryOptions: {
+                maxRetries: this.config.retry?.maxRetries ?? 3,
+                baseDelay: this.config.retry?.baseDelay ?? 1000,
+                maxDelay: this.config.retry?.maxDelay ?? 10000,
+                retryStatusCodes: this.config.retry?.retryStatusCodes ?? [
+                    408, 429, 500, 502, 503, 504,
+                ],
+                jitter: this.config.retry?.jitter ?? true,
+            },
+            verbose: this.verboseEnabled,
+            logger: this.config.logger,
         });
         this.defaultHeaders = {
             Accept: "application/json, text/plain, */*",
             "Accept-Encoding": "gzip, deflate, br",
-            "User-Agent": this.options.userAgent,
+            "User-Agent": this.config.network?.userAgent,
         };
     }
-    /**
-     * @en Core internal method for handling all HTTP requests.
-     * @ru Основной внутренний метод для обработки всех HTTP-запросов.
-     * @param method HTTP method (GET, POST, etc.)
-     * @param req Request object
-     * @param useCache Whether to use caching for this request
-     * @param responseType Expected response format
-     */
-    async requestInternal(method, req, useCache = true, responseType = "auto") {
-        const url = req.getURL();
-        if (this.metricsManager.isCircuitOpen(url)) {
-            throw new index_js_1.HttpClientError(`Circuit Breaker is OPEN`, "CIRCUIT_OPEN", 503, undefined, url, method);
-        }
-        if (this.limiter && this.options.enableRateLimit) {
-            await this.limiter.wait();
-        }
-        const { body, headers } = this.prepareRequestData(method, req);
-        const key = method === "GET"
-            ? `GET:${url}`
-            : `${method}:${url}:${body ? JSON.stringify(body) : ""}`;
-        if (method === "GET" && useCache && this.cache) {
-            const cached = await this.cache.get(key);
-            if (cached)
-                return cached;
-        }
-        if (this.inflight.has(key))
-            return this.inflight.get(key).promise;
-        const internalController = new AbortController();
-        const userSignal = req.getSignal?.();
-        const abortHandler = () => internalController.abort();
-        if (userSignal) {
-            userSignal.addEventListener("abort", abortHandler, { once: true });
-        }
-        const executeAction = async () => {
-            const metrics = this.createInitialMetrics(url, method);
-            try {
-                const rawResponse = await this.executor.execute(method, url, headers, body, metrics, internalController.signal);
-                const bufferBody = await this.transformer.readBodyWithLimit(rawResponse.body);
-                this.metricsManager.recordBytes(bufferBody.length);
-                const parsed = await this.transformer.parseResponse({ ...rawResponse, body: bufferBody }, responseType);
-                if (method === "HEAD")
-                    return {
-                        status: rawResponse.status,
-                        headers: rawResponse.headers,
-                    };
-                if (method === "GET" &&
-                    useCache &&
-                    this.cache &&
-                    parsed !== undefined) {
-                    this.cache.set(key, parsed);
-                }
-                this.recordSuccess(metrics, rawResponse.status);
-                return parsed;
-            }
-            catch (error) {
-                this.recordError(metrics, error);
-                throw error;
-            }
-            finally {
-                if (userSignal)
-                    userSignal.removeEventListener("abort", abortHandler);
-                this.inflight.delete(key);
-            }
-        };
-        const promise = this.options.enableQueue && this.queue
-            ? this.queue.enqueue(() => executeAction())
-            : executeAction();
-        this.inflight.set(key, { promise, controller: internalController });
-        return promise;
-    }
     /**
      * @en Performs an HTTP GET request.
      * @ru Выполняет HTTP GET запрос.
@@ -163,78 +117,62 @@ class HttpClientImproved {
      * @param responseType Expected response format
      */
     post(req, body, responseType = "auto") {
-        const requestObj = this.normalizeRequest(req, body);
-        return this.requestInternal("POST", requestObj, false, responseType);
+        return this.requestInternal("POST", this.normalizeRequest(req, body), false, responseType);
     }
     /**
      * @en Performs an HTTP PUT request.
      * @ru Выполняет HTTP PUT запрос.
      */
     put(req, body, responseType = "auto") {
-        const requestObj = this.normalizeRequest(req, body);
-        return this.requestInternal("PUT", requestObj, false, responseType);
+        return this.requestInternal("PUT", this.normalizeRequest(req, body), false, responseType);
     }
     /**
      * @en Performs an HTTP DELETE request.
      * @ru Выполняет HTTP DELETE запрос.
      */
     delete(req, responseType = "auto") {
-        const requestObj = this.normalizeRequest(req);
-        return this.requestInternal("DELETE", requestObj, false, responseType);
+        return this.requestInternal("DELETE", this.normalizeRequest(req), false, responseType);
     }
     /**
      * @en Performs an HTTP PATCH request.
      * @ru Выполняет HTTP PATCH запрос.
      */
     patch(req, body, responseType = "auto") {
-        const requestObj = this.normalizeRequest(req, body);
-        return this.requestInternal("PATCH", requestObj, false, responseType);
-    }
-    /**
-     * @en Creates a RequestBuilder for a fluent API approach.
-     * @ru Создает RequestBuilder для использования Fluent API.
-     * @example client.request('url').get().send();
-     */
-    request(url) {
-        return new RequestBuilder_js_1.RequestBuilder(url, this);
+        return this.requestInternal("PATCH", this.normalizeRequest(req, body), false, responseType);
     }
     /**
-     * @en Releases all resources, aborts active requests, and closes connections.
-     * @ru Освобождает ресурсы клиента, отменяет активные запросы и закрывает соединения.
+     * @en Performs an HTTP OPTIONS request.
+     * @ru Выполняет HTTP OPTIONS запрос.
      */
-    async destroy() {
-        if (this.inflight.size > 0) {
-            if (this.options.verbose) {
-                this.options.logger?.("info", `Aborting ${this.inflight.size} active requests...`);
-            }
-            for (const { controller } of this.inflight.values()) {
-                controller.abort();
-            }
-            this.inflight.clear();
-        }
-        if (this.agent) {
-            try {
-                if (typeof this.agent.destroy === "function") {
-                    await this.agent.destroy();
-                }
-                else if (typeof this.agent.close === "function") {
-                    await this.agent.close();
-                }
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        if (this.cache)
-            this.cache.clear();
+    options(req, body, responseType = "auto") {
+        return this.requestInternal("OPTIONS", this.normalizeRequest(req, body), false, responseType);
     }
     /**
      * @en Performs an HTTP HEAD request.
      * @ru Выполняет HTTP HEAD запрос.
      */
     async head(req) {
-        const requestObj = this.normalizeRequest(req);
-        return this.requestInternal("HEAD", requestObj, false);
+        return this.requestInternal("HEAD", this.normalizeRequest(req), false);
+    }
+    /**
+     * @en Creates a new HttpClient instance with merged configuration.
+     * @ru Создаёт новый экземпляр HttpClient с объединённой конфигурацией.
+     *
+     * @param options Partial configuration to override current settings
+     * @returns New HttpClientImproved instance
+     */
+    extend(options) {
+        return new HttpClientImproved(this.mergeOptions(this.config, options));
+    }
+    /**
+     * @en Alias for extend(). Creates a new configured client instance.
+     * @ru Алиас для extend(). Создаёт новый настроенный экземпляр клиента.
+     *
+     * @param options Partial configuration overrides
+     * @returns New HttpClientImproved instance
+     */
+    create(options) {
+        return this.extend(options);
     }
     /**
      * @en Executes a request and returns an AsyncIterable stream.
@@ -244,47 +182,57 @@ class HttpClientImproved {
         const requestObj = this.normalizeRequest(req);
         const url = requestObj.getURL();
         const { body, headers } = this.prepareRequestData("GET", requestObj);
-        const key = `STREAM:GET:${url}`;
-        const internalController = new AbortController();
+        const controller = new AbortController();
         const userSignal = requestObj.getSignal?.();
-        const abortHandler = () => internalController.abort();
-        if (userSignal) {
-            userSignal.addEventListener("abort", abortHandler, { once: true });
+        const signal = userSignal
+            ? AbortSignal.any([userSignal, controller.signal])
+            : controller.signal;
+        const rawResponse = await this.executor.execute("GET", url, headers, body, undefined, signal);
+        const cleanup = () => {
+            this.inflight.delete(url);
+        };
+        rawResponse.body.once("close", cleanup);
+        rawResponse.body.once("error", cleanup);
+        rawResponse.body.once("end", cleanup);
+        this.inflight.set(url, {
+            promise: Promise.resolve(undefined),
+            controller,
+        });
+        return {
+            status: rawResponse.status,
+            headers: rawResponse.headers,
+            body: rawResponse.body,
+            url: rawResponse.url,
+        };
+    }
+    /**
+     * @en Creates a RequestBuilder for a fluent API approach.
+     * @ru Создает RequestBuilder для использования Fluent API.
+     * @example client.request('url').get().send();
+     */
+    request(url) {
+        return new RequestBuilder_js_1.RequestBuilder(url, this);
+    }
+    async destroy() {
+        for (const { controller } of this.inflight.values()) {
+            controller.abort();
         }
+        this.inflight.clear();
         try {
-            const rawResponse = await this.executor.execute("GET", url, headers, body, undefined, internalController.signal);
-            this.inflight.set(key, {
-                promise: Promise.resolve(),
-                controller: internalController,
-            });
-            const cleanup = () => {
-                if (userSignal)
-                    userSignal.removeEventListener("abort", abortHandler);
-                this.inflight.delete(key);
-            };
-            rawResponse.body.on("close", cleanup);
-            rawResponse.body.on("error", cleanup);
-            return {
-                status: rawResponse.status,
-                headers: rawResponse.headers,
-                body: rawResponse.body,
-                url: rawResponse.url,
-            };
+            if (typeof this.agent.destroy === "function") {
+                await this.agent.destroy();
+            }
+            else if (typeof this.agent.close === "function") {
+                await this.agent.close();
+            }
         }
-        catch (error) {
-            if (userSignal)
-                userSignal.removeEventListener("abort", abortHandler);
-            throw error;
+        catch {
+            /* ignore */
         }
+        this.cache?.clear();
     }
-    /**
-     * @en Clears the internal cache.
-     * @ru Полностью очищает внутренний кэш клиента.
-     */
     clearCache() {
-        if (this.cache) {
-            this.cache.clear();
-        }
+        this.cache?.clear();
     }
     /**
      * @en Clears all collected performance metrics.
@@ -292,7 +240,6 @@ class HttpClientImproved {
      */
     clearMetrics() {
         this.metricsManager.clear();
-        this.options.logger?.("info", "Metrics cleared");
     }
     /**
      * @en Retrieves metrics for a specific URL.
@@ -317,17 +264,41 @@ class HttpClientImproved {
         return {
             cacheSize: this.cache?.size ?? 0,
             inflightRequests: this.inflight.size,
-            queuedRequests: this.options.enableQueue && this.queue
+            queuedRequests: this.queueEnabled && this.queue
                 ? (this.queue.queuedCount ?? 0)
                 : 0,
-            activeRequests: this.options.enableQueue && this.queue
+            activeRequests: this.queueEnabled && this.queue
                 ? (this.queue.activeCount ?? 0)
                 : 0,
-            currentRateLimit: this.options.enableRateLimit && this.limiter
+            currentRateLimit: this.limiterEnabled && this.limiter
                 ? (this.limiter.currentCount ?? 0)
                 : 0,
         };
     }
+    async warmup(urls, count = 10) {
+        const tasks = [];
+        for (let i = 0; i < count; i++) {
+            const url = urls[i % urls.length];
+            tasks.push(this.get(url, "text").catch(() => undefined));
+        }
+        await Promise.all(tasks);
+    }
+    mergeOptions(base, patch) {
+        return {
+            ...base,
+            ...patch,
+            network: { ...base.network, ...patch.network },
+            retry: { ...base.retry, ...patch.retry },
+            cache: { ...base.cache, ...patch.cache },
+            rateLimit: { ...base.rateLimit, ...patch.rateLimit },
+            metrics: { ...base.metrics, ...patch.metrics },
+            queue: { ...base.queue, ...patch.queue },
+            responseConverter: {
+                ...base.responseConverter,
+                ...patch.responseConverter,
+            },
+        };
+    }
     normalizeRequest(req, body) {
         if (typeof req === "string") {
             return {
@@ -338,35 +309,161 @@ class HttpClientImproved {
         }
         return req;
     }
-    applyDefaultOptions(opt) {
+    applyDefaulthcoptions(opt) {
         const defaults = {
-            timeout: 30000,
-            maxRetries: 3,
-            followRedirects: true,
-            maxRedirects: 5,
-            userAgent: "Hyperttp/2.0",
-            maxResponseBytes: 10 * 1024 * 1024, // 10MB
-            cacheTTL: 1000 * 60 * 5,
-            cacheMaxSize: 500,
-            enableCache: true,
-            enableQueue: true,
-            enableRateLimit: true,
-            allowHttp2: false,
-            retryOptions: {
+            network: {
+                timeout: 30000,
+                maxRedirects: 5,
+                followRedirects: true,
+                maxResponseBytes: 10 * 1024 * 1024,
+                userAgent: "Hyperttp/2.0",
+                allowHttp2: true,
+                pipelining: 10,
+                keepAliveTimeout: 30000,
+                maxConcurrent: 0,
+                rejectUnauthorized: false,
+            },
+            cache: {
+                enabled: true,
+                ttl: 1000 * 60 * 5,
+                maxSize: 500,
+                methods: [],
+            },
+            retry: {
                 maxRetries: 3,
                 baseDelay: 1000,
                 maxDelay: 10000,
                 retryStatusCodes: [408, 429, 500, 502, 503, 504],
                 jitter: true,
             },
+            rateLimit: {
+                enabled: false,
+                maxRequests: 100,
+                windowMs: 60000,
+            },
+            metrics: {
+                enabled: true,
+                maxHistory: 1000,
+            },
+            queue: {
+                enabled: true,
+            },
+            responseConverter: {
+                maxBodySize: 0,
+                parseHTML: false,
+                htmlMode: "simple",
+                charset: "utf-8",
+            },
+        };
+        return {
+            ...defaults,
+            ...opt,
+            network: { ...defaults.network, ...opt?.network },
+            cache: { ...defaults.cache, ...opt?.cache },
+            retry: { ...defaults.retry, ...opt?.retry },
+            rateLimit: { ...defaults.rateLimit, ...opt?.rateLimit },
+            metrics: { ...defaults.metrics, ...opt?.metrics },
+            queue: { ...defaults.queue, ...opt?.queue },
+            responseConverter: {
+                ...defaults.responseConverter,
+                ...opt?.responseConverter,
+            },
         };
-        return { ...defaults, ...opt };
+    }
+    /**
+     * @en Core internal method for handling all HTTP requests.
+     * @ru Основной внутренний метод для обработки всех HTTP-запросов.
+     * @param method HTTP method (GET, POST, etc.)
+     * @param req Request object
+     * @param useCache Whether to use caching for this request
+     * @param responseType Expected response format
+     */
+    async requestInternal(method, req, useCache = true, responseType = "auto") {
+        const url = req.getURL();
+        if (this.metricsManager.isCircuitOpen(url)) {
+            throw new errors_js_1.HttpClientError("Circuit Breaker is OPEN", "CIRCUIT_OPEN", 503, undefined, url, method);
+        }
+        if (this.limiter) {
+            await this.limiter.wait();
+        }
+        const userSignal = req.getSignal?.();
+        const { body, headers } = this.prepareRequestData(method, req);
+        const key = method === "GET"
+            ? `GET:${url}`
+            : body !== undefined && body !== null
+                ? `${method}:${url}:${typeof body === "string" ? body : JSON.stringify(body)}`
+                : `${method}:${url}`;
+        if (this.cache && method === "GET" && useCache) {
+            const cached = this.cache.get(key);
+            if (cached !== undefined) {
+                return cached;
+            }
+        }
+        const existing = this.inflight.get(key);
+        if (existing) {
+            return existing.promise;
+        }
+        const internalController = new AbortController();
+        const abortHandler = () => internalController.abort();
+        if (userSignal) {
+            userSignal.addEventListener("abort", abortHandler, { once: true });
+        }
+        const run = () => (async () => {
+            let metrics;
+            const needMetrics = this.metricsEnabled;
+            if (needMetrics) {
+                metrics = this.createInitialMetrics(url, method);
+            }
+            try {
+                if (method === "HEAD") {
+                    const rawResponse = await this.executor.execute(method, url, headers, body, metrics, internalController.signal);
+                    if (needMetrics && metrics) {
+                        this.recordSuccess(metrics, rawResponse.status);
+                    }
+                    return {
+                        status: rawResponse.status,
+                        headers: rawResponse.headers,
+                    };
+                }
+                const rawResponse = await this.executor.execute(method, url, headers, body, metrics, internalController.signal);
+                const bufferBody = await this.converter.readBody(rawResponse.body);
+                const parsed = await this.converter.convert(bufferBody, responseType, {
+                    contentType: rawResponse.headers["content-type"],
+                    contentEncoding: rawResponse.headers["content-encoding"],
+                    url: rawResponse.url,
+                });
+                if (this.cache &&
+                    method === "GET" &&
+                    useCache &&
+                    parsed !== undefined) {
+                    this.cache.set(key, parsed);
+                }
+                if (needMetrics && metrics) {
+                    this.recordSuccess(metrics, rawResponse.status);
+                }
+                return parsed;
+            }
+            catch (error) {
+                if (needMetrics && metrics) {
+                    this.recordError(metrics, error);
+                }
+                throw error;
+            }
+            finally {
+                if (userSignal) {
+                    userSignal.removeEventListener("abort", abortHandler);
+                }
+                this.inflight.delete(key);
+            }
+        })();
+        const promise = this.queueEnabled && this.queue ? this.queue.enqueue(run) : run();
+        this.inflight.set(key, { promise, controller: internalController });
+        return promise;
     }
     prepareRequestData(method, req) {
         const headers = { ...this.defaultHeaders, ...req.getHeaders() };
         let rawBody = req.getBodyData();
-        const methodsWithBody = ["POST", "PUT", "PATCH", "DELETE"];
-        if (!methodsWithBody.includes(method)) {
+        if (!["POST", "PUT", "PATCH", "DELETE"].includes(method)) {
             return { body: undefined, headers };
         }
         if (rawBody &&
@@ -378,8 +475,7 @@ class HttpClientImproved {
             if (contentType.includes("application/x-www-form-urlencoded")) {
                 const params = new URLSearchParams();
                 for (const [key, value] of Object.entries(rawBody)) {
-                    const finalValue = typeof value === "object" ? JSON.stringify(value) : String(value);
-                    params.append(key, finalValue);
+                    params.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
                 }
                 rawBody = params.toString();
             }
@@ -413,8 +509,8 @@ class HttpClientImproved {
         metrics.duration = metrics.endTime - metrics.startTime;
         metrics.statusCode = status;
         this.metricsManager.record(metrics);
-        if (this.options.verbose && this.options.logger) {
-            this.options.logger("info", `Request successful: ${metrics.method} ${metrics.url}`, {
+        if (this.verboseEnabled) {
+            this.config.logger?.("info", `Request successful: ${metrics.method} ${metrics.url}`, {
                 duration: metrics.duration,
                 status: metrics.statusCode,
             });
@@ -423,12 +519,12 @@ class HttpClientImproved {
     recordError(metrics, error) {
         metrics.endTime = Date.now();
         metrics.duration = metrics.endTime - metrics.startTime;
-        metrics.statusCode = error.statusCode || 0;
+        metrics.statusCode = error?.statusCode || 0;
         this.metricsManager.record(metrics);
-        if (this.options.verbose && this.options.logger) {
-            this.options.logger("error", `Request failed: ${metrics.method} ${metrics.url}`, {
-                error: error.message,
-                code: error.code,
+        if (this.verboseEnabled) {
+            this.config.logger?.("error", `Request failed: ${metrics.method} ${metrics.url}`, {
+                error: error?.message,
+                code: error?.code,
             });
         }
     }