@browserless.io/browserless 2.7.1 → 2.9.0

package/build/browsers/webkit.playwright.js

@@ -1,4 +1,4 @@
-import { ServerError, createLogger, } from '@browserless.io/browserless';
+import { ServerError, } from '@browserless.io/browserless';
 import playwright from 'playwright-core';
 import { EventEmitter } from 'events';
 import httpProxy from 'http-proxy';
@@ -10,12 +10,13 @@ export class WebkitPlaywright extends EventEmitter {
     proxy = httpProxy.createProxyServer();
     browser = null;
     browserWSEndpoint = null;
-    debug = createLogger('browsers:webkit:playwright');
-    constructor({ config, userDataDir, }) {
+    logger;
+    constructor({ config, userDataDir, logger, }) {
         super();
         this.userDataDir = userDataDir;
         this.config = config;
-        this.debug(`Starting new browser instance`);
+        this.logger = logger;
+        this.logger.info(`Starting new ${this.constructor.name} instance`);
     }
     cleanListeners() {
         this.removeAllListeners();
@@ -23,7 +24,7 @@ export class WebkitPlaywright extends EventEmitter {
     isRunning = () => this.running;
     close = async () => {
         if (this.browser) {
-            this.debug(`Closing browser process and all listeners`);
+            this.logger.info(`Closing ${this.constructor.name} process and all listeners`);
             this.emit('close');
             this.cleanListeners();
             this.browser.close();
@@ -34,16 +35,16 @@ export class WebkitPlaywright extends EventEmitter {
     };
     pages = async () => [];
     getPageId = () => {
-        throw new ServerError(`#getPageId is not yet supported with this browser.`);
+        throw new ServerError(`#getPageId is not yet supported with ${this.constructor.name}.`);
     };
     makeLiveURL = () => {
-        throw new ServerError(`Live URLs are not yet supported with this browser.`);
+        throw new ServerError(`Live URLs are not yet supported with ${this.constructor.name}.`);
     };
     newPage = async () => {
-        throw new ServerError(`Can't create new page with this browser`);
+        throw new ServerError(`Can't create new page with ${this.constructor.name}`);
     };
     launch = async (options = {}) => {
-        this.debug(`Launching Playwright Handler`);
+        this.logger.info(`Launching ${this.constructor.name} Handler`);
         this.browser = await playwright.webkit.launchServer({
             ...options,
             args: [
@@ -53,7 +54,7 @@ export class WebkitPlaywright extends EventEmitter {
             executablePath: playwright.webkit.executablePath(),
         });
         const browserWSEndpoint = this.browser.wsEndpoint();
-        this.debug(`Browser is running on ${browserWSEndpoint}`);
+        this.logger.info(`${this.constructor.name} is running on ${browserWSEndpoint}`);
         this.browserWSEndpoint = browserWSEndpoint;
         this.running = true;
         return this.browser;
@@ -72,14 +73,14 @@ export class WebkitPlaywright extends EventEmitter {
         return externalURL.href;
     };
     proxyPageWebSocket = async () => {
-        console.warn(`Not yet implemented`);
+        this.logger.warn(`Not yet implemented`);
     };
     proxyWebSocket = async (req, socket, head) => new Promise((resolve, reject) => {
         if (!this.browserWSEndpoint) {
             throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
         }
         socket.once('close', resolve);
-        this.debug(`Proxying ${req.parsed.href} to browser ${this.browserWSEndpoint}`);
+        this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
         // Delete headers known to cause issues
         delete req.headers.origin;
         req.url = '';
@@ -87,7 +88,7 @@ export class WebkitPlaywright extends EventEmitter {
             changeOrigin: true,
             target: this.browserWSEndpoint,
         }, (error) => {
-            this.debug(`Error proxying session: ${error}`);
+            this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
             this.close();
             return reject(error);
         });

package/build/config.d.ts

@@ -18,6 +18,7 @@ export declare class Config extends EventEmitter {
     protected queued: number;
     protected timeout: number;
     protected static: string;
+    protected debuggerDir: string;
     protected retries: number;
     protected allowFileProtocol: boolean;
     protected allowGet: boolean;
@@ -53,6 +54,7 @@ export declare class Config extends EventEmitter {
     getQueued: () => number;
     getTimeout: () => number;
     getStatic: () => string;
+    getDebuggerDir: () => string;
     getRetries: () => number;
     getAllowFileProtocol: () => boolean;
     getCPULimit: () => number;
@@ -63,6 +65,7 @@ export declare class Config extends EventEmitter {
     getRejectAlertURL: () => string | null;
     getTimeoutAlertURL: () => string | null;
     getErrorAlertURL: () => string | null;
+    hasDebugger: () => Promise<boolean>;
     /**
      * If true, allows GET style calls on our browser-based APIs, using
      * ?body=JSON format.

package/build/config.js

@@ -124,6 +124,7 @@ export class Config extends EventEmitter {
         process.env.CONNECTION_TIMEOUT ??
         '30000');
     static = process.env.STATIC ?? path.join(__dirname, '..', 'static');
+    debuggerDir = path.join(this.static, 'debugger');
     retries = +(process.env.RETRIES ?? '5');
     allowFileProtocol = !!parseEnvVars(false, 'ALLOW_FILE_PROTOCOL');
     allowGet = !!parseEnvVars(false, 'ALLOW_GET', 'ENABLE_API_GET');
@@ -159,6 +160,7 @@ export class Config extends EventEmitter {
     getQueued = () => this.queued;
     getTimeout = () => this.timeout;
     getStatic = () => this.static;
+    getDebuggerDir = () => this.debuggerDir;
     getRetries = () => this.retries;
     getAllowFileProtocol = () => this.allowFileProtocol;
     getCPULimit = () => this.maxCpu;
@@ -169,6 +171,7 @@ export class Config extends EventEmitter {
     getRejectAlertURL = () => this.rejectAlertURL;
     getTimeoutAlertURL = () => this.timeoutAlertURL;
     getErrorAlertURL = () => this.errorAlertURL;
+    hasDebugger = () => exists(this.debuggerDir);
     /**
      * If true, allows GET style calls on our browser-based APIs, using
      * ?body=JSON format.

package/build/exports.d.ts

@@ -5,6 +5,7 @@ export * from './file-system.js';
 export * from './hooks.js';
 export * from './http.js';
 export * from './limiter.js';
+export * from './logger.js';
 export * from './metrics.js';
 export * from './mime-types.js';
 export * from './monitoring.js';

package/build/exports.js

@@ -6,6 +6,7 @@ export * from './file-system.js';
 export * from './hooks.js';
 export * from './http.js';
 export * from './limiter.js';
+export * from './logger.js';
 export * from './metrics.js';
 export * from './mime-types.js';
 export * from './monitoring.js';

package/build/file-system.d.ts

@@ -1,13 +1,12 @@
 /// <reference types="node" />
-/// <reference types="debug" />
 /// <reference types="node" />
-import { Config } from '@browserless.io/browserless';
+import { Config, Logger } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 export declare class FileSystem extends EventEmitter {
     protected config: Config;
     protected fsMap: Map<string, string[]>;
     protected currentAESKey: Buffer;
-    protected log: import("debug").Debugger;
+    protected logger: Logger;
     constructor(config: Config);
     /**
      * Appends contents to a file-path for persistance. File contents are

package/build/file-system.js

@@ -1,11 +1,11 @@
-import { createLogger, decrypt, encrypt, } from '@browserless.io/browserless';
+import { Logger, decrypt, encrypt } from '@browserless.io/browserless';
 import { readFile, writeFile } from 'fs/promises';
 import { EventEmitter } from 'events';
 export class FileSystem extends EventEmitter {
     config;
     fsMap = new Map();
     currentAESKey;
-    log = createLogger('file-system');
+    logger = new Logger('file-system');
     constructor(config) {
         super();
         this.config = config;

package/build/index.js

@@ -1,7 +1,7 @@
-import { Browserless, createLogger } from '@browserless.io/browserless';
+import { Browserless, Logger } from '@browserless.io/browserless';
 (async () => {
     const browserless = new Browserless();
-    const debug = createLogger('index.js');
+    const logger = new Logger('index.js');
     browserless.start();
     process
         .on('unhandledRejection', async (reason, promise) => {
@@ -13,27 +13,27 @@ import { Browserless, createLogger } from '@browserless.io/browserless';
         process.exit(1);
     })
         .once('SIGTERM', async () => {
-        debug(`SIGTERM received, saving and closing down`);
+        logger.info(`SIGTERM received, saving and closing down`);
         await browserless.stop();
         process.exit(0);
     })
         .once('SIGINT', async () => {
-        debug(`SIGINT received, saving and closing down`);
+        logger.info(`SIGINT received, saving and closing down`);
         await browserless.stop();
         process.exit(0);
     })
         .once('SIGHUP', async () => {
-        debug(`SIGHUP received, saving and closing down`);
+        logger.info(`SIGHUP received, saving and closing down`);
         await browserless.stop();
         process.exit(0);
     })
         .once('SIGUSR2', async () => {
-        debug(`SIGUSR2 received, saving and closing down`);
+        logger.info(`SIGUSR2 received, saving and closing down`);
         await browserless.stop();
         process.exit(0);
     })
         .once('exit', () => {
-        debug(`Process is finished, exiting`);
+        logger.info(`Process is finished, exiting`);
         process.exit(0);
     });
 })();

package/build/limiter.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="debug" />
-import { AfterResponse, Config, Hooks, Metrics, Monitoring, WebHooks } from '@browserless.io/browserless';
+import { AfterResponse, Config, Hooks, Logger, Metrics, Monitoring, WebHooks } from '@browserless.io/browserless';
 import q from 'queue';
 export type LimitFn<TArgs extends unknown[], TResult> = (...args: TArgs) => Promise<TResult>;
 export type ErrorFn<TArgs extends unknown[]> = (...args: TArgs) => void;
@@ -17,7 +16,7 @@ export declare class Limiter extends q {
     protected webhooks: WebHooks;
     protected hooks: Hooks;
     protected queued: number;
-    protected debug: import("debug").Debugger;
+    protected logger: Logger;
     constructor(config: Config, metrics: Metrics, monitor: Monitoring, webhooks: WebHooks, hooks: Hooks);
     protected handleEnd(): void;
     protected jobEnd(jobInfo: AfterResponse): void;

package/build/limiter.js

@@ -1,4 +1,4 @@
-import { TooManyRequests, createLogger, } from '@browserless.io/browserless';
+import { Logger, TooManyRequests, } from '@browserless.io/browserless';
 import q from 'queue';
 export class Limiter extends q {
     config;
@@ -7,7 +7,7 @@ export class Limiter extends q {
     webhooks;
     hooks;
     queued;
-    debug = createLogger('limiter');
+    logger = new Logger('limiter');
     constructor(config, metrics, monitor, webhooks, hooks) {
         super({
             autostart: true,
@@ -20,17 +20,17 @@ export class Limiter extends q {
         this.webhooks = webhooks;
         this.hooks = hooks;
         this.queued = config.getQueued();
-        this.debug(`Concurrency: ${this.concurrency} queue: ${this.queued} timeout: ${this.timeout}ms`);
+        this.logger.info(`Concurrency: ${this.concurrency} queue: ${this.queued} timeout: ${this.timeout}ms`);
         config.on('concurrent', (concurrency) => {
-            this.debug(`Concurrency updated to ${concurrency}`);
+            this.logger.info(`Concurrency updated to ${concurrency}`);
             this.concurrency = concurrency;
         });
         config.on('queued', (queued) => {
-            this.debug(`Queue updated to ${queued}`);
+            this.logger.info(`Queue updated to ${queued}`);
             this.queued = queued;
         });
         config.on('timeout', (timeout) => {
-            this.debug(`Timeout updated to ${timeout}ms`);
+            this.logger.info(`Timeout updated to ${timeout}ms`);
             this.timeout = timeout <= 0 ? 0 : timeout;
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -49,7 +49,7 @@ export class Limiter extends q {
     }
     handleSuccess({ detail: { job } }) {
         const timeUsed = Date.now() - job.start;
-        this.debug(`Job has succeeded after ${timeUsed.toLocaleString()}ms of activity.`);
+        this.logger.info(`Job has succeeded after ${timeUsed.toLocaleString()}ms of activity.`);
         this.metrics.addSuccessful(Date.now() - job.start);
         // @TODO Figure out a better argument handling for jobs
         this.jobEnd({
@@ -60,10 +60,10 @@ export class Limiter extends q {
     }
     handleJobTimeout({ detail: { next, job }, }) {
         const timeUsed = Date.now() - job.start;
-        this.debug(`Job has hit timeout after ${timeUsed.toLocaleString()}ms of activity.`);
+        this.logger.warn(`Job has hit timeout after ${timeUsed.toLocaleString()}ms of activity.`);
         this.metrics.addTimedout(Date.now() - job.start);
         this.webhooks.callTimeoutAlertURL();
-        this.debug(`Calling timeout handler`);
+        this.logger.info(`Calling timeout handler`);
         job?.onTimeoutFn(job);
         this.jobEnd({
             req: job.args[0],
@@ -73,7 +73,7 @@ export class Limiter extends q {
         next();
     }
     handleFail({ detail: { error, job }, }) {
-        this.debug(`Recording failed stat, cleaning up: "${error?.toString()}"`);
+        this.logger.info(`Recording failed stat, cleaning up: "${error?.toString()}"`);
         this.metrics.addError(Date.now() - job.start);
         this.webhooks.callErrorAlertURL(error?.toString() ?? 'Unknown Error');
         this.jobEnd({
@@ -83,7 +83,7 @@ export class Limiter extends q {
         });
     }
     logQueue(message) {
-        this.debug(`(Running: ${this.executing}, Pending: ${this.waiting}) ${message} `);
+        this.logger.info(`(Running: ${this.executing}, Pending: ${this.waiting}) ${message} `);
     }
     get executing() {
         return this.length > this.concurrency ? this.concurrency : this.length;

package/build/logger.d.ts

@@ -0,0 +1,19 @@
+import { Request } from '@browserless.io/browserless';
+export declare class Logger {
+    protected prefix: string;
+    protected request?: Request | undefined;
+    protected _trace: (...args: unknown[]) => void;
+    protected _debug: (...args: unknown[]) => void;
+    protected _info: (...args: unknown[]) => void;
+    protected _warn: (...args: unknown[]) => void;
+    protected _error: (...args: unknown[]) => void;
+    protected _fatal: (...args: unknown[]) => void;
+    constructor(prefix: string, request?: Request | undefined);
+    protected get reqInfo(): string;
+    trace: (...messages: unknown[]) => void;
+    debug: (...messages: unknown[]) => void;
+    info: (...messages: unknown[]) => void;
+    warn: (...messages: unknown[]) => void;
+    error: (...messages: unknown[]) => void;
+    fatal: (...messages: unknown[]) => void;
+}

package/build/logger.js

@@ -0,0 +1,43 @@
+import { createLogger } from '@browserless.io/browserless';
+export class Logger {
+    prefix;
+    request;
+    _trace;
+    _debug;
+    _info;
+    _warn;
+    _error;
+    _fatal;
+    constructor(prefix, request) {
+        this.prefix = prefix;
+        this.request = request;
+        const logger = createLogger(prefix);
+        this._trace = logger.extend('trace');
+        this._debug = logger.extend('debug');
+        this._info = logger.extend('info');
+        this._warn = logger.extend('warn');
+        this._error = logger.extend('error');
+        this._fatal = logger.extend('fatal');
+    }
+    get reqInfo() {
+        return this.request ? this.request.socket.remoteAddress ?? 'Unknown' : '';
+    }
+    trace = (...messages) => {
+        this._trace(this.reqInfo, ...messages);
+    };
+    debug = (...messages) => {
+        this._debug(this.reqInfo, ...messages);
+    };
+    info = (...messages) => {
+        this._info(this.reqInfo, ...messages);
+    };
+    warn = (...messages) => {
+        this._warn(this.reqInfo, ...messages);
+    };
+    error = (...messages) => {
+        this._error(this.reqInfo, ...messages);
+    };
+    fatal = (...messages) => {
+        this._fatal(this.reqInfo, ...messages);
+    };
+}

package/build/monitoring.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="debug" />
 /// <reference types="node" />
-import { Config, IResourceLoad } from '@browserless.io/browserless';
+import { Config, IResourceLoad, Logger } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 export declare class Monitoring extends EventEmitter {
     protected config: Config;
-    protected log: import("debug").Debugger;
+    protected log: Logger;
     constructor(config: Config);
     getMachineStats: () => Promise<IResourceLoad>;
     overloaded: () => Promise<{

package/build/monitoring.js

@@ -1,9 +1,9 @@
-import { createLogger, } from '@browserless.io/browserless';
+import { Logger } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 import si from 'systeminformation';
 export class Monitoring extends EventEmitter {
     config;
-    log = createLogger('hardware');
+    log = new Logger('hardware');
     constructor(config) {
         super();
         this.config = config;
@@ -13,7 +13,7 @@ export class Monitoring extends EventEmitter {
             si.currentLoad(),
             si.mem(),
         ]).catch((err) => {
-            this.log(`Error checking machine stats`, err);
+            this.log.error(`Error checking machine stats`, err);
             return [null, null];
         });
         const cpu = cpuLoad ? cpuLoad.currentLoadUser / 100 : null;
@@ -27,7 +27,7 @@ export class Monitoring extends EventEmitter {
         const { cpu, memory } = await this.getMachineStats();
         const cpuInt = cpu && Math.ceil(cpu * 100);
         const memoryInt = memory && Math.ceil(memory * 100);
-        this.log(`Checking overload status: CPU ${cpuInt}% Memory ${memoryInt}%`);
+        this.log.info(`Checking overload status: CPU ${cpuInt}% Memory ${memoryInt}%`);
         const cpuOverloaded = !!(cpuInt && cpuInt >= this.config.getCPULimit());
         const memoryOverloaded = !!(memoryInt && memoryInt >= this.config.getMemoryLimit());
         return {

package/build/router.d.ts

@@ -1,19 +1,18 @@
-/// <reference types="debug" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { BrowserHTTPRoute, BrowserManager, BrowserWebsocketRoute, Config, HTTPRoute, Limiter, Request, Response, WebSocketRoute } from '@browserless.io/browserless';
+import { BrowserHTTPRoute, BrowserManager, BrowserWebsocketRoute, Config, HTTPRoute, Limiter, Logger, Request, Response, WebSocketRoute } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 import stream from 'stream';
 export declare class Router extends EventEmitter {
     protected config: Config;
     protected browserManager: BrowserManager;
     protected limiter: Limiter;
-    protected log: import("debug").Debugger;
-    protected verbose: import("debug").Debugger;
+    protected logger: typeof Logger;
+    protected log: Logger;
     protected httpRoutes: Array<HTTPRoute | BrowserHTTPRoute>;
     protected webSocketRoutes: Array<WebSocketRoute | BrowserWebsocketRoute>;
-    constructor(config: Config, browserManager: BrowserManager, limiter: Limiter);
+    constructor(config: Config, browserManager: BrowserManager, limiter: Limiter, logger: typeof Logger);
     protected getTimeout(req: Request): number | undefined;
     protected onQueueFullHTTP: (_req: Request, res: Response) => void;
     protected onQueueFullWebSocket: (_req: Request, socket: stream.Duplex) => void;

package/build/router.js

@@ -1,49 +1,51 @@
-import { HTTPManagementRoutes, contentTypes, createLogger, isConnected, writeResponse, } from '@browserless.io/browserless';
+import { HTTPManagementRoutes, Logger, contentTypes, isConnected, writeResponse, } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 import micromatch from 'micromatch';
 export class Router extends EventEmitter {
     config;
     browserManager;
     limiter;
-    log = createLogger('router');
-    verbose = createLogger('router:verbose');
+    logger;
+    log = new Logger('router');
     httpRoutes = [];
     webSocketRoutes = [];
-    constructor(config, browserManager, limiter) {
+    constructor(config, browserManager, limiter, logger) {
         super();
         this.config = config;
         this.browserManager = browserManager;
         this.limiter = limiter;
+        this.logger = logger;
     }
     getTimeout(req) {
         const timer = req.parsed.searchParams.get('timeout');
         return timer ? +timer : undefined;
     }
     onQueueFullHTTP = (_req, res) => {
-        this.log(`Queue is full, sending 429 response`);
+        this.log.warn(`Queue is full, sending 429 response`);
         return writeResponse(res, 429, 'Too many requests');
     };
     onQueueFullWebSocket = (_req, socket) => {
-        this.log(`Queue is full, sending 429 response`);
+        this.log.warn(`Queue is full, sending 429 response`);
         return writeResponse(socket, 429, 'Too many requests');
     };
     onHTTPTimeout = (_req, res) => {
-        this.log(`HTTP job has timedout, sending 429 response`);
+        this.log.error(`HTTP job has timedout, sending 429 response`);
         return writeResponse(res, 408, 'Request has timed out');
     };
     onWebsocketTimeout = (_req, socket) => {
-        this.log(`Websocket job has timedout, sending 429 response`);
+        this.log.error(`Websocket job has timedout, sending 429 response`);
         return writeResponse(socket, 408, 'Request has timed out');
     };
     wrapHTTPHandler = (route, handler) => async (req, res) => {
         if (!isConnected(res)) {
-            this.log(`HTTP Request has closed prior to running`);
+            this.log.warn(`HTTP Request has closed prior to running`);
             return Promise.resolve();
         }
+        const logger = new this.logger(route.name, req);
         if ('browser' in route && route.browser) {
-            const browser = await this.browserManager.getBrowserForRequest(req, route);
+            const browser = await this.browserManager.getBrowserForRequest(req, route, logger);
             if (!isConnected(res)) {
-                this.log(`HTTP Request has closed prior to running`);
+                this.log.warn(`HTTP Request has closed prior to running`);
                 this.browserManager.complete(browser);
                 return Promise.resolve();
             }
@@ -51,36 +53,37 @@ export class Router extends EventEmitter {
                 return writeResponse(res, 500, `Error loading the browser`);
             }
             try {
-                this.verbose(`Running found HTTP handler.`);
+                this.log.trace(`Running found HTTP handler.`);
                 return await Promise.race([
-                    handler(req, res, browser),
+                    handler(req, res, logger, browser),
                     new Promise((resolve, reject) => {
                         res.once('close', () => {
                             if (!res.writableEnded) {
                                 reject(new Error(`Request closed prior to writing results`));
                             }
-                            this.verbose(`Response has been written, resolving`);
+                            this.log.trace(`Response has been written, resolving`);
                             resolve(null);
                         });
                     }),
                 ]);
             }
             finally {
-                this.verbose(`HTTP Request handler has finished.`);
+                this.log.trace(`HTTP Request handler has finished.`);
                 this.browserManager.complete(browser);
             }
         }
-        return handler(req, res);
+        return handler(req, res, logger);
     };
     wrapWebSocketHandler = (route, handler) => async (req, socket, head) => {
         if (!isConnected(socket)) {
-            this.log(`WebSocket Request has closed prior to running`);
+            this.log.warn(`WebSocket Request has closed prior to running`);
             return Promise.resolve();
         }
+        const logger = new this.logger(route.name, req);
         if ('browser' in route && route.browser) {
-            const browser = await this.browserManager.getBrowserForRequest(req, route);
+            const browser = await this.browserManager.getBrowserForRequest(req, route, logger);
             if (!isConnected(socket)) {
-                this.log(`WebSocket Request has closed prior to running`);
+                this.log.warn(`WebSocket Request has closed prior to running`);
                 this.browserManager.complete(browser);
                 return Promise.resolve();
             }
@@ -88,19 +91,19 @@ export class Router extends EventEmitter {
                 return writeResponse(socket, 500, `Error loading the browser.`);
             }
             try {
-                this.verbose(`Running found WebSocket handler.`);
-                await handler(req, socket, head, browser);
+                this.log.trace(`Running found WebSocket handler.`);
+                await handler(req, socket, head, logger, browser);
             }
             finally {
-                this.verbose(`WebSocket Request handler has finished.`);
+                this.log.trace(`WebSocket Request handler has finished.`);
                 this.browserManager.complete(browser);
             }
             return;
         }
-        return handler(req, socket, head);
+        return handler(req, socket, head, logger);
     };
     registerHTTPRoute(route) {
-        this.verbose(`Registering HTTP ${route.method.toUpperCase()} ${route.path}`);
+        this.log.trace(`Registering HTTP ${route.method.toUpperCase()} ${route.path}`);
         const bound = route.handler.bind(route);
         const wrapped = this.wrapHTTPHandler(route, bound);
         route.handler = route.concurrency
@@ -110,13 +113,13 @@ export class Router extends EventEmitter {
         const registeredPaths = this.httpRoutes.map((r) => r.path).flat();
         const duplicatePaths = registeredPaths.filter((path) => route.path.includes(path));
         if (duplicatePaths.length) {
-            this.log(`Found duplicate routes: ${duplicatePaths.join(', ')}`);
+            this.log.warn(`Found duplicate routes: ${duplicatePaths.join(', ')}`);
         }
         this.httpRoutes.push(route);
         return route;
     }
     registerWebSocketRoute(route) {
-        this.verbose(`Registering WebSocket "${route.path}"`);
+        this.log.trace(`Registering WebSocket "${route.path}"`);
         const bound = route.handler.bind(route);
         const wrapped = this.wrapWebSocketHandler(route, bound);
         route.handler = route.concurrency
@@ -126,7 +129,7 @@ export class Router extends EventEmitter {
         const registeredPaths = this.webSocketRoutes.map((r) => r.path).flat();
         const duplicatePaths = registeredPaths.filter((path) => route.path.includes(path));
         if (duplicatePaths.length) {
-            this.log(`Found duplicate routes: ${duplicatePaths.join(', ')}`);
+            this.log.warn(`Found duplicate routes: ${duplicatePaths.join(', ')}`);
         }
         this.webSocketRoutes.push(route);
         return route;
@@ -141,7 +144,7 @@ export class Router extends EventEmitter {
         // Once registered, paths are always an array here.
         r.path.some((p) => micromatch.isMatch(req.parsed.pathname, p)) &&
             r.method === req.method?.toLocaleLowerCase() &&
-            (accepts.some((a) => a.startsWith('*/*')) ||
+            (accepts.some((a) => a.includes('*/*')) ||
                 r.contentTypes.some((contentType) => accepts.includes(contentType))) &&
             ((!contentType && r.accepts.includes(contentTypes.any)) ||
                 r.accepts.includes(contentType))) ||