detox 21.0.0-breaking.new-global-lifecycle.0 → 21.0.1-rc.0

package/src/logger/utils/DetoxLogFinalizer.js

@@ -0,0 +1,166 @@
+const path = require('path');
+
+const fs = require('fs-extra');
+
+const temporary = require('../../artifacts/utils/temporaryPath');
+
+const { BunyanTransformer, ChromeTraceTransformer } = require('./streams');
+
+/**
+ * @typedef DetoxLogFinalizerConfig
+ * @property {import('../../ipc/SessionState')} session
+ * @property {import('../DetoxLogger')} logger
+ */
+
+class DetoxLogFinalizer {
+  /** @param {DetoxLogFinalizerConfig} config */
+  constructor(config) {
+    this._session = config.session;
+    this._bunyanTransformer = new BunyanTransformer(
+      config.logger.child({ cat: 'logger' }),
+    );
+    this._chromeTransformer = new ChromeTraceTransformer();
+  }
+
+  createEventStream() {
+    const sessionId = this._session.id;
+    const logs = temporary.find.jsonl.sync(`${sessionId}.*`);
+
+    const toChromeTrace = this._chromeTransformer.createStream();
+    return this._bunyanTransformer.uniteSessionLogs(logs).pipe(toChromeTrace);
+  }
+
+  async finalize() {
+    const sessionId = this._session.id;
+    const logs = await temporary.find.jsonl.async(`${sessionId}.*`);
+    if (logs.length === 0) {
+      return;
+    }
+
+    if (this._shouldSaveLogs()) {
+      const rootDir = this._config.artifacts.rootDir;
+
+      await fs.mkdirp(rootDir);
+
+      const firstPass = this._bunyanTransformer.uniteSessionLogs(logs);
+      await this._chromeTransformer.scanThreadIDs(firstPass);
+
+      const secondPass = this._bunyanTransformer.uniteSessionLogs(logs);
+      const outStreams = [this._createPlainFileStream(), this._createChromeTraceStream()];
+
+      await Promise.all(outStreams.map(stream => {
+        return new Promise((resolve, reject) => {
+          stream.target
+            .on('finish', resolve)
+            .on('error', reject);
+
+          secondPass.pipe(stream.writable);
+        });
+      }));
+    }
+
+    await Promise.all(logs.map(filepath => fs.remove(filepath)));
+  }
+
+  finalizeSync() {
+    const sessionId = this._session.id;
+    const logs = temporary.find.jsonl.sync(`${sessionId}.*`);
+    if (logs.length === 0) {
+      return;
+    }
+
+    const shouldSaveLogs = this._shouldSaveLogs(true);
+    const rootDir = shouldSaveLogs ? this._config.artifacts.rootDir : '';
+    if (shouldSaveLogs) {
+      fs.mkdirpSync(rootDir);
+    }
+
+    for (const log of logs) {
+      if (shouldSaveLogs) {
+        const dest = path.join(rootDir, path.basename(log));
+        this._safeMoveSync(log, dest);
+      } else {
+        this._safeRemoveSync(log);
+      }
+    }
+  }
+
+  _createPlainFileStream() {
+    const rootDir = this._config.artifacts.rootDir;
+    const bunyanOptions = this._config.logger.options;
+    const transformer = this._bunyanTransformer.createPlainTransformer(bunyanOptions);
+    const fileStream = fs.createWriteStream(path.join(rootDir, 'detox.log'));
+    transformer.readable.pipe(fileStream);
+
+    return { writable: transformer.writable, target: fileStream };
+  }
+
+  _createChromeTraceStream() {
+    const rootDir = this._config.artifacts.rootDir;
+    const transformer = this._chromeTransformer.createSerializedStream();
+    const fileStream = fs.createWriteStream(path.join(rootDir, 'detox.trace.json'));
+    transformer.readable.pipe(fileStream);
+
+    return { writable: transformer.writable, target: fileStream };
+  }
+
+  /* istanbul ignore next */
+  _safeMoveSync(src, dest) {
+    // Using console.* instead of logger.* because this is the end of the execution,
+    // and the logger is already closed.
+
+    try {
+      fs.moveSync(src, dest);
+    } catch (moveError) {
+      console.warn(`Failed to move a log file from: ${src}.\nReason: ${moveError.message}`);
+      try {
+        fs.copySync(src, dest);
+      } catch (copyError) {
+        console.warn(`Attempt to copy the file also failed.\nReason: ${copyError.message}`);
+      }
+    }
+  }
+
+  /* istanbul ignore next */
+  _safeRemoveSync(filepath) {
+    try {
+      fs.removeSync(filepath);
+    } catch (removeError) {
+      console.warn(`Failed to remove a log file at: ${filepath}.\nReason: ${removeError.message}`);
+    }
+  }
+
+  /** @private */
+  get _config() {
+    // The config appears later in the lifecycle, so we need to access it lazily
+    return this._session.detoxConfig;
+  }
+
+  /** @private */
+  _shouldSaveLogs(isEmergencyExit = false) {
+    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;
+    }
+
+    if (isEmergencyExit) {
+      return true;
+    }
+
+    return this._session.testResults.some(r => !r.success);
+  }
+}
+
+module.exports = DetoxLogFinalizer;

package/src/logger/utils/MessageStack.js

@@ -0,0 +1,35 @@
+const getMainCategory = require('./getMainCategory');
+
+class MessageStack {
+  constructor() {
+    this._map = {};
+  }
+
+  push(context, msg) {
+    const hash = this._hash(context);
+
+    if (this._map[hash] == null) {
+      this._map[hash] = [];
+    }
+
+    return this._map[hash].push(msg);
+  }
+
+  pop(context) {
+    const hash = this._hash(context);
+    const stack = this._map[hash];
+    if (stack == null || stack.length === 0) {
+      return ['<no begin message>'];
+    }
+
+    return stack.pop();
+  }
+
+  _hash(context) {
+    const cat = getMainCategory(context.cat);
+    const tid = context.tid;
+    return `${cat}:${tid}`;
+  }
+}
+
+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;

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({ cat: 'user', origin: getOrigin() }, util.format(...args));
   };
 }
 
 function proxyTracing(bunyanLoggerFn) {
   return (...args) => {
-    bunyanLoggerFn({ event: 'USER_LOG' }, getOrigin(), '\n  Trace:', util.format(...args), '\n\r' + getStackDump());
+    bunyanLoggerFn({ cat: 'user', 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({ cat: 'user', origin: getOrigin() }, 'AssertionError:', util.format(...args));
     }
   };
 }
@@ -47,19 +47,36 @@ function overrideConsoleMethods(console, bunyanLogger) {
   if (!console.__detox_log__) {
     const log = bunyanLogger;
 
+    console.__detox_log__ = {
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      trace: console.trace,
+      error: console.error,
+      debug: console.debug,
+      assert: console.assert,
+    };
+
     override(console, 'log', log.info.bind(log));
+    override(console, 'info', log.info.bind(log));
     override(console, 'warn', log.warn.bind(log));
     override(console, 'trace', log.info.bind(log));
     override(console, 'error', log.error.bind(log));
     override(console, 'debug', log.debug.bind(log));
     override(console, 'assert', log.error.bind(log));
-
-    console.__detox_log__ = log;
   }
 
   return console;
 }
 
+function restoreConsoleMethods(console) {
+  if (console.__detox_log__) {
+    Object.assign(console, console.__detox_log__);
+    delete console.__detox_log__;
+  }
+}
+
 module.exports = {
   overrideConsoleMethods,
+  restoreConsoleMethods,
 };

package/src/logger/utils/getMainCategory.js

@@ -0,0 +1,5 @@
+function getMainCategory(category) {
+  return category ? String(category).split(',', 1)[0] : 'undefined';
+}
+
+module.exports = getMainCategory;

package/src/logger/utils/sanitizeBunyanContext.js

@@ -0,0 +1,30 @@
+const _ = require('lodash');
+
+const RESERVED_PROPERTIES = [
+  'hostname',
+  'level',
+  'msg',
+  'name',
+  'pid',
+  'tid',
+  'ph',
+  '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 context && hasReservedProperties(context) ? _.mapKeys(context, escapeCallback) : context;
+}
+
+module.exports = sanitizeBunyanContext;

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

@@ -0,0 +1,72 @@
+const fs = require('fs');
+const { PassThrough } = require('stream');
+
+const bunyanDebugStream = require('bunyan-debug-stream');
+const multiSort = require('multi-sort-stream');
+const pipe = require('multipipe');
+const stripAnsi = require('strip-ansi');
+
+const DetoxJSONLParser = require('./DetoxJSONLParser');
+const { mapTransform, through } = require('./transformers');
+
+class BunyanTransformer {
+  /**
+   * @param {Detox.Logger} log
+   */
+  constructor(log) {
+    this._jsonlParser = new DetoxJSONLParser(log);
+  }
+
+  /**
+   * @param {string[]} logFilePaths
+   */
+  uniteSessionLogs(logFilePaths) {
+    const intermediate = mapTransform(BunyanTransformer.normalizeBunyanRecord);
+    const reemitError = (err) => intermediate.emit('error', err);
+
+    const jsonlStreams = logFilePaths.map(filePath => {
+      const { readable, writable } = this._jsonlParser.createTransformer();
+      fs.createReadStream(filePath)
+        .on('error', reemitError)
+        .pipe(writable);
+
+      return readable;
+    });
+
+    const multisorted = multiSort(jsonlStreams, BunyanTransformer.compareTimestamps);
+    return pipe(multisorted, intermediate, through());
+  }
+
+  createPlainTransformer(bunyanOptions) {
+    /** @type {*} */
+    const readable = new PassThrough({ encoding: 'utf8', objectMode: false });
+    const writable = bunyanDebugStream.default({
+      ...bunyanOptions,
+
+      colors: false,
+      out: readable,
+    });
+
+    writable.on('error', /* istanbul ignore next */ (err) => readable.emit('error', err));
+    writable.on('finish', () => readable.end());
+
+    return {
+      writable,
+      readable,
+    };
+  }
+
+  static normalizeBunyanRecord(record) {
+    const value = record.value;
+    value.msg = stripAnsi(value.msg);
+    value.time = new Date(value.time);
+
+    return value;
+  }
+
+  static compareTimestamps(a, b) {
+    return +(a.value.time > b.value.time) - +(a.value.time < b.value.time);
+  }
+}
+
+module.exports = BunyanTransformer;

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

@@ -0,0 +1,132 @@
+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, {
+      primaryPid: NaN,
+      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>; primaryPid: 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)) {
+      if (Number.isNaN(state.primaryPid)) {
+        state.primaryPid = pid;
+      }
+
+      builder.metadata({ pid, ts, name: 'process_name', args: { name: pid === state.primaryPid ? '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 }, 'Failed to parse log line:');
+          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,
+};