feat: report os info telemetry COMPASS-5820 (#3086)

* feat: report os info

* make test pass

* remove unused package

* fix tests

* account for quotes in releases file

* remove unused export

* add channel and distribution to identify

* add common properties

* remove compass_full_version from e2e

Author: mcasimir

packages/compass-e2e-tests/helpers/commands/listen-for-telemetry-events.ts

@@ -29,6 +29,7 @@ export async function listenForTelemetryEvents(
     const ev = lookupNewEvent(eventName);
     const properties = { ...ev.properties };
     delete properties.compass_version;
+    delete properties.compass_full_version;
     delete properties.compass_distribution;
     delete properties.compass_channel;
     return properties;

packages/compass/package.json

@@ -164,8 +164,8 @@
     "clipboard": "^2.0.6",
     "kerberos": "^2.0.0",
     "keytar": "^7.7.0",
-    "os-dns-native": "^1.2.0",
     "mongodb-client-encryption": "^2.2.0-alpha.0",
+    "os-dns-native": "^1.2.0",
     "system-ca": "^1.0.2"
   },
   "devDependencies": {
@@ -272,8 +272,8 @@
     "web-vitals": "^2.1.2"
   },
   "optionalDependencies": {
-    "vscode-windows-registry": "1.0.2",
     "macos-export-certificate-and-key": "^1.1.1",
+    "vscode-windows-registry": "1.0.2",
     "win-export-certificate-and-key": "^1.1.1"
   },
   "engines": {

packages/compass/src/main/get-os-info.spec.ts

@@ -0,0 +1,57 @@
+import { expect } from 'chai';
+import os from 'os';
+import { promises as fs } from 'fs';
+
+import { getOsInfo } from './get-os-info';
+
+describe('get-os-info', function () {
+  let osInfo;
+  beforeEach(async function () {
+    osInfo = await getOsInfo();
+  });
+
+  it('returns info from "os" module', function () {
+    const { os_arch, os_type, os_version, os_release } = osInfo;
+    expect({ os_arch, os_type, os_version, os_release }).to.deep.equal({
+      os_arch: os.arch(),
+      os_type: os.type(),
+      os_version: os.version(),
+      os_release: os.release(),
+    });
+  });
+
+  describe('on linux', function () {
+    beforeEach(function () {
+      if (process.platform !== 'linux') {
+        this.skip();
+      }
+    });
+
+    it('returns info from /etc/releases', async function () {
+      const etcRelease = await fs.readFile('/etc/os-release', 'utf-8');
+
+      const releaseKv = etcRelease
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .map((l) => l.split('='));
+
+      const distroId = releaseKv
+        .find(([k]) => k === 'ID')[1]
+        .replace(/["']/g, '');
+      const distroVer = releaseKv
+        .find(([k]) => k === 'VERSION_ID')[1]
+        .replace(/["']/g, '');
+
+      // check that we test against actual values and not just an empty string
+      expect(distroId).to.match(/^(rhel|ubuntu|debian)$/);
+      expect(distroVer).to.match(/^\d+/);
+
+      const { os_linux_dist, os_linux_release } = osInfo;
+      expect({ os_linux_dist, os_linux_release }).to.deep.equal({
+        os_linux_dist: distroId,
+        os_linux_release: distroVer,
+      });
+    });
+  });
+});

packages/compass/src/main/get-os-info.ts

@@ -0,0 +1,56 @@
+import os from 'os';
+import { promises as fs } from 'fs';
+
+type OsInfo = {
+  os_type: string;
+  os_version: string;
+  os_arch: string;
+  os_release: string;
+  os_linux_dist?: string;
+  os_linux_release?: string;
+};
+
+async function getLinuxInfo(): Promise<{
+  os_linux_dist: string;
+  os_linux_release: string;
+}> {
+  try {
+    const releaseFile = '/etc/os-release';
+    const etcRelease = await fs.readFile(releaseFile, 'utf-8');
+
+    const releaseKv = etcRelease
+      .split('\n')
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .map((l) => l.split('='));
+
+    const distId = releaseKv
+      .find(([k]) => k === 'ID')?.[1]
+      .replace(/["']/g, '');
+    const distVer = releaseKv
+      .find(([k]) => k === 'VERSION_ID')?.[1]
+      .replace(/["']/g, '');
+
+    return {
+      os_linux_dist: distId || 'unknown',
+      os_linux_release: distVer || 'unknown',
+    };
+  } catch (e) {
+    // couldn't read /etc/os-release
+  }
+
+  return {
+    os_linux_dist: 'unknown',
+    os_linux_release: 'unknown',
+  };
+}
+
+export async function getOsInfo(): Promise<OsInfo> {
+  return {
+    os_type: os.type(),
+    os_version: os.version(),
+    os_arch: os.arch(),
+    os_release: os.release(),
+    ...(process.platform === 'linux' ? await getLinuxInfo() : {}),
+  };
+}

packages/compass/src/main/telemetry.ts

@@ -4,9 +4,9 @@ import { ipcMain } from 'hadron-ipc';
 import { createLoggerAndTelemetry } from '@mongodb-js/compass-logging';
 import type { CompassApplication } from './application';
 import type { EventEmitter } from 'events';
+import { getOsInfo } from './get-os-info';
 
-const { log, mongoLogId } =
-  createLoggerAndTelemetry('COMPASS-TELEMETRY');
+const { log, mongoLogId } = createLoggerAndTelemetry('COMPASS-TELEMETRY');
 
 interface EventInfo {
   event: string;
@@ -41,14 +41,24 @@ class CompassTelemetry {
 
   private static initPromise: Promise<void> | null = null;
 
-  private static _track(info: EventInfo) {
-    const commonProperties = {
-      compass_version: app.getVersion().split('.').slice(0, 2).join('.'), // only major.minor
+  private static _getCommonProperties() {
+    // Used in both track and identify to add common traits
+    // to any event that we send to segment
+    return {
+      compass_version: app.getVersion().split('.').slice(0, 2).join('.'),
+      compass_full_version: app.getVersion(),
       compass_distribution: process.env.HADRON_DISTRIBUTION,
       compass_channel: process.env.HADRON_CHANNEL,
     };
+  }
+
+  private static _track(info: EventInfo) {
+    const commonProperties = this._getCommonProperties();
 
-    if (this.state === 'waiting-for-user-config' || !this.telemetryAnonymousId) {
+    if (
+      this.state === 'waiting-for-user-config' ||
+      !this.telemetryAnonymousId
+    ) {
       this.queuedEvents.push(info);
       return;
     }
@@ -86,15 +96,28 @@ class CompassTelemetry {
         queuedEvents: this.queuedEvents.length,
       }
     );
-    if (this.state === 'enabled' && this.analytics && this.telemetryAnonymousId) {
-      this.analytics.identify({
-        userId: this.currentUserId,
-        anonymousId: this.telemetryAnonymousId,
-        traits: {
-          platform: process.platform,
-          arch: process.arch,
-        },
-      });
+    if (
+      this.state === 'enabled' &&
+      this.analytics &&
+      this.telemetryAnonymousId
+    ) {
+      void getOsInfo()
+        .catch(() => ({})) // still identify even if getOsInfo fails
+        .then((osInfo) => {
+          this.analytics?.identify({
+            userId: this.currentUserId,
+            anonymousId: this.telemetryAnonymousId,
+            traits: {
+              ...this._getCommonProperties(),
+              platform: process.platform,
+              arch: process.arch,
+              ...osInfo,
+            },
+          });
+        })
+        .catch(() => {
+          //
+        });
     }
 
     let event: EventInfo | undefined;
@@ -114,7 +137,7 @@ class CompassTelemetry {
 
     ipcMain.respondTo(
       'compass:usage:identify',
-      (evt, meta: { currentUserId?: string, telemetryAnonymousId: string }) => {
+      (evt, meta: { currentUserId?: string; telemetryAnonymousId: string }) => {
         // This always happens after the first enable/disable call.
         this.currentUserId = meta.currentUserId;
         this.telemetryAnonymousId = meta.telemetryAnonymousId;
@@ -165,7 +188,8 @@ class CompassTelemetry {
   }
 
   static init(app: typeof CompassApplication): Promise<void> {
-    return (this.initPromise ??= this._init(app));
+    this.initPromise ??= Promise.resolve(this._init(app));
+    return this.initPromise;
   }
 
   static track(info: EventInfo): void {