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

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,25 @@
+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) => logger.trace.complete(name, action);
+  },
+};
+
+function installLegacyTracerInterface(logger, target) {
+  target.traceCall = methods.traceCall(logger);
+  target.trace = Object.freeze({
+    startSection: methods.startSection(logger),
+    endSection: methods.endSection(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.loggerConfig
-      : 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]);
   }
 }

package/src/realms/DetoxPrimaryContext.js

@@ -1,24 +1,34 @@
 const path = require('path');
 const { URL } = require('url');
+const { promisify } = require('util');
 
 const fs = require('fs-extra');
+const glob = require('glob');
 const pipe = require('multipipe');
+const onSignalExit = require('signal-exit');
 
 const temporary = require('../artifacts/utils/temporaryPath');
 const { DetoxRuntimeError } = require('../errors');
-const { PrimarySessionState } = require('../ipc/state');
+const SessionState = require('../ipc/SessionState');
 const symbols = require('../symbols');
 
+const globAsync = promisify(glob);
+const globSync = glob.sync;
+
 const DetoxContext = require('./DetoxContext');
 
-const { $logger, $restoreSessionState, $sessionState } = DetoxContext.protected;
+const { $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
 
 const _finalizeLogs = Symbol('finalizeLogs');
+const _finalizeLogsSync = Symbol('finalizeLogsSync');
 const _globalLifecycleHandler = Symbol('globalLifecycleHandler');
 const _ipcServer = Symbol('ipcServer');
 const _resetLockFile = Symbol('resetLockFile');
 const _wss = Symbol('wss');
 const _dirty = Symbol('dirty');
+const _emergencyTeardown = Symbol('emergencyTeardown');
+const _areLogsEnabled = Symbol('areLogsEnabled');
+const _lifecycleLogger = Symbol('lifecycleLogger');
 
 class DetoxPrimaryContext extends DetoxContext {
   constructor() {
@@ -31,6 +41,8 @@ class DetoxPrimaryContext extends DetoxContext {
      * @type {import('../ipc/IPCServer') | null}
      */
     this[_ipcServer] = null;
+    /** @type {Detox.Logger} */
+    this[_lifecycleLogger] = this[symbols.logger].child({ cat: 'lifecycle' });
   }
 
   //#region Internal members
@@ -52,9 +64,9 @@ class DetoxPrimaryContext extends DetoxContext {
 
   /**
    * @override
-   * @param {Partial<DetoxInternals.DetoxGlobalSetupOptions>} [opts]
+   * @param {Partial<DetoxInternals.DetoxInitOptions>} [opts]
    */
-  async [symbols.globalSetup](opts) {
+  async [symbols.init](opts = {}) {
     if (this[_dirty]) {
       throw new DetoxRuntimeError({
         message: 'Cannot initialize primary Detox context more than once.',
@@ -63,21 +75,26 @@ class DetoxPrimaryContext extends DetoxContext {
     }
 
     this[_dirty] = true;
+    onSignalExit(this[_emergencyTeardown]);
+
     const detoxConfig = await this[symbols.resolveConfig](opts);
 
-    const { behaviorConfig, deviceConfig, loggerConfig, sessionConfig } = detoxConfig;
-    await this[$logger].setConfig(loggerConfig);
+    const {
+      behavior: behaviorConfig,
+      device: deviceConfig,
+      logger: loggerConfig,
+      session: sessionConfig
+    } = detoxConfig;
+    await this[symbols.logger].setConfig(loggerConfig);
 
-    this.trace.begin({
-      cat: 'lifecycle',
-      args: this[$sessionState],
-      name: process.argv.slice(1).join(' '),
-    });
+    this[_lifecycleLogger].trace.begin({
+      data: this[$sessionState],
+    }, process.argv.slice(1).join(' '));
 
     const IPCServer = require('../ipc/IPCServer');
     this[_ipcServer] = new IPCServer({
       sessionState: this[$sessionState],
-      logger: this[$logger],
+      logger: this[symbols.logger],
     });
 
     await this[_ipcServer].init();
@@ -106,63 +123,98 @@ class DetoxPrimaryContext extends DetoxContext {
     }
 
     if (!sessionConfig.server && this[_wss]) {
+      // @ts-ignore
       sessionConfig.server = `ws://localhost:${this[_wss].port}`;
     }
 
     await fs.writeFile(this[$sessionState].detoxConfigSnapshotPath, this[$sessionState].stringify());
     process.env.DETOX_CONFIG_SNAPSHOT_PATH = this[$sessionState].detoxConfigSnapshotPath;
 
-    // TODO: think about signal-exit and cleaning up the logs
+    if (opts.workerId !== null) {
+      await this[symbols.installWorker](opts);
+    }
   }
 
   /**
    * @override
-   * @param {Partial<DetoxInternals.DetoxConfigurationSetupOptions>} [opts]
+   * @param {Partial<DetoxInternals.DetoxInstallWorkerOptions>} [opts]
    */
-  async [symbols.setup](opts) {
-    const workerId = opts.workerId || 1;
-    this[$sessionState].workerId = workerId;
+  async [symbols.installWorker](opts = {}) {
+    const workerId = this[$sessionState].workerId = opts.workerId = opts.workerId || 'worker';
     this[_ipcServer].onRegisterWorker({ workerId });
-    await super[symbols.setup](opts);
+
+    await super[symbols.installWorker](opts);
   }
 
   /** @override */
-  async [symbols.globalTeardown]() {
+  async [symbols.cleanup]() {
+    try {
+      if (this[$worker]) {
+        await this[symbols.uninstallWorker]();
+      }
+    } finally {
+      if (this[_globalLifecycleHandler]) {
+        await this[_globalLifecycleHandler].globalCleanup();
+        this[_globalLifecycleHandler] = null;
+      }
+
+      if (this[_wss]) {
+        await this[_wss].close();
+        this[_wss] = null;
+      }
+
+      if (this[_ipcServer]) {
+        await this[_ipcServer].dispose();
+        this[_ipcServer] = null;
+      }
+
+      await fs.remove(this[$sessionState].detoxConfigSnapshotPath);
+
+      try {
+        this[_lifecycleLogger].trace.end();
+        await this[_finalizeLogs]();
+      } catch (err) {
+        this[_lifecycleLogger].error({ err }, 'Encountered an error while merging the process logs:');
+      }
+    }
+  }
+
+  [_emergencyTeardown] = (_code, signal) => {
+    if (!signal) {
+      return;
+    }
+
     if (this[_globalLifecycleHandler]) {
-      await this[_globalLifecycleHandler].globalCleanup();
+      this[_globalLifecycleHandler].emergencyCleanup();
       this[_globalLifecycleHandler] = null;
     }
 
     if (this[_wss]) {
-      await this[_wss].close();
-      this[_wss] = null;
+      this[_wss].close();
     }
 
     if (this[_ipcServer]) {
-      await this[_ipcServer].dispose();
-      this[_ipcServer] = null;
+      this[_ipcServer].dispose();
     }
 
-    await fs.remove(this[$sessionState].detoxConfigSnapshotPath);
-    delete process.env.DETOX_CONFIG_SNAPSHOT_PATH;
-
     try {
-      this.trace.end({ cat: 'lifecycle' });
-      await this[_finalizeLogs]();
+      this[_lifecycleLogger].trace.end({ abortSignal: signal });
+      this[_finalizeLogsSync]();
     } catch (err) {
-      this[$logger].error({ err }, 'Encountered an error while merging the process logs:');
+      this[symbols.logger].error({ err }, 'Encountered an error while merging the process logs:');
     }
-  }
+  };
+
   //#endregion
 
   //#region Protected members
   /**
    * @protected
    * @override
-   * @return {PrimarySessionState}
+   * @return {SessionState}
    */
   [$restoreSessionState]() {
-    return new PrimarySessionState({
+    return new SessionState({
       detoxConfigSnapshotPath: temporary.for.json(),
       detoxIPCServer: `primary-${process.pid}`,
     });
@@ -171,17 +223,16 @@ class DetoxPrimaryContext extends DetoxContext {
 
   //#region Private members
   async[_finalizeLogs]() {
-    const logs = [this[$logger].file, ...this[$sessionState].logFiles].filter(f => f && fs.existsSync(f));
+    const sessionId = this[$sessionState].id;
+    const logs = await globAsync(temporary.for.jsonl(`${sessionId}.*`));
     if (logs.length === 0) {
       return;
     }
 
-    const streamUtils = require('../utils/streamUtils');
-    const { rootDir, plugins } = this[symbols.config].artifactsConfig || {};
-    const logConfig = plugins && plugins.log || 'none';
-    const enabled = rootDir && (typeof logConfig === 'string' ? logConfig !== 'none' : logConfig.enabled);
+    if (this[_areLogsEnabled]) {
+      const streamUtils = require('../utils/streamUtils');
+      const { rootDir } = this[symbols.config].artifacts;
 
-    if (enabled) {
       await fs.mkdirp(rootDir);
       const [out1Stream, out2Stream, out3Stream] = ['detox.log.jsonl', 'detox.log', 'detox.trace.json']
         .map((filename) => fs.createWriteStream(path.join(rootDir, filename)));
@@ -193,7 +244,7 @@ class DetoxPrimaryContext extends DetoxContext {
 
       await Promise.all([
         pipe(mergedStream, streamUtils.writeJSONL(), out1Stream),
-        pipe(mergedStream, streamUtils.debugStream(this[$logger].config.options), out2Stream),
+        pipe(mergedStream, streamUtils.debugStream(this[symbols.logger].config.options), out2Stream),
         pipe(mergedStream, streamUtils.chromeTraceStream(), streamUtils.writeJSON(), out3Stream),
       ]);
     }
@@ -201,10 +252,36 @@ class DetoxPrimaryContext extends DetoxContext {
     await Promise.all(logs.map(filepath => fs.remove(filepath)));
   }
 
+  async[_finalizeLogsSync]() {
+    const logsEnabled = this[_areLogsEnabled]();
+
+    const { rootDir } = this[symbols.config].artifacts;
+    fs.mkdirpSync(rootDir);
+
+    const sessionId = this[$sessionState].id;
+    const logs = globSync(temporary.for.jsonl(`${sessionId}.*`));
+
+    for (const log of logs) {
+      if (logsEnabled) {
+        fs.moveSync(log, path.join(rootDir, path.basename(log)));
+      } else {
+        fs.removeSync(log);
+      }
+    }
+  }
+
+  [_areLogsEnabled]() {
+    const { rootDir, plugins } = this[symbols.config].artifacts || {};
+    const logConfig = plugins && plugins.log || 'none';
+    const enabled = rootDir && (typeof logConfig === 'string' ? logConfig !== 'none' : logConfig.enabled);
+
+    return enabled;
+  }
+
   async[_resetLockFile]() {
     const DeviceRegistry = require('../devices/DeviceRegistry');
 
-    const deviceType = this[symbols.config].deviceConfig.type;
+    const deviceType = this[symbols.config].device.type;
 
     switch (deviceType) {
       case 'ios.none':