chore: adds tracking for loading of saved connections along with few relevant parameters - VSCODE-446 (#565)

Co-authored-by: Alena Khineika <[email protected]>

Author: himanshusinghs

src/connectionController.ts

@@ -26,9 +26,7 @@ import {
 } from './storage/storageController';
 import { StorageController, StorageVariables } from './storage';
 import { StatusView } from './views';
-import TelemetryService, {
-  TelemetryEventTypes,
-} from './telemetry/telemetryService';
+import TelemetryService from './telemetry/telemetryService';
 import LINKS from './utils/links';
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const packageJSON = require('../package.json');
@@ -202,23 +200,36 @@ export default class ConnectionController {
       )
     ).filter((conn): conn is FailedMigrationConnectionDescriptor => !!conn);
 
-    if (Object.keys(this._connections).length) {
+    const loadedConnections = Object.values(this._connections);
+    if (loadedConnections.length) {
       this.eventEmitter.emit(DataServiceEventTypes.CONNECTIONS_DID_CHANGE);
     }
 
+    this._telemetryService.trackSavedConnectionsLoaded({
+      saved_connections: globalAndWorkspaceConnections.length,
+      loaded_connections: loadedConnections.length,
+      connections_with_secrets_in_keytar: loadedConnections.filter(
+        (connection) =>
+          connection.secretStorageLocation === SecretStorageLocation.Keytar
+      ).length,
+      connections_with_secrets_in_secret_storage: loadedConnections.filter(
+        (connection) =>
+          connection.secretStorageLocation ===
+          SecretStorageLocation.SecretStorage
+      ).length,
+    });
+
     if (connectionsThatDidNotMigrate.length) {
       log.error(
         `Could not migrate secrets for ${connectionsThatDidNotMigrate.length} connections`,
         connectionsThatDidNotMigrate
       );
-      this._telemetryService.track(
-        TelemetryEventTypes.KEYTAR_SECRETS_MIGRATION_FAILED,
-        {
-          totalConnections: globalAndWorkspaceConnections.length,
-          connectionsWithFailedKeytarMigration:
-            connectionsThatDidNotMigrate.length,
-        }
-      );
+      this._telemetryService.trackKeytarSecretsMigrationFailed({
+        saved_connections: globalAndWorkspaceConnections.length,
+        loaded_connections: loadedConnections.length,
+        connections_with_failed_keytar_migration:
+          connectionsThatDidNotMigrate.length,
+      });
       void vscode.window.showInformationMessage(
         keytarMigrationFailedMessage(connectionsThatDidNotMigrate.length)
       );

src/telemetry/telemetryService.ts

@@ -69,8 +69,21 @@ type PlaygroundLoadedTelemetryEventProperties = {
 };
 
 type KeytarSecretsMigrationFailedProperties = {
-  totalConnections: number;
-  connectionsWithFailedKeytarMigration: number;
+  saved_connections: number;
+  loaded_connections: number;
+  connections_with_failed_keytar_migration: number;
+};
+
+type SavedConnectionsLoadedProperties = {
+  // Total number of connections saved on disk
+  saved_connections: number;
+  // Total number of connections that extension was able to load, it might
+  // differ from saved_connections since there might be failures in loading
+  // secrets for a connection in which case we don't list the connections in the
+  // list of loaded connections.
+  loaded_connections: number;
+  connections_with_secrets_in_keytar: number;
+  connections_with_secrets_in_secret_storage: number;
 };
 
 export type TelemetryEventProperties =
@@ -84,7 +97,8 @@ export type TelemetryEventProperties =
   | PlaygroundCreatedTelemetryEventProperties
   | PlaygroundSavedTelemetryEventProperties
   | PlaygroundLoadedTelemetryEventProperties
-  | KeytarSecretsMigrationFailedProperties;
+  | KeytarSecretsMigrationFailedProperties
+  | SavedConnectionsLoadedProperties;
 
 export enum TelemetryEventTypes {
   PLAYGROUND_CODE_EXECUTED = 'Playground Code Executed',
@@ -99,6 +113,7 @@ export enum TelemetryEventTypes {
   AGGREGATION_EXPORTED = 'Aggregation Exported',
   PLAYGROUND_CREATED = 'Playground Created',
   KEYTAR_SECRETS_MIGRATION_FAILED = 'Keytar Secrets Migration Failed',
+  SAVED_CONNECTIONS_LOADED = 'Saved Connections Loaded',
 }
 
 /**
@@ -341,4 +356,22 @@ export default class TelemetryService {
       playground_type: playgroundType,
     });
   }
+
+  trackSavedConnectionsLoaded(
+    savedConnectionsLoadedProps: SavedConnectionsLoadedProperties
+  ) {
+    this.track(
+      TelemetryEventTypes.SAVED_CONNECTIONS_LOADED,
+      savedConnectionsLoadedProps
+    );
+  }
+
+  trackKeytarSecretsMigrationFailed(
+    keytarSecretsMigrationFailedProps: KeytarSecretsMigrationFailedProperties
+  ) {
+    this.track(
+      TelemetryEventTypes.KEYTAR_SECRETS_MIGRATION_FAILED,
+      keytarSecretsMigrationFailedProps
+    );
+  }
 }

src/test/suite/connectionController.test.ts

@@ -1679,7 +1679,10 @@ suite('Connection Controller Test Suite', function () {
             secretStorageLocation: SecretStorageLocation.Keytar,
           } as any)
       );
-      const trackStub = testSandbox.stub(testTelemetryService, 'track');
+      const trackStub = testSandbox.stub(
+        testTelemetryService,
+        'trackKeytarSecretsMigrationFailed'
+      );
 
       // Clear any connections and load so we get our stubbed connections from above.
       testConnectionController.clearAllConnections();
@@ -1694,8 +1697,11 @@ suite('Connection Controller Test Suite', function () {
       // Tracked
       assert.strictEqual(trackStub.calledOnce, true);
       assert.deepStrictEqual(trackStub.lastCall.args, [
-        'Keytar Secrets Migration Failed',
-        { totalConnections: 2, connectionsWithFailedKeytarMigration: 1 },
+        {
+          saved_connections: 2,
+          loaded_connections: 2,
+          connections_with_failed_keytar_migration: 1,
+        },
       ]);
     });
 
@@ -1740,7 +1746,10 @@ suite('Connection Controller Test Suite', function () {
             secretStorageLocation: SecretStorageLocation.Keytar,
           } as any)
       );
-      const trackStub = testSandbox.stub(testTelemetryService, 'track');
+      const trackStub = testSandbox.stub(
+        testTelemetryService,
+        'trackKeytarSecretsMigrationFailed'
+      );
 
       // Clear any connections and load so we get our stubbed connections from above.
       testConnectionController.clearAllConnections();
@@ -1749,8 +1758,78 @@ suite('Connection Controller Test Suite', function () {
       // No notification sent to the user
       assert.strictEqual(showInformationMessageStub.notCalled, true);
 
-      // No tracking done
+      // Tracks only the saved connections laoded event
       assert.strictEqual(trackStub.notCalled, true);
     });
+
+    test('should track SAVED_CONNECTIONS_LOADED event on load of saved connections', async () => {
+      testSandbox.replace(testStorageController, 'get', (key, storage) => {
+        if (
+          storage === StorageLocation.WORKSPACE ||
+          key === StorageVariables.WORKSPACE_SAVED_CONNECTIONS
+        ) {
+          return {};
+        }
+
+        return {
+          'random-connection-1': {
+            id: 'random-connection-1',
+            name: 'localhost:27017',
+            storageLocation: 'GLOBAL',
+            secretStorageLocation: SecretStorageLocation.SecretStorage,
+            connectionOptions: {
+              connectionString:
+                'mongodb://localhost:27017/?readPreference=primary&ssl=false',
+            },
+          },
+          'random-connection-2': {
+            id: 'random-connection-2',
+            name: 'localhost:27018',
+            storageLocation: 'GLOBAL',
+            secretStorageLocation: SecretStorageLocation.SecretStorage,
+            connectionOptions: {
+              connectionString:
+                'mongodb://localhost:27018/?readPreference=primary&ssl=false',
+            },
+          },
+          'random-connection-3': {
+            id: 'random-connection-3',
+            name: 'localhost:27018',
+            storageLocation: 'GLOBAL',
+            secretStorageLocation: SecretStorageLocation.Keytar,
+            connectionOptions: {
+              connectionString:
+                'mongodb://localhost:27018/?readPreference=primary&ssl=false',
+            },
+          },
+        } as any;
+      });
+      testSandbox.replace(
+        testConnectionController,
+        '_getConnectionInfoWithSecrets',
+        (connectionInfo) => Promise.resolve(connectionInfo as any)
+      );
+      const trackStub = testSandbox.stub(
+        testTelemetryService,
+        'trackSavedConnectionsLoaded'
+      );
+
+      // Clear any connections and load so we get our stubbed connections from above.
+      testConnectionController.clearAllConnections();
+      await testConnectionController.loadSavedConnections();
+
+      // Load connections tracked. Called once because in the current load of
+      // migration there were no errors and hence the error tracking event won't
+      // be called.
+      assert.strictEqual(trackStub.calledOnce, true);
+      assert.deepStrictEqual(trackStub.lastCall.args, [
+        {
+          connections_with_secrets_in_keytar: 1,
+          connections_with_secrets_in_secret_storage: 2,
+          saved_connections: 3,
+          loaded_connections: 3,
+        },
+      ]);
+    });
   });
 });

src/test/suite/telemetry/telemetryService.test.ts

@@ -716,4 +716,48 @@ suite('Telemetry Controller Test Suite', () => {
       );
     });
   });
+
+  test('track saved connections loaded', () => {
+    testTelemetryService.trackSavedConnectionsLoaded({
+      saved_connections: 3,
+      loaded_connections: 3,
+      connections_with_secrets_in_keytar: 0,
+      connections_with_secrets_in_secret_storage: 3,
+    });
+
+    sandbox.assert.calledWith(
+      fakeSegmentAnalyticsTrack,
+      sinon.match({
+        anonymousId,
+        event: 'Saved Connections Loaded',
+        properties: {
+          saved_connections: 3,
+          loaded_connections: 3,
+          connections_with_secrets_in_keytar: 0,
+          connections_with_secrets_in_secret_storage: 3,
+        },
+      })
+    );
+  });
+
+  test('track failed keytar secrets migrations', () => {
+    testTelemetryService.trackKeytarSecretsMigrationFailed({
+      saved_connections: 3,
+      loaded_connections: 3,
+      connections_with_failed_keytar_migration: 1,
+    });
+
+    sandbox.assert.calledWith(
+      fakeSegmentAnalyticsTrack,
+      sinon.match({
+        anonymousId,
+        event: 'Keytar Secrets Migration Failed',
+        properties: {
+          saved_connections: 3,
+          loaded_connections: 3,
+          connections_with_failed_keytar_migration: 1,
+        },
+      })
+    );
+  });
 });