@browserless.io/browserless 2.7.1 → 2.9.0

package/src/router.ts

@@ -6,13 +6,13 @@ import {
   HTTPManagementRoutes,
   HTTPRoute,
   Limiter,
+  Logger,
   Methods,
   PathTypes,
   Request,
   Response,
   WebSocketRoute,
   contentTypes,
-  createLogger,
   isConnected,
   writeResponse,
 } from '@browserless.io/browserless';
@@ -21,8 +21,7 @@ import micromatch from 'micromatch';
 import stream from 'stream';
 
 export class Router extends EventEmitter {
-  protected log = createLogger('router');
-  protected verbose = createLogger('router:verbose');
+  protected log = new Logger('router');
   protected httpRoutes: Array<HTTPRoute | BrowserHTTPRoute> = [];
   protected webSocketRoutes: Array<WebSocketRoute | BrowserWebsocketRoute> = [];
 
@@ -30,6 +29,7 @@ export class Router extends EventEmitter {
     protected config: Config,
     protected browserManager: BrowserManager,
     protected limiter: Limiter,
+    protected logger: typeof Logger,
   ) {
     super();
   }
@@ -41,22 +41,22 @@ export class Router extends EventEmitter {
   }
 
   protected onQueueFullHTTP = (_req: Request, res: Response) => {
-    this.log(`Queue is full, sending 429 response`);
+    this.log.warn(`Queue is full, sending 429 response`);
     return writeResponse(res, 429, 'Too many requests');
   };
 
   protected onQueueFullWebSocket = (_req: Request, socket: stream.Duplex) => {
-    this.log(`Queue is full, sending 429 response`);
+    this.log.warn(`Queue is full, sending 429 response`);
     return writeResponse(socket, 429, 'Too many requests');
   };
 
   protected onHTTPTimeout = (_req: Request, res: Response) => {
-    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');
   };
 
   protected onWebsocketTimeout = (_req: Request, socket: stream.Duplex) => {
-    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');
   };
 
@@ -67,18 +67,19 @@ export class Router extends EventEmitter {
     ) =>
     async (req: Request, res: Response) => {
       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,
+          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();
         }
@@ -88,26 +89,26 @@ export class Router extends EventEmitter {
         }
 
         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 as HTTPRoute['handler'])(req, res);
+      return (handler as HTTPRoute['handler'])(req, res, logger);
     };
 
   protected wrapWebSocketHandler =
@@ -117,18 +118,19 @@ export class Router extends EventEmitter {
     ) =>
     async (req: Request, socket: stream.Duplex, head: Buffer) => {
       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,
+          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();
         }
@@ -138,21 +140,21 @@ export class Router extends EventEmitter {
         }
 
         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 as WebSocketRoute['handler'])(req, socket, head);
+      return (handler as WebSocketRoute['handler'])(req, socket, head, logger);
     };
 
   public registerHTTPRoute(
     route: HTTPRoute | BrowserHTTPRoute,
   ): HTTPRoute | BrowserHTTPRoute {
-    this.verbose(
+    this.log.trace(
       `Registering HTTP ${route.method.toUpperCase()} ${route.path}`,
     );
 
@@ -174,7 +176,7 @@ export class Router extends EventEmitter {
     );
 
     if (duplicatePaths.length) {
-      this.log(`Found duplicate routes: ${duplicatePaths.join(', ')}`);
+      this.log.warn(`Found duplicate routes: ${duplicatePaths.join(', ')}`);
     }
     this.httpRoutes.push(route);
 
@@ -184,7 +186,7 @@ export class Router extends EventEmitter {
   public registerWebSocketRoute(
     route: WebSocketRoute | BrowserWebsocketRoute,
   ): WebSocketRoute | BrowserWebsocketRoute {
-    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);
@@ -204,7 +206,7 @@ export class Router extends EventEmitter {
     );
 
     if (duplicatePaths.length) {
-      this.log(`Found duplicate routes: ${duplicatePaths.join(', ')}`);
+      this.log.warn(`Found duplicate routes: ${duplicatePaths.join(', ')}`);
     }
     this.webSocketRoutes.push(route);
     return route;
@@ -230,7 +232,7 @@ export class Router extends EventEmitter {
             micromatch.isMatch(req.parsed.pathname, p),
           ) &&
           r.method === (req.method?.toLocaleLowerCase() as Methods) &&
-          (accepts.some((a) => a.startsWith('*/*')) ||
+          (accepts.some((a) => a.includes('*/*')) ||
             r.contentTypes.some((contentType) =>
               accepts.includes(contentType),
             )) &&

package/src/routes/firefox/ws/playwright.ts

@@ -5,6 +5,7 @@ import {
   BrowserWebsocketRoute,
   BrowserlessRoutes,
   FirefoxPlaywright,
+  Logger,
   Request,
   SystemQueryParameters,
   WebsocketRoutes,
@@ -29,6 +30,7 @@ export default class FirefoxPlaywrightWebSocketRoute extends BrowserWebsocketRou
     req: Request,
     socket: Duplex,
     head: Buffer,
+    _logger: Logger,
     browser: FirefoxPlaywright,
   ): Promise<void> => {
     const isPlaywright = req.headers['user-agent']

package/src/routes/management/http/static.get.ts

@@ -3,6 +3,7 @@ import {
   BrowserlessRoutes,
   HTTPManagementRoutes,
   HTTPRoute,
+  Logger,
   Methods,
   NotFound,
   Request,
@@ -23,21 +24,21 @@ const pathMap: Map<
 > = new Map();
 
 const streamFile = (
-  debug: debug.Debugger,
+  logger: Logger,
   res: ServerResponse,
   file: string,
   contentType?: string,
 ) =>
   new Promise((resolve, reject) => {
     if (contentType) {
-      debug(`Setting content-type ${contentType}`);
+      logger.debug(`Setting content-type ${contentType}`);
       res.setHeader('Content-Type', contentType);
     }
 
     return createReadStream(file)
       .on('error', (error) => {
         if (error) {
-          debug(`Error finding file ${file}, sending 404`);
+          logger.error(`Error finding file ${file}, sending 404`);
           pathMap.delete(file);
           return reject(
             new NotFound(`Request for file "${file}" was not found`),
@@ -59,14 +60,16 @@ export default class StaticGetRoute extends HTTPRoute {
   method = Methods.get;
   path = HTTPManagementRoutes.static;
   tags = [APITags.management];
-  handler = async (req: Request, res: ServerResponse): Promise<unknown> => {
+  handler = async (
+    req: Request,
+    res: ServerResponse,
+    logger: Logger,
+  ): Promise<unknown> => {
     const { pathname } = req.parsed;
     const fileCache = pathMap.get(pathname);
-    const debug = this.debug();
-    const verbose = debug.extend('verbose');
 
     if (fileCache) {
-      return streamFile(verbose, res, fileCache.path, fileCache.contentType);
+      return streamFile(logger, res, fileCache.path, fileCache.contentType);
     }
 
     const config = this.config();
@@ -93,13 +96,13 @@ export default class StaticGetRoute extends HTTPRoute {
     }
 
     if (foundFilePaths.length > 1) {
-      debug(
+      logger.warn(
         `Multiple files found for request to "${pathname}". Only the first file is served, so please name your files uniquely.`,
       );
     }
 
     const [foundFilePath] = foundFilePaths;
-    verbose(`Found new file "${foundFilePath}", caching path and serving`);
+    logger.info(`Found new file "${foundFilePath}", caching path and serving`);
 
     const contentType = mimeTypes.get(path.extname(foundFilePath));
 
@@ -113,6 +116,6 @@ export default class StaticGetRoute extends HTTPRoute {
       path: foundFilePath,
     });
 
-    return streamFile(verbose, res, foundFilePath, contentType);
+    return streamFile(logger, res, foundFilePath, contentType);
   };
 }

package/src/routes/management/tests/management.spec.ts

@@ -81,4 +81,19 @@ describe('Management APIs', function () {
       },
     );
   });
+
+  it('allows HEAD requests to /active', async () => {
+    await start();
+
+    await fetch('http://localhost:3000/active?token=6R0W53R135510', {
+      method: 'HEAD',
+    }).then(
+      async (res) => {
+        expect(res.headers.get('content-type')).to.equal(
+          'text/plain; charset=UTF-8',
+        );
+        expect(res.status).to.equal(204);
+      },
+    );
+  });
 });

package/src/routes/webkit/ws/playwright.ts

@@ -4,6 +4,7 @@ import {
   BrowserServerOptions,
   BrowserWebsocketRoute,
   BrowserlessRoutes,
+  Logger,
   Request,
   SystemQueryParameters,
   WebkitPlaywright,
@@ -27,6 +28,7 @@ export default class WebKitPlaywrightWebSocketRoute extends BrowserWebsocketRout
     req: Request,
     socket: Duplex,
     head: Buffer,
+    _logger: Logger,
     browser: WebkitPlaywright,
   ): Promise<void> => {
     const isPlaywright = req.headers['user-agent']

package/src/sdk-utils.ts

@@ -83,8 +83,8 @@ export const prompt = async (question: string) => {
 
 export const installDependencies = async (
   workingDirectory: string,
-): Promise<void> =>
-  new Promise((resolve, reject) => {
+): Promise<void> => {
+  await new Promise<void>((resolve, reject) => {
     spawn('npm', ['i'], {
       cwd: workingDirectory,
       stdio: 'inherit',
@@ -97,6 +97,24 @@ export const installDependencies = async (
       );
     });
   });
+  await new Promise<void>((resolve, reject) => {
+    spawn(
+      'npx',
+      'playwright-core install --with-deps chromium firefox webkit'.split(' '),
+      {
+        cwd: workingDirectory,
+        stdio: 'inherit',
+      },
+    ).once('close', (code) => {
+      if (code === 0) {
+        return resolve();
+      }
+      return reject(
+        `Error when installing dependencies, see output for more details`,
+      );
+    });
+  });
+};
 
 export const buildDockerImage = async (
   cmd: string,

package/src/server.ts

@@ -2,6 +2,7 @@ import * as http from 'http';
 import * as stream from 'stream';
 import {
   BadRequest,
+  Logger as BlessLogger,
   Config,
   HTTPRoute,
   Hooks,
@@ -17,7 +18,6 @@ import {
   WebSocketRoute,
   contentTypes,
   convertPathToURL,
-  createLogger,
   queryParamsToObject,
   readBody,
   shimLegacyRequests,
@@ -40,8 +40,7 @@ export class HTTPServer extends EventEmitter {
   protected server: http.Server = http.createServer();
   protected port: number;
   protected host?: string;
-  protected log = createLogger('server');
-  protected verbose = createLogger('server:verbose');
+  protected logger = new BlessLogger('server');
 
   constructor(
     protected config: Config,
@@ -49,12 +48,13 @@ export class HTTPServer extends EventEmitter {
     protected token: Token,
     protected router: Router,
     protected hooks: Hooks,
+    protected Logger: typeof BlessLogger,
   ) {
     super();
     this.host = config.getHost();
     this.port = config.getPort();
 
-    this.log(
+    this.logger.info(
       `Server instantiated with host "${this.host}" on port "${
         this.port
       }" using token "${this.config.getToken()}"`,
@@ -62,7 +62,9 @@ export class HTTPServer extends EventEmitter {
   }
 
   protected onHTTPUnauthorized = (_req: Request, res: Response) => {
-    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.');
   };
@@ -71,7 +73,7 @@ export class HTTPServer extends EventEmitter {
     _req: Request,
     socket: stream.Duplex,
   ) => {
-    this.log(
+    this.logger.error(
       `Websocket request is not properly authorized, responding with 401`,
     );
     this.metrics.addUnauthorized();
@@ -79,7 +81,7 @@ export class HTTPServer extends EventEmitter {
   };
 
   public async start(): Promise<void> {
-    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);
@@ -96,7 +98,7 @@ export class HTTPServer extends EventEmitter {
         },
         undefined,
         () => {
-          this.log(listenMessage);
+          this.logger.info(listenMessage);
           r(undefined);
         },
       );
@@ -107,7 +109,7 @@ export class HTTPServer extends EventEmitter {
     request: http.IncomingMessage,
     res: http.ServerResponse,
   ) => {
-    this.verbose(
+    this.logger.trace(
       `Handling inbound HTTP request on "${request.method}: ${request.url}"`,
     );
 
@@ -129,6 +131,11 @@ export class HTTPServer extends EventEmitter {
       }
     }
 
+    if (req.method?.toLowerCase() === 'head') {
+      this.logger.debug(`Inbound HEAD request, setting to GET`);
+      req.method = 'GET';
+    }
+
     if (
       this.config.getAllowGetCalls() &&
       req.method === 'GET' &&
@@ -143,17 +150,17 @@ export class HTTPServer extends EventEmitter {
     const route = await this.router.getRouteForHTTPRequest(req);
 
     if (!route) {
-      this.log(
+      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) {
@@ -177,7 +184,7 @@ export class HTTPServer extends EventEmitter {
     }
 
     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,7 +204,7 @@ export class HTTPServer extends EventEmitter {
             )
             .join('\n');
 
-          this.log(
+          this.logger.error(
             `HTTP query-params contain errors sending 400:${errorDetails}`,
           );
 
@@ -210,7 +217,7 @@ export class HTTPServer extends EventEmitter {
           return Promise.resolve();
         }
       } catch (e) {
-        this.log(`Error parsing body schema`, e);
+        this.logger.error(`Error parsing body schema`, e);
         writeResponse(
           res,
           500,
@@ -222,7 +229,7 @@ export class HTTPServer extends EventEmitter {
     }
 
     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 });
@@ -240,7 +247,9 @@ export class HTTPServer extends EventEmitter {
             )
             .join('\n');
 
-          this.log(`HTTP body contain errors sending 400:${errorDetails}`);
+          this.logger.error(
+            `HTTP body contain errors sending 400:${errorDetails}`,
+          );
 
           writeResponse(
             res,
@@ -251,7 +260,7 @@ export class HTTPServer extends EventEmitter {
           return Promise.resolve();
         }
       } catch (e) {
-        this.log(`Error parsing body schema`, e);
+        this.logger.error(`Error parsing body schema`, e);
         writeResponse(
           res,
           500,
@@ -263,9 +272,9 @@ export class HTTPServer extends EventEmitter {
     }
 
     return (route as HTTPRoute)
-      .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) {
@@ -297,7 +306,7 @@ export class HTTPServer extends EventEmitter {
     socket: stream.Duplex,
     head: Buffer,
   ) => {
-    this.verbose(`Handling inbound WebSocket request on "${request.url}"`);
+    this.logger.trace(`Handling inbound WebSocket request on "${request.url}"`);
 
     const req = request as Request;
     const proceed = await this.hooks.before({ head, req, socket });
@@ -311,10 +320,14 @@ export class HTTPServer extends EventEmitter {
     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) {
@@ -323,7 +336,7 @@ export class HTTPServer extends EventEmitter {
       }
 
       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, {
@@ -343,7 +356,7 @@ export class HTTPServer extends EventEmitter {
               )
               .join('\n');
 
-            this.log(
+            this.logger.error(
               `WebSocket query-params contain errors sending 400:${errorDetails}`,
             );
 
@@ -356,7 +369,7 @@ export class HTTPServer extends EventEmitter {
             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,
@@ -368,9 +381,9 @@ export class HTTPServer extends EventEmitter {
       }
 
       return (route as WebSocketRoute)
-        .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) {
@@ -389,7 +402,7 @@ export class HTTPServer extends EventEmitter {
             return writeResponse(socket, 429, e.message);
           }
 
-          this.log(
+          this.logger.error(
             `Error handling request at "${route.path}": ${e}\n${e.stack}`,
           );
 
@@ -397,18 +410,20 @@ export class HTTPServer extends EventEmitter {
         });
     }
 
-    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');
   };
 
   public async shutdown(): Promise<void> {
-    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`);
   }
 
   /**

package/src/shared/browser.ws.ts

@@ -4,6 +4,7 @@ import {
   BrowserlessRoutes,
   CDPLaunchOptions,
   ChromiumCDP,
+  Logger,
   Request,
   SystemQueryParameters,
   WebsocketRoutes,
@@ -31,6 +32,7 @@ export default class ChromiumBrowserWebSocketRoute extends BrowserWebsocketRoute
     req: Request,
     socket: Duplex,
     head: Buffer,
+    _logger: Logger,
     browser: ChromiumCDP,
   ): Promise<void> => browser.proxyWebSocket(req, socket, head);
 }

package/src/shared/chromium.playwright.ws.ts

@@ -5,6 +5,7 @@ import {
   BrowserWebsocketRoute,
   BrowserlessRoutes,
   ChromiumPlaywright,
+  Logger,
   Request,
   SystemQueryParameters,
   WebsocketRoutes,
@@ -30,6 +31,7 @@ export default class ChromiumPlaywrightWebSocketRoute extends BrowserWebsocketRo
     req: Request,
     socket: Duplex,
     head: Buffer,
+    _logger: Logger,
     browser: ChromiumPlaywright,
   ): Promise<void> => {
     const isPlaywright = req.headers['user-agent']

package/src/shared/chromium.ws.ts

@@ -4,6 +4,7 @@ import {
   BrowserlessRoutes,
   CDPLaunchOptions,
   ChromiumCDP,
+  Logger,
   Request,
   SystemQueryParameters,
   WebsocketRoutes,
@@ -26,6 +27,7 @@ export default class ChromiumCDPWebSocketRoute extends BrowserWebsocketRoute {
     req: Request,
     socket: Duplex,
     head: Buffer,
+    _logger: Logger,
     browser: ChromiumCDP,
   ): Promise<void> => browser.proxyWebSocket(req, socket, head);
 }