detox 19.13.0 → 20.0.0

package/src/logger/DetoxLogger.js

@@ -0,0 +1,348 @@
+const path = require('path');
+
+const _ = require('lodash');
+
+const { DetoxInternalError, DetoxError } = require('../errors');
+const { shortFormat } = require('../utils/dateUtils');
+const isPromise = require('../utils/isPromise');
+
+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 SharedLoggerConfig
+ * @property {string} file
+ * @property {Detox.DetoxLoggerConfig} [userConfig]
+ * @property {CategoryThreadDispatcher} [dispatcher]
+ * @property {BunyanLogger} [bunyan]
+ * @property {MessageStack} [messageStack]
+ */
+
+class DetoxLogger {
+  /**
+   * @param {Pick<SharedLoggerConfig, 'file' | 'userConfig'>} sharedConfig
+   * @param {object} [context]
+   */
+  constructor(sharedConfig, context) {
+    /**
+     * @type {SharedLoggerConfig}
+     * IMPORTANT: all instances of {@link DetoxLogger} must share the same object instance of this._sharedConfig.
+     */
+    this._sharedConfig = sharedConfig;
+
+    /** @type {object | undefined} */
+    this._context = context;
+
+    /** @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');
+
+    if (!context) {
+      // In this branch, `this` refers to the first (root) logger instance.
+
+      this._sharedConfig.userConfig = this._sharedConfig.userConfig || {
+        level: 'info',
+        overrideConsole: false,
+        options: {
+          showDate: false,
+          showLoggerName: false,
+          showProcess: false,
+          showPid: false,
+          showLevel: false,
+          showPrefixes: false,
+          showMetadata: false,
+        },
+      };
+
+      this._sharedConfig.bunyan = new BunyanLogger()
+        .installFileStream(this.file)
+        .installDebugStream(this.config);
+
+      this._sharedConfig.dispatcher = new CategoryThreadDispatcher();
+      this._sharedConfig.messageStack = new MessageStack();
+
+      this.overrideConsole();
+    }
+  }
+
+  /**
+   * @public
+   * @returns {Detox.DetoxLogLevel}
+   */
+  get level() {
+    return this.config.level;
+  }
+
+  /**
+   * @public
+   * @param {object} [overrides]
+   * @returns {DetoxLogger}
+   */
+  child(overrides) {
+    const merged = this._mergeContexts(this._context, sanitizeBunyanContext(overrides));
+    return new DetoxLogger(this._sharedConfig, merged);
+  }
+
+  /** @internal */
+  get config() {
+    return this._sharedConfig.userConfig;
+  }
+
+  /** @internal */
+  get file() {
+    return this._sharedConfig.file;
+  }
+
+  /**
+   * @internal
+   * @param config
+   */
+  async setConfig(config) {
+    if (this._context) {
+      throw new DetoxInternalError('Trying to set a config in a non-root logger');
+    }
+
+    _.merge(this.config, config);
+    this._sharedConfig.bunyan.installDebugStream(this.config);
+    this.overrideConsole();
+  }
+
+  /**
+   * @internal
+   */
+  overrideConsole(sandbox) {
+    const enabled = this.config.overrideConsole;
+    if (!enabled) {
+      return;
+    }
+
+    customConsoleLogger.overrideConsoleMethods((sandbox || global).console, this);
+  }
+
+  /**
+   * @private
+   */
+  _mergeContexts(...contexts) {
+    const context = Object.assign({}, ...contexts);
+    const categories = _(contexts).flatMap((c) => {
+      if (c && c.cat) {
+        return _.isArray(c.cat) ? c.cat : c.cat.split(',');
+      }
+
+      return [];
+    }).uniq().join(',');
+
+    if (context.error || context.err) {
+      context.error = DetoxError.format(context.error || context.err);
+      delete context.err;
+    }
+
+    if (categories) {
+      context.cat = categories;
+    } else {
+      delete context.cat;
+    }
+
+    if (context.__filename) {
+      context.__filename = path.basename(context.__filename);
+    }
+
+    context.ph = context.ph || 'i';
+    context.tid = this._sharedConfig.dispatcher.resolve(
+      context.ph,
+      context.cat,
+      context.id || 0
+    );
+
+    return context;
+  }
+
+  /**
+   * @private
+   * @param {Detox.DetoxLogLevel} level
+   * @returns {Detox._LogMethod}
+   */
+  _setupLogMethod(level) {
+    const logMethod = this[level] = this._instant.bind(this, level);
+
+    return Object.assign(logMethod, {
+      begin: this._begin.bind(this, level),
+      complete: this._complete.bind(this, level),
+      end: this._end.bind(this, level),
+    });
+  }
+
+  /** @private */
+  _begin(level, ...args) {
+    const { context, msg } = this._parseArgs({ ph: 'B' }, args);
+    this._beginInternal(level, context, msg);
+  }
+
+  /** @private */
+  _beginInternal(level, context, msg) {
+    this._sharedConfig.messageStack.push(context.tid, msg);
+    this._sharedConfig.bunyan.logger[level](context, ...msg);
+  }
+
+  /** @private */
+  _end(level, ...args) {
+    let { context, msg } = this._parseArgs({ ph: 'E' }, args);
+    this._endInternal(level, context, msg);
+  }
+
+  /** @private */
+  _endInternal(level, context, msg) {
+    const beginMsg = this._sharedConfig.messageStack.pop(context.tid);
+    if (msg.length === 0) {
+      msg = beginMsg;
+    }
+
+    this._sharedConfig.bunyan.logger[level](context, ...msg);
+  }
+
+  /**
+   * @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);
+  }
+
+  /**
+   * @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({
+      id: context.id,
+      cat: context.cat,
+      ...ctx,
+    });
+
+    let result;
+    this._beginInternal(level, { ...context, ph: 'B' }, msg);
+    try {
+      result = typeof action === 'function'
+        ? action()
+        : action;
+
+      if (!isPromise(result)) {
+        end({ success: true });
+      } else {
+        result.then(
+          () => end({ success: true }),
+          (err) => end({ success: false, err }),
+        );
+      }
+
+      return result;
+    } catch (err) {
+      end({ success: false, err });
+      throw err;
+    }
+  }
+
+  /** @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;
+
+    const context = this._mergeContexts(
+      this._context,
+      boundContext,
+      sanitizeBunyanContext(userContext),
+    );
+
+    return { context, msg };
+  }
+
+  /** @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}
+   */
+  static castLevel(level) {
+    switch (level) {
+      case 'fatal':
+      case 'error':
+      case 'warn':
+      case 'info':
+      case 'debug':
+      case 'trace':
+        return level;
+      case 'verbose':
+        return 'debug';
+      default:
+        return 'info';
+    }
+  }
+}
+
+module.exports = DetoxLogger;

package/src/logger/index.js

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

package/src/logger/utils/BunyanLogger.js

@@ -0,0 +1,76 @@
+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) {
+    if (this._debugStream) {
+      _.remove(this._bunyan['streams'], this._debugStream);
+      // @ts-ignore
+      this._debugStream.stream.end();
+      this._debugStream = null;
+    }
+
+    const streamOptions = { out: null, ...config.options };
+    /* istanbul ignore next */
+    if (!streamOptions.out) {
+      // This is a default if-else branch, used everywhere except for the unit tests.
+      streamOptions.out = new PassThrough().pipe(process.stderr);
+    }
+
+    this._debugStream = {
+      type: 'raw',
+      level: config.level,
+      stream: bds.default(streamOptions),
+    };
+
+    this._bunyan.addStream(this._debugStream);
+    return this;
+  }
+
+  /**
+   * @param {string} file
+   * @returns {this}
+   */
+  installFileStream(file) {
+    /* istanbul ignore next */
+    if (this._fileStream) {
+      // This is an impossible condition, but we keep it here for the sake of completeness.
+      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,36 @@
+const ThreadDispatcher = require('./ThreadDispatcher');
+
+class CategoryThreadDispatcher {
+  constructor() {
+    /** @type {Record<string, ThreadDispatcher>} */
+    this._dispatchers = {};
+  }
+
+  /**
+   * @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] : 'undefined';
+    if (!this._dispatchers[mainCategory]) {
+      this._dispatchers[mainCategory] = new ThreadDispatcher(mainCategory);
+    }
+
+    return this._dispatchers[mainCategory];
+  }
+}
+
+module.exports = CategoryThreadDispatcher;

package/src/logger/utils/DetoxLogFinalizer.js

@@ -0,0 +1,140 @@
+const path = require('path');
+const { promisify } = require('util');
+
+const fs = require('fs-extra');
+const glob = require('glob');
+const pipe = require('multipipe');
+
+const temporary = require('../../artifacts/utils/temporaryPath');
+
+const globAsync = promisify(glob);
+const globSync = glob.sync;
+const streamUtils = () => require('../../logger/utils/streamUtils');
+
+/**
+ * @typedef DetoxLogFinalizerConfig
+ * @property {import('../../ipc/SessionState')} session
+ */
+
+class DetoxLogFinalizer {
+  /** @param {DetoxLogFinalizerConfig} config */
+  constructor(config) {
+    this._session = config.session;
+  }
+
+  createEventStream() {
+    const sessionId = this._session.id;
+    const logs = globSync(temporary.for.jsonl(`${sessionId}.*`));
+
+    return streamUtils()
+      .uniteSessionLogs(logs)
+      .pipe(streamUtils().chromeTraceStream());
+  }
+
+  async finalize() {
+    const sessionId = this._session.id;
+    const logs = await globAsync(temporary.for.jsonl(`${sessionId}.*`));
+    if (logs.length === 0) {
+      return;
+    }
+
+    if (this._areLogsEnabled()) {
+      const rootDir = this._config.artifacts.rootDir;
+
+      await fs.mkdirp(rootDir);
+      const [out1Stream, out2Stream] = ['detox.log', 'detox.trace.json']
+        .map((filename) => fs.createWriteStream(path.join(rootDir, filename)));
+
+      const tidHashMap = await this._scanForThreadIds(logs);
+      const mergedStream = streamUtils().uniteSessionLogs(logs);
+
+      await Promise.all([
+        pipe(mergedStream, streamUtils().debugStream(this._config.logger.options), out1Stream),
+        pipe(mergedStream, streamUtils().chromeTraceStream(tidHashMap), streamUtils().writeJSON(), out2Stream),
+      ]);
+    }
+
+    await Promise.all(logs.map(filepath => fs.remove(filepath)));
+  }
+
+  finalizeSync() {
+    const sessionId = this._session.id;
+    const logs = globSync(temporary.for.jsonl(`${sessionId}.*`));
+    if (logs.length === 0) {
+      return;
+    }
+
+    const logsEnabled = this._areLogsEnabled();
+    const rootDir = logsEnabled ? this._config.artifacts.rootDir : '';
+    if (logsEnabled) {
+      fs.mkdirpSync(rootDir);
+    }
+
+    for (const log of logs) {
+      if (logsEnabled) {
+        fs.moveSync(log, path.join(rootDir, path.basename(log)));
+      } else {
+        fs.removeSync(log);
+      }
+    }
+  }
+
+  /** @private */
+  get _config() {
+    // The config appears later in the lifecycle, so we need to access it lazily
+    return this._session.detoxConfig;
+  }
+
+  /** @private */
+  _areLogsEnabled() {
+    if (!this._config) {
+      return false;
+    }
+
+    const { rootDir, plugins } = this._config.artifacts;
+    if (!rootDir || !plugins) {
+      return false;
+    }
+
+    if (!plugins.log.enabled) {
+      return false;
+    }
+
+    if (!plugins.log.keepOnlyFailedTestsArtifacts) {
+      return true;
+    }
+
+    return this._session.testResults.some(r => !r.success);
+  }
+
+  /** @private */
+  async _scanForThreadIds(logs) {
+    const processes = await new Promise((resolve, reject) => {
+      const result = {};
+      streamUtils().uniteSessionLogs(logs)
+        .on('end', () => resolve(result))
+        .on('error', /* istanbul ignore next */ (err) => reject(err))
+        .on('data', (event) => {
+          const { ph, pid, tid, cat } = event;
+          if (ph === 'B' || ph === 'i') {
+            const categories = (result[pid] = result[pid] || {});
+            const mainCategory = String(cat).split(',')[0];
+            const tids = (categories[mainCategory] = categories[mainCategory] || []);
+            if (!tids.includes(tid)) {
+              tids.push(tid);
+            }
+          }
+        });
+    });
+
+    const tidArray = Object.entries(processes).flatMap(([pid, categories]) => {
+      return Object.entries(categories).flatMap(([category, tids]) => {
+        return tids.map(tid => `${pid}:${category}:${tid}`);
+      });
+    });
+
+    return new Map(tidArray.map((hash, index) => [hash, index]));
+  }
+}
+
+module.exports = DetoxLogFinalizer;

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;

package/src/logger/utils/ThreadDispatcher.js

@@ -0,0 +1,61 @@
+const isUndefined = (x) => x === undefined;
+
+class ThreadDispatcher {
+  /**
+   * @param {string} name
+   */
+  constructor(name) {
+    this.name = name;
+    this.stacks = [];
+    this.threads = [];
+  }
+
+  /**
+   * @param {string | number} [id]
+   * @returns {number}
+   */
+  begin(id) {
+    const tid = this._findTID(id);
+    this.threads[tid] = id;
+    this.stacks[tid] = (this.stacks[tid] || 0) + 1;
+    return tid;
+  }
+
+  /**
+   * @param {string | number} [id]
+   * @returns {number}
+   */
+  resolve(id) {
+    return this._findTID(id);
+  }
+
+  /**
+   * @param {string | number} [id]
+   * @returns {number}
+   */
+  end(id) {
+    const tid = this._findTID(id);
+    if (this.stacks[tid] && --this.stacks[tid] === 0) {
+      delete this.threads[tid];
+    }
+    return tid;
+  }
+
+  /**
+   * @param {string | number | undefined} id
+   * @returns {number}
+   * @private
+   *
+   * Memory-efficient finder of a free item index in the threads array.
+   */
+  _findTID(id) {
+    let tid = this.threads.indexOf(id);
+    if (tid === -1) {
+      // Try to find a recently released slot in the array:
+      tid = this.threads.findIndex(isUndefined);
+    }
+    return tid === -1 ? this.threads.length : tid;
+  }
+}
+
+module.exports = ThreadDispatcher;