detox 20.0.3-breaking.new-global-lifecycle.0 → 20.0.3

package/src/logger/utils/streams/ChromeTraceTransformer.js

@@ -0,0 +1,127 @@
+const { AbstractEventBuilder } = require('trace-event-lib');
+
+const getMainCategory = require('../getMainCategory');
+
+const JSONLStringer = require('./JSONLStringer');
+const { flatMapTransform } = require('./transformers');
+
+class ChromeTraceTransformer {
+  constructor() {
+    /** @type {Map<string, number>} */
+    this._globalThreadMap = null;
+  }
+
+  /**
+   * @param {NodeJS.ReadableStream} eventStream
+   */
+  async scanThreadIDs(eventStream) {
+    const processes = await new Promise((resolve, reject) => {
+      const result = {};
+      eventStream
+        .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}`);
+      });
+    });
+
+    this._globalThreadMap = new Map(tidArray.map((hash, index) => [hash, index]));
+  }
+
+  /**
+   * @returns {module:stream.internal.Transform}
+   */
+  createStream() {
+    const transformFn = this._transformBunyanRecord.bind(this, {
+      knownPids: new Set(),
+      knownTids: new Set(),
+    });
+
+    return flatMapTransform(transformFn);
+  }
+
+  createSerializedStream() {
+    const writable = this.createStream();
+    const readable = JSONLStringer.serializeJSON();
+    writable.pipe(readable);
+    return { writable, readable };
+  }
+
+  /**
+   * @param {{ knownPids: Set<number>, knownTids: Set<number> }} state
+   * @param {*} bunyanLogRecord
+   * @returns {import('trace-event-lib').Event[]}
+   * @private
+   */
+  _transformBunyanRecord(state, bunyanLogRecord) {
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+    const { cat: rawCat, msg: name, ph, pid, tid: _tid, time, name: _name, hostname: _hostname, ...args } = bunyanLogRecord;
+    const ts = new Date(time).getTime() * 1E3;
+    const cat = rawCat || 'undefined';
+    const tid = this._resolveGlobalTID(bunyanLogRecord);
+
+    const builder = new SimpleEventBuilder();
+    if (!state.knownPids.has(pid)) {
+      builder.metadata({ pid, ts, name: 'process_name', args: { name: pid === process.pid ? 'primary' : 'secondary' } });
+      builder.metadata({ pid, ts, name: 'process_sort_index', args: { sort_index: state.knownPids.size } });
+      state.knownPids.add(pid);
+    }
+
+    if (!state.knownTids.has(tid)) {
+      const mainCategory = getMainCategory(cat);
+      builder.metadata({ pid, tid, ts, name: 'thread_name', args: { name: mainCategory } });
+      builder.metadata({ pid, tid, ts, name: 'thread_sort_index', args: { sort_index: tid } });
+      state.knownTids.add(tid);
+    }
+
+    const event = { ph, name, pid, tid, cat, ts, args };
+    if (ph === 'E') {
+      delete event.name;
+    }
+
+    builder.events.push(event);
+    return builder.events;
+  }
+
+  _resolveGlobalTID(event) {
+    const hash = this._computeThreadHash(event);
+    const tid = this._globalThreadMap ? this._globalThreadMap.get(hash) : event.tid;
+
+    // Impossible condition, but anyway it is better to be safe than sorry.
+    /* istanbul ignore next */
+    return tid === undefined ? ChromeTraceTransformer.ERROR_TID : tid;
+  }
+
+  _computeThreadHash({ pid, tid, cat }) {
+    return `${pid}:${getMainCategory(cat)}:${tid}`;
+  }
+
+  /* istanbul ignore next */
+  static get ERROR_TID() {
+    return 37707;
+  }
+}
+
+class SimpleEventBuilder extends AbstractEventBuilder {
+  events = [];
+
+  send(event) {
+    this.events.push(event);
+  }
+}
+
+module.exports = ChromeTraceTransformer;

package/src/logger/utils/streams/DetoxJSONLParser.js

@@ -0,0 +1,31 @@
+const JsonlParser = require('stream-json/jsonl/Parser');
+
+const { through } = require('./transformers');
+
+class DetoxJSONLParser {
+  constructor(log) {
+    this._log = log;
+  }
+
+  createTransformer() {
+    const log = this._log;
+    const readable = through();
+    const writable = JsonlParser.make({ checkErrors: true })
+      .on('error', (err) => {
+        /* istanbul ignore else */
+        if (err instanceof SyntaxError) {
+          log.debug({ err });
+          readable.end();
+        } else {
+          readable.emit('error', err);
+        }
+      });
+
+    return {
+      writable,
+      readable: writable.pipe(readable),
+    };
+  }
+}
+
+module.exports = DetoxJSONLParser;

package/src/logger/utils/streams/JSONLStringer.js

@@ -0,0 +1,55 @@
+const { Transform } = require('stream');
+
+class JSONLStringer extends Transform {
+  constructor({ replacer, header, delimiter, footer }) {
+    super({ writableObjectMode: true, readableObjectMode: false });
+
+    this._replacer = replacer;
+    this._header = header;
+    this._delimiter = delimiter;
+    this._footer = footer;
+  }
+
+  _transform(chunk, _, callback) {
+    if (this._header) {
+      this.push(this._header);
+    }
+
+    this.push(JSON.stringify(chunk, this._replacer));
+    this._transform = this._nextTransform;
+    callback(null);
+  }
+
+  _nextTransform(chunk, _, callback) {
+    this.push(this._delimiter + JSON.stringify(chunk, this._replacer));
+    callback(null);
+  }
+
+  _flush(callback) {
+    if (this._footer) {
+      this.push(this._footer);
+    }
+
+    callback();
+  }
+
+  static serializeJSONL() {
+    return new JSONLStringer({
+      replacer: undefined,
+      header: '',
+      delimiter: '\n',
+      footer: '',
+    });
+  }
+
+  static serializeJSON() {
+    return new JSONLStringer({
+      replacer: undefined,
+      header: '[\n\t',
+      delimiter: ',\n\t',
+      footer: '\n]\n',
+    });
+  }
+}
+
+module.exports = JSONLStringer;

package/src/logger/utils/streams/index.js

@@ -0,0 +1,7 @@
+const BunyanTransformer = require('./BunyanTransformer');
+const ChromeTraceTransformer = require('./ChromeTraceTransformer');
+
+module.exports = {
+  BunyanTransformer,
+  ChromeTraceTransformer,
+};

package/src/logger/utils/streams/transformers.js

@@ -0,0 +1,39 @@
+const { PassThrough, Transform } = require('stream');
+
+function through() {
+  return new PassThrough({ objectMode: true });
+}
+
+function mapTransform(fn) {
+  return new Transform({
+    objectMode: true,
+    transform(chunk, encoding, callback){
+      this.push(fn(chunk));
+      callback();
+    },
+  });
+}
+
+function flatMapTransform(fn) {
+  let index = 0;
+
+  return new Transform({
+    objectMode: true,
+    transform(chunk, encoding, callback){
+      const results = fn(chunk, index++);
+      // eslint-disable-next-line unicorn/no-array-method-this-argument
+      results.forEach(pushThis, this);
+      callback();
+    },
+  });
+}
+
+function pushThis(x) {
+  return this.push(x);
+}
+
+module.exports = {
+  through,
+  mapTransform,
+  flatMapTransform,
+};

package/src/logger/utils/tracerLegacy.js

@@ -0,0 +1,37 @@
+const methods = {
+  startSection(logger) {
+    return (msg, args) => {
+      if (args !== undefined) {
+        return logger.trace.begin(args, msg);
+      } else {
+        return logger.trace.begin(msg);
+      }
+    };
+  },
+
+  endSection(logger) {
+    return (_msg, args) => {
+      if (args !== undefined) {
+        return logger.trace.end(args);
+      } else {
+        return logger.trace.end();
+      }
+    };
+  },
+
+  traceCall(logger) {
+    return (name, action, args = {}) => logger.trace.complete(args, 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,71 @@
 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, DetoxLogFinalizer, installLegacyTracerInterface } = require('../logger');
 const symbols = require('../symbols');
 
 const DetoxConstants = require('./DetoxConstants');
 
+//#region Protected symbols
 const $cleanup = Symbol('cleanup');
-const $logger = Symbol('logger');
+const $logFinalizer = Symbol('logFinalizer');
 const $restoreSessionState = Symbol('restoreSessionState');
 const $sessionState = Symbol('restoreSessionState');
-const $tracer = Symbol('tracer');
-
-const _worker = Symbol('worker');
+const $status = Symbol('status');
+const $worker = Symbol('worker');
+//#endregion
 
 class DetoxContext {
   constructor() {
-    this[symbols.globalSetup] = this[symbols.globalSetup].bind(this);
-    this[symbols.globalTeardown] = this[symbols.globalTeardown].bind(this);
-    this[symbols.reportFailedTests] = this[symbols.reportFailedTests].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.reportTestResults] = this[symbols.reportTestResults].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);
+
+    this[$logFinalizer] = new DetoxLogFinalizer({
+      session: this[$sessionState],
+      logger: this[symbols.logger],
+    });
+
     /** @type {import('../DetoxWorker') | null} */
-    this[_worker] = null;
+    this[$worker] = null;
   }
 
   //#region Public members
@@ -62,91 +85,81 @@ class DetoxContext {
     return DetoxConstants;
   }
 
-  /**
-   * @returns {Detox.Logger}
-   */
-  get log() {
-    return this[$logger];
-  }
-
-  /**
-   * @returns {Detox.Tracer}
-   */
-  get trace() {
-    return this[$tracer];
-  }
   //#endregion
 
   //#region Internal members
-  [symbols.onRunStart] = (...args) => this[symbols.worker].onRunStart(...args);
   [symbols.onRunDescribeStart] = (...args) => this[symbols.worker].onRunDescribeStart(...args);
   [symbols.onTestStart] = (...args) => this[symbols.worker].onTestStart(...args);
-  [symbols.onHookStart] = (...args) => this[symbols.worker].onHookStart(...args);
   [symbols.onHookFailure] = (...args) => this[symbols.worker].onHookFailure(...args);
-  [symbols.onHookSuccess] = (...args) => this[symbols.worker].onHookSuccess(...args);
-  [symbols.onTestFnStart] = (...args) => this[symbols.worker].onTestFnStart(...args);
   [symbols.onTestFnFailure] = (...args) => this[symbols.worker].onTestFnFailure(...args);
-  [symbols.onTestFnSuccess] = (...args) => this[symbols.worker].onTestFnSuccess(...args);
   [symbols.onTestDone] = (...args) => this[symbols.worker].onTestDone(...args);
   [symbols.onRunDescribeFinish] = (...args) => this[symbols.worker].onRunDescribeFinish(...args);
-  [symbols.onRunFinish] = (...args) => this[symbols.worker].onRunFinish(...args);
   [symbols.config] = funpermaproxy(() => this[symbols.session].detoxConfig);
   [symbols.session] = funpermaproxy(() => this[$sessionState]);
+  [symbols.tracing] = Object.freeze({
+    createEventStream: () => this[$logFinalizer].createEventStream(),
+  });
   /** @abstract */
-  [symbols.reportFailedTests](_testFilePaths, _permanent) {}
+  [symbols.reportTestResults](_testResults) {}
   /**
    * @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 +176,9 @@ class DetoxContext {
 module.exports = DetoxContext;
 module.exports.protected = {
   $cleanup,
-  $logger,
+  $logFinalizer,
   $restoreSessionState,
+  $status,
   $sessionState,
-  $tracer,
+  $worker,
 };

package/src/realms/DetoxInternalsFacade.js

@@ -8,26 +8,22 @@ 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];
     this.onRunDescribeFinish = context[symbols.onRunDescribeFinish];
     this.onRunDescribeStart = context[symbols.onRunDescribeStart];
-    this.onRunFinish = context[symbols.onRunFinish];
-    this.onRunStart = context[symbols.onRunStart];
     this.onTestDone = context[symbols.onTestDone];
     this.onTestFnFailure = context[symbols.onTestFnFailure];
-    this.onTestFnStart = context[symbols.onTestFnStart];
-    this.onTestFnSuccess = context[symbols.onTestFnSuccess];
     this.onTestStart = context[symbols.onTestStart];
-    this.reportFailedTests = context[symbols.reportFailedTests];
+    this.reportTestResults = context[symbols.reportTestResults];
     this.resolveConfig = context[symbols.resolveConfig];
     this.session = context[symbols.session];
+    this.tracing = context[symbols.tracing];
     this.worker = funpermaproxy(() => context[symbols.worker]);
   }
 }