fix(compass): move telemetry setup to main process entirely COMPASS-6113 COMPASS-6092 (#3534)

Set up telemetry entirely as part of the main process initialization, and use that
to ensure that telemetry events from CLI connection export/import are sent.

Author: addaleax

packages/compass-e2e-tests/helpers/commands/set-feature.ts

@@ -6,24 +6,13 @@ export async function setFeature(
   value: boolean | string
 ): Promise<void> {
   await browser.execute(
-    (_name, _value) => {
+    async (_name, _value) => {
       // eslint-disable-next-line @typescript-eslint/no-var-requires
-      require('electron').ipcRenderer.invoke('compass:save-preferences', {
+      await require('electron').ipcRenderer.invoke('compass:save-preferences', {
         [_name]: _value,
       });
     },
     name,
     value
   );
-
-  // Enable telemetry (CompassTelemetry.state).
-  // Setting the feature above, just updates it in the global hadron.
-  // Since the app has bootrapped already, we force update.
-  if (name === 'trackUsageStatistics') {
-    const event = value ? 'compass:usage:enabled' : 'compass:usage:disabled';
-    await browser.execute((_event) => {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      require('electron').ipcRenderer.call(_event);
-    }, event);
-  }
 }

packages/compass-e2e-tests/tests/import-export-connections.test.ts

@@ -4,13 +4,18 @@ import os from 'os';
 import path from 'path';
 import { promises as fs } from 'fs';
 import * as Selectors from '../helpers/selectors';
+import type { Telemetry } from '../helpers/telemetry';
+import { startTelemetryServer } from '../helpers/telemetry';
 
 describe('Connection Import / Export', function () {
   let tmpdir: string;
   let i = 0;
   let originalDisableKeychainUsage: string | undefined;
+  let telemetry: Telemetry;
 
   beforeEach(async function () {
+    telemetry = await startTelemetryServer();
+
     tmpdir = path.join(
       os.tmpdir(),
       `compass-import-export-${Date.now().toString(32)}-${++i}`
@@ -33,6 +38,8 @@ describe('Connection Import / Export', function () {
     else delete process.env.COMPASS_E2E_DISABLE_KEYCHAIN_USAGE;
 
     await fs.rmdir(tmpdir, { recursive: true });
+
+    await telemetry.stop();
   });
 
   for (const variant of ['plaintext', 'encrypted'] as const) {
@@ -59,6 +66,7 @@ describe('Connection Import / Export', function () {
       }
 
       {
+        const existingEventsCount = telemetry.events().length;
         // Export favorite, roughly verify file contents
         await runCompassOnce([
           `--export-connections=${file}`,
@@ -79,12 +87,18 @@ describe('Connection Import / Export', function () {
           );
           expect(conn.connectionSecrets).to.not.exist;
         } else {
-          console.log({ conn });
           expect(conn.connectionOptions.connectionString).to.equal(
             connectionStringWithoutCredentials
           );
           expect(conn.connectionSecrets).to.be.a('string');
         }
+
+        const newEvents = telemetry.events().slice(existingEventsCount);
+        expect(newEvents).to.have.lengthOf(1);
+        expect(newEvents[0].event).to.equal('Connection Exported');
+        expect(newEvents[0].properties.context).to.equal('CLI');
+        // inequality since we may have lingering connections from other test runs
+        expect(newEvents[0].properties.count).to.be.greaterThanOrEqual(1);
       }
 
       {
@@ -100,11 +114,19 @@ describe('Connection Import / Export', function () {
       }
 
       {
+        const existingEventsCount = telemetry.events().length;
         // Import favorite
         await runCompassOnce([
           `--import-connections=${file}`,
           ...passphraseArgs,
         ]);
+
+        const newEvents = telemetry.events().slice(existingEventsCount);
+        expect(newEvents).to.have.lengthOf(1);
+        expect(newEvents[0].event).to.equal('Connection Imported');
+        expect(newEvents[0].properties.context).to.equal('CLI');
+        // inequality since we may have lingering connections from other test runs
+        expect(newEvents[0].properties.count).to.be.greaterThanOrEqual(1);
       }
 
       {

packages/compass-e2e-tests/tests/logging.test.ts

@@ -139,27 +139,6 @@ describe('Logging and Telemetry integration', function () {
             expect(actual.cryptSharedLibPath).to.include('mongo_crypt_v1');
           },
         },
-        {
-          s: 'I',
-          c: 'COMPASS-TELEMETRY',
-          id: 1_001_000_095,
-          ctx: 'Telemetry',
-          msg: 'Disabling Telemetry reporting',
-        },
-        {
-          s: 'I',
-          c: 'COMPASS-TELEMETRY',
-          id: 1_001_000_093,
-          ctx: 'Telemetry',
-          msg: 'Loading telemetry config',
-          attr: (actual: any) => {
-            expect(actual.telemetryCapableEnvironment).to.equal(true);
-            expect(actual.hasAnalytics).to.equal(true);
-            expect(actual.currentUserId).to.not.exist;
-            expect(actual.telemetryAnonymousId).to.be.a('string');
-            expect(actual.state).to.equal('waiting-for-user-config');
-          },
-        },
         {
           s: 'I',
           c: 'COMPASS-APP',

packages/compass-preferences-model/src/preferences.ts

@@ -676,7 +676,7 @@ export class Preferences {
     changedPreferencesValues: Partial<AllPreferences>
   ): void {
     for (const callback of this._onPreferencesChangedCallbacks) {
-      return callback(changedPreferencesValues);
+      callback(changedPreferencesValues);
     }
   }
 

packages/compass/src/app/index.js

@@ -1,6 +1,5 @@
 const ipc = require('hadron-ipc');
 const remote = require('@electron/remote');
-const semver = require('semver');
 
 const { preferencesAccess: preferences } = require('compass-preferences-model');
 
@@ -195,39 +194,19 @@ const Application = View.extend({
   fetchUser: async function () {
     debug('getting user preferences');
     const {
-      currentUserId,
       telemetryAnonymousId,
-      trackUsageStatistics,
-      lastKnownVersion,
+      lastKnownVersion
     } = preferences.getPreferences();
 
-    // Check if uuid was stored as currentUserId, if not pass telemetryAnonymousId to fetch a user.
-    const user = await User.getOrCreate(currentUserId || telemetryAnonymousId);
-
-    const changedPreferences = { telemetryAnonymousId: user.id };
+    // The main process ensured that `telemetryAnonymousId` contains the id of the User model
+    const user = await User.getOrCreate(telemetryAnonymousId);
 
     this.user.set(user.serialize());
     this.user.trigger('sync');
     debug('user fetch successful', user.serialize());
 
     this.previousVersion = lastKnownVersion || '0.0.0';
-
-    if (semver.neq(this.previousVersion, APP_VERSION)) {
-      changedPreferences.lastKnownVersion = APP_VERSION;
-    }
-
-    const savedPreferences = await preferences.savePreferences(
-      changedPreferences
-    );
-
-    ipc.call('compass:usage:identify', {
-      currentUserId: savedPreferences.currentUserId,
-      telemetryAnonymousId: user.id,
-    });
-    ipc.call(
-      trackUsageStatistics ? 'compass:usage:enabled' : 'compass:usage:disabled'
-    );
-
+    await preferences.savePreferences({ lastKnownVersion: APP_VERSION });
     return user;
   },
 });

packages/compass/src/main/application.ts

@@ -10,7 +10,7 @@ import { CompassTelemetry } from './telemetry';
 import { CompassWindowManager } from './window-manager';
 import { CompassMenu } from './menu';
 import { setupCSFLELibrary } from './setup-csfle-library';
-import { setupPreferences } from 'compass-preferences-model';
+import { setupPreferencesAndUserModel } from './setup-preferences-and-user-model';
 import type { ParsedGlobalPreferencesResult } from 'compass-preferences-model';
 
 const debug = createDebug('mongodb-compass:main:application');
@@ -40,8 +40,9 @@ class CompassApplication {
     }
 
     this.setupUserDirectory();
-    await setupPreferences(globalPreferences);
-    await Promise.all([this.setupLogging(), this.setupTelemetry()]);
+    await setupPreferencesAndUserModel(globalPreferences);
+    await this.setupLogging();
+    await this.setupTelemetry();
 
     if (mode === 'CLI') {
       return;

packages/compass/src/main/setup-preferences-and-user-model.ts

@@ -0,0 +1,18 @@
+import type { ParsedGlobalPreferencesResult} from 'compass-preferences-model';
+import preferences, { setupPreferences } from 'compass-preferences-model';
+// @ts-expect-error no TS definitions available
+import User from 'compass-user-model';
+
+export async function setupPreferencesAndUserModel(globalPreferences: ParsedGlobalPreferencesResult): Promise<void> {
+  await setupPreferences(globalPreferences);
+
+  const {
+    currentUserId,
+    telemetryAnonymousId
+  } = preferences.getPreferences();
+
+  // Check if uuid was stored as currentUserId, if not pass telemetryAnonymousId to fetch a user.
+  const user = await User.getOrCreate(currentUserId || telemetryAnonymousId);
+  const changedPreferences = { telemetryAnonymousId: user.id };
+  await preferences.savePreferences(changedPreferences);
+}

packages/compass/src/main/telemetry.ts

@@ -5,6 +5,7 @@ import { createLoggerAndTelemetry } from '@mongodb-js/compass-logging';
 import type { CompassApplication } from './application';
 import type { EventEmitter } from 'events';
 import { getOsInfo } from './get-os-info';
+import preferences from 'compass-preferences-model';
 
 const { log, mongoLogId } = createLoggerAndTelemetry('COMPASS-TELEMETRY');
 
@@ -28,8 +29,7 @@ const telemetryCapableEnvironment = !!(
 
 class CompassTelemetry {
   private static analytics: Analytics | null = null;
-  private static state: 'enabled' | 'disabled' | 'waiting-for-user-config' =
-    'waiting-for-user-config';
+  private static state: 'enabled' | 'disabled' = 'disabled';
   private static queuedEvents: EventInfo[] = []; // Events that happen before we fetch user preferences
   private static currentUserId?: string; // Deprecated field. Should be used only for old users to keep their analytics in Segment.
   private static telemetryAnonymousId = ''; // The randomly generated anonymous user id.
@@ -56,7 +56,6 @@ class CompassTelemetry {
     const commonProperties = this._getCommonProperties();
 
     if (
-      this.state === 'waiting-for-user-config' ||
       !this.telemetryAnonymousId
     ) {
       this.queuedEvents.push(info);
@@ -126,50 +125,41 @@ class CompassTelemetry {
   }
 
   private static _init(app: typeof CompassApplication) {
-    process.on('compass:track', (meta: EventInfo) => {
-      this._track(meta);
-    });
-
-    ipcMain.respondTo('compass:track', (evt, meta: EventInfo) => {
-      (process as EventEmitter).emit('compass:track', meta);
-    });
-
-    ipcMain.respondTo(
-      'compass:usage:identify',
-      (evt, { currentUserId, telemetryAnonymousId }: { currentUserId?: string; telemetryAnonymousId: string }) => {
-        // This always happens after the first enable/disable call.
-        this.currentUserId = currentUserId;
-        this.telemetryAnonymousId = telemetryAnonymousId;
-        void this.identify();
-      }
-    );
-
-    ipcMain.respondTo('compass:usage:enabled', () => {
-      log.info(
-        mongoLogId(1_001_000_094),
-        'Telemetry',
-        'Enabling Telemetry reporting'
-      );
-      if (this.state !== 'enabled') {
+    const { trackUsageStatistics, currentUserId, telemetryAnonymousId } = preferences.getPreferences();
+    this.currentUserId = currentUserId;
+    this.telemetryAnonymousId = telemetryAnonymousId;
+    const onTrackUsageStatisticsChanged = (value: boolean) => {
+      if (value && this.state !== 'enabled') {
+        log.info(
+          mongoLogId(1_001_000_094),
+          'Telemetry',
+          'Enabling Telemetry reporting'
+        );
         this.state = 'enabled';
         void this.identify();
-      }
-    });
-
-    ipcMain.respondTo('compass:usage:disabled', () => {
-      log.info(
-        mongoLogId(1_001_000_095),
-        'Telemetry',
-        'Disabling Telemetry reporting'
-      );
-      if (this.state === 'enabled') {
+      } else if (!value && this.state !== 'disabled') {
+        log.info(
+          mongoLogId(1_001_000_095),
+          'Telemetry',
+          'Disabling Telemetry reporting'
+        );
         this._track({
           event: 'Telemetry Disabled',
           properties: {},
         });
         this.analytics?.flush();
+        this.state = 'disabled';
       }
-      this.state = 'disabled';
+    };
+    onTrackUsageStatisticsChanged(trackUsageStatistics); // initial setup with current value
+    preferences.onPreferenceValueChanged('trackUsageStatistics', onTrackUsageStatisticsChanged);
+
+    process.on('compass:track', (meta: EventInfo) => {
+      this._track(meta);
+    });
+
+    ipcMain.respondTo('compass:track', (evt, meta: EventInfo) => {
+      (process as EventEmitter).emit('compass:track', meta);
     });
 
     // only used in tests