detox 20.0.4-breaking.new-global-lifecycle.0 → 20.0.5-breaking.new-global-lifecycle.0

package/src/logger/DetoxLogger.js

@@ -1,201 +1,335 @@
 const path = require('path');
-const { PassThrough } = require('stream');
 
-const bunyan = require('bunyan');
-const bunyanDebugStream = require('bunyan-debug-stream');
 const _ = require('lodash');
 
 const temporaryPath = require('../artifacts/utils/temporaryPath');
-const { DetoxInternalError } = require('../errors');
+const { DetoxInternalError, DetoxError } = require('../errors');
 const { shortFormat } = require('../utils/dateUtils');
+const isPromise = require('../utils/isPromise');
 
-const customConsoleLogger = require('./customConsoleLogger');
+const BunyanLogger = require('./utils/BunyanLogger');
+const CategoryThreadDispatcher = require('./utils/CategoryThreadDispatcher');
+const MessageStack = require('./utils/MessageStack');
+const customConsoleLogger = require('./utils/customConsoleLogger');
+const sanitizeBunyanContext = require('./utils/sanitizeBunyanContext');
 
 /**
- * @typedef PrivateLoggerConfig
- * @property {string} [file]
+ * @typedef SharedLoggerConfig
+ * @property {string} file
+ * @property {Detox.DetoxLoggerConfig} userConfig
+ * @property {CategoryThreadDispatcher} [dispatcher]
+ * @property {BunyanLogger} [bunyan]
+ * @property {MessageStack} [messageStack]
  */
 
 class DetoxLogger {
   /**
-   * @param {Detox.DetoxLoggerConfig & PrivateLoggerConfig} [config]
+   * @param {Pick<SharedLoggerConfig, 'file' | 'userConfig'>} sharedConfig
    * @param {object} [context]
-   * @param {bunyan} [bunyanLogger]
    */
-  constructor(config, context, bunyanLogger) {
-    // IMPORTANT: all the loggers should share the same object instance of this._config
-    this._config = config || {
-      level: 'info',
-      overrideConsole: 'none',
-      options: {
-        showDate: true,
-        showLoggerName: true,
-        showPid: true,
-        showMetadata: false,
-      },
-    };
-
-    if (config && !context) {
-      this._config.file = temporaryPath.for.jsonl();
+  constructor(sharedConfig, context) {
+    /**
+     * @type {SharedLoggerConfig}
+     * IMPORTANT: all instances of {@link DetoxLogger} must share the same object instance of this._sharedConfig.
+     */
+    this._sharedConfig = sharedConfig;
+
+    if (!context) {
+      // In this branch, `this` refers to the first (root) logger instance.
+
+      this._sharedConfig.userConfig = this._sharedConfig.userConfig || {
+        level: 'info',
+        overrideConsole: 'none',
+        options: {
+          showDate: true,
+          showLoggerName: true,
+          showPid: true,
+          showPrefixes: false,
+          showMetadata: false,
+        },
+      };
+
+      this._sharedConfig.bunyan = new BunyanLogger()
+        .installFileStream(this.file)
+        .installDebugStream(this.config);
+
+      this._sharedConfig.dispatcher = new CategoryThreadDispatcher({
+        logger: this,
+        categories: {
+          'lifecycle': [0],
+          'cli': [1],
+          'logger': [2],
+          'ipc': [29],
+          'ws-server': [50, 99],
+          'ws-client': [100, 149],
+          'device': [150, 159],
+          'artifacts-manager': [300],
+          'artifacts-plugin': [310, 349],
+          'artifact': [350, 399],
+          'child-process': [400, 499],
+          'default': [999],
+          'user': [10000, 10999]
+        },
+      });
+
+      this._sharedConfig.messageStack = new MessageStack();
+
+      this.overrideConsole();
     }
 
     /** @type {object | undefined} */
     this._context = context;
-    /** @type {bunyan} */
-    this._bunyan = bunyanLogger || this._initBunyanLogger();
 
-    this.fatal = this._forward.bind(this, 'fatal');
-    this.error = this._forward.bind(this, 'error');
-    this.warn = this._forward.bind(this, 'warn');
-    this.info = this._forward.bind(this, 'info');
-    this.debug = this._forward.bind(this, 'debug');
-    this.trace = this._forward.bind(this, 'trace');
-
-    this.overrideConsole();
+    /** @public */
+    this.fatal = this._setupLogMethod('fatal');
+    /** @public */
+    this.error = this._setupLogMethod('error');
+    /** @public */
+    this.warn = this._setupLogMethod('warn');
+    /** @public */
+    this.info = this._setupLogMethod('info');
+    /** @public */
+    this.debug = this._setupLogMethod('debug');
+    /** @public */
+    this.trace = this._setupLogMethod('trace');
   }
 
   /**
-   * @internal
+   * @public
+   * @returns {Detox.DetoxLogLevel}
    */
-  get config() {
-    return this._config;
-  }
-
-  /** @returns {Detox.DetoxLogLevel} */
   get level() {
-    return this._config.level;
+    return this.config.level;
   }
 
   /**
-   * @internal
+   * @public
+   * @param {object} [overrides]
+   * @returns {DetoxLogger}
    */
+  child(overrides) {
+    const merged = this._mergeContexts(this._context, overrides);
+    return new DetoxLogger(this._sharedConfig, merged);
+  }
+
+  /** @internal */
+  get config() {
+    return this._sharedConfig.userConfig;
+  }
+
+  /** @internal */
   get file() {
-    return this._config.file;
+    return this._sharedConfig.file;
   }
 
   /**
+   * @internal
    * @param config
    */
   async setConfig(config) {
-    if (this._context !== undefined) {
-      throw new DetoxInternalError('Trying to set a config for a non-root logger');
+    if (this._context) {
+      throw new DetoxInternalError('Trying to set a config in a non-root logger');
     }
 
-    if (this.file) {
-      throw new DetoxInternalError('Trying to set a config for a fully initialized logger');
-    }
-
-    _.merge(this._config, config);
-
-    // @ts-ignore
-    const [oldStream] = this._bunyan.streams.splice(0, 1);
-    oldStream.stream.end();
-    this._bunyan.addStream(this._createDebugStream());
+    _.merge(this.config, config);
+    this._sharedConfig.file = temporaryPath.for.jsonl();
+    this._sharedConfig.bunyan.installDebugStream(this.config);
+    this.overrideConsole();
+  }
 
-    this._config.file = temporaryPath.for.jsonl();
-    this._bunyan.addStream({
-      level: 'trace',
-      path: this._config.file,
-    });
+  /**
+   * @internal
+   */
+  overrideConsole(sandbox) {
+    const option = this.config.overrideConsole;
+    if (option === 'none') {
+      return;
+    }
 
-    this.overrideConsole();
+    if ((option === 'sandbox' && sandbox) || option === 'all') {
+      customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
+    }
   }
 
   /**
-   * @param {object} [overrides]
-   * @returns {DetoxLogger}
+   * @private
    */
-  child(overrides) {
-    if (overrides && overrides.__filename) {
-      overrides.__filename = path.basename(overrides.__filename, '.js');
+  _mergeContexts(...contexts) {
+    const context = Object.assign({}, ...contexts);
+
+    if (context.error || context.err) {
+      context.error = DetoxError.format(context.error || context.err);
+      delete context.err;
+    }
+
+    if (Array.isArray(context.cat)) {
+      context.cat = context.cat.join(',');
+    }
+
+    if (context.__filename) {
+      context.__filename = path.basename(context.__filename);
     }
 
-    return new DetoxLogger(this._config, {
-      ...this._context,
-      ...overrides,
-    }, this._bunyan);
+    context.ph = context.ph || 'i';
+    context.cat = context.cat || '';
+
+    context.tid = this._sharedConfig.dispatcher.resolve(
+      context.ph,
+      context.cat,
+      context.id || 0
+    );
+
+    return sanitizeBunyanContext(context);
   }
 
   /**
-   * @param {bunyan.LogLevel} level
-   * @param {any[]} args
    * @private
+   * @param {Detox.DetoxLogLevel} level
+   * @returns {Detox._LogMethod}
    */
-  _forward(level, ...args) {
-    const msgContext = _.isError(args[0]) ? { err: args[0] } : _.isObject(args[0]) ? args[0] : undefined;
-    const msgArgs = msgContext !== undefined ? args.slice(1) : args;
-    const mergedContext = sanitizeBunyanContext({
-      ...this._context,
-      ...msgContext,
-    });
+  _setupLogMethod(level) {
+    const logMethod = this[level] = this._instant.bind(this, level);
 
-    this._bunyan[level](mergedContext, ...msgArgs);
+    return Object.assign(logMethod, {
+      begin: this._begin.bind(this, level),
+      complete: this._complete.bind(this, level),
+      end: this._end.bind(this, level),
+    });
   }
 
-  _initBunyanLogger() {
-    /** @type {bunyan.Stream[]} */
-    const streams = [this._createDebugStream()];
+  /** @private */
+  _begin(level, ...args) {
+    const { context, msg } = this._parseArgs({ ph: 'B' }, args);
+    this._sharedConfig.messageStack.push(context.tid, msg);
+    this._sharedConfig.bunyan.logger[level](context, ...msg);
+  }
 
-    if (this._config.file) {
-      streams.push({
-        level: 'trace',
-        path: this._config.file,
-      });
+  /** @private */
+  _end(level, ...args) {
+    let { context, msg } = this._parseArgs({ ph: 'E' }, args);
+    if (msg.length === 0) {
+      msg = this._sharedConfig.messageStack.pop(context.tid);
     }
 
-    return bunyan.createLogger({ name: 'detox', streams });
+    this._sharedConfig.bunyan.logger[level](context, ...msg);
   }
 
-  _createDebugStream() {
-    const { out = process.stderr, ...streamOptions } = this._config.options;
-    const passthrough = new PassThrough().pipe(out);
-
-    return {
-      type: 'raw',
-      level: this._config.level,
-      stream: bunyanDebugStream.default({
-        ...streamOptions,
-        out: passthrough,
-      }),
-    };
+  /**
+   * @private
+   * @param {import('bunyan').LogLevel} level
+   * @param {any[]} args
+   */
+  _instant(level, ...args) {
+    const { context, msg } = this._parseArgs(null, args);
+    this._sharedConfig.bunyan.logger[level](context, ...msg);
   }
 
-  overrideConsole(sandbox) {
-    const option = this._config.overrideConsole;
-    if (option === 'none') {
-      return;
+  /**
+   * @param {import('bunyan').LogLevel} level
+   * @private
+   */
+  _complete(level, maybeContext, maybeMessage, maybeAction) {
+    const action = typeof maybeContext !== 'string' ? maybeAction : maybeMessage;
+    const args = maybeAction === action ? [maybeContext, maybeMessage] : [maybeContext];
+    const { context, msg } = this._parseArgs(null, args);
+    const end = (ctx) => this[level].end(ctx);
+
+    let result;
+    this[level].begin(context, ...msg);
+    try {
+      result = typeof action === 'function'
+        ? action()
+        : action;
+
+      if (!isPromise(result)) {
+        end(context);
+      } else {
+        result.then(
+          () => end({ success: true }),
+          (err) => end({ success: false, err }),
+        );
+      }
+
+      return result;
+    } catch (err) {
+      end({ success: false, err });
+      throw err;
     }
+  }
 
-    if ((option === 'sandbox' && sandbox) || option === 'all') {
-      customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
+  /** @private */
+  _parseArgs(boundContext, args) {
+    const userContext = _.isError(args[0])
+      ? { err: args[0] }
+      : _.isObject(args[0])
+        ? args[0]
+        : undefined;
+    const msg = userContext !== undefined ? args.slice(1) : args;
+
+    if (userContext) {
+      delete userContext.pid;
+      delete userContext.tid;
+      delete userContext.ts;
+      delete userContext.time;
+      delete userContext.ph;
     }
+
+    const context = this._mergeContexts(
+      this._context,
+      boundContext,
+      userContext,
+    );
+
+    return { context, msg };
   }
 
-  /** @type {bunyanDebugStream.BunyanDebugStreamOptions} */
-  static defaultOptions = {
-    showDate: shortFormat,
-    showLoggerName: true,
-    showPid: true,
-    showMetadata: false,
-    basepath: path.join(__dirname, '..'),
-    prefixers: {
-      '__filename': (filename, { entry }) => {
-        if (entry.event === 'USER_LOG') {
-          return '';
-        }
-
-        if (entry.event === 'ERROR') {
-          return `${filename}/${entry.event}`;
-        }
-
-        return entry.event ? entry.event : filename;
-      },
-      'trackingId': id => ` #${id}`,
-      'cpid': pid => ` cpid=${pid}`,
-    },
-  };
+  /** @internal */
+  static defaultOptions({ level }) {
+    const ph = level === 'trace' || level === 'debug'
+      ? value => require('chalk').grey(value) + ' '
+      : value => require('chalk').grey(value);
+
+    const id = level === 'trace'
+      ? value => require('chalk').yellow(`@${value}`)
+      : undefined;
+
+    const cat = level === 'trace' || level === 'debug'
+      ? (value) => require('chalk').yellow((value || '').split(',', 1)[0])
+      : undefined;
+
+    const event = level === 'trace' || level === 'debug'
+      ? (value) => require('chalk').grey(`:${value}`)
+      : undefined;
+
+    const identity = x => x;
+
+    return ({
+      showDate: shortFormat,
+      showLoggerName: true,
+      showPid: true,
+      showLevel: false,
+      showMetadata: false,
+      showPrefixes: (p) => p.join(''),
+      basepath: path.join(__dirname, '..'),
+      prefixers: _.omitBy({
+        ph,
+        cat,
+        event,
+        id,
+      }, _.isUndefined),
+      stringifiers: _.omitBy({
+        // eslint-disable-next-line unicorn/no-array-method-this-argument
+        'args': args => `(${require('lodash').map(args, a => JSON.stringify(a)).join(', ')})`,
+        'error': identity,
+        'data': json => typeof json === 'string' ? json : JSON.stringify(json, null, 2),
+        'stack': level === 'trace' || level === 'debug' ? identity : undefined,
+        'origin': level === 'trace' || level === 'debug' ? identity : undefined,
+      }, _.isUndefined),
+    });
+  }
 
   /**
+   * @internal
    * @param {string} level
    * @returns {Detox.DetoxLogLevel}
    */
@@ -216,29 +350,4 @@ class DetoxLogger {
   }
 }
 
-const RESERVED_PROPERTIES = [
-  'hostname',
-  'level',
-  'msg',
-  'name',
-  'pid',
-  'time',
-];
-
-function hasProperty(p) {
-  return _.has(this, p);
-}
-
-function hasReservedProperties(o) {
-  return RESERVED_PROPERTIES.some(hasProperty, o); // eslint-disable-line unicorn/no-array-method-this-argument
-}
-
-function escapeCallback(value, key) {
-  return RESERVED_PROPERTIES.includes(key) ? `${key}$` : key;
-}
-
-function sanitizeBunyanContext(context) {
-  return hasReservedProperties(context) ? _.mapKeys(context, escapeCallback) : context;
-}
-
 module.exports = DetoxLogger;

package/src/logger/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  DetoxLogger: require('./DetoxLogger'),
+  installLegacyTracerInterface: require('./utils/tracerLegacy').install,
+};

package/src/logger/utils/BunyanLogger.js

@@ -0,0 +1,72 @@
+const { PassThrough } = require('stream');
+
+const bunyan = require('bunyan');
+const bds = require('bunyan-debug-stream');
+const _ = require('lodash');
+
+const { DetoxInternalError } = require('../../errors');
+
+class BunyanLogger {
+  constructor() {
+    this._bunyan = bunyan.createLogger({ name: 'detox', streams: [] });
+    /** @type {bunyan.Stream} */
+    this._debugStream = null;
+    /** @type {bunyan.Stream} */
+    this._fileStream = null;
+  }
+
+  /**
+   * @returns {bunyan}
+   */
+  get logger() {
+    return this._bunyan;
+  }
+
+  /**
+   * @param {Detox.DetoxLoggerConfig} config
+   * @returns {this}
+   */
+  installDebugStream(config) {
+    const level = config.level || 'info';
+
+    if (this._debugStream) {
+      _.remove(this._bunyan['streams'], this._debugStream);
+      // @ts-ignore
+      this._debugStream.stream.end();
+      this._debugStream = null;
+    }
+
+    this._debugStream = {
+      type: 'raw',
+      level,
+      stream: bds.default({
+        ...config.options,
+        out: new PassThrough().pipe(process.stderr),
+      }),
+    };
+
+    this._bunyan.addStream(this._debugStream);
+    return this;
+  }
+
+  /**
+   * @param {string} file
+   * @returns {this}
+   */
+  installFileStream(file) {
+    if (this._fileStream) {
+      throw new DetoxInternalError('Trying to install a second file stream inside already initialized Bunyan logger');
+    }
+
+    this._fileStream = {
+      level: 'trace',
+      path: file,
+    };
+
+    this._bunyan.addStream(this._fileStream);
+
+    return this;
+  }
+}
+
+module.exports = BunyanLogger;

package/src/logger/utils/CategoryThreadDispatcher.js

@@ -0,0 +1,58 @@
+const _ = require('lodash');
+
+const ThreadDispatcher = require('./ThreadDispatcher');
+
+class CategoryThreadDispatcher {
+  /**
+   * @param {object} config
+   * @param {Record<string, [number, number?]>} config.categories
+   * @param {Detox.Logger} config.logger
+   */
+  constructor(config) {
+    this.categories = config.categories;
+    this.dispatchers = _.mapValues(this.categories, (range, name) => {
+      return new ThreadDispatcher({
+        name,
+        logger: config.logger,
+        min: range[0],
+        max: range[1] || range[0],
+      });
+    });
+  }
+
+  /**
+   * @param {'B' | 'E' | 'i'} ph
+   * @param {string[] | undefined} cat
+   * @param {string | number} id
+   * @returns {number}
+   */
+  resolve(ph, cat, id) {
+    const dispatcher = this._resolveDispatcher(cat);
+
+    switch (ph) {
+      case 'B': return dispatcher.begin(id);
+      case 'E': return dispatcher.end(id);
+      default: return dispatcher.resolve(id);
+    }
+  }
+
+  /** @returns {ThreadDispatcher} */
+  _resolveDispatcher(cat) {
+    const mainCategory = cat ? cat.split(',', 1)[0] : '';
+    return this.dispatchers[mainCategory] || this.dispatchers.default;
+  }
+
+  categorize(tid) {
+    return _.findKey(this.categories, ([min, max]) => min <= tid && tid <= max) || 'default';
+  }
+
+  threadize(cat) {
+    if (!cat) {
+      return this.categories.default[0];
+    }
+
+    return _.find(this.categories, (_, key) => key === cat[0]);
+  }
+}
+
+module.exports = CategoryThreadDispatcher;

package/src/logger/utils/MessageStack.js

@@ -0,0 +1,24 @@
+class MessageStack {
+  constructor() {
+    this._map = {};
+  }
+
+  push(tid, msg) {
+    if (this._map[tid] == null) {
+      this._map[tid] = [];
+    }
+
+    return this._map[tid].push(msg);
+  }
+
+  pop(tid) {
+    const stack = this._map[tid];
+    if (stack == null || stack.length === 0) {
+      return ['<no begin message>'];
+    }
+
+    return stack.pop();
+  }
+}
+
+module.exports = MessageStack;