Merge remote-tracking branch 'origin/main' into beta-releases

Author: github-actions[bot]

THIRD-PARTY-NOTICES.md

@@ -1,5 +1,5 @@
 The following third-party software is used by and included in **Mongodb Compass**.
-This document was automatically generated on Sun Feb 02 2025.
+This document was automatically generated on Tue Feb 04 2025.
 
 ## List of dependencies
 

docs/tracking-plan.md

@@ -7,7 +7,7 @@
 > the tracking plan for the specific Compass version you can use the following
 > URL: `https://github.com/mongodb-js/compass/blob/<compass version>/docs/tracking-plan.md`
 
-Generated on Sun, Feb 2, 2025
+Generated on Tue, Feb 4, 2025
 
 ## Table of Contents
 

packages/compass-schema/src/modules/schema-analysis.ts

@@ -64,6 +64,7 @@ export const analyzeSchema = async (
       },
       {
         abortSignal,
+        fallbackReadPreference: 'secondaryPreferred',
       }
     );
     const schemaData = await mongodbSchema(docs);

packages/compass-schema/src/stores/reducer.ts

@@ -1,5 +1,6 @@
 import type { Schema } from 'mongodb-schema';
 import type { Action, AnyAction, Reducer } from 'redux';
+import type { AggregateOptions } from 'mongodb';
 import { type AnalysisState } from '../constants/analysis-states';
 import {
   ANALYSIS_STATE_ANALYZING,
@@ -250,7 +251,7 @@ export const startAnalysis = (): SchemaThunkAction<
       fields: query.project ?? undefined,
     };
 
-    const driverOptions = {
+    const driverOptions: AggregateOptions = {
       maxTimeMS: capMaxTimeMSAtPreferenceLimit(preferences, query.maxTimeMS),
     };
 

packages/compass-schema/src/stores/store.spec.ts

@@ -1,4 +1,5 @@
-import { activateSchemaPlugin, type SchemaStore } from './store';
+import { activateSchemaPlugin } from './store';
+import type { SchemaStore, SchemaPluginServices } from './store';
 import AppRegistry, { createActivateHelpers } from 'hadron-app-registry';
 import { expect } from 'chai';
 
@@ -7,7 +8,6 @@ import { createSandboxFromDefaultPreferences } from 'compass-preferences-model';
 import { createNoopLogger } from '@mongodb-js/compass-logging/provider';
 import type { FieldStoreService } from '@mongodb-js/compass-field-store';
 import { createNoopTrack } from '@mongodb-js/compass-telemetry/provider';
-import type { ConnectionInfoRef } from '@mongodb-js/compass-connections/provider';
 import { startAnalysis, stopAnalysis } from './reducer';
 import Sinon from 'sinon';
 
@@ -26,46 +26,61 @@ const mockQueryBar = {
 };
 
 describe('Schema Store', function () {
-  describe('#configureStore', function () {
-    let store: SchemaStore;
-    let deactivate: () => void;
-    let sandbox: Sinon.SinonSandbox;
-    const localAppRegistry = new AppRegistry();
-    const globalAppRegistry = new AppRegistry();
-    const namespace = 'db.coll';
+  let store: SchemaStore;
+  let deactivate: () => void;
+  let sandbox: Sinon.SinonSandbox;
+  const localAppRegistry = new AppRegistry();
+  const globalAppRegistry = new AppRegistry();
+  const namespace = 'db.coll';
+  let sampleStub: Sinon.SinonStub;
+  let isCancelErrorStub: Sinon.SinonStub;
+
+  beforeEach(function () {
+    sandbox = Sinon.createSandbox();
+    sampleStub = sandbox.stub();
+    isCancelErrorStub = sandbox.stub();
+  });
+
+  async function createStore(services: Partial<SchemaPluginServices> = {}) {
+    const dataService = {
+      sample: sampleStub,
+      isCancelError: isCancelErrorStub,
+    };
     const connectionInfoRef = {
-      current: {},
-    } as ConnectionInfoRef;
-    let sampleStub: Sinon.SinonStub;
-    let isCancelErrorStub: Sinon.SinonStub;
+      current: {
+        connectionOptions: {
+          connectionString: 'mongodb://localhost:27017',
+        },
+        title: 'test',
+        id: 'test',
+      },
+    };
+
+    const plugin = activateSchemaPlugin(
+      {
+        namespace: namespace,
+      },
+      {
+        localAppRegistry: localAppRegistry,
+        globalAppRegistry: globalAppRegistry,
+        dataService,
+        logger: dummyLogger,
+        track: dummyTrack,
+        preferences: await createSandboxFromDefaultPreferences(),
+        fieldStoreService: mockFieldStoreService,
+        queryBar: mockQueryBar as any,
+        connectionInfoRef,
+        ...services,
+      },
+      createActivateHelpers()
+    );
+    store = plugin.store;
+    deactivate = () => plugin.deactivate();
+  }
 
+  describe('#configureStore', function () {
     beforeEach(async function () {
-      sandbox = Sinon.createSandbox();
-      sampleStub = sandbox.stub();
-      isCancelErrorStub = sandbox.stub();
-      const dataService = {
-        sample: sampleStub,
-        isCancelError: isCancelErrorStub,
-      };
-      const plugin = activateSchemaPlugin(
-        {
-          namespace: namespace,
-        },
-        {
-          localAppRegistry: localAppRegistry,
-          globalAppRegistry: globalAppRegistry,
-          dataService: dataService as any,
-          logger: dummyLogger,
-          track: dummyTrack,
-          preferences: await createSandboxFromDefaultPreferences(),
-          fieldStoreService: mockFieldStoreService,
-          queryBar: mockQueryBar as any,
-          connectionInfoRef,
-        },
-        createActivateHelpers()
-      );
-      store = plugin.store;
-      deactivate = () => plugin.deactivate();
+      await createStore();
     });
 
     afterEach(function () {
@@ -107,5 +122,37 @@ describe('Schema Store', function () {
       await analysisPromise;
       expect(store.getState().analysisState).to.equal('initial');
     });
+
+    it('runs the analysis with fallback read pref secondaryPreferred', async function () {
+      sampleStub.resolves([{ name: 'Hans' }, { name: 'Greta' }]);
+      await store.dispatch(startAnalysis());
+      expect(sampleStub.getCall(0).args[3])
+        .property('fallbackReadPreference')
+        .to.equal('secondaryPreferred');
+    });
+  });
+
+  describe('with a connection string with explicit read preference set', function () {
+    beforeEach(async function () {
+      await createStore({
+        connectionInfoRef: {
+          current: {
+            connectionOptions: {
+              connectionString:
+                'mongodb://localhost:27017/?readPreference=primary',
+            },
+            title: 'test',
+            id: 'test',
+          },
+        },
+      });
+    });
+
+    it('does not set read preference to secondaryPreferred', async function () {
+      await store.dispatch(startAnalysis());
+      expect(sampleStub.getCall(0).args[2]).not.to.have.property(
+        'readPreference'
+      );
+    });
   });
 });

packages/compass/src/app/utils/telemetry.ts

@@ -5,6 +5,8 @@ import { getCloudInfo } from 'mongodb-cloud-info';
 import ConnectionString from 'mongodb-connection-string-url';
 import resolveMongodbSrv from 'resolve-mongodb-srv';
 import type { KMSProviders, MongoClientOptions } from 'mongodb';
+import { createLogger } from '@mongodb-js/compass-logging';
+const { debug, log, mongoLogId } = createLogger('COMPASS-TELEMETRY');
 
 type HostInformation = {
   is_localhost: boolean;
@@ -38,6 +40,14 @@ async function getPublicCloudInfo(host: string): Promise<{
       public_cloud_name,
     };
   } catch (err) {
+    debug(`getCloudInfo failed for "${host}": ${(err as Error).message}`);
+
+    log.warn(
+      mongoLogId(1_001_000_341),
+      'getPublicCloudInfo',
+      'Failed to look up host cloud information for telemetry',
+      { host, error: (err as Error).message }
+    );
     return {};
   }
 }
@@ -148,7 +158,20 @@ async function getHostnameForConnection(
   );
   if (connectionStringData.isSRV) {
     const uri = await resolveMongodbSrv(connectionStringData.toString()).catch(
-      () => {
+      (err: unknown) => {
+        debug(
+          `resolveMongodbSrv failed for "${connectionStringData.hosts.join(
+            ','
+          )}": ${(err as Error).message}`
+        );
+
+        log.warn(
+          mongoLogId(1_001_000_340),
+          'resolveMongodbSrv',
+          'Failed to resolve mongodb srv for telemetry',
+          { hosts: connectionStringData.hosts, error: (err as Error).message }
+        );
+
         return null;
       }
     );

packages/data-service/src/data-service.spec.ts

@@ -7,6 +7,7 @@ import { Collection, MongoServerError } from 'mongodb';
 import { MongoClient } from 'mongodb';
 import { Int32, UUID } from 'bson';
 import sinon from 'sinon';
+import ConnectionStringUrl from 'mongodb-connection-string-url';
 import type { DataService } from './data-service';
 import { DataServiceImpl } from './data-service';
 import type {
@@ -1044,6 +1045,54 @@ describe('DataService', function () {
           { allowDiskUse: false }
         );
       });
+
+      it('allows to pass fallbackReadPreference and sets the read preference when unset', function () {
+        sandbox.spy(dataService, 'aggregate');
+        void dataService.sample(
+          'db.coll',
+          {},
+          {},
+          {
+            fallbackReadPreference: 'secondaryPreferred',
+          }
+        );
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(dataService.aggregate).to.have.been.calledWith(
+          'db.coll',
+          [{ $sample: { size: 1000 } }],
+          { allowDiskUse: true, readPreference: 'secondaryPreferred' }
+        );
+      });
+
+      it('allows to pass fallbackReadPreference and does not set the read preference when it is already set', function () {
+        sandbox.spy(dataService, 'aggregate');
+        const connectionStringReplacement = new ConnectionStringUrl(
+          cluster().connectionString
+        );
+        connectionStringReplacement.searchParams.set(
+          'readPreference',
+          'primary'
+        );
+        sandbox.replace(dataService as any, '_connectionOptions', {
+          connectionString: connectionStringReplacement.toString(),
+        });
+        void dataService.sample(
+          'db.coll',
+          {},
+          {},
+          {
+            fallbackReadPreference: 'secondaryPreferred',
+          }
+        );
+
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        expect(dataService.aggregate).to.have.been.calledWith(
+          'db.coll',
+          [{ $sample: { size: 1000 } }],
+          { allowDiskUse: true }
+        );
+      });
     });
 
     describe('#getLastSeenTopology', function () {

packages/data-service/src/data-service.ts

@@ -51,6 +51,7 @@ import type {
   ClientEncryptionDataKeyProvider,
   ClientEncryptionCreateDataKeyProviderOptions,
   SearchIndexDescription,
+  ReadPreferenceMode,
 } from 'mongodb';
 import ConnectionStringUrl from 'mongodb-connection-string-url';
 import parseNamespace from 'mongodb-ns';
@@ -126,6 +127,12 @@ function isEmptyObject(obj: Record<string, unknown>) {
   return Object.keys(obj).length === 0;
 }
 
+function isReadPreferenceSet(connectionString: string): boolean {
+  return !!new ConnectionStringUrl(connectionString).searchParams.get(
+    'readPreference'
+  );
+}
+
 let id = 0;
 
 type ClientType = 'CRUD' | 'META';
@@ -665,7 +672,9 @@ export interface DataService {
     ns: string,
     args?: { query?: Filter<Document>; size?: number; fields?: Document },
     options?: AggregateOptions,
-    executionOptions?: ExecutionOptions
+    executionOptions?: ExecutionOptions & {
+      fallbackReadPreference?: ReadPreferenceMode;
+    }
   ): Promise<Document[]>;
 
   /*** Insert ***/
@@ -2219,7 +2228,9 @@ class DataServiceImpl extends WithLogContext implements DataService {
       fields,
     }: { query?: Filter<Document>; size?: number; fields?: Document } = {},
     options: AggregateOptions = {},
-    executionOptions?: ExecutionOptions
+    executionOptions?: ExecutionOptions & {
+      fallbackReadPreference?: ReadPreferenceMode;
+    }
   ): Promise<Document[]> {
     const pipeline = [];
     if (query && Object.keys(query).length > 0) {
@@ -2246,6 +2257,15 @@ class DataServiceImpl extends WithLogContext implements DataService {
       pipeline,
       {
         allowDiskUse: true,
+        // When the read preference isn't set in the connection string explicitly,
+        // then we allow consumers to default to a read preference, for instance
+        // secondaryPreferred to avoid using the primary for analyzing documents.
+        ...(executionOptions?.fallbackReadPreference &&
+        !isReadPreferenceSet(this._connectionOptions.connectionString)
+          ? {
+              readPreference: executionOptions?.fallbackReadPreference,
+            }
+          : {}),
         ...options,
       },
       executionOptions