@browserless.io/browserless 2.8.0 → 2.9.0

package/src/limiter.ts

@@ -2,11 +2,11 @@ import {
   AfterResponse,
   Config,
   Hooks,
+  Logger,
   Metrics,
   Monitoring,
   TooManyRequests,
   WebHooks,
-  createLogger,
 } from '@browserless.io/browserless';
 import q from 'queue';
 
@@ -26,7 +26,7 @@ interface Job {
 
 export class Limiter extends q {
   protected queued: number;
-  protected debug = createLogger('limiter');
+  protected logger = new Logger('limiter');
 
   constructor(
     protected config: Config,
@@ -42,22 +42,22 @@ export class Limiter extends q {
     });
     this.queued = config.getQueued();
 
-    this.debug(
+    this.logger.info(
       `Concurrency: ${this.concurrency} queue: ${this.queued} timeout: ${this.timeout}ms`,
     );
 
     config.on('concurrent', (concurrency: number) => {
-      this.debug(`Concurrency updated to ${concurrency}`);
+      this.logger.info(`Concurrency updated to ${concurrency}`);
       this.concurrency = concurrency;
     });
 
     config.on('queued', (queued: number) => {
-      this.debug(`Queue updated to ${queued}`);
+      this.logger.info(`Queue updated to ${queued}`);
       this.queued = queued;
     });
 
     config.on('timeout', (timeout: number) => {
-      this.debug(`Timeout updated to ${timeout}ms`);
+      this.logger.info(`Timeout updated to ${timeout}ms`);
       this.timeout = timeout <= 0 ? 0 : timeout;
     });
 
@@ -83,7 +83,7 @@ export class Limiter extends q {
 
   protected handleSuccess({ detail: { job } }: { detail: { job: Job } }) {
     const timeUsed = Date.now() - job.start;
-    this.debug(
+    this.logger.info(
       `Job has succeeded after ${timeUsed.toLocaleString()}ms of activity.`,
     );
     this.metrics.addSuccessful(Date.now() - job.start);
@@ -101,12 +101,12 @@ export class Limiter extends q {
     detail: { job: Job; next: Job };
   }) {
     const timeUsed = Date.now() - job.start;
-    this.debug(
+    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],
@@ -122,7 +122,9 @@ export class Limiter extends q {
   }: {
     detail: { error: unknown; job: 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({
@@ -133,7 +135,7 @@ export class Limiter extends q {
   }
 
   protected logQueue(message: string) {
-    this.debug(
+    this.logger.info(
       `(Running: ${this.executing}, Pending: ${this.waiting}) ${message} `,
     );
   }

package/src/logger.ts

@@ -1,31 +1,52 @@
 import { Request, createLogger } from '@browserless.io/browserless';
 
 export class Logger {
-  protected _log: ReturnType<typeof createLogger>;
-  protected _verbose: ReturnType<typeof createLogger>;
-  protected _error: ReturnType<typeof createLogger>;
+  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(
     protected prefix: string,
-    protected request: Request,
+    protected request?: Request,
   ) {
-    this._log = createLogger(prefix);
-    this._verbose = this._log.extend('verbose');
-    this._error = this._log.extend('error');
-  }
+    const logger = createLogger(prefix);
 
-  public verbose(...messages: string[]) {
-    const ip = this.request.socket.remoteAddress ?? 'Unknown';
-    this._verbose(ip, ...messages);
+    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');
   }
 
-  public log(...messages: string[]) {
-    const ip = this.request.socket.remoteAddress ?? 'Unknown';
-    this._log(ip, ...messages);
+  protected get reqInfo() {
+    return this.request ? this.request.socket.remoteAddress ?? 'Unknown' : '';
   }
 
-  public error(...messages: string[]) {
-    const ip = this.request.socket.remoteAddress ?? 'Unknown';
-    this._error(ip, ...messages);
-  }
+  public trace = (...messages: unknown[]) => {
+    this._trace(this.reqInfo, ...messages);
+  };
+
+  public debug = (...messages: unknown[]) => {
+    this._debug(this.reqInfo, ...messages);
+  };
+
+  public info = (...messages: unknown[]) => {
+    this._info(this.reqInfo, ...messages);
+  };
+
+  public warn = (...messages: unknown[]) => {
+    this._warn(this.reqInfo, ...messages);
+  };
+
+  public error = (...messages: unknown[]) => {
+    this._error(this.reqInfo, ...messages);
+  };
+
+  public fatal = (...messages: unknown[]) => {
+    this._fatal(this.reqInfo, ...messages);
+  };
 }

package/src/monitoring.ts

@@ -1,13 +1,9 @@
-import {
-  Config,
-  IResourceLoad,
-  createLogger,
-} from '@browserless.io/browserless';
+import { Config, IResourceLoad, Logger } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
 import si from 'systeminformation';
 
 export class Monitoring extends EventEmitter {
-  protected log = createLogger('hardware');
+  protected log = new Logger('hardware');
   constructor(protected config: Config) {
     super();
   }
@@ -17,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];
     });
 
@@ -40,7 +36,9 @@ export class Monitoring extends EventEmitter {
     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 = !!(

package/src/router.ts

@@ -13,7 +13,6 @@ import {
   Response,
   WebSocketRoute,
   contentTypes,
-  createLogger,
   isConnected,
   writeResponse,
 } from '@browserless.io/browserless';
@@ -22,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> = [];
 
@@ -43,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');
   };
 
@@ -69,7 +67,7 @@ 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);
@@ -77,10 +75,11 @@ export class Router extends EventEmitter {
         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();
         }
@@ -90,7 +89,7 @@ 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, logger, browser),
             new Promise((resolve, reject) => {
@@ -98,13 +97,13 @@ export class Router extends EventEmitter {
                 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);
         }
       }
@@ -119,7 +118,7 @@ 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);
@@ -127,10 +126,11 @@ export class Router extends EventEmitter {
         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();
         }
@@ -140,10 +140,10 @@ export class Router extends EventEmitter {
         }
 
         try {
-          this.verbose(`Running found WebSocket handler.`);
+          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;
@@ -154,7 +154,7 @@ export class Router extends EventEmitter {
   public registerHTTPRoute(
     route: HTTPRoute | BrowserHTTPRoute,
   ): HTTPRoute | BrowserHTTPRoute {
-    this.verbose(
+    this.log.trace(
       `Registering HTTP ${route.method.toUpperCase()} ${route.path}`,
     );
 
@@ -176,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);
 
@@ -186,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);
@@ -206,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;

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

@@ -31,7 +31,7 @@ const streamFile = (
 ) =>
   new Promise((resolve, reject) => {
     if (contentType) {
-      logger.log(`Setting content-type ${contentType}`);
+      logger.debug(`Setting content-type ${contentType}`);
       res.setHeader('Content-Type', contentType);
     }
 
@@ -96,15 +96,13 @@ export default class StaticGetRoute extends HTTPRoute {
     }
 
     if (foundFilePaths.length > 1) {
-      logger.log(
+      logger.warn(
         `Multiple files found for request to "${pathname}". Only the first file is served, so please name your files uniquely.`,
       );
     }
 
     const [foundFilePath] = foundFilePaths;
-    logger.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));
 

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/server.ts

@@ -18,7 +18,6 @@ import {
   WebSocketRoute,
   contentTypes,
   convertPathToURL,
-  createLogger,
   queryParamsToObject,
   readBody,
   shimLegacyRequests,
@@ -41,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,
@@ -56,7 +54,7 @@ export class HTTPServer extends EventEmitter {
     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()}"`,
@@ -64,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.');
   };
@@ -73,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();
@@ -81,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);
@@ -98,7 +98,7 @@ export class HTTPServer extends EventEmitter {
         },
         undefined,
         () => {
-          this.log(listenMessage);
+          this.logger.info(listenMessage);
           r(undefined);
         },
       );
@@ -109,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}"`,
     );
 
@@ -131,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' &&
@@ -145,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) {
@@ -179,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, {
@@ -199,7 +204,7 @@ export class HTTPServer extends EventEmitter {
             )
             .join('\n');
 
-          this.log(
+          this.logger.error(
             `HTTP query-params contain errors sending 400:${errorDetails}`,
           );
 
@@ -212,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,
@@ -224,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 });
@@ -242,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,
@@ -253,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,
@@ -267,7 +274,7 @@ export class HTTPServer extends EventEmitter {
     return (route as HTTPRoute)
       .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) {
@@ -299,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 });
@@ -313,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) {
@@ -325,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, {
@@ -345,7 +356,7 @@ export class HTTPServer extends EventEmitter {
               )
               .join('\n');
 
-            this.log(
+            this.logger.error(
               `WebSocket query-params contain errors sending 400:${errorDetails}`,
             );
 
@@ -358,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,
@@ -372,7 +383,7 @@ export class HTTPServer extends EventEmitter {
       return (route as WebSocketRoute)
         .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) {
@@ -391,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}`,
           );
 
@@ -399,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`);
   }
 
   /**