feat(compass-collection): Collection Plugin Experimentation Assignment Integration – CLOUDP-333845

packages/compass-collection/src/index.ts

@@ -6,10 +6,14 @@ import {
   dataServiceLocator,
   type DataServiceLocator,
   type DataService,
+  connectionInfoRefLocator,
 } from '@mongodb-js/compass-connections/provider';
 import { collectionModelLocator } from '@mongodb-js/compass-app-stores/provider';
 import type { WorkspacePlugin } from '@mongodb-js/compass-workspaces';
 import { workspacesServiceLocator } from '@mongodb-js/compass-workspaces/provider';
+import { experimentationServiceLocator } from '@mongodb-js/compass-telemetry/provider';
+import { createLoggerLocator } from '@mongodb-js/compass-logging/provider';
+import { preferencesLocator } from 'compass-preferences-model/provider';
 import {
   CollectionWorkspaceTitle,
   CollectionPluginTitleComponent,
@@ -29,6 +33,10 @@ export const WorkspaceTab: WorkspacePlugin<typeof CollectionWorkspaceTitle> = {
       dataService: dataServiceLocator as DataServiceLocator<keyof DataService>,
       collection: collectionModelLocator,
       workspaces: workspacesServiceLocator,
+      experimentationServices: experimentationServiceLocator,
+      connectionInfoRef: connectionInfoRefLocator,
+      logger: createLoggerLocator('COMPASS-COLLECTION'),
+      preferences: preferencesLocator,
     }
   ),
   content: CollectionTab,

packages/compass-collection/src/modules/collection-tab.ts

@@ -5,6 +5,7 @@ import type AppRegistry from '@mongodb-js/compass-app-registry';
 import type { workspacesServiceLocator } from '@mongodb-js/compass-workspaces/provider';
 import type { CollectionSubtab } from '@mongodb-js/compass-workspaces';
 import type { DataService } from '@mongodb-js/compass-connections/provider';
+import type { experimentationServiceLocator } from '@mongodb-js/compass-telemetry';
 
 function isAction<A extends AnyAction>(
   action: AnyAction,
@@ -20,6 +21,7 @@ type CollectionThunkAction<R, A extends AnyAction = AnyAction> = ThunkAction<
     localAppRegistry: AppRegistry;
     dataService: DataService;
     workspaces: ReturnType<typeof workspacesServiceLocator>;
+    experimentationServices: ReturnType<typeof experimentationServiceLocator>;
   },
   A
 >;

packages/compass-collection/src/stores/collection-tab.spec.ts

@@ -6,6 +6,11 @@ import Sinon from 'sinon';
 import AppRegistry from '@mongodb-js/compass-app-registry';
 import { expect } from 'chai';
 import type { workspacesServiceLocator } from '@mongodb-js/compass-workspaces/provider';
+import type { experimentationServiceLocator } from '@mongodb-js/compass-telemetry';
+import type { connectionInfoRefLocator } from '@mongodb-js/compass-connections/provider';
+import { createNoopLogger } from '@mongodb-js/compass-logging/provider';
+import { ReadOnlyPreferenceAccess } from 'compass-preferences-model/provider';
+import { TestName } from '@mongodb-js/compass-telemetry/provider';
 
 const defaultMetadata = {
   namespace: 'test.foo',
@@ -32,6 +37,32 @@ const mockCollection = {
   },
 };
 
+const mockAtlasConnectionInfo = {
+  current: {
+    id: 'test-connection',
+    title: 'Test Connection',
+    connectionOptions: {
+      connectionString: 'mongodb://localhost:27017',
+    },
+    atlasMetadata: {
+      clusterName: 'test-cluster',
+      projectId: 'test-project',
+      orgId: 'test-org',
+      clusterUniqueId: 'test-cluster-unique-id',
+      clusterType: 'REPLICASET' as const,
+      clusterState: 'IDLE' as const,
+      metricsId: 'test-metrics-id',
+      metricsType: 'replicaSet' as const,
+      regionalBaseUrl: null,
+      instanceSize: 'M10',
+      supports: {
+        globalWrites: false,
+        rollingIndexes: true,
+      },
+    },
+  },
+};
+
 describe('Collection Tab Content store', function () {
   const sandbox = Sinon.createSandbox();
 
@@ -42,7 +73,19 @@ describe('Collection Tab Content store', function () {
 
   const configureStore = async (
     options: Partial<CollectionTabOptions> = {},
-    workspaces: Partial<ReturnType<typeof workspacesServiceLocator>> = {}
+    workspaces: Partial<ReturnType<typeof workspacesServiceLocator>> = {},
+    experimentationServices: Partial<
+      ReturnType<typeof experimentationServiceLocator>
+    > = {},
+    connectionInfoRef: Partial<
+      ReturnType<typeof connectionInfoRefLocator>
+    > = {},
+    logger = createNoopLogger('COMPASS-COLLECTION-TEST'),
+    preferences = new ReadOnlyPreferenceAccess({
+      enableGenAIFeatures: true,
+      enableGenAIFeaturesAtlasOrg: true,
+      cloudFeatureRolloutAccess: { GEN_AI_COMPASS: true },
+    })
   ) => {
     ({ store, deactivate } = activatePlugin(
       {
@@ -54,6 +97,10 @@ describe('Collection Tab Content store', function () {
         localAppRegistry,
         collection: mockCollection as any,
         workspaces: workspaces as any,
+        experimentationServices: experimentationServices as any,
+        connectionInfoRef: connectionInfoRef as any,
+        logger,
+        preferences,
       },
       { on() {}, cleanup() {} } as any
     ));
@@ -76,11 +123,112 @@ describe('Collection Tab Content store', function () {
       const store = await configureStore(undefined, {
         openCollectionWorkspaceSubtab,
       });
-      store.dispatch(selectTab('Documents'));
+      store.dispatch(selectTab('Documents') as any);
       expect(openCollectionWorkspaceSubtab).to.have.been.calledWith(
         'workspace-tab-id',
         'Documents'
       );
     });
   });
+
+  describe('experimentation integration', function () {
+    it('should assign experiment when Atlas metadata is available', async function () {
+      const assignExperiment = sandbox.spy(() => Promise.resolve(null));
+
+      await configureStore(
+        undefined,
+        {},
+        { assignExperiment },
+        mockAtlasConnectionInfo
+      );
+
+      await waitFor(() => {
+        expect(assignExperiment).to.have.been.calledOnceWith(
+          TestName.mockDataGenerator,
+          {
+            team: 'Atlas Growth',
+          }
+        );
+      });
+    });
+
+    it('should not assign experiment when Atlas metadata is missing', async function () {
+      const assignExperiment = sandbox.spy(() => Promise.resolve(null));
+      const mockConnectionInfoRef = {
+        current: {
+          id: 'test-connection',
+          title: 'Test Connection',
+          connectionOptions: {
+            connectionString: 'mongodb://localhost:27017',
+          },
+          // No atlasMetadata
+        },
+      };
+
+      await configureStore(
+        undefined,
+        {},
+        { assignExperiment },
+        mockConnectionInfoRef
+      );
+
+      // Wait a bit to ensure assignment would have happened if it was going to
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(assignExperiment).to.not.have.been.called;
+    });
+
+    it('should not assign experiment when AI features are disabled at the org level', async function () {
+      const assignExperiment = sandbox.spy(() => Promise.resolve(null));
+
+      const mockPreferences = new ReadOnlyPreferenceAccess({
+        enableGenAIFeatures: true,
+        enableGenAIFeaturesAtlasOrg: false, // Disabled at org level
+        cloudFeatureRolloutAccess: { GEN_AI_COMPASS: true },
+      });
+
+      const store = await configureStore(
+        undefined,
+        {},
+        { assignExperiment },
+        mockAtlasConnectionInfo,
+        undefined,
+        mockPreferences
+      );
+
+      // Wait a bit to ensure assignment would have happened if it was going to
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(assignExperiment).to.not.have.been.called;
+
+      // Store should still be functional
+      await waitFor(() => {
+        expect(store.getState())
+          .to.have.property('metadata')
+          .deep.eq(defaultMetadata);
+      });
+    });
+
+    it('should handle assignment errors gracefully', async function () {
+      const assignExperiment = sandbox.spy(() =>
+        Promise.reject(new Error('Assignment failed'))
+      );
+
+      await configureStore(
+        undefined,
+        {},
+        { assignExperiment },
+        mockAtlasConnectionInfo
+      );
+
+      await waitFor(() => {
+        expect(assignExperiment).to.have.been.calledOnce;
+      });
+
+      // Store should still be functional despite assignment error
+      await waitFor(() => {
+        expect(store.getState())
+          .to.have.property('metadata')
+          .deep.eq(defaultMetadata);
+      });
+    });
+  });
 });

packages/compass-collection/src/stores/collection-tab.ts

@@ -9,6 +9,14 @@ import reducer, {
 import type { Collection } from '@mongodb-js/compass-app-stores/provider';
 import type { ActivateHelpers } from '@mongodb-js/compass-app-registry';
 import type { workspacesServiceLocator } from '@mongodb-js/compass-workspaces/provider';
+import type { experimentationServiceLocator } from '@mongodb-js/compass-telemetry';
+import type { connectionInfoRefLocator } from '@mongodb-js/compass-connections/provider';
+import type { Logger } from '@mongodb-js/compass-logging/provider';
+import {
+  isAIFeatureEnabled,
+  type PreferencesAccess,
+} from 'compass-preferences-model/provider';
+import { TestName } from '@mongodb-js/compass-telemetry/provider';
 
 export type CollectionTabOptions = {
   /**
@@ -31,18 +39,29 @@ export type CollectionTabServices = {
   collection: Collection;
   localAppRegistry: AppRegistry;
   workspaces: ReturnType<typeof workspacesServiceLocator>;
+  experimentationServices: ReturnType<typeof experimentationServiceLocator>;
+  connectionInfoRef: ReturnType<typeof connectionInfoRefLocator>;
+  logger: Logger;
+  preferences: PreferencesAccess;
 };
 
 export function activatePlugin(
   { namespace, editViewName, tabId }: CollectionTabOptions,
   services: CollectionTabServices,
   { on, cleanup }: ActivateHelpers
-) {
+): {
+  store: ReturnType<typeof createStore>;
+  deactivate: () => void;
+} {
   const {
     dataService,
     collection: collectionModel,
     localAppRegistry,
     workspaces,
+    experimentationServices,
+    connectionInfoRef,
+    logger,
+    preferences,
   } = services;
 
   if (!collectionModel) {
@@ -64,6 +83,7 @@ export function activatePlugin(
         dataService,
         workspaces,
         localAppRegistry,
+        experimentationServices,
       })
     )
   );
@@ -86,6 +106,25 @@ export function activatePlugin(
 
   void collectionModel.fetchMetadata({ dataService }).then((metadata) => {
     store.dispatch(collectionMetadataFetched(metadata));
+
+    // Assign experiment for Mock Data Generator
+    // Only assign when we're connected to Atlas and the org-level setting for AI features is enabled
+    if (
+      connectionInfoRef.current?.atlasMetadata?.clusterName && // Ensures we only assign in Atlas
+      isAIFeatureEnabled(preferences.getPreferences()) // Ensures org-level AI features setting is enabled
+    ) {
+      void experimentationServices
+        .assignExperiment(TestName.mockDataGenerator, {
+          team: 'Atlas Growth',
+        })
+        .catch((error) => {
+          logger.debug('Mock Data Generator experiment assignment failed', {
+            experiment: TestName.mockDataGenerator,
+            namespace: namespace,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        });
+    }
   });
 
   return {

packages/compass-telemetry/src/experimentation-provider.tsx

@@ -1,15 +1,16 @@
 import React, { createContext, useContext, useRef } from 'react';
 import type { types } from '@mongodb-js/mdb-experiment-js';
 import type { typesReact } from '@mongodb-js/mdb-experiment-js/react';
+import type { TestName } from './growth-experiments';
 
 type UseAssignmentHook = (
-  experimentName: string,
+  experimentName: TestName,
   trackIsInSample: boolean,
   options?: typesReact.UseAssignmentOptions<types.TypeData>
 ) => typesReact.UseAssignmentResponse<types.TypeData>;
 
 type AssignExperimentFn = (
-  experimentName: string,
+  experimentName: TestName,
   options?: types.AssignOptions<string>
 ) => Promise<types.AsyncStatus | null>;
 
@@ -34,7 +35,7 @@ const initialContext: CompassExperimentationProviderContextValue = {
   },
 };
 
-const ExperimentationContext =
+export const ExperimentationContext =
   createContext<CompassExperimentationProviderContextValue>(initialContext);
 
 // Provider component that accepts MMS experiment utils as props

packages/compass-telemetry/src/growth-experiments.ts

@@ -1,3 +1,4 @@
 export enum TestName {
   earlyJourneyIndexesGuidance = 'EARLY_JOURNEY_INDEXES_GUIDANCE_20250328',
+  mockDataGenerator = 'MOCK_DATA_GENERATOR_20251001',
 }

packages/compass-telemetry/src/index.ts

@@ -7,3 +7,4 @@ export type {
 } from './types';
 
 export { CompassExperimentationProvider } from './experimentation-provider';
+export { TestName } from './growth-experiments';

packages/compass-telemetry/src/provider.tsx

@@ -1,9 +1,11 @@
-import React, { useRef } from 'react';
+import React, { useRef, useContext } from 'react';
 import { createServiceLocator } from '@mongodb-js/compass-app-registry';
 import { createTrack, type TelemetryServiceOptions } from './generic-track';
 import { useLogger } from '@mongodb-js/compass-logging/provider';
 import type { TrackFunction } from './types';
 import { TestName } from './growth-experiments';
+import { ExperimentationContext } from './experimentation-provider';
+import type { types } from '@mongodb-js/mdb-experiment-js';
 
 const noop = () => {
   // noop
@@ -47,6 +49,22 @@ export function useTelemetry(): TrackFunction {
   return track;
 }
 
+export interface ExperimentationServices {
+  assignExperiment: (
+    experimentName: TestName,
+    options?: types.AssignOptions<string>
+  ) => Promise<types.AsyncStatus | null>;
+}
+
+// Service locator for experimentation services (non-component access)
+export const experimentationServiceLocator = createServiceLocator(
+  function useExperimentationServices(): ExperimentationServices {
+    const { assignExperiment } = useContext(ExperimentationContext);
+    return { assignExperiment };
+  },
+  'experimentationServiceLocator'
+);
+
 type FirstArgument<F> = F extends (...args: [infer A, ...any]) => any
   ? A
   : F extends { new (...args: [infer A, ...any]): any }