@browserless.io/browserless 2.8.0 → 2.10.0

package/CHANGELOG.md

@@ -1,6 +1,18 @@
-# [Latest](https://github.com/browserless/chrome/compare/v2.8.0...main)
+# [Latest](https://github.com/browserless/chrome/compare/v2.10.0...main)
 - Dependency updates.
 
+# [v2.10.0](https://github.com/browserless/chrome/compare/v2.9.0...v2.10.0)
+- Adds back in the `/pressure` API from V1.
+- Dependency updates.
+
+# [v2.9.0](https://github.com/browserless/chrome/compare/v2.8.0...v2.9.0)
+- Dependency updates.
+- Debugger is now included and mounted under the `/debugger` path.
+- Browserless now uses the `Logger` utility internally. Better logs for certain classes as well.
+- Fix number of connected clients when using the Page websocket route.
+- Allows "HEAD" requests for most "GET"-based APIs.
+-
+
 # [v2.8.0](https://github.com/browserless/chrome/compare/v2.7.1...v2.8.0)
 **April 12, 2024**
 **Potentially Breaking**

package/README.md

@@ -1,4 +1,4 @@
-<!-- markdownlint-disable first-line-h1 no-emphasis-as-heading -->
+<!-- markdownlint-disable commands-show-output first-line-h1 no-emphasis-as-heading -->
 
 ![browserless.io logo](/assets/logo.png)
 
@@ -28,6 +28,8 @@ If you've been struggling to deploy headless browsers without running into issue
   - [Puppeteer](#puppeteer)
   - [Playwright](#playwright)
 - [Extending (NodeJS SDK)](#extending-nodejs-sdk)
+- [Debugger](#debugger)
+  - [Install debugger](#install-debugger)
 - [Usage with other libraries](#usage-with-other-libraries)
 - [Motivations](#motivations)
 - [Licensing](#licensing)
@@ -70,7 +72,7 @@ You still execute the script itself which gives you total control over what libr
 
 ### Docker
 
-> [!TIP]  
+> [!TIP]
 > See more options on our [full documentation site](https://docs.browserless.io/Docker/docker-quickstart).
 
 1. `docker run -p 3000:3000 ghcr.io/browserless/chromium`
@@ -107,7 +109,7 @@ const browser = await puppeteer.connect({
 
 ### Playwright
 
-We support running with playwright via their their browser's remot connection protocols interface out of the box. Just make sure that your Docker image, playwright browser type _and_ endpoint match:
+We support running with playwright via their their browser's remote connection protocols interface out of the box. Just make sure that your Docker image, playwright browser type _and_ endpoint match:
 
 **Before**
 
@@ -137,6 +139,42 @@ After that, the rest of your code remains the same with no other changes require
 
 Browserless comes with built-in extension capabilities, and allows for extending nearly any aspect of the system (for Version 2+). For more details on how to write your own routes, build docker images, and more, [see our SDK README.md](/bin/scaffold/README.md) or simply run "npx @browserless.io/browserless create" in a terminal and follow the onscreen prompts.
 
+## Debugger
+
+You can install a first-party interactive debugger for Browserless, that makes writing scripts faster and interactive. You can take advantage of things like `debugger;` calls and the page's console output to see what's happening on the page while your script is running. All of the Chrome devtools are there at your disposal.
+
+![browserless.io logo](/assets/debugger.png)
+
+A small list of features includes:
+
+- Running `debugger;` and `console.log` calls
+- Errors in the script are caught and show up in the console tab
+- DOM inspection, watch network requests, and even see how the page is rendering
+- Exporting you debugging script as a Node project
+- Everything included in Chrome DevTools
+
+### Install debugger
+
+Installing the debugger is as simple as running the `install:debugger` script _after_ the project has been built. This way:
+
+```sh
+$ npm run build
+$ npm run install:debugger #or npm install:dev
+```
+
+You will then see the debugger url during the startup process.
+
+```log
+---------------------------------------------------------
+| browserless.io
+| To read documentation and more, load in your browser:
+|
+| OpenAPI: http://localhost:3000/docs
+| Full Documentation: https://docs.browserless.io/
+| Debbuger: http://localhost:3000/debugger/?token=6R0W53R135510
+---------------------------------------------------------
+```
+
 ## Usage with other libraries
 
 Most libraries allow you to specify a remote instance of Chrome to interact with. They are either looking for a websocket endpoint, a host and port, or some address. Browserless supports these by default, however if you're having issues please make an issue in this project and we'll try and work with the library authors to get them integrated with browserless. Please note that in V2 we no longer support selenium or webdriver integrations.

package/bin/scaffold/src/hello-world.http.ts

@@ -23,10 +23,11 @@ export default class HelloWorldHTTPRoute extends HTTPRoute {
   path = '/hello';
   tags = [APITags.management];
   handler = async (
-    _req: Request,
-    _logger: Logger,
+    req: Request,
     res: Response,
+    logger: Logger,
   ): Promise<void> => {
+    logger.verbose(`${req.method} /hello was called!`);
     const response: ResponseSchema = 'Hello World!';
     return writeResponse(res, 200, response, contentTypes.text);
   };

package/build/browserless.d.ts

@@ -1,10 +1,10 @@
-/// <reference types="debug" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { Logger as BlessLogger, BrowserManager, Config, FileSystem, HTTPServer, Hooks, Limiter, Metrics, Monitoring, Router, Token, WebHooks } from '@browserless.io/browserless';
+import { Logger as BlessLogger, BrowserHTTPRoute, BrowserManager, BrowserWebsocketRoute, Config, FileSystem, HTTPRoute, HTTPServer, Hooks, Limiter, Metrics, Monitoring, Router, Token, WebHooks, WebSocketRoute } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
+type routeInstances = HTTPRoute | BrowserHTTPRoute | WebSocketRoute | BrowserWebsocketRoute;
 export declare class Browserless extends EventEmitter {
-    protected debug: debug.Debugger;
+    protected logger: BlessLogger;
     protected browserManager: BrowserManager;
     protected config: Config;
     protected fileSystem: FileSystem;
@@ -38,7 +38,7 @@ export declare class Browserless extends EventEmitter {
     });
     protected saveMetrics: () => Promise<void>;
     setMetricsSaveInterval: (interval: number) => void;
-    private routeIsDisabled;
+    protected routeIsDisabled(route: routeInstances): boolean;
     setStaticSDKDir(dir: string): void;
     disableRoutes(...routeNames: string[]): void;
     addHTTPRoute(httpRouteFilePath: string): void;
@@ -47,3 +47,4 @@ export declare class Browserless extends EventEmitter {
     stop(): Promise<[void | undefined, void, void, void, void, void, void, void, void, void, void]>;
     start(): Promise<void>;
 }
+export {};

package/build/browserless.js

@@ -1,11 +1,11 @@
 import * as path from 'path';
-import { Logger as BlessLogger, BrowserManager, ChromeCDP, ChromiumCDP, ChromiumPlaywright, Config, FileSystem, FirefoxPlaywright, HTTPServer, Hooks, Limiter, Metrics, Monitoring, Router, Token, WebHooks, WebkitPlaywright, availableBrowsers, createLogger, getRouteFiles, makeExternalURL, printLogo, safeParse, } from '@browserless.io/browserless';
+import { Logger as BlessLogger, BrowserManager, ChromeCDP, ChromiumCDP, ChromiumPlaywright, Config, FileSystem, FirefoxPlaywright, HTTPServer, Hooks, Limiter, Metrics, Monitoring, Router, Token, WebHooks, WebkitPlaywright, availableBrowsers, getRouteFiles, makeExternalURL, printLogo, safeParse, } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 import { readFile } from 'fs/promises';
 import { userInfo } from 'os';
 const routeSchemas = ['body', 'query'];
 export class Browserless extends EventEmitter {
-    debug = createLogger('index');
+    logger;
     browserManager;
     config;
     fileSystem;
@@ -27,6 +27,7 @@ export class Browserless extends EventEmitter {
     constructor({ browserManager, config, fileSystem, hooks, limiter, Logger: LoggerOverride, metrics, monitoring, router, token, webhooks, } = {}) {
         super();
         this.Logger = LoggerOverride ?? BlessLogger;
+        this.logger = new this.Logger('index');
         this.config = config || new Config();
         this.metrics = metrics || new Metrics();
         this.token = token || new Token(this.config);
@@ -53,7 +54,7 @@ export class Browserless extends EventEmitter {
             memory,
         };
         this.metrics.reset();
-        this.debug(`Current period usage: ${JSON.stringify({
+        this.logger.info(`Current period usage: ${JSON.stringify({
             date: aggregatedStats.date,
             error: aggregatedStats.error,
             maxConcurrent: aggregatedStats.maxConcurrent,
@@ -67,7 +68,7 @@ export class Browserless extends EventEmitter {
             units: aggregatedStats.units,
         })}`);
         if (metricsPath) {
-            this.debug(`Saving metrics to "${metricsPath}"`);
+            this.logger.info(`Saving metrics to "${metricsPath}"`);
             this.fileSystem.append(metricsPath, JSON.stringify(aggregatedStats), false);
         }
     };
@@ -127,10 +128,13 @@ export class Browserless extends EventEmitter {
             WebkitPlaywright,
         ];
         const [[internalHttpRouteFiles, internalWsRouteFiles], installedBrowsers] = await Promise.all([getRouteFiles(this.config), availableBrowsers]);
+        const hasDebugger = await this.config.hasDebugger();
+        const debuggerURL = hasDebugger &&
+            makeExternalURL(this.config.getExternalAddress(), `/debugger/?token=${this.config.getToken()}`);
         const docsLink = makeExternalURL(this.config.getExternalAddress(), '/docs');
-        this.debug(printLogo(docsLink));
-        this.debug(`Running as user "${userInfo().username}"`);
-        this.debug('Starting import of HTTP Routes');
+        this.logger.info(printLogo(docsLink, debuggerURL));
+        this.logger.info(`Running as user "${userInfo().username}"`);
+        this.logger.info('Starting import of HTTP Routes');
         for (const httpRoute of [
             ...this.httpRouteFiles,
             ...internalHttpRouteFiles,
@@ -143,11 +147,12 @@ export class Browserless extends EventEmitter {
                 }));
                 const routeImport = `${this.config.getIsWin() ? 'file:///' : ''}${httpRoute}`;
                 const { default: Route, } = await import(routeImport + `?cb=${Date.now()}`);
-                const route = new Route(this.browserManager, this.config, this.fileSystem, this.metrics, this.monitoring, this.staticSDKDir);
+                const route = new Route(this.browserManager, this.config, this.fileSystem, this.metrics, this.monitoring, this.staticSDKDir, this.limiter);
                 if (!this.routeIsDisabled(route)) {
                     route.bodySchema = safeParse(bodySchema);
                     route.querySchema = safeParse(querySchema);
                     route.config = () => this.config;
+                    route.limiter = () => this.limiter;
                     route.metrics = () => this.metrics;
                     route.monitoring = () => this.monitoring;
                     route.fileSystem = () => this.fileSystem;
@@ -156,7 +161,7 @@ export class Browserless extends EventEmitter {
                 }
             }
         }
-        this.debug('Starting import of WebSocket Routes');
+        this.logger.info('Starting import of WebSocket Routes');
         for (const wsRoute of [
             ...this.webSocketRouteFiles,
             ...internalWsRouteFiles,
@@ -169,10 +174,11 @@ export class Browserless extends EventEmitter {
                 }));
                 const wsImport = `${this.config.getIsWin() ? 'file:///' : ''}${wsRoute}`;
                 const { default: Route, } = await import(wsImport + `?cb=${Date.now()}`);
-                const route = new Route(this.browserManager, this.config, this.fileSystem, this.metrics, this.monitoring, this.staticSDKDir);
+                const route = new Route(this.browserManager, this.config, this.fileSystem, this.metrics, this.monitoring, this.staticSDKDir, this.limiter);
                 if (!this.routeIsDisabled(route)) {
                     route.querySchema = safeParse(querySchema);
                     route.config = () => this.config;
+                    route.limiter = () => this.limiter;
                     route.metrics = () => this.metrics;
                     route.monitoring = () => this.monitoring;
                     route.fileSystem = () => this.fileSystem;
@@ -195,14 +201,14 @@ export class Browserless extends EventEmitter {
             .filter((e, i, a) => a.findIndex((r) => r.name === e.name) !== i)
             .map((r) => r.name);
         if (duplicateNamedRoutes.length) {
-            this.debug(`Found duplicate routing names. Route names must be unique:`, duplicateNamedRoutes);
+            this.logger.warn(`Found duplicate routing names. Route names must be unique:`, duplicateNamedRoutes);
         }
         httpRoutes.forEach((r) => this.router.registerHTTPRoute(r));
         wsRoutes.forEach((r) => this.router.registerWebSocketRoute(r));
-        this.debug(`Imported and validated all route files, starting up server.`);
+        this.logger.info(`Imported and validated all route files, starting up server.`);
         this.server = new HTTPServer(this.config, this.metrics, this.token, this.router, this.hooks, this.Logger);
         await this.server.start();
-        this.debug(`Starting metrics collection.`);
+        this.logger.info(`Starting metrics collection.`);
         this.metricsSaveIntervalID = setInterval(() => this.saveMetrics(), this.metricsSaveInterval);
     }
 }

package/build/browsers/chrome.cdp.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="debug" />
+import { Logger } from '@browserless.io/browserless';
 import { ChromiumCDP } from './chromium.cdp.js';
 export declare class ChromeCDP extends ChromiumCDP {
     protected executablePath: string;
-    protected debug: import("debug").Debugger;
+    protected logger: Logger;
 }

package/build/browsers/chrome.cdp.js

@@ -1,6 +1,6 @@
-import { chromeExecutablePath, createLogger, } from '@browserless.io/browserless';
+import { Logger, chromeExecutablePath } from '@browserless.io/browserless';
 import { ChromiumCDP } from './chromium.cdp.js';
 export class ChromeCDP extends ChromiumCDP {
     executablePath = chromeExecutablePath();
-    debug = createLogger('browsers:chrome:cdp');
+    logger = new Logger('browsers:chrome:cdp');
 }

package/build/browsers/chrome.playwright.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="debug" />
+import { Logger } from '@browserless.io/browserless';
 import { ChromiumPlaywright } from './chromium.playwright.js';
 export declare class ChromePlaywright extends ChromiumPlaywright {
     protected executablePath: string;
-    protected debug: import("debug").Debugger;
+    protected logger: Logger;
 }

package/build/browsers/chrome.playwright.js

@@ -1,6 +1,6 @@
-import { chromeExecutablePath, createLogger, } from '@browserless.io/browserless';
+import { Logger, chromeExecutablePath } from '@browserless.io/browserless';
 import { ChromiumPlaywright } from './chromium.playwright.js';
 export class ChromePlaywright extends ChromiumPlaywright {
     executablePath = chromeExecutablePath();
-    debug = createLogger('browsers:chrome:playwright');
+    logger = new Logger('browsers:chrome:playwright');
 }

package/build/browsers/chromium.cdp.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="debug" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { CDPLaunchOptions, Config, Request } from '@browserless.io/browserless';
+import { CDPLaunchOptions, Config, Logger, Request } from '@browserless.io/browserless';
 import { Browser, Page, Target } from 'puppeteer-core';
 import { Duplex } from 'stream';
 import { EventEmitter } from 'events';
@@ -17,12 +16,13 @@ export declare class ChromiumCDP extends EventEmitter {
     protected browser: Browser | null;
     protected browserWSEndpoint: string | null;
     protected port?: number;
-    protected debug: import("debug").Debugger;
+    protected logger: Logger;
     protected proxy: httpProxy<import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>>;
     protected executablePath: string;
-    constructor({ blockAds, config, userDataDir, }: {
+    constructor({ blockAds, config, userDataDir, logger, }: {
         blockAds: boolean;
         config: Config;
+        logger: Logger;
         userDataDir: ChromiumCDP['userDataDir'];
     });
     protected cleanListeners(): void;

package/build/browsers/chromium.cdp.js

@@ -1,4 +1,4 @@
-import { BLESS_PAGE_IDENTIFIER, ServerError, createLogger, noop, once, } from '@browserless.io/browserless';
+import { BLESS_PAGE_IDENTIFIER, ServerError, noop, once, } from '@browserless.io/browserless';
 import puppeteer from 'puppeteer-core';
 import { EventEmitter } from 'events';
 import StealthPlugin from 'puppeteer-extra-plugin-stealth';
@@ -17,15 +17,16 @@ export class ChromiumCDP extends EventEmitter {
     browser = null;
     browserWSEndpoint = null;
     port;
-    debug = createLogger('browsers:chromium:cdp');
+    logger;
     proxy = httpProxy.createProxyServer();
     executablePath = playwright.chromium.executablePath();
-    constructor({ blockAds, config, userDataDir, }) {
+    constructor({ blockAds, config, userDataDir, logger, }) {
         super();
         this.userDataDir = userDataDir;
         this.config = config;
         this.blockAds = blockAds;
-        this.debug(`Starting new browser instance`);
+        this.logger = logger;
+        this.logger.info(`Starting new ${this.constructor.name} instance`);
     }
     cleanListeners() {
         this.browser?.removeAllListeners();
@@ -38,27 +39,44 @@ export class ChromiumCDP extends EventEmitter {
     onTargetCreated = async (target) => {
         if (target.type() === 'page') {
             const page = await target.page().catch((e) => {
-                this.debug(`Error in new page ${e}`);
+                this.logger.error(`Error in ${this.constructor.name} new page ${e}`);
                 return null;
             });
             if (page) {
-                if (!this.config.getAllowFileProtocol()) {
-                    this.debug(`Setting up file:// protocol request rejection`);
-                    page.on('request', async (request) => {
-                        if (request.url().startsWith('file://')) {
-                            this.debug(`File protocol request found in request, terminating`);
-                            page.close().catch(noop);
-                            this.close();
-                        }
-                    });
-                    page.on('response', async (response) => {
-                        if (response.url().startsWith('file://')) {
-                            this.debug(`File protocol request found in response, terminating`);
-                            page.close().catch(noop);
-                            this.close();
-                        }
-                    });
-                }
+                this.logger.trace(`Setting up file:// protocol request rejection`);
+                page.on('error', (err) => {
+                    this.logger.error(err);
+                });
+                page.on('pageerror', (err) => {
+                    this.logger.warn(err);
+                });
+                page.on('framenavigated', (frame) => {
+                    this.logger.trace(`Navigation to ${frame.url()}`);
+                });
+                page.on('console', (message) => {
+                    this.logger.trace(`${message.type()}: ${message.text()}`);
+                });
+                page.on('requestfailed', (req) => {
+                    this.logger.warn(`"${req.failure()?.errorText}": ${req.url()}`);
+                });
+                page.on('request', async (request) => {
+                    this.logger.trace(`${request.method()}: ${request.url()}`);
+                    if (!this.config.getAllowFileProtocol() &&
+                        request.url().startsWith('file://')) {
+                        this.logger.error(`File protocol request found in request to ${this.constructor.name}, terminating`);
+                        page.close().catch(noop);
+                        this.close();
+                    }
+                });
+                page.on('response', async (response) => {
+                    this.logger.trace(`${response.status()}: ${response.url()}`);
+                    if (!this.config.getAllowFileProtocol() &&
+                        response.url().startsWith('file://')) {
+                        this.logger.error(`File protocol request found in response to ${this.constructor.name}, terminating`);
+                        page.close().catch(noop);
+                        this.close();
+                    }
+                });
                 this.emit('newPage', page);
             }
         }
@@ -66,13 +84,13 @@ export class ChromiumCDP extends EventEmitter {
     isRunning = () => this.running;
     newPage = async () => {
         if (!this.browser) {
-            throw new ServerError(`Browser hasn't been launched yet!`);
+            throw new ServerError(`${this.constructor.name} hasn't been launched yet!`);
         }
         return this.browser.newPage();
     };
     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.removeAllListeners();
@@ -86,7 +104,7 @@ export class ChromiumCDP extends EventEmitter {
     process = () => this.browser?.process() || null;
     launch = async (options = {}) => {
         this.port = await getPort();
-        this.debug(`Got open port ${this.port}`);
+        this.logger.info(`${this.constructor.name} got open port ${this.port}`);
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
         const finalOptions = {
             ...options,
@@ -107,13 +125,12 @@ export class ChromiumCDP extends EventEmitter {
         const launch = options.stealth
             ? puppeteerStealth.launch.bind(puppeteerStealth)
             : puppeteer.launch.bind(puppeteer);
-        this.debug(finalOptions, `Launching CDP Handler`);
-        // @ts-ignore mis-matched types from stealth...
+        this.logger.info(finalOptions, `Launching ${this.constructor.name} Handler`);
         this.browser = (await launch(finalOptions));
         this.browser.on('targetcreated', this.onTargetCreated);
         this.running = true;
         this.browserWSEndpoint = this.browser.wsEndpoint();
-        this.debug(`Browser is running on ${this.browserWSEndpoint}`);
+        this.logger.info(`${this.constructor.name} is running on ${this.browserWSEndpoint}`);
         return this.browser;
     };
     wsEndpoint = () => this.browserWSEndpoint;
@@ -134,7 +151,7 @@ export class ChromiumCDP extends EventEmitter {
             throw new ServerError(`No browserWSEndpoint found, did you launch first?`);
         }
         socket.once('close', resolve);
-        this.debug(`Proxying ${req.parsed.href}`);
+        this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name}`);
         const shouldMakePage = req.parsed.pathname.includes(BLESS_PAGE_IDENTIFIER);
         const page = shouldMakePage ? await this.browser.newPage() : null;
         const pathname = page
@@ -148,7 +165,7 @@ export class ChromiumCDP extends EventEmitter {
             changeOrigin: true,
             target,
         }, (error) => {
-            this.debug(`Error proxying session: ${error}`);
+            this.logger.error(`Error proxying session to ${this.constructor.name}: ${error}`);
             this.close();
             return reject(error);
         });
@@ -166,7 +183,7 @@ export class ChromiumCDP extends EventEmitter {
         this.browser?.once('close', close);
         this.browser?.process()?.once('close', close);
         socket.once('close', close);
-        this.debug(`Proxying ${req.parsed.href} to browser ${this.browserWSEndpoint}`);
+        this.logger.info(`Proxying ${req.parsed.href} to ${this.constructor.name} ${this.browserWSEndpoint}`);
         req.url = '';
         // Delete headers known to cause issues
         delete req.headers.origin;
@@ -174,7 +191,7 @@ export class ChromiumCDP 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/browsers/chromium.playwright.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="node" />
-/// <reference types="debug" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { BrowserServerOptions, Config, Request } from '@browserless.io/browserless';
+import { BrowserServerOptions, Config, Logger, Request } from '@browserless.io/browserless';
 import playwright, { Page } from 'playwright-core';
 import { Duplex } from 'stream';
 import { EventEmitter } from 'events';
@@ -12,13 +11,14 @@ export declare class ChromiumPlaywright extends EventEmitter {
     protected config: Config;
     protected userDataDir: string | null;
     protected running: boolean;
+    protected logger: Logger;
     protected proxy: httpProxy<import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>>;
     protected browser: playwright.BrowserServer | null;
     protected browserWSEndpoint: string | null;
-    protected debug: import("debug").Debugger;
     protected executablePath: string;
-    constructor({ config, userDataDir, }: {
+    constructor({ config, userDataDir, logger, }: {
         config: Config;
+        logger: Logger;
         userDataDir: ChromiumPlaywright['userDataDir'];
     });
     protected cleanListeners(): void;

package/build/browsers/chromium.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';
@@ -7,16 +7,17 @@ export class ChromiumPlaywright extends EventEmitter {
     config;
     userDataDir;
     running = false;
+    logger;
     proxy = httpProxy.createProxyServer();
     browser = null;
     browserWSEndpoint = null;
-    debug = createLogger('browsers:chromium:playwright');
     executablePath = playwright.chromium.executablePath();
-    constructor({ config, userDataDir, }) {
+    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();
@@ -24,7 +25,7 @@ export class ChromiumPlaywright 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();
@@ -35,20 +36,20 @@ export class ChromiumPlaywright 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. In the future this will be at "${this.config.getExternalAddress()}"`);
+        throw new ServerError(`Live URLs are not yet supported with ${this.constructor.name}. In the future this will be at "${this.config.getExternalAddress()}"`);
     };
     newPage = async () => {
         if (!this.browser || !this.browserWSEndpoint) {
-            throw new ServerError(`Browser hasn't been launched yet!`);
+            throw new ServerError(`${this.constructor.name} hasn't been launched yet!`);
         }
         const browser = await playwright.chromium.connect(this.browserWSEndpoint);
         return await browser.newPage();
     };
     launch = async (options = {}) => {
-        this.debug(`Launching Playwright Handler`);
+        this.logger.info(`Launching ${this.constructor.name} Handler`);
         this.browser = await playwright.chromium.launchServer({
             ...options,
             args: [
@@ -59,7 +60,7 @@ export class ChromiumPlaywright extends EventEmitter {
             executablePath: this.executablePath,
         });
         const browserWSEndpoint = this.browser.wsEndpoint();
-        this.debug(`Browser is running on ${browserWSEndpoint}`);
+        this.logger.info(`${this.constructor.name} is running on ${browserWSEndpoint}`);
         this.running = true;
         this.browserWSEndpoint = browserWSEndpoint;
         return this.browser;
@@ -78,14 +79,14 @@ export class ChromiumPlaywright extends EventEmitter {
         return externalURL.href;
     };
     proxyPageWebSocket = async () => {
-        console.warn(`Not yet implemented`);
+        this.logger.warn(`${this.constructor.name} 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 = '';
@@ -93,7 +94,7 @@ export class ChromiumPlaywright 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/browsers/firefox.playwright.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="node" />
-/// <reference types="debug" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { BrowserServerOptions, Config, Request } from '@browserless.io/browserless';
+import { BrowserServerOptions, Config, Logger, Request } from '@browserless.io/browserless';
 import playwright, { Page } from 'playwright-core';
 import { Duplex } from 'stream';
 import { EventEmitter } from 'events';
@@ -12,12 +11,13 @@ export declare class FirefoxPlaywright extends EventEmitter {
     protected config: Config;
     protected userDataDir: string | null;
     protected running: boolean;
+    protected logger: Logger;
     protected proxy: httpProxy<import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>>;
     protected browser: playwright.BrowserServer | null;
     protected browserWSEndpoint: string | null;
-    protected debug: import("debug").Debugger;
-    constructor({ config, userDataDir, }: {
+    constructor({ config, userDataDir, logger, }: {
         config: Config;
+        logger: Logger;
         userDataDir: FirefoxPlaywright['userDataDir'];
     });
     protected cleanListeners(): void;