feat: align with Atlas CLI hashing and resolve device ID asynchronously

Author: gagik

packages/logging/src/logging-and-telemetry.spec.ts

@@ -7,6 +7,10 @@ import type { MongoshBus } from '@mongosh/types';
 import type { Writable } from 'stream';
 import type { MongoshLoggingAndTelemetry } from '.';
 import { setupLoggingAndTelemetry } from '.';
+import { getDeviceId } from './logging-and-telemetry';
+import sinon from 'sinon';
+import type { MongoshLoggingAndTelemetryArguments } from './types';
+import { eventually } from '../../../testing/eventually';
 
 describe('MongoshLoggingAndTelemetry', function () {
   let logOutput: any[];
@@ -32,20 +36,25 @@ describe('MongoshLoggingAndTelemetry', function () {
 
   let loggingAndTelemetry: MongoshLoggingAndTelemetry;
 
-  beforeEach(function () {
-    logOutput = [];
-    analyticsOutput = [];
-    bus = new EventEmitter();
-
-    loggingAndTelemetry = setupLoggingAndTelemetry({
-      bus,
+  const testLoggingArguments: Omit<MongoshLoggingAndTelemetryArguments, 'bus'> =
+    {
       analytics,
       deviceId: 'test-device',
       userTraits: {
         platform: process.platform,
         arch: process.arch,
       },
       mongoshVersion: '1.0.0',
+    };
+
+  beforeEach(function () {
+    logOutput = [];
+    analyticsOutput = [];
+    bus = new EventEmitter();
+
+    loggingAndTelemetry = setupLoggingAndTelemetry({
+      ...testLoggingArguments,
+      bus,
     });
 
     logger = new MongoLogWriter(logId, `/tmp/${logId}_log`, {
@@ -193,6 +202,94 @@ describe('MongoshLoggingAndTelemetry', function () {
     ]);
   });
 
+  describe('device ID', function () {
+    let loggingAndTelemetry: MongoshLoggingAndTelemetry;
+    let bus: EventEmitter;
+    beforeEach(function () {
+      bus = new EventEmitter();
+      loggingAndTelemetry = setupLoggingAndTelemetry({
+        ...testLoggingArguments,
+        bus,
+        deviceId: undefined,
+      });
+    });
+
+    it('uses device ID "unknown" if it fails to resolve it', async function () {
+      loggingAndTelemetry.attachLogger(logger);
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      sinon.stub(require('child_process'), 'exec').throws();
+
+      bus.emit('mongosh:new-user', { userId, anonymousId: userId });
+
+      await eventually(() => {
+        expect(analyticsOutput).deep.equal([
+          [
+            'identify',
+            {
+              deviceId: undefined,
+              anonymousId: userId,
+              traits: {
+                platform: process.platform,
+                arch: process.arch,
+                session_id: logId,
+              },
+            },
+          ],
+          [
+            'identify',
+            {
+              deviceId: 'unknown',
+              anonymousId: userId,
+              traits: {
+                platform: process.platform,
+                arch: process.arch,
+                session_id: logId,
+              },
+            },
+          ],
+        ]);
+      });
+      sinon.restore();
+    });
+
+    it('automatically sets up device ID for telemetry', async function () {
+      loggingAndTelemetry.attachLogger(logger);
+
+      bus.emit('mongosh:new-user', { userId, anonymousId: userId });
+
+      const deviceId = await getDeviceId();
+
+      await eventually(() => {
+        expect(analyticsOutput).deep.equal([
+          [
+            'identify',
+            {
+              deviceId: undefined,
+              anonymousId: userId,
+              traits: {
+                platform: process.platform,
+                arch: process.arch,
+                session_id: logId,
+              },
+            },
+          ],
+          [
+            'identify',
+            {
+              deviceId,
+              anonymousId: userId,
+              traits: {
+                platform: process.platform,
+                arch: process.arch,
+                session_id: logId,
+              },
+            },
+          ],
+        ]);
+      });
+    });
+  });
+
   it('detaching logger leads to no logging but persists analytics', function () {
     loggingAndTelemetry.attachLogger(logger);
 
@@ -1060,4 +1157,13 @@ describe('MongoshLoggingAndTelemetry', function () {
       ],
     ]);
   });
+
+  describe('getDeviceId()', function () {
+    it('is consistent on the same machine', async function () {
+      const idA = await getDeviceId();
+      const idB = await getDeviceId();
+
+      expect(idA).equals(idB);
+    });
+  });
 });

packages/logging/src/logging-and-telemetry.ts

@@ -52,29 +52,35 @@ import type {
   MongoshLoggingAndTelemetryArguments,
   MongoshTrackingProperties,
 } from './types';
-import { machineIdSync } from 'node-machine-id';
+import { machineId } from 'node-machine-id';
+import { createHmac } from 'crypto';
 
 export function setupLoggingAndTelemetry(
   props: MongoshLoggingAndTelemetryArguments
 ): MongoshLoggingAndTelemetry {
-  if (!props.deviceId) {
-    try {
-      props.deviceId = machineIdSync();
-    } catch (error) {
-      props.bus.emit(
-        'mongosh:error',
-        new Error('Failed to get device ID'),
-        'telemetry'
-      );
-    }
-  }
-
   const loggingAndTelemetry = new LoggingAndTelemetry(props);
 
   loggingAndTelemetry.setup();
   return loggingAndTelemetry;
 }
 
+/**
+ * @returns A hashed, unique identifier for the running device.
+ * @throws If something goes wrong when getting the device ID.
+ */
+export async function getDeviceId(): Promise<string> {
+  // Create a hashed format from the all uppercase version of the machine ID
+  // to match it exactly with the denisbrodbeck/machineid library that Atlas CLI uses.
+  const originalId = (await machineId(true)).toUpperCase();
+  const hmac = createHmac('sha256', originalId);
+
+  /** This matches the message used to create the hashes in Atlas CLI */
+  const DEVICE_ID_HASH_MESSAGE = 'atlascli';
+
+  hmac.update(DEVICE_ID_HASH_MESSAGE);
+  return hmac.digest('hex');
+}
+
 class LoggingAndTelemetry implements MongoshLoggingAndTelemetry {
   private static dummyLogger = new MongoLogWriter(
     '',
@@ -170,6 +176,7 @@ class LoggingAndTelemetry implements MongoshLoggingAndTelemetry {
     usesShellOption: false,
     telemetryAnonymousId: undefined,
     userId: undefined,
+    deviceId: undefined,
   };
 
   private setupBusEventListeners(): void {
@@ -207,15 +214,47 @@ class LoggingAndTelemetry implements MongoshLoggingAndTelemetry {
       session_id: this.log.logId,
     });
 
+    /** Eventually sets up the device ID and re-identifies the user. */
+    const getCurrentDeviceId = async (): Promise<string> => {
+      try {
+        this.busEventState.deviceId ??= this.deviceId ?? (await getDeviceId());
+      } catch (error) {
+        this.bus.emit('mongosh:error', error as Error, 'telemetry');
+        this.busEventState.deviceId = 'unknown';
+      }
+      return this.busEventState.deviceId;
+    };
+
     const getTelemetryUserIdentity = (): MongoshAnalyticsIdentity => {
       return {
+        deviceId: this.busEventState.deviceId ?? this.deviceId,
         anonymousId:
           this.busEventState.telemetryAnonymousId ??
           (this.busEventState.userId as string),
-        deviceId: this.deviceId,
       };
     };
 
+    const identifyUser = async (): Promise<void> => {
+      // We first instantly identify the user with the
+      // current user information we have.
+      this.analytics.identify({
+        ...getTelemetryUserIdentity(),
+        traits: getUserTraits(),
+      });
+
+      if (!this.busEventState.deviceId) {
+        // If the Device ID had not been resolved yet,
+        // we wait to resolve it and re-identify the user.
+        this.busEventState.deviceId ??= await getCurrentDeviceId();
+
+        this.analytics.identify({
+          ...getTelemetryUserIdentity(),
+          deviceId: await getCurrentDeviceId(),
+          traits: getUserTraits(),
+        });
+      }
+    };
+
     onBus('mongosh:start-mongosh-repl', (ev: StartMongoshReplEvent) => {
       this.log.info(
         'MONGOSH',
@@ -301,10 +340,8 @@ class LoggingAndTelemetry implements MongoshLoggingAndTelemetry {
         }
         this.busEventState.telemetryAnonymousId =
           newTelemetryUserIdentity.anonymousId;
-        this.analytics.identify({
-          ...getTelemetryUserIdentity(),
-          traits: getUserTraits(),
-        });
+
+        void identifyUser();
       }
     );
 
@@ -320,10 +357,7 @@ class LoggingAndTelemetry implements MongoshLoggingAndTelemetry {
         } else {
           this.busEventState.userId = updatedTelemetryUserIdentity.userId;
         }
-        this.analytics.identify({
-          ...getTelemetryUserIdentity(),
-          traits: getUserTraits(),
-        });
+        void identifyUser();
         this.log.info(
           'MONGOSH',
           mongoLogId(1_000_000_005),

packages/logging/src/types.ts

@@ -34,4 +34,5 @@ export type LoggingAndTelemetryBusEventState = {
   usesShellOption: boolean;
   telemetryAnonymousId: string | undefined;
   userId: string | undefined;
+  deviceId: string | undefined;
 };