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

package/src/realms/DetoxPrimaryContext.js

@@ -1,24 +1,31 @@
-const path = require('path');
 const { URL } = require('url');
 
 const fs = require('fs-extra');
-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 { getCurrentCommand } = require('../utils/argparse');
+const uuid = require('../utils/uuid');
 
 const DetoxContext = require('./DetoxContext');
 
-const { $logger, $restoreSessionState, $sessionState } = DetoxContext.protected;
+// Protected symbols
+const { $logFinalizer, $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
 
-const _finalizeLogs = Symbol('finalizeLogs');
+//#region Private symbols
 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 _lifecycleLogger = Symbol('lifecycleLogger');
+const _sessionFile = Symbol('sessionFile');
+const _logFinalError = Symbol('logFinalError');
+//#endregion
 
 class DetoxPrimaryContext extends DetoxContext {
   constructor() {
@@ -27,21 +34,25 @@ class DetoxPrimaryContext extends DetoxContext {
     this[_dirty] = false;
     this[_wss] = null;
     this[_globalLifecycleHandler] = null;
+    /** Path to file where the initial session object is serialized */
+    this[_sessionFile] = '';
     /**
      * @type {import('../ipc/IPCServer') | null}
      */
     this[_ipcServer] = null;
+    /** @type {Detox.Logger} */
+    this[_lifecycleLogger] = this[symbols.logger].child({ cat: 'lifecycle' });
   }
 
   //#region Internal members
-  async [symbols.reportFailedTests](testFilePaths, permanent = false) {
+  async [symbols.reportTestResults](testResults) {
     if (this[_ipcServer]) {
-      this[_ipcServer].onFailedTests({ testFilePaths, permanent });
+      this[_ipcServer].onReportTestResults({ testResults });
     }
   }
 
   async [symbols.resolveConfig](opts = {}) {
-    const session = this[symbols.session];
+    const session = this[$sessionState];
     if (!session.detoxConfig) {
       const configuration = require('../configuration');
       session.detoxConfig = await configuration.composeDetoxConfig(opts);
@@ -52,9 +63,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,6 +74,8 @@ class DetoxPrimaryContext extends DetoxContext {
     }
 
     this[_dirty] = true;
+    onSignalExit(this[_emergencyTeardown]);
+
     const detoxConfig = await this[symbols.resolveConfig](opts);
 
     const {
@@ -71,18 +84,17 @@ class DetoxPrimaryContext extends DetoxContext {
       logger: loggerConfig,
       session: sessionConfig
     } = detoxConfig;
-    await this[$logger].setConfig(loggerConfig);
+    await this[symbols.logger].setConfig(loggerConfig);
 
-    this.trace.begin({
-      cat: 'lifecycle',
-      args: this[$sessionState],
-      name: process.argv.slice(1).join(' '),
-    });
+    this[_lifecycleLogger].trace.begin({
+      cwd: process.cwd(),
+      data: this[$sessionState],
+    }, getCurrentCommand());
 
     const IPCServer = require('../ipc/IPCServer');
     this[_ipcServer] = new IPCServer({
       sessionState: this[$sessionState],
-      logger: this[$logger],
+      logger: this[symbols.logger],
     });
 
     await this[_ipcServer].init();
@@ -111,101 +123,123 @@ 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;
+    this[_sessionFile] = temporary.for.json(this[$sessionState].id);
+    await fs.writeFile(this[_sessionFile], this[$sessionState].stringify());
+    process.env.DETOX_CONFIG_SNAPSHOT_PATH = this[_sessionFile];
+    this[_lifecycleLogger].trace(`Serialized the session state at: ${this[_sessionFile]}`);
 
-    // 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;
+  async [symbols.installWorker](opts = {}) {
+    const workerId = opts.workerId || 'worker';
+
     this[$sessionState].workerId = workerId;
     this[_ipcServer].onRegisterWorker({ workerId });
-    await super[symbols.setup](opts);
+
+    await super[symbols.installWorker]({ ...opts, workerId });
   }
 
   /** @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;
+      }
+
+      if (this[_sessionFile]) {
+        await fs.remove(this[_sessionFile]);
+      }
+
+      if (this[_dirty]) {
+        try {
+          this[_lifecycleLogger].trace.end();
+          await this[symbols.logger].close();
+          await this[$logFinalizer].finalize();
+        } catch (err) {
+          this[_logFinalError](err);
+        }
+      }
+    }
+  }
+
+  [_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;
+    if (this[_sessionFile]) {
+      fs.removeSync(this[_sessionFile]);
+    }
 
     try {
-      this.trace.end({ cat: 'lifecycle' });
-      await this[_finalizeLogs]();
+      this[_lifecycleLogger].trace.end({ abortSignal: signal });
+      this[symbols.logger].close().catch(this[_logFinalError]);
+      this[$logFinalizer].finalizeSync();
     } catch (err) {
-      this[$logger].error({ err }, 'Encountered an error while merging the process logs:');
+      this[_logFinalError](err);
     }
-  }
+  };
+
+  [_logFinalError] = (err) => {
+    this[_lifecycleLogger].error(err, 'Encountered an error while merging the process logs:');
+  };
+
   //#endregion
 
   //#region Protected members
   /**
    * @protected
    * @override
-   * @return {PrimarySessionState}
+   * @return {SessionState}
    */
   [$restoreSessionState]() {
-    return new PrimarySessionState({
-      detoxConfigSnapshotPath: temporary.for.json(),
+    return new SessionState({
+      id: uuid.UUID(),
       detoxIPCServer: `primary-${process.pid}`,
     });
   }
   //#endregion
 
   //#region Private members
-  async[_finalizeLogs]() {
-    const logs = [this[$logger].file, ...this[$sessionState].logFiles].filter(f => f && fs.existsSync(f));
-    if (logs.length === 0) {
-      return;
-    }
-
-    const streamUtils = require('../utils/streamUtils');
-    const { rootDir, plugins } = this[symbols.config].artifacts || {};
-    const logConfig = plugins && plugins.log || 'none';
-    const enabled = rootDir && (typeof logConfig === 'string' ? logConfig !== 'none' : logConfig.enabled);
-
-    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)));
-
-      const mergedStream = streamUtils
-        .mergeSortedJSONL(
-          logs.map(filePath => fs.createReadStream(filePath).pipe(streamUtils.readJSONL()))
-        );
-
-      await Promise.all([
-        pipe(mergedStream, streamUtils.writeJSONL(), out1Stream),
-        pipe(mergedStream, streamUtils.debugStream(this[$logger].config.options), out2Stream),
-        pipe(mergedStream, streamUtils.chromeTraceStream(), streamUtils.writeJSON(), out3Stream),
-      ]);
-    }
-
-    await Promise.all(logs.map(filepath => fs.remove(filepath)));
-  }
-
   async[_resetLockFile]() {
     const DeviceRegistry = require('../devices/DeviceRegistry');
 

package/src/realms/DetoxSecondaryContext.js

@@ -1,29 +1,33 @@
 const fs = require('fs');
 
 const { DetoxInternalError } = require('../errors');
-const { SecondarySessionState } = require('../ipc/state');
+const SessionState = require('../ipc/SessionState');
 const symbols = require('../symbols');
 
 const DetoxContext = require('./DetoxContext');
 
-const { $logger, $restoreSessionState, $sessionState } = DetoxContext.protected;
+// Protected symbols
+const { $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
+
+//#region Private symbols
 const _ipcClient = Symbol('ipcClient');
+//#endregion
 
 class DetoxSecondaryContext extends DetoxContext {
   constructor() {
     super();
 
     /**
-     * @protected
-     * @type {*}
+     * @private
+     * @type {import('../ipc/IPCClient')}
      */
     this[_ipcClient] = null;
   }
 
   //#region Internal members
-  async [symbols.reportFailedTests](testFilePaths, permanent = false) {
+  async [symbols.reportTestResults](testResults) {
     if (this[_ipcClient]) {
-      await this[_ipcClient].reportFailedTests(testFilePaths, permanent);
+      await this[_ipcClient].reportTestResults(testResults);
     } else {
       throw new DetoxInternalError('Detected an attempt to report failed tests using a non-initialized context.');
     }
@@ -34,41 +38,28 @@ class DetoxSecondaryContext extends DetoxContext {
   }
 
   /** @override */
-  async [symbols.globalSetup](_opts = {}) {
-    // This is a no-op function.
-    // It is forbidden to add any logic to `globalSetup` of the secondary context.
-    // Violating this principle will almost definitely break some flows, where it is
-    // not guaranteed that `globalSetup` will ever get called. See UML diagrams.
-  }
-
-  /** @override */
-  async [symbols.globalTeardown]() {
-    // This is a no-op function.
-    // It is forbidden to add any logic to `globalTeardown` of the secondary context.
-    // Violating this principle will almost definitely break some flows, where it is
-    // not guaranteed that `globalTeardown` will ever get called. See UML diagrams.
-  }
-
-  /** @override */
-  async [symbols.setup](opts) {
+  async [symbols.init](opts = {}) {
     const IPCClient = require('../ipc/IPCClient');
 
     this[_ipcClient] = new IPCClient({
       id: `secondary-${process.pid}`,
       state: this[$sessionState],
-      logger: this[$logger],
+      logger: this[symbols.logger],
     });
 
-    const workerId = opts.workerId || 1;
     await this[_ipcClient].init();
-    await this[_ipcClient].registerWorker(workerId);
-    await super[symbols.setup](opts);
+
+    if (opts.workerId !== null) {
+      await this[symbols.installWorker](opts);
+    }
   }
 
   /** @override */
-  async [symbols.teardown]() {
+  async [symbols.cleanup]() {
     try {
-      await super[symbols.teardown]();
+      if (this[$worker]) {
+        await this[symbols.uninstallWorker]();
+      }
     } finally {
       if (this[_ipcClient]) {
         await this[_ipcClient].dispose();
@@ -76,17 +67,23 @@ class DetoxSecondaryContext extends DetoxContext {
       }
     }
   }
+
+  /** @override */
+  async [symbols.installWorker](opts = {}) {
+    const workerId = opts.workerId || 'worker';
+    await this[_ipcClient].registerWorker(workerId);
+    await super[symbols.installWorker]({ ...opts, workerId });
+  }
   //#endregion
 
   //#region Protected members
-
   /**
    * @protected
    * @override
-   * @return {SecondarySessionState}
+   * @return {SessionState}
    */
   [$restoreSessionState]() {
-    return SecondarySessionState.parse(fs.readFileSync(process.env.DETOX_CONFIG_SNAPSHOT_PATH));
+    return SessionState.parse(fs.readFileSync(process.env.DETOX_CONFIG_SNAPSHOT_PATH));
   }
   //#endregion
 }

package/src/server/DetoxConnection.js

@@ -1,43 +1,37 @@
-// @ts-nocheck
 const _ = require('lodash');
-const { WebSocket } = require('ws'); // eslint-disable-line @typescript-eslint/no-unused-vars, no-unused-vars
 
 const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
-const logger = require('../utils/logger').child({ __filename, cat: 'ws-server,ws' });
+const logger = require('../utils/logger').child({ cat: 'ws-server,ws' });
 
 const AnonymousConnectionHandler = require('./handlers/AnonymousConnectionHandler');
 
-const EVENTS = {
-  NEW: { event: 'WSS_CONNECTION' },
-  GET: { event: 'WSS_GET_FROM' },
-  SEND: { event: 'WSS_SEND_TO' },
-  ERROR: { event: 'ERROR' },
-  SOCKET_ERROR: { event: 'WSS_SOCKET_ERROR' },
-};
-
 class DetoxConnection {
   /**
-   * @param {DetoxSessionManager} sessionManager
-   * @param {WebSocket} webSocket
-   * @param {Socket} socket
+   * @param {{
+   *   sessionManager: import('./DetoxSessionManager');
+   *   webSocket: import('ws');
+   *   socket: import('net').Socket;
+   * }} config
    */
   constructor({ sessionManager, webSocket, socket }) {
     this._onMessage = this._onMessage.bind(this);
     this._onError = this._onError.bind(this);
     this._onClose = this._onClose.bind(this);
 
-    this._log = logger.child({ trackingId: socket.remotePort });
+    this._log = logger.child({ id: socket.remotePort });
+    this._log.debug.begin(`connection :${socket.localPort}<->:${socket.remotePort}`);
+
     this._sessionManager = sessionManager;
     this._webSocket = webSocket;
     this._webSocket.on('message', this._onMessage);
     this._webSocket.on('error', this._onError);
     this._webSocket.on('close', this._onClose);
-    this._log.debug(EVENTS.NEW, 'registered a new connection.');
 
-    const log = this._log;
+    // eslint-disable-next-line unicorn/no-this-assignment
+    const self = this;
     this._handler = new AnonymousConnectionHandler({
       api: {
-        get log() { return log; },
+        get log() { return self._log; },
         appendLogDetails: (details) => { this._log = this._log.child(details); },
 
         registerSession: (params) => this._sessionManager.registerSession(this, params),
@@ -49,13 +43,13 @@ class DetoxConnection {
 
   sendAction(action) {
     const messageAsString = JSON.stringify(action);
-    this._log.trace(EVENTS.SEND, messageAsString);
+    this._log.trace({ data: action }, 'send');
     this._webSocket.send(messageAsString + '\n ');
   }
 
   _onMessage(rawData) {
     const data = _.isString(rawData) ? rawData : rawData.toString('utf8');
-    this._log.trace(EVENTS.GET, data);
+    this._log.trace({ data }, 'get');
 
     try {
       let action;
@@ -84,16 +78,17 @@ class DetoxConnection {
         this._handler.onError(handlerError, action);
       }
     } catch (error) {
-      this._log.warn({ ...EVENTS.ERROR }, error instanceof DetoxRuntimeError ? error.message : `${error}`);
+      this._log.warn({ error }, 'Caught unhandled error:');
     }
   }
 
-  _onError(e) {
-    this._log.warn(EVENTS.SOCKET_ERROR, DetoxRuntimeError.format(e));
+  _onError(error) {
+    this._log.warn({ error }, 'Caught socket error:');
   }
 
   _onClose() {
     this._sessionManager.unregisterConnection(this._webSocket);
+    this._log.debug.end();
   }
 }
 

package/src/server/DetoxServer.js

@@ -4,7 +4,7 @@ const WebSocket = require('ws');
 
 const { DetoxInternalError, DetoxRuntimeError } = require('../errors');
 const Deferred = require('../utils/Deferred');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-server,ws' });
 
 const DetoxSessionManager = require('./DetoxSessionManager');
 
@@ -40,18 +40,16 @@ class DetoxServer {
     await this._startListening();
 
     const level = this._options.standalone ? 'info' : 'debug';
-    log[level]({ event: 'WSS_CREATE' }, `Detox server listening on localhost:${this.port}...`);
+    log[level](`Detox server listening on localhost:${this.port}...`);
   }
 
   async close() {
     try {
       await this._closeWithTimeout(10000);
-      log.debug({ event: 'WSS_CLOSE' }, 'Detox server has been closed gracefully');
-    } catch (e) {
-      log.warn({ event: 'ERROR' },
-        `Detox server has been closed abruptly! See the error details below:\n`
-        + DetoxRuntimeError.format(e) + '\n'
-        + DetoxRuntimeError.reportIssue
+      log.debug('Detox server has been closed gracefully');
+    } catch (err) {
+      log.warn({ err },
+        `Detox server has been closed abruptly! See the error details below:`
       );
     }
   }
@@ -90,8 +88,7 @@ class DetoxServer {
     } else if (this._closing) {
       this._closing.reject(err);
     } else {
-      const formattedError = DetoxRuntimeError.format(err);
-      log.error('Detox server has got an unhandled error:\n' + formattedError);
+      log.error({ err }, 'Detox server has got an unhandled error:');
     }
   }
 

package/src/server/DetoxSession.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const DetoxInternalError = require('../errors/DetoxInternalError');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-server,ws-session' });
 
 class DetoxSession {
   /**
@@ -17,7 +17,7 @@ class DetoxSession {
     /** @type {boolean | null} */
     this._pendingTesterStatus = null;
 
-    log.trace({ event: 'SESSION_CREATED' }, `created session ${id}`);
+    log.trace(`created session ${id}`);
   }
 
   get id() {
@@ -120,7 +120,7 @@ class DetoxSession {
   }
 
   _notifyAboutAppConnect() {
-    log.trace({ event: 'SESSION_JOINED' }, `app joined session ${this.id}`);
+    log.trace(`app joined session ${this.id}`);
 
     if (!this._tester) {
       return;
@@ -132,7 +132,7 @@ class DetoxSession {
   }
 
   _notifyAboutAppDisconnect() {
-    log.trace({ event: 'SESSION_TORN' }, `app exited session ${this.id}`);
+    log.trace(`app exited session ${this.id}`);
 
     if (!this._tester) {
       return;
@@ -144,11 +144,11 @@ class DetoxSession {
   }
 
   _notifyAboutTesterConnect() {
-    log.trace({ event: 'SESSION_JOINED' }, `tester joined session ${this.id}`);
+    log.trace(`tester joined session ${this.id}`);
   }
 
   _notifyAboutTesterDisconnect() {
-    log.trace({ event: 'SESSION_TORN' }, `tester exited session ${this.id}`);
+    log.trace(`tester exited session ${this.id}`);
 
     if (!this._app) {
       return;

package/src/server/DetoxSessionManager.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const DetoxInternalError = require('../errors/DetoxInternalError');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-server,ws' });
 
 const DetoxConnection = require('./DetoxConnection');
 const DetoxSession = require('./DetoxSession');

package/src/server/handlers/RegisteredConnectionHandler.js

@@ -1,7 +1,6 @@
 // @ts-nocheck
 const { serializeError } = require('serialize-error');
 
-const DetoxError = require('../../errors/DetoxError');
 const DetoxInternalError = require('../../errors/DetoxInternalError');
 
 class RegisteredConnectionHandler {
@@ -41,7 +40,7 @@ class RegisteredConnectionHandler {
         messageId: action && action.messageId,
       });
     } catch (err) {
-      this._api.log.error('Cannot forward the error details to the tester due to the error:\n' + DetoxError.format(err));
+      this._api.log.error({ err }, 'Cannot forward the error details to the tester due to the error:');
       throw error;
     }
   }