@browserless.io/browserless 2.7.1 → 2.9.0

package/build/server.d.ts

@@ -1,11 +1,10 @@
 /// <reference types="node" />
-/// <reference types="debug" />
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
 import * as http from 'http';
 import * as stream from 'stream';
-import { Config, Hooks, Metrics, Request, Response, Router, Token } from '@browserless.io/browserless';
+import { Logger as BlessLogger, Config, Hooks, Metrics, Request, Response, Router, Token } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 export interface HTTPServerOptions {
     concurrent: number;
@@ -20,12 +19,12 @@ export declare class HTTPServer extends EventEmitter {
     protected token: Token;
     protected router: Router;
     protected hooks: Hooks;
+    protected Logger: typeof BlessLogger;
     protected server: http.Server;
     protected port: number;
     protected host?: string;
-    protected log: import("debug").Debugger;
-    protected verbose: import("debug").Debugger;
-    constructor(config: Config, metrics: Metrics, token: Token, router: Router, hooks: Hooks);
+    protected logger: BlessLogger;
+    constructor(config: Config, metrics: Metrics, token: Token, router: Router, hooks: Hooks, Logger: typeof BlessLogger);
     protected onHTTPUnauthorized: (_req: Request, res: Response) => void;
     protected onWebsocketUnauthorized: (_req: Request, socket: stream.Duplex) => void;
     start(): Promise<void>;

package/build/server.js

@@ -1,5 +1,5 @@
 import * as http from 'http';
-import { BadRequest, NotFound, Timeout, TooManyRequests, Unauthorized, contentTypes, convertPathToURL, createLogger, queryParamsToObject, readBody, shimLegacyRequests, writeResponse, } from '@browserless.io/browserless';
+import { BadRequest, Logger as BlessLogger, NotFound, Timeout, TooManyRequests, Unauthorized, contentTypes, convertPathToURL, queryParamsToObject, readBody, shimLegacyRequests, writeResponse, } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 // @ts-ignore
 import Enjoi from 'enjoi';
@@ -9,34 +9,35 @@ export class HTTPServer extends EventEmitter {
     token;
     router;
     hooks;
+    Logger;
     server = http.createServer();
     port;
     host;
-    log = createLogger('server');
-    verbose = createLogger('server:verbose');
-    constructor(config, metrics, token, router, hooks) {
+    logger = new BlessLogger('server');
+    constructor(config, metrics, token, router, hooks, Logger) {
         super();
         this.config = config;
         this.metrics = metrics;
         this.token = token;
         this.router = router;
         this.hooks = hooks;
+        this.Logger = Logger;
         this.host = config.getHost();
         this.port = config.getPort();
-        this.log(`Server instantiated with host "${this.host}" on port "${this.port}" using token "${this.config.getToken()}"`);
+        this.logger.info(`Server instantiated with host "${this.host}" on port "${this.port}" using token "${this.config.getToken()}"`);
     }
     onHTTPUnauthorized = (_req, res) => {
-        this.log(`HTTP request is not properly authorized, responding with 401`);
+        this.logger.error(`HTTP request is not properly authorized, responding with 401`);
         this.metrics.addUnauthorized();
         return writeResponse(res, 401, 'Bad or missing authentication.');
     };
     onWebsocketUnauthorized = (_req, socket) => {
-        this.log(`Websocket request is not properly authorized, responding with 401`);
+        this.logger.error(`Websocket request is not properly authorized, responding with 401`);
         this.metrics.addUnauthorized();
         return writeResponse(socket, 401, 'Bad or missing authentication.');
     };
     async start() {
-        this.log(`HTTP Server is starting`);
+        this.logger.info(`HTTP Server is starting`);
         this.server.on('request', this.handleRequest);
         this.server.on('upgrade', this.handleWebSocket);
         const listenMessage = [
@@ -48,13 +49,13 @@ export class HTTPServer extends EventEmitter {
                 host: this.host,
                 port: this.port,
             }, undefined, () => {
-                this.log(listenMessage);
+                this.logger.info(listenMessage);
                 r(undefined);
             });
         });
     }
     handleRequest = async (request, res) => {
-        this.verbose(`Handling inbound HTTP request on "${request.method}: ${request.url}"`);
+        this.logger.trace(`Handling inbound HTTP request on "${request.method}: ${request.url}"`);
         const req = request;
         const proceed = await this.hooks.before({ req, res });
         req.parsed = convertPathToURL(request.url || '', this.config);
@@ -68,6 +69,10 @@ export class HTTPServer extends EventEmitter {
                 return res.end();
             }
         }
+        if (req.method?.toLowerCase() === 'head') {
+            this.logger.debug(`Inbound HEAD request, setting to GET`);
+            req.method = 'GET';
+        }
         if (this.config.getAllowGetCalls() &&
             req.method === 'GET' &&
             req.parsed.searchParams.has('body')) {
@@ -78,13 +83,13 @@ export class HTTPServer extends EventEmitter {
         }
         const route = await this.router.getRouteForHTTPRequest(req);
         if (!route) {
-            this.log(`No matching HTTP route handler for "${req.method}: ${req.parsed.href}"`);
+            this.logger.error(`No matching HTTP route handler for "${req.method}: ${req.parsed.href}"`);
             writeResponse(res, 404, 'Not Found');
             return Promise.resolve();
         }
-        this.verbose(`Found matching HTTP route handler "${route.path}"`);
+        this.logger.trace(`Found matching HTTP route handler "${route.path}"`);
         if (route?.auth) {
-            this.verbose(`Authorizing HTTP request to "${request.url}"`);
+            this.logger.trace(`Authorizing HTTP request to "${request.url}"`);
             const isPermitted = await this.token.isAuthorized(req, route);
             if (!isPermitted) {
                 return this.onHTTPUnauthorized(req, res);
@@ -102,7 +107,7 @@ export class HTTPServer extends EventEmitter {
             return Promise.resolve();
         }
         if (route.querySchema) {
-            this.verbose(`Validating route query-params with QUERY schema`);
+            this.logger.trace(`Validating route query-params with QUERY schema`);
             try {
                 const schema = Enjoi.schema(route.querySchema);
                 const valid = schema.validate(req.queryParams, {
@@ -112,19 +117,19 @@ export class HTTPServer extends EventEmitter {
                     const errorDetails = valid.error.details
                         .map(({ message, context, }) => context?.message || message)
                         .join('\n');
-                    this.log(`HTTP query-params contain errors sending 400:${errorDetails}`);
+                    this.logger.error(`HTTP query-params contain errors sending 400:${errorDetails}`);
                     writeResponse(res, 400, `Query-parameter validation failed: ${errorDetails}`, contentTypes.text);
                     return Promise.resolve();
                 }
             }
             catch (e) {
-                this.log(`Error parsing body schema`, e);
+                this.logger.error(`Error parsing body schema`, e);
                 writeResponse(res, 500, 'There was an error handling your request', contentTypes.text);
                 return Promise.resolve();
             }
         }
         if (route.bodySchema) {
-            this.verbose(`Validating route payload with BODY schema`);
+            this.logger.trace(`Validating route payload with BODY schema`);
             try {
                 const schema = Enjoi.schema(route.bodySchema);
                 const valid = schema.validate(body, { abortEarly: false });
@@ -132,21 +137,21 @@ export class HTTPServer extends EventEmitter {
                     const errorDetails = valid.error.details
                         .map(({ message, context, }) => context?.message || message)
                         .join('\n');
-                    this.log(`HTTP body contain errors sending 400:${errorDetails}`);
+                    this.logger.error(`HTTP body contain errors sending 400:${errorDetails}`);
                     writeResponse(res, 400, `POST Body validation failed: ${errorDetails}`, contentTypes.text);
                     return Promise.resolve();
                 }
             }
             catch (e) {
-                this.log(`Error parsing body schema`, e);
+                this.logger.error(`Error parsing body schema`, e);
                 writeResponse(res, 500, 'There was an error handling your request', contentTypes.text);
                 return Promise.resolve();
             }
         }
         return route
-            .handler(req, res)
+            .handler(req, res, new this.Logger(route.name, req))
             .then(() => {
-            this.verbose('HTTP connection complete');
+            this.logger.trace('HTTP connection complete');
         })
             .catch((e) => {
             if (e instanceof BadRequest) {
@@ -168,7 +173,7 @@ export class HTTPServer extends EventEmitter {
         });
     };
     handleWebSocket = async (request, socket, head) => {
-        this.verbose(`Handling inbound WebSocket request on "${request.url}"`);
+        this.logger.trace(`Handling inbound WebSocket request on "${request.url}"`);
         const req = request;
         const proceed = await this.hooks.before({ head, req, socket });
         req.parsed = convertPathToURL(request.url || '', this.config);
@@ -178,16 +183,16 @@ export class HTTPServer extends EventEmitter {
         req.queryParams = queryParamsToObject(req.parsed.searchParams);
         const route = await this.router.getRouteForWebSocketRequest(req);
         if (route) {
-            this.verbose(`Found matching WebSocket route handler "${route.path}"`);
+            this.logger.trace(`Found matching WebSocket route handler "${route.path}"`);
             if (route?.auth) {
-                this.verbose(`Authorizing WebSocket request to "${req.parsed.href}"`);
+                this.logger.trace(`Authorizing WebSocket request to "${req.parsed.href}"`);
                 const isPermitted = await this.token.isAuthorized(req, route);
                 if (!isPermitted) {
                     return this.onWebsocketUnauthorized(req, socket);
                 }
             }
             if (route.querySchema) {
-                this.verbose(`Validating route query-params with QUERY schema`);
+                this.logger.trace(`Validating route query-params with QUERY schema`);
                 try {
                     const schema = Enjoi.schema(route.querySchema);
                     const valid = schema.validate(req.queryParams, {
@@ -197,21 +202,21 @@ export class HTTPServer extends EventEmitter {
                         const errorDetails = valid.error.details
                             .map(({ message, context, }) => context?.message || message)
                             .join('\n');
-                        this.log(`WebSocket query-params contain errors sending 400:${errorDetails}`);
+                        this.logger.error(`WebSocket query-params contain errors sending 400:${errorDetails}`);
                         writeResponse(socket, 400, `Query-parameter validation failed: ${errorDetails}`, contentTypes.text);
                         return Promise.resolve();
                     }
                 }
                 catch (e) {
-                    this.log(`Error parsing query-params schema`, e);
+                    this.logger.error(`Error parsing query-params schema`, e);
                     writeResponse(socket, 500, 'There was an error handling your request', contentTypes.text);
                     return Promise.resolve();
                 }
             }
             return route
-                .handler(req, socket, head)
+                .handler(req, socket, head, new this.Logger(route.name, req))
                 .then(() => {
-                this.verbose('Websocket connection complete');
+                this.logger.trace('Websocket connection complete');
             })
                 .catch((e) => {
                 if (e instanceof BadRequest) {
@@ -226,20 +231,20 @@ export class HTTPServer extends EventEmitter {
                 if (e instanceof TooManyRequests) {
                     return writeResponse(socket, 429, e.message);
                 }
-                this.log(`Error handling request at "${route.path}": ${e}\n${e.stack}`);
+                this.logger.error(`Error handling request at "${route.path}": ${e}\n${e.stack}`);
                 return writeResponse(socket, 500, e.message);
             });
         }
-        this.log(`No matching WebSocket route handler for "${req.parsed.href}"`);
+        this.logger.error(`No matching WebSocket route handler for "${req.parsed.href}"`);
         return writeResponse(socket, 404, 'Not Found');
     };
     async shutdown() {
-        this.log(`HTTP Server is shutting down`);
+        this.logger.info(`HTTP Server is shutting down`);
         await new Promise((r) => this.server.close(r));
         this.server && this.server.removeAllListeners();
         // @ts-ignore garbage collect this reference
         this.server = null;
-        this.log(`HTTP Server shutdown complete`);
+        this.logger.info(`HTTP Server shutdown complete`);
     }
     /**
      * Left blank for downstream SDK modules to optionally implement.

package/build/shared/browser.ws.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { APITags, BrowserWebsocketRoute, CDPLaunchOptions, ChromiumCDP, Request, SystemQueryParameters, WebsocketRoutes } from '@browserless.io/browserless';
+import { APITags, BrowserWebsocketRoute, CDPLaunchOptions, ChromiumCDP, Logger, Request, SystemQueryParameters, WebsocketRoutes } from '@browserless.io/browserless';
 import { Duplex } from 'stream';
 export interface QuerySchema extends SystemQueryParameters {
     launch?: CDPLaunchOptions | string;
@@ -13,5 +13,5 @@ export default class ChromiumBrowserWebSocketRoute extends BrowserWebsocketRoute
     description: string;
     path: WebsocketRoutes;
     tags: APITags[];
-    handler: (req: Request, socket: Duplex, head: Buffer, browser: ChromiumCDP) => Promise<void>;
+    handler: (req: Request, socket: Duplex, head: Buffer, _logger: Logger, browser: ChromiumCDP) => Promise<void>;
 }

package/build/shared/browser.ws.js

@@ -9,5 +9,5 @@ export default class ChromiumBrowserWebSocketRoute extends BrowserWebsocketRoute
     must already be launched in order to not return a 404.`);
     path = WebsocketRoutes.browser;
     tags = [APITags.browserWS];
-    handler = async (req, socket, head, browser) => browser.proxyWebSocket(req, socket, head);
+    handler = async (req, socket, head, _logger, browser) => browser.proxyWebSocket(req, socket, head);
 }

package/build/shared/chromium.playwright.ws.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { APITags, BrowserServerOptions, BrowserWebsocketRoute, ChromiumPlaywright, Request, SystemQueryParameters, WebsocketRoutes } from '@browserless.io/browserless';
+import { APITags, BrowserServerOptions, BrowserWebsocketRoute, ChromiumPlaywright, Logger, Request, SystemQueryParameters, WebsocketRoutes } from '@browserless.io/browserless';
 import { Duplex } from 'stream';
 export interface QuerySchema extends SystemQueryParameters {
     launch?: BrowserServerOptions | string;
@@ -13,5 +13,5 @@ export default class ChromiumPlaywrightWebSocketRoute extends BrowserWebsocketRo
     description: string;
     path: WebsocketRoutes[];
     tags: APITags[];
-    handler: (req: Request, socket: Duplex, head: Buffer, browser: ChromiumPlaywright) => Promise<void>;
+    handler: (req: Request, socket: Duplex, head: Buffer, _logger: Logger, browser: ChromiumPlaywright) => Promise<void>;
 }

package/build/shared/chromium.playwright.ws.js

@@ -10,7 +10,7 @@ export default class ChromiumPlaywrightWebSocketRoute extends BrowserWebsocketRo
         WebsocketRoutes.chromiumPlaywright,
     ];
     tags = [APITags.browserWS];
-    handler = async (req, socket, head, browser) => {
+    handler = async (req, socket, head, _logger, browser) => {
         const isPlaywright = req.headers['user-agent']
             ?.toLowerCase()
             .includes('playwright');

package/build/shared/chromium.ws.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { APITags, BrowserWebsocketRoute, CDPLaunchOptions, ChromiumCDP, Request, SystemQueryParameters, WebsocketRoutes } from '@browserless.io/browserless';
+import { APITags, BrowserWebsocketRoute, CDPLaunchOptions, ChromiumCDP, Logger, Request, SystemQueryParameters, WebsocketRoutes } from '@browserless.io/browserless';
 import { Duplex } from 'stream';
 export interface QuerySchema extends SystemQueryParameters {
     launch?: CDPLaunchOptions | string;
@@ -13,5 +13,5 @@ export default class ChromiumCDPWebSocketRoute extends BrowserWebsocketRoute {
     description: string;
     path: WebsocketRoutes[];
     tags: APITags[];
-    handler: (req: Request, socket: Duplex, head: Buffer, browser: ChromiumCDP) => Promise<void>;
+    handler: (req: Request, socket: Duplex, head: Buffer, _logger: Logger, browser: ChromiumCDP) => Promise<void>;
 }

package/build/shared/chromium.ws.js

@@ -7,5 +7,5 @@ export default class ChromiumCDPWebSocketRoute extends BrowserWebsocketRoute {
     description = `Launch and connect to Chromium with a library like puppeteer or others that work over chrome-devtools-protocol.`;
     path = [WebsocketRoutes['/'], WebsocketRoutes.chromium];
     tags = [APITags.browserWS];
-    handler = async (req, socket, head, browser) => browser.proxyWebSocket(req, socket, head);
+    handler = async (req, socket, head, _logger, browser) => browser.proxyWebSocket(req, socket, head);
 }

package/build/shared/content.http.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { APITags, BrowserHTTPRoute, BrowserInstance, CDPLaunchOptions, ChromiumCDP, HTTPRoutes, Methods, Request, SystemQueryParameters, WaitForEventOptions, WaitForFunctionOptions, WaitForSelectorOptions, bestAttempt, contentTypes, rejectRequestPattern, rejectResourceTypes, requestInterceptors, setJavaScriptEnabled } from '@browserless.io/browserless';
+import { APITags, BrowserHTTPRoute, BrowserInstance, CDPLaunchOptions, ChromiumCDP, HTTPRoutes, Logger, Methods, Request, SystemQueryParameters, WaitForEventOptions, WaitForFunctionOptions, WaitForSelectorOptions, bestAttempt, contentTypes, rejectRequestPattern, rejectResourceTypes, requestInterceptors, setJavaScriptEnabled } from '@browserless.io/browserless';
 import { Page } from 'puppeteer-core';
 import { ServerResponse } from 'http';
 export interface BodySchema {
@@ -43,5 +43,5 @@ export default class ChromiumContentPostRoute extends BrowserHTTPRoute {
     method: Methods;
     path: HTTPRoutes[];
     tags: APITags[];
-    handler: (req: Request, res: ServerResponse, browser: BrowserInstance) => Promise<void>;
+    handler: (req: Request, res: ServerResponse, logger: Logger, browser: BrowserInstance) => Promise<void>;
 }

package/build/shared/content.http.js

@@ -10,7 +10,8 @@ export default class ChromiumContentPostRoute extends BrowserHTTPRoute {
     method = Methods.post;
     path = [HTTPRoutes.content, HTTPRoutes.chromiumContent];
     tags = [APITags.browserAPI];
-    handler = async (req, res, browser) => {
+    handler = async (req, res, logger, browser) => {
+        logger.info('Content API invoked with body:', req.body);
         const contentType = !req.headers.accept || req.headers.accept?.includes('*')
             ? contentTypes.html
             : req.headers.accept;
@@ -53,6 +54,7 @@ export default class ChromiumContentPostRoute extends BrowserHTTPRoute {
             page.on('request', (req) => {
                 if (!!rejectRequestPattern.find((pattern) => req.url().match(pattern)) ||
                     rejectResourceTypes.includes(req.resourceType())) {
+                    logger.debug(`Aborting request ${req.method()}: ${req.url()}`);
                     return req.abort();
                 }
                 const interceptor = requestInterceptors.find((r) => req.url().match(r.pattern));
@@ -102,6 +104,7 @@ export default class ChromiumContentPostRoute extends BrowserHTTPRoute {
         }
         const markup = await page.content();
         page.close().catch(noop);
+        logger.info('Content API request completed');
         return writeResponse(res, 200, markup, contentTypes.html);
     };
 }

package/build/shared/download.http.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { APITags, BrowserHTTPRoute, BrowserInstance, CDPLaunchOptions, ChromiumCDP, HTTPRoutes, Methods, Request, SystemQueryParameters, contentTypes } from '@browserless.io/browserless';
+import { APITags, BrowserHTTPRoute, BrowserInstance, CDPLaunchOptions, ChromiumCDP, HTTPRoutes, Logger, Methods, Request, SystemQueryParameters, contentTypes } from '@browserless.io/browserless';
 import { ServerResponse } from 'http';
 interface JSONSchema {
     code: string;
@@ -25,6 +25,6 @@ export default class ChromiumDownloadPostRoute extends BrowserHTTPRoute {
     method: Methods;
     path: HTTPRoutes[];
     tags: APITags[];
-    handler: (req: Request, res: ServerResponse, browser: BrowserInstance) => Promise<void>;
+    handler: (req: Request, res: ServerResponse, logger: Logger, browser: BrowserInstance) => Promise<void>;
 }
 export {};

package/build/shared/download.http.js

@@ -21,15 +21,14 @@ export default class ChromiumDownloadPostRoute extends BrowserHTTPRoute {
     method = Methods.post;
     path = [HTTPRoutes.download, HTTPRoutes.chromiumDownload];
     tags = [APITags.browserAPI];
-    handler = async (req, res, browser) => new Promise(async (resolve, reject) => {
-        const debug = this.debug();
+    handler = async (req, res, logger, browser) => new Promise(async (resolve, reject) => {
         const config = this.config();
         const downloadPath = path.join(await config.getDownloadsDir(), `.browserless.download.${id()}`);
-        debug(`Generating a download directory at "${downloadPath}"`);
+        logger.info(`Generating a download directory at "${downloadPath}"`);
         await mkdir(downloadPath);
-        const handler = functionHandler(config, debug, { downloadPath });
+        const handler = functionHandler(config, logger, { downloadPath });
         const response = await handler(req, browser).catch((e) => {
-            debug(`Error running download code handler: "${e}"`);
+            logger.error(`Error running download code handler: "${e}"`);
             reject(e);
             return null;
         });
@@ -37,10 +36,10 @@ export default class ChromiumDownloadPostRoute extends BrowserHTTPRoute {
             return;
         }
         const { page } = response;
-        debug(`Download function has returned, finding downloads...`);
+        logger.info(`Download function has returned, finding downloads...`);
         async function checkIfDownloadComplete() {
             if (res.headersSent) {
-                debug(`Request headers have been sent, terminating download watch.`);
+                logger.trace(`Request headers have been sent, terminating download watch.`);
                 return null;
             }
             const [fileName] = await readdir(downloadPath);
@@ -48,20 +47,20 @@ export default class ChromiumDownloadPostRoute extends BrowserHTTPRoute {
                 await sleep(500);
                 return checkIfDownloadComplete();
             }
-            debug(`All files have finished downloading`);
+            logger.info(`All files have finished downloading`);
             return path.join(downloadPath, fileName);
         }
         const filePath = await checkIfDownloadComplete();
-        debug(`Closing pages.`);
+        logger.info(`Closing pages.`);
         page.close();
         page.removeAllListeners();
         const rmDownload = once(() => filePath &&
             deleteAsync(filePath, { force: true })
                 .then(() => {
-                debug(`Successfully deleted downloads from disk at "${filePath}"`);
+                logger.info(`Successfully deleted downloads from disk at "${filePath}"`);
             })
                 .catch((err) => {
-                debug(`Error cleaning up downloaded files: "${err}" at "${filePath}"`);
+                logger.error(`Error cleaning up downloaded files: "${err}" at "${filePath}"`);
             }));
         if (res.headersSent || !filePath) {
             rmDownload();
@@ -79,7 +78,7 @@ export default class ChromiumDownloadPostRoute extends BrowserHTTPRoute {
             }
         })
             .on('end', () => {
-            debug(`Downloads successfully sent`);
+            logger.info(`Downloads successfully sent`);
             rmDownload();
             return resolve();
         })

package/build/shared/function.http.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { APITags, BrowserHTTPRoute, BrowserInstance, CDPLaunchOptions, ChromiumCDP, HTTPRoutes, Methods, Request, SystemQueryParameters, contentTypes } from '@browserless.io/browserless';
+import { APITags, BrowserHTTPRoute, BrowserInstance, CDPLaunchOptions, ChromiumCDP, HTTPRoutes, Logger, Methods, Request, SystemQueryParameters, contentTypes } from '@browserless.io/browserless';
 import { ServerResponse } from 'http';
 interface JSONSchema {
     code: string;
@@ -27,6 +27,6 @@ export default class ChromiumFunctionPostRoute extends BrowserHTTPRoute {
     method: Methods;
     path: HTTPRoutes[];
     tags: APITags[];
-    handler: (req: Request, res: ServerResponse, browser: BrowserInstance) => Promise<void>;
+    handler: (req: Request, res: ServerResponse, logger: Logger, browser: BrowserInstance) => Promise<void>;
 }
 export {};

package/build/shared/function.http.js

@@ -18,12 +18,11 @@ export default class ChromiumFunctionPostRoute extends BrowserHTTPRoute {
     method = Methods.post;
     path = [HTTPRoutes.function, HTTPRoutes.chromiumFunction];
     tags = [APITags.browserAPI];
-    handler = async (req, res, browser) => {
-        const debug = this.debug();
+    handler = async (req, res, logger, browser) => {
         const config = this.config();
-        const handler = functionHandler(config, debug);
+        const handler = functionHandler(config, logger);
         const { contentType, payload, page } = await handler(req, browser);
-        debug(`Got function response of "${contentType}"`);
+        logger.info(`Got function response of "${contentType}"`);
         page.close();
         page.removeAllListeners();
         if (contentType === 'uint8array') {
@@ -34,7 +33,7 @@ export default class ChromiumFunctionPostRoute extends BrowserHTTPRoute {
                 throw new BadRequest(`Couldn't determine function's response type.`);
             }
             else {
-                debug(`Sending file-type response of "${type}"`);
+                logger.info(`Sending file-type response of "${type}"`);
                 const readStream = new Stream.PassThrough();
                 readStream.end(response);
                 res.setHeader('Content-Type', type);

package/build/shared/json-protocol.http.d.ts

@@ -1,7 +1,7 @@
-import { APITags, HTTPRoute, HTTPRoutes, Methods, Request, Response, contentTypes } from '@browserless.io/browserless';
+import { APITags, HTTPRoute, HTTPRoutes, Logger, Methods, Request, Response, contentTypes } from '@browserless.io/browserless';
 export type ResponseSchema = object;
 export default class ChromiumJSONProtocolGetRoute extends HTTPRoute {
-    private cachedProtocol;
+    protected cachedProtocol: object | undefined;
     name: string;
     accepts: contentTypes[];
     auth: boolean;
@@ -12,5 +12,5 @@ export default class ChromiumJSONProtocolGetRoute extends HTTPRoute {
     method: Methods;
     path: HTTPRoutes;
     tags: APITags[];
-    handler: (_req: Request, res: Response) => Promise<void>;
+    handler: (_req: Request, res: Response, logger: Logger) => Promise<void>;
 }

package/build/shared/json-protocol.http.js

@@ -11,10 +11,10 @@ export default class ChromiumJSONProtocolGetRoute extends HTTPRoute {
     method = Methods.get;
     path = HTTPRoutes.jsonProtocol;
     tags = [APITags.browserAPI];
-    handler = async (_req, res) => {
+    handler = async (_req, res, logger) => {
         const browserManager = this.browserManager();
         if (!this.cachedProtocol) {
-            this.cachedProtocol = await browserManager.getProtocolJSON();
+            this.cachedProtocol = await browserManager.getProtocolJSON(logger);
         }
         return jsonResponse(res, 200, this.cachedProtocol);
     };

package/build/shared/json-version.http.d.ts

@@ -1,7 +1,7 @@
-import { APITags, BrowserManager, HTTPRoute, HTTPRoutes, Methods, Request, Response, UnwrapPromise, contentTypes } from '@browserless.io/browserless';
+import { APITags, BrowserManager, HTTPRoute, HTTPRoutes, Logger, Methods, Request, Response, UnwrapPromise, contentTypes } from '@browserless.io/browserless';
 export type ResponseSchema = UnwrapPromise<ReturnType<BrowserManager['getVersionJSON']>>;
 export default class ChromiumJSONVersionGetRoute extends HTTPRoute {
-    private cachedJSON;
+    protected cachedJSON: ResponseSchema | undefined;
     name: string;
     accepts: contentTypes[];
     auth: boolean;
@@ -12,5 +12,5 @@ export default class ChromiumJSONVersionGetRoute extends HTTPRoute {
     method: Methods;
     path: HTTPRoutes;
     tags: APITags[];
-    handler: (req: Request, res: Response) => Promise<void>;
+    handler: (req: Request, res: Response, logger: Logger) => Promise<void>;
 }

package/build/shared/json-version.http.js

@@ -11,14 +11,14 @@ export default class ChromiumJSONVersionGetRoute extends HTTPRoute {
     method = Methods.get;
     path = HTTPRoutes.jsonVersion;
     tags = [APITags.browserAPI];
-    handler = async (req, res) => {
+    handler = async (req, res, logger) => {
         const baseUrl = req.parsed.host;
         const protocol = req.parsed.protocol.includes('s') ? 'wss' : 'ws';
         try {
             if (!this.cachedJSON) {
                 const browserManager = this.browserManager();
                 this.cachedJSON = {
-                    ...(await browserManager.getVersionJSON()),
+                    ...(await browserManager.getVersionJSON(logger)),
                     webSocketDebuggerUrl: `${protocol}://${baseUrl}`,
                 };
             }

package/build/shared/page.ws.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { APITags, BrowserWebsocketRoute, CDPLaunchOptions, ChromiumCDP, Request, SystemQueryParameters, WebsocketRoutes } from '@browserless.io/browserless';
+import { APITags, BrowserWebsocketRoute, CDPLaunchOptions, ChromiumCDP, Logger, Request, SystemQueryParameters, WebsocketRoutes } from '@browserless.io/browserless';
 import { Duplex } from 'stream';
 export interface QuerySchema extends SystemQueryParameters {
     launch?: CDPLaunchOptions | string;
@@ -13,5 +13,5 @@ export default class ChromiumPageWebSocketRoute extends BrowserWebsocketRoute {
     description: string;
     path: WebsocketRoutes;
     tags: APITags[];
-    handler: (req: Request, socket: Duplex, head: Buffer, browser: ChromiumCDP) => Promise<void>;
+    handler: (req: Request, socket: Duplex, head: Buffer, _logger: Logger, browser: ChromiumCDP) => Promise<void>;
 }

package/build/shared/page.ws.js

@@ -10,5 +10,5 @@ export default class ChromiumPageWebSocketRoute extends BrowserWebsocketRoute {
     or by finding the page's unique ID from your library of choice.`);
     path = WebsocketRoutes.page;
     tags = [APITags.browserWS];
-    handler = async (req, socket, head, browser) => browser.proxyPageWebSocket(req, socket, head);
+    handler = async (req, socket, head, _logger, browser) => browser.proxyPageWebSocket(req, socket, head);
 }

package/build/shared/pdf.http.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { APITags, BrowserHTTPRoute, BrowserInstance, CDPLaunchOptions, ChromiumCDP, HTTPRoutes, Methods, Request, SystemQueryParameters, WaitForEventOptions, WaitForFunctionOptions, WaitForSelectorOptions, bestAttempt, contentTypes, rejectRequestPattern, rejectResourceTypes, requestInterceptors } from '@browserless.io/browserless';
+import { APITags, BrowserHTTPRoute, BrowserInstance, CDPLaunchOptions, ChromiumCDP, HTTPRoutes, Logger, Methods, Request, SystemQueryParameters, WaitForEventOptions, WaitForFunctionOptions, WaitForSelectorOptions, bestAttempt, contentTypes, rejectRequestPattern, rejectResourceTypes, requestInterceptors } from '@browserless.io/browserless';
 import { Page } from 'puppeteer-core';
 import { ServerResponse } from 'http';
 export interface BodySchema {
@@ -43,5 +43,5 @@ export default class ChromiumPDFPostRoute extends BrowserHTTPRoute {
     method: Methods;
     path: HTTPRoutes[];
     tags: APITags[];
-    handler: (req: Request, res: ServerResponse, browser: BrowserInstance) => Promise<void>;
+    handler: (req: Request, res: ServerResponse, logger: Logger, browser: BrowserInstance) => Promise<void>;
 }