feat(tracking): connection tracking COMPASS-5192 (#2563)

Author: mabaasit

packages/compass-connect/package.json

@@ -105,6 +105,8 @@
     "mocha": "^7.0.1",
     "mocha-webpack": "^2.0.0-beta.0",
     "moment": "^2.27.0",
+    "mongodb-build-info": "^1.2.0",
+    "mongodb-cloud-info": "^1.1.3",
     "mongodb-connection-model": "^21.8.0",
     "mongodb-data-service": "^21.12.0",
     "mongodb-runner": "^4.8.3",

packages/compass-connect/src/stores/index.js

@@ -7,6 +7,8 @@ const StateMixin = require('reflux-state-mixin');
 const { promisify } = require('util');
 const { getConnectionTitle, convertConnectionModelToInfo } = require('mongodb-data-service');
 const debug = require('debug')('compass-connect:store');
+const { isAtlas, isLocalhost, isDigitalOcean } = require('mongodb-build-info');
+const { getCloudInfo } = require('mongodb-cloud-info');
 
 const Actions = require('../actions');
 const {
@@ -19,7 +21,7 @@ const ConnectionCollection = Connection.ConnectionCollection;
 const userAgent = navigator.userAgent.toLowerCase();
 
 const { createLoggerAndTelemetry } = require('@mongodb-js/compass-logging');
-const { log, mongoLogId } = createLoggerAndTelemetry('COMPASS-CONNECT-UI');
+const { log, track, mongoLogId } = createLoggerAndTelemetry('COMPASS-CONNECT-UI');
 
 /**
  * A default driverUrl.
@@ -311,6 +313,14 @@ const Store = Reflux.createStore({
       return;
     }
 
+    const { connectionModel } = this.state;
+    const trackEvent = {
+      is_favorite: connectionModel.isFavorite,
+      is_recent: Boolean(connectionModel.lastUsed && !connectionModel.isFavorite),
+      is_new: !connectionModel.lastUsed,
+    };
+    track('Connection Attempt', trackEvent);
+
     this.setState({
       currentConnectionAttempt: createConnectionAttempt(),
       connectingStatusText: LOADING_CONNECTION_TEXT
@@ -682,6 +692,7 @@ const Store = Reflux.createStore({
 
   /**
    * Resets the connection after clicking on the new connection section.
+   *
    */
   onResetConnectionClicked() {
     this.state.viewType = CONNECTION_STRING_VIEW;
@@ -960,6 +971,40 @@ const Store = Reflux.createStore({
     }
   },
 
+  async _trackConnectionInfo() {
+    const { dataService } = this;
+    const {
+      dataLake,
+      genuineMongoDB,
+      host,
+      build,
+    } = await dataService.instance();
+    const {
+      hostname,
+      authMechanism,
+    } = this.state.connectionModel;
+    const { isAws, isAzure, isGcp } = await getCloudInfo(hostname);
+    const isPublicCloud = isAws || isAzure || isGcp;
+    const publicCloudName = isAws ? 'AWS' : isAzure ? 'Azure' : isGcp ? 'GCP' : '';
+
+    const trackEvent = {
+      is_localhost: isLocalhost(hostname),
+      is_atlas: isAtlas(hostname),
+      is_dataLake: dataLake.isDataLake,
+      is_enterprise: build.isEnterprise,
+      is_public_cloud: isPublicCloud,
+      is_do: isDigitalOcean(hostname),
+      public_cloud_name: publicCloudName,
+      is_genuine: genuineMongoDB.isGenuine,
+      non_genuine_server_name: genuineMongoDB.dbType,
+      server_version: host.kernel_version,
+      server_arch: host.arch,
+      server_os_family: host.os_family,
+      auth_type: authMechanism ?? '',
+    };
+    track('New Connection', trackEvent);
+  },
+
   _onConnectSuccess(dataService, connectionInfo) {
     const connectionModel = this.state.connectionModel;
     const currentSaved = this.state.connections[connectionModel._id];
@@ -996,6 +1041,8 @@ const Store = Reflux.createStore({
     // bar, which is hidden after the instance information is loaded
     // in another plugin.
     this.StatusActions.showIndeterminateProgressBar();
+
+    void this._trackConnectionInfo();
   },
 
   /**

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

@@ -47,15 +47,15 @@ describe('Logging and Telemetry integration', function () {
         );
       });
 
-      it('contains an identify call', function () {
+      it('tracks an event for identify call', function () {
         const identify = telemetry
           .events()
           .find((entry) => entry.type === 'identify');
         expect(identify.traits.platform).to.equal(process.platform);
         expect(identify.traits.arch).to.equal(process.arch);
       });
 
-      it('contains a call for the welcome tour being closed', function () {
+      it('tracks an event for the welcome tour being closed', function () {
         const tourClosed = telemetry
           .events()
           .find((entry) => entry.event === 'Tour Closed');
@@ -66,21 +66,54 @@ describe('Logging and Telemetry integration', function () {
         expect(tourClosed.properties.compass_channel).to.be.a('string');
       });
 
-      it('contains call for shell use events', function () {
+      it('tracks an event for shell use', function () {
         const shellUse = telemetry
           .events()
           .find((entry) => entry.event === 'Shell Use');
         expect(shellUse.properties.compass_version).to.be.a('string');
       });
 
-      it('contains call for shell connection events', function () {
+      it('tracks an event for shell connection', function () {
         const shellNewConnection = telemetry
           .events()
           .find((entry) => entry.event === 'Shell New Connection');
         expect(shellNewConnection.properties.is_localhost).to.equal(true);
       });
 
-      it('contains calls for screens that were accessed', function () {
+      it('tracks an event for an attempt to establish a new connection', function () {
+        const connectionAttempt = telemetry
+          .events()
+          .find((entry) => entry.event === 'Connection Attempt');
+        expect(connectionAttempt.properties.is_favorite).to.equal(false);
+        expect(connectionAttempt.properties.is_recent).to.equal(false);
+        expect(connectionAttempt.properties.is_new).to.equal(true);
+      });
+
+      it('tracks an event when a connection is established', function () {
+        const connectionAttempt = telemetry
+          .events()
+          .find((entry) => entry.event === 'New Connection');
+        expect(connectionAttempt.properties.is_localhost).to.equal(true);
+        expect(connectionAttempt.properties.is_atlas).to.equal(false);
+        expect(connectionAttempt.properties.is_dataLake).to.equal(false);
+        expect(connectionAttempt.properties.is_enterprise).to.equal(false);
+        expect(connectionAttempt.properties.is_public_cloud).to.equal(false);
+        expect(connectionAttempt.properties.is_do).to.equal(false);
+
+        expect(connectionAttempt.properties.public_cloud_name).to.be.a(
+          'string'
+        );
+        expect(connectionAttempt.properties.is_genuine).to.be.a('boolean');
+        expect(connectionAttempt.properties.non_genuine_server_name).to.be.a(
+          'string'
+        );
+        expect(connectionAttempt.properties.server_version).to.be.a('string');
+        expect(connectionAttempt.properties.server_arch).to.be.a('string');
+        expect(connectionAttempt.properties.server_os_family).to.be.a('string');
+        expect(connectionAttempt.properties.auth_type).to.be.a('string');
+      });
+
+      it('tracks an event for screens that were accessed', function () {
         expect(telemetry.screens()).to.include('databases');
       });
     });
@@ -295,12 +328,10 @@ describe('Logging and Telemetry integration', function () {
       ];
 
       let criticalPathActualLogs;
+      const testedIndexes = new Set();
 
       // eslint-disable-next-line mocha/no-hooks-for-single-case
       before(function () {
-        const criticalPathIds = new Set(
-          criticalPathExpectedLogs.map((entry) => entry.id)
-        );
         criticalPathActualLogs = compassLog.filter((entry) => {
           // Remove most mongosh entries as they are quite noisy
           if (
@@ -312,29 +343,31 @@ describe('Logging and Telemetry integration', function () {
             return false;
           }
 
-          return criticalPathIds.has(entry.id);
+          return true;
         });
       });
 
       // eslint-disable-next-line mocha/no-setup-in-describe
-      criticalPathExpectedLogs.forEach((expected, i) => {
+      criticalPathExpectedLogs.forEach((expected) => {
         it(`logs "${expected.msg}"`, function () {
-          if (!criticalPathActualLogs[i]) {
+          const actualLogIndex = criticalPathActualLogs.findIndex(
+            ({ id }, index) => id === expected.id && !testedIndexes.has(index)
+          );
+          if (actualLogIndex < 0) {
             throw new Error(
-              `No criticalPathActualLog for index ${i} expected ${JSON.stringify(
-                expected
-              )} was empty`
+              `No actual log found for expected ${JSON.stringify(expected)}`
             );
           }
 
+          testedIndexes.add(actualLogIndex);
           const { attr: expectedAttr, ...expectedWithoutAttr } = expected;
-          const { attr: actualAttr, ...actualWihoutAttr } =
-            criticalPathActualLogs[i];
+          const { attr: actualAttr, ...actualWithoutAttr } =
+            criticalPathActualLogs[actualLogIndex];
 
           // Timestamps vary between each execution
-          delete actualWihoutAttr.t;
+          delete actualWithoutAttr.t;
 
-          expect(expectedWithoutAttr).to.deep.equal(actualWihoutAttr);
+          expect(expectedWithoutAttr).to.deep.equal(actualWithoutAttr);
 
           // we already know this would fail the expectation
           if (