chore(logs): rework logs for simplicity (#2592)

src/api.ts

@@ -22,7 +22,7 @@ export { Dialog } from './dialog';
 export { Download } from './download';
 export { ElementHandle } from './dom';
 export { FileChooser } from './fileChooser';
-export { Logger } from './logger';
+export { Logger } from './types';
 export { TimeoutError } from './errors';
 export { Frame } from './frames';
 export { Keyboard, Mouse } from './input';

src/browser.ts

@@ -20,11 +20,11 @@ import { EventEmitter } from 'events';
 import { Download } from './download';
 import type { BrowserServer } from './server/browserServer';
 import { Events } from './events';
-import { InnerLogger } from './logger';
+import { Loggers } from './logger';
 import { ProxySettings } from './types';
 
 export type BrowserOptions = {
-  logger: InnerLogger,
+  loggers: Loggers,
   downloadsPath?: string,
   headful?: boolean,
   persistent?: PersistentContextOptions,  // Undefined means no persistent context.

src/browserContext.ts

@@ -25,7 +25,7 @@ import * as types from './types';
 import { Events } from './events';
 import { Download } from './download';
 import { BrowserBase } from './browser';
-import { InnerLogger, Logger } from './logger';
+import { Loggers, Logger } from './logger';
 import { EventEmitter } from 'events';
 import { ProgressController } from './progress';
 import { DebugController } from './debug/debugController';
@@ -52,7 +52,7 @@ type CommonContextOptions = {
 
 export type PersistentContextOptions = CommonContextOptions;
 export type BrowserContextOptions = CommonContextOptions & {
-  logger?: Logger,
+  logger?: types.Logger,
 };
 
 export interface BrowserContext {
@@ -89,14 +89,15 @@ export abstract class BrowserContextBase extends EventEmitter implements Browser
   readonly _permissions = new Map<string, string[]>();
   readonly _downloads = new Set<Download>();
   readonly _browserBase: BrowserBase;
-  readonly _logger: InnerLogger;
+  readonly _apiLogger: Logger;
   private _debugController: DebugController | undefined;
 
   constructor(browserBase: BrowserBase, options: BrowserContextOptions) {
     super();
     this._browserBase = browserBase;
     this._options = options;
-    this._logger = options.logger ? new InnerLogger(options.logger) : browserBase._options.logger;
+    const loggers = options.logger ? new Loggers(options.logger) : browserBase._options.loggers;
+    this._apiLogger = loggers.api;
     this._closePromise = new Promise(fulfill => this._closePromiseFulfill = fulfill);
   }
 
@@ -115,7 +116,7 @@ export abstract class BrowserContextBase extends EventEmitter implements Browser
 
   async waitForEvent(event: string, optionsOrPredicate: types.WaitForEventOptions = {}): Promise<any> {
     const options = typeof optionsOrPredicate === 'function' ? { predicate: optionsOrPredicate } : optionsOrPredicate;
-    const progressController = new ProgressController(this._logger, this._timeoutSettings.timeout(options));
+    const progressController = new ProgressController(this._apiLogger, this._timeoutSettings.timeout(options), 'browserContext.waitForEvent');
     if (event !== Events.BrowserContext.Close)
       this._closePromise.then(error => progressController.abort(error));
     return progressController.run(progress => helper.waitForEvent(progress, this, event, options.predicate));

src/chromium/crBrowser.ts

@@ -46,7 +46,7 @@ export class CRBrowser extends BrowserBase {
   private _tracingClient: CRSession | undefined;
 
   static async connect(transport: ConnectionTransport, options: BrowserOptions, devtools?: CRDevTools): Promise<CRBrowser> {
-    const connection = new CRConnection(SlowMoTransport.wrap(transport, options.slowMo), options.logger);
+    const connection = new CRConnection(SlowMoTransport.wrap(transport, options.slowMo), options.loggers);
     const browser = new CRBrowser(connection, options);
     browser._devtools = devtools;
     const session = connection.rootSession;

src/chromium/crConnection.ts

@@ -16,10 +16,10 @@
  */
 
 import { assert } from '../helper';
-import { ConnectionTransport, ProtocolRequest, ProtocolResponse, protocolLog } from '../transport';
+import { ConnectionTransport, ProtocolRequest, ProtocolResponse } from '../transport';
 import { Protocol } from './protocol';
 import { EventEmitter } from 'events';
-import { InnerLogger, errorLog } from '../logger';
+import { Loggers, Logger } from '../logger';
 import { rewriteErrorMessage } from '../utils/stackTrace';
 
 export const ConnectionEvents = {
@@ -36,12 +36,12 @@ export class CRConnection extends EventEmitter {
   private readonly _sessions = new Map<string, CRSession>();
   readonly rootSession: CRSession;
   _closed = false;
-  readonly _logger: InnerLogger;
+  readonly _logger: Logger;
 
-  constructor(transport: ConnectionTransport, logger: InnerLogger) {
+  constructor(transport: ConnectionTransport, loggers: Loggers) {
     super();
     this._transport = transport;
-    this._logger = logger;
+    this._logger = loggers.protocol;
     this._transport.onmessage = this._onMessage.bind(this);
     this._transport.onclose = this._onClose.bind(this);
     this.rootSession = new CRSession(this, '', 'browser', '');
@@ -62,15 +62,15 @@ export class CRConnection extends EventEmitter {
     const message: ProtocolRequest = { id, method, params };
     if (sessionId)
       message.sessionId = sessionId;
-    if (this._logger.isLogEnabled(protocolLog))
-      this._logger.log(protocolLog, 'SEND ► ' + rewriteInjectedScriptEvaluationLog(message));
+    if (this._logger.isEnabled())
+      this._logger.info('SEND ► ' + rewriteInjectedScriptEvaluationLog(message));
     this._transport.send(message);
     return id;
   }
 
   async _onMessage(message: ProtocolResponse) {
-    if (this._logger.isLogEnabled(protocolLog))
-      this._logger.log(protocolLog, '◀ RECV ' + JSON.stringify(message));
+    if (this._logger.isEnabled())
+      this._logger.info('◀ RECV ' + JSON.stringify(message));
     if (message.id === kBrowserCloseMessageId)
       return;
     if (message.method === 'Target.attachedToTarget') {
@@ -166,9 +166,9 @@ export class CRSession extends EventEmitter {
   }
 
   _sendMayFail<T extends keyof Protocol.CommandParameters>(method: T, params?: Protocol.CommandParameters[T]): Promise<Protocol.CommandReturnValues[T] | void> {
-    return this.send(method, params).catch(error => {
+    return this.send(method, params).catch((error: Error) => {
       if (this._connection)
-        this._connection._logger.log(errorLog, error, []);
+        this._connection._logger.error(error);
     });
   }