detox 20.0.4-breaking.new-global-lifecycle.0 → 20.0.7-prerelease.0

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;

package/src/logger/{TraceThreadDispatcher.js → utils/ThreadDispatcher.js}

@@ -1,6 +1,6 @@
 const isUndefined = (x) => x === undefined;
 
-class TraceThreadDispatcher {
+class ThreadDispatcher {
   /**
    * @param {object} options
    * @param {Detox.Logger} options.logger
@@ -17,14 +17,31 @@ class TraceThreadDispatcher {
     this.threads = [];
   }
 
-  begin(id = 0) {
+  /**
+   * @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 this._transpose(tid);
   }
 
-  end(id = 0) {
+  /**
+   * @param {string | number} [id]
+   * @returns {number}
+   */
+  resolve(id) {
+    const tid = this._findTID(id);
+    return this._transpose(tid);
+  }
+
+  /**
+   * @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];
@@ -32,9 +49,17 @@ class TraceThreadDispatcher {
     return this._transpose(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;
@@ -43,10 +68,14 @@ class TraceThreadDispatcher {
   _transpose(id) {
     const result = this.min + id;
     if (result > this.max) {
-      this.logger.warn({ event: 'THREAD_DISPATCHER' }, `${this.name} trace thread dispatcher has run out of available thread IDs: ${this.min}..${this.max}`);
+      this.logger.warn(
+        { cat: ['logger', 'thread-dispatcher'] },
+        `${this.name} trace thread dispatcher has run out of available thread IDs: ${this.min}..${this.max}`
+      );
     }
+
     return Math.min(result, this.max);
   }
 }
 
-module.exports = TraceThreadDispatcher;
+module.exports = ThreadDispatcher;

package/src/logger/{customConsoleLogger.js → utils/customConsoleLogger.js}

@@ -1,6 +1,6 @@
 const util = require('util');
 
-const callsites = require('../utils/callsites');
+const callsites = require('../../utils/callsites');
 
 const USER_STACK_FRAME_INDEX = 2;
 
@@ -25,20 +25,20 @@ function getStackDump() {
 
 function proxyLog(bunyanLoggerFn) {
   return (...args) => {
-    bunyanLoggerFn({ event: 'USER_LOG' }, getOrigin(), '\n', util.format(...args));
+    bunyanLoggerFn({ origin: getOrigin() }, util.format(...args));
   };
 }
 
 function proxyTracing(bunyanLoggerFn) {
   return (...args) => {
-    bunyanLoggerFn({ event: 'USER_LOG' }, getOrigin(), '\n  Trace:', util.format(...args), '\n\r' + getStackDump());
+    bunyanLoggerFn({ origin: getOrigin(), stack: getStackDump() }, util.format(...args));
   };
 }
 
 function proxyAssert(bunyanLoggerFn) {
   return (condition, ...args) => {
     if (!condition) {
-      bunyanLoggerFn({ event: 'USER_LOG' }, getOrigin(), '\n  AssertionError:', util.format(...args));
+      bunyanLoggerFn({ origin: getOrigin() }, 'AssertionError:', util.format(...args));
     }
   };
 }

package/src/logger/utils/sanitizeBunyanContext.js

@@ -0,0 +1,28 @@
+const _ = require('lodash');
+
+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 = sanitizeBunyanContext;

package/src/logger/utils/tracerLegacy.js

@@ -0,0 +1,48 @@
+const methods = {
+  startSection(logger) {
+    return (msg, args) => logger.trace.begin(args, msg);
+  },
+
+  endSection(logger) {
+    return (msg, args) => logger.trace.end(args);
+  },
+
+  traceCall(logger) {
+    return (name, action, args = {}) => logger.trace.complete(args, name, action);
+  },
+
+  invocationCall(logger) {
+    return (sectionName, invocation, action) => {
+      return logger.trace.complete({
+        cat: 'ws-client,ws-client-invocation',
+        data: invocation,
+        stack: _getCallStackTrace(),
+      }, sectionName, action);
+    };
+  },
+};
+
+function _getCallStackTrace() {
+  return new Error().stack
+    .split('\n')
+    .slice(1) // Ignore Error message
+    .map(line => line
+      .replace(/^\s*at\s+/, '')
+      .replace(process.cwd(), '')
+    )
+    .filter(line => !line.includes('/detox/src')) // Ignore detox internal calls
+    .join('\n');
+}
+
+function installLegacyTracerInterface(logger, target) {
+  target.traceCall = methods.traceCall(logger);
+  target.trace = Object.freeze({
+    startSection: methods.startSection(logger),
+    endSection: methods.endSection(logger),
+    invocationCall: methods.invocationCall(logger),
+  });
+
+  return this;
+}
+
+module.exports = { install: installLegacyTracerInterface };

package/src/realms/DetoxContext.js

@@ -1,48 +1,63 @@
 const funpermaproxy = require('funpermaproxy');
 
+const temporary = require('../artifacts/utils/temporaryPath');
 const { DetoxRuntimeError } = require('../errors');
-const DetoxLogger = require('../logger/DetoxLogger');
-const DetoxTracer = require('../logger/DetoxTracer');
+const { DetoxLogger, installLegacyTracerInterface } = require('../logger');
 const symbols = require('../symbols');
 
 const DetoxConstants = require('./DetoxConstants');
 
 const $cleanup = Symbol('cleanup');
-const $logger = Symbol('logger');
 const $restoreSessionState = Symbol('restoreSessionState');
 const $sessionState = Symbol('restoreSessionState');
-const $tracer = Symbol('tracer');
-
-const _worker = Symbol('worker');
+const $status = Symbol('status');
+const $worker = Symbol('worker');
 
 class DetoxContext {
   constructor() {
-    this[symbols.globalSetup] = this[symbols.globalSetup].bind(this);
-    this[symbols.globalTeardown] = this[symbols.globalTeardown].bind(this);
+    /** @type {DetoxInternals.DetoxStatus} */
+    this[$status] = 'inactive';
+
+    const _init = this[symbols.init].bind(this);
+    this[symbols.init] = async (opts) => {
+      this[$status] = 'init';
+      await _init(opts);
+      this[$status] = 'active';
+    };
+
+    const _cleanup = this[symbols.cleanup].bind(this);
+    this[symbols.cleanup] = async () => {
+      this[$status] = 'cleanup';
+      try {
+        await _cleanup();
+      } finally {
+        this[$status] = 'inactive';
+      }
+    };
+
+    this[symbols.getStatus] = this[symbols.getStatus].bind(this);
     this[symbols.reportFailedTests] = this[symbols.reportFailedTests].bind(this);
     this[symbols.resolveConfig] = this[symbols.resolveConfig].bind(this);
-    this[symbols.setup] = this[symbols.setup].bind(this);
-    this[symbols.teardown] = this[symbols.teardown].bind(this);
+    this[symbols.installWorker] = this[symbols.installWorker].bind(this);
+    this[symbols.uninstallWorker] = this[symbols.uninstallWorker].bind(this);
 
     this[$sessionState] = this[$restoreSessionState]();
 
-    const loggerConfig = this[$sessionState].detoxConfig
-      ? this[$sessionState].detoxConfig.logger
-      : undefined;
-
     /**
-     * @protected
      * @type {DetoxLogger & Detox.Logger}
      */
-    this[$logger] = new DetoxLogger(loggerConfig);
-    /** @protected */
-    this[$tracer] = DetoxTracer.default({
-      logger: this[$logger],
+    this[symbols.logger] = new DetoxLogger({
+      file: temporary.for.jsonl(`${this[$sessionState].id}.${process.pid}`),
+      userConfig: this[$sessionState].detoxConfig
+        ? this[$sessionState].detoxConfig.logger
+        : null,
     });
-    /** @deprecated */
-    this.traceCall = this[$tracer].bind(this[$tracer]);
+
+    this.log = this[symbols.logger].child({ cat: 'user' });
+    installLegacyTracerInterface(this.log, this);
+
     /** @type {import('../DetoxWorker') | null} */
-    this[_worker] = null;
+    this[$worker] = null;
   }
 
   //#region Public members
@@ -62,19 +77,6 @@ class DetoxContext {
     return DetoxConstants;
   }
 
-  /**
-   * @returns {Detox.Logger}
-   */
-  get log() {
-    return this[$logger];
-  }
-
-  /**
-   * @returns {Detox.Tracer}
-   */
-  get trace() {
-    return this[$tracer];
-  }
   //#endregion
 
   //#region Internal members
@@ -96,57 +98,63 @@ class DetoxContext {
   [symbols.reportFailedTests](_testFilePaths, _permanent) {}
   /**
    * @abstract
-   * @param {Partial<DetoxInternals.DetoxGlobalSetupOptions>} _opts
+   * @param {Partial<DetoxInternals.DetoxInitOptions>} _opts
    * @returns {Promise<DetoxInternals.RuntimeConfig>}
    */
   async [symbols.resolveConfig](_opts) { return null; }
 
+  [symbols.getStatus]() {
+    return this[$status];
+  }
+
   get [symbols.worker]() {
-    if (!this[_worker]) {
+    if (!this[$worker]) {
       throw new DetoxRuntimeError({
-        message: `Detox worker instance has not been initialized in this context (${this.constructor.name}).`,
-        hint: DetoxRuntimeError.reportIssueIfJest + '\n' + 'Otherwise, make sure you call detox.setup() beforehand.',
+        message: `Detox worker instance has not been installed in this context (${this.constructor.name}).`,
+        hint: DetoxRuntimeError.reportIssueIfJest + '\n' + 'Otherwise, make sure you call detox.installWorker() beforehand.',
       });
     }
 
-    return this[_worker];
+    return this[$worker];
   }
 
   /**
    * @abstract
-   * @param {Partial<DetoxInternals.DetoxGlobalSetupOptions>} [_opts]
+   * @param {Partial<DetoxInternals.DetoxInitOptions>} [_opts]
    * @returns {Promise<void>}
    */
-  async [symbols.globalSetup](_opts = {}) {}
+  async [symbols.init](_opts = {}) {}
 
   /**
-   * @param {Partial<DetoxInternals.DetoxConfigurationSetupOptions>} [opts]
+   * @param {Partial<DetoxInternals.DetoxInstallWorkerOptions>} [opts]
    */
-  async [symbols.setup](opts) {
-    const theGlobal = opts.global || global;
-    theGlobal['__detox__'] = this;
-    this[$logger].overrideConsole(theGlobal);
+  async [symbols.installWorker](opts) {
+    if (opts.global) {
+      opts.global['__detox__'] = this;
+      this.log.overrideConsole(opts.global);
+    }
 
     const DetoxWorker = require('../DetoxWorker');
-    DetoxWorker.global = theGlobal;
-    this[_worker] = new DetoxWorker(this);
-    await this[_worker].init();
+    DetoxWorker.global = opts.global || global;
+    this[$worker] = new DetoxWorker(this);
+    this[$worker].id = opts.workerId;
+    await this[$worker].init();
   }
 
-  async [symbols.teardown]() {
+  async [symbols.uninstallWorker]() {
     try {
-      if (this[_worker]) {
-        await this[_worker].cleanup();
+      if (this[$worker]) {
+        await this[$worker].cleanup();
       }
     } finally {
-      this[_worker] = null;
+      this[$worker] = null;
     }
   }
 
   /**
    * @abstract
    */
-  async [symbols.globalTeardown]() {}
+  async [symbols.cleanup]() {}
   //#endregion
 
   //#region Protected members
@@ -163,8 +171,8 @@ class DetoxContext {
 module.exports = DetoxContext;
 module.exports.protected = {
   $cleanup,
-  $logger,
   $restoreSessionState,
+  $status,
   $sessionState,
-  $tracer,
+  $worker,
 };

package/src/realms/DetoxInternalsFacade.js

@@ -8,11 +8,12 @@ class DetoxInternalsFacade {
    */
   constructor(context) {
     this.config = context[symbols.config];
-    this.globalSetup = context[symbols.globalSetup];
-    this.globalTeardown = context[symbols.globalTeardown];
-    this.log = context.log;
-    this.setup = context[symbols.setup];
-    this.teardown = context[symbols.teardown];
+    this.getStatus = context[symbols.getStatus];
+    this.init = context[symbols.init];
+    this.cleanup = context[symbols.cleanup];
+    this.log = context[symbols.logger];
+    this.installWorker = context[symbols.installWorker];
+    this.uninstallWorker = context[symbols.uninstallWorker];
     this.onHookFailure = context[symbols.onHookFailure];
     this.onHookStart = context[symbols.onHookStart];
     this.onHookSuccess = context[symbols.onHookSuccess];
@@ -28,6 +29,7 @@ class DetoxInternalsFacade {
     this.reportFailedTests = context[symbols.reportFailedTests];
     this.resolveConfig = context[symbols.resolveConfig];
     this.session = context[symbols.session];
+    this.trace = context.trace;
     this.worker = funpermaproxy(() => context[symbols.worker]);
   }
 }