chore(data-service, connections): make sure that instance info is only fetched once on initial connection

Author: gribnoysup

packages/compass-app-stores/src/stores/instance-store.ts

@@ -2,6 +2,7 @@ import type { MongoDBInstanceProps } from 'mongodb-instance-model';
 import { MongoDBInstance } from 'mongodb-instance-model';
 import toNS from 'mongodb-ns';
 import type {
+  ConnectionInfo,
   ConnectionsService,
   DataService,
 } from '@mongodb-js/compass-connections/provider';
@@ -14,6 +15,8 @@ import { openToast } from '@mongodb-js/compass-components';
 import { MongoDBInstancesManager } from '../instances-manager';
 import type { PreferencesAccess } from 'compass-preferences-model';
 
+type InstanceDetails = Awaited<ReturnType<DataService['instance']>>;
+
 function serversArray(
   serversMap: NonNullable<
     ReturnType<DataService['getLastSeenTopology']>
@@ -305,55 +308,68 @@ export function createInstancesStore(
     instancesManager.removeMongoDBInstanceForConnection(connectionInfoId);
   });
 
-  on(connections, 'connected', function (instanceConnectionId: string) {
-    const dataService =
-      connections.getDataServiceForConnection(instanceConnectionId);
-    const connectionString = dataService.getConnectionString();
-    const firstHost = connectionString.hosts[0] || '';
-    const [hostname, port] = firstHost.split(':');
-
-    const initialInstanceProps: Partial<MongoDBInstanceProps> = {
-      _id: firstHost,
-      hostname: hostname,
-      port: port ? +port : undefined,
-      topologyDescription: getTopologyDescription(
-        dataService.getLastSeenTopology()
-      ),
-      preferences,
-    };
-    const instance = instancesManager.createMongoDBInstanceForConnection(
-      instanceConnectionId,
-      initialInstanceProps as MongoDBInstanceProps
-    );
+  on(
+    connections,
+    'connected',
+    function (
+      instanceConnectionId: string,
+      _connectionInfo: ConnectionInfo,
+      instanceInfo: InstanceDetails
+    ) {
+      const dataService =
+        connections.getDataServiceForConnection(instanceConnectionId);
+      const connectionString = dataService.getConnectionString();
+      const firstHost = connectionString.hosts[0] || '';
+      const [hostname, port] = firstHost.split(':');
+
+      const initialInstanceProps: Partial<MongoDBInstanceProps> = {
+        _id: firstHost,
+        hostname: hostname,
+        port: port ? +port : undefined,
+        topologyDescription: getTopologyDescription(
+          dataService.getLastSeenTopology()
+        ),
+        preferences,
+      };
+      const instance = instancesManager.createMongoDBInstanceForConnection(
+        instanceConnectionId,
+        initialInstanceProps as MongoDBInstanceProps
+      );
+      instance.set({
+        status: 'ready',
+        statusError: null,
+        ...(instanceInfo as Partial<MongoDBInstanceProps>),
+      });
 
-    addCleanup(() => {
-      instance.removeAllListeners();
-    });
+      addCleanup(() => {
+        instance.removeAllListeners();
+      });
 
-    void refreshInstance(
-      {
-        fetchDatabases: true,
-        fetchDbStats: true,
-      },
-      {
-        connectionId: instanceConnectionId,
-      }
-    );
+      void refreshInstance(
+        {
+          fetchDatabases: true,
+          fetchDbStats: true,
+        },
+        {
+          connectionId: instanceConnectionId,
+        }
+      );
 
-    on(
-      dataService,
-      'topologyDescriptionChanged',
-      ({
-        newDescription,
-      }: {
-        newDescription: ReturnType<DataService['getLastSeenTopology']>;
-      }) => {
-        instance.set({
-          topologyDescription: getTopologyDescription(newDescription),
-        });
-      }
-    );
-  });
+      on(
+        dataService,
+        'topologyDescriptionChanged',
+        ({
+          newDescription,
+        }: {
+          newDescription: ReturnType<DataService['getLastSeenTopology']>;
+        }) => {
+          instance.set({
+            topologyDescription: getTopologyDescription(newDescription),
+          });
+        }
+      );
+    }
+  );
 
   on(
     globalAppRegistry,

packages/compass-connections/src/stores/connections-store-redux.ts

@@ -16,6 +16,7 @@ import type {
   ConnectionAttempt,
   ConnectionOptions,
   DataService,
+  InstanceDetails,
 } from 'mongodb-data-service';
 import { createConnectionAttempt } from 'mongodb-data-service';
 import { UUID } from 'bson';
@@ -42,7 +43,8 @@ import {
 export type ConnectionsEventMap = {
   connected: (
     connectionId: ConnectionId,
-    connectionInfo: ConnectionInfo
+    connectionInfo: ConnectionInfo,
+    instanceInfo: InstanceDetails
   ) => void;
   disconnected: (
     connectionId: ConnectionId,
@@ -1657,6 +1659,14 @@ const connectWithOptions = (
           return;
         }
 
+        // We're trying to optimise the initial Compass loading times here: to
+        // make sure that the driver connection pool doesn't immediately get
+        // overwhelmed with requests, we fetch instance info only once and then
+        // pass it down to telemetry and instance model. This is a relatively
+        // expensive dataService operation so we're trying to keep the usage
+        // very limited
+        const instanceInfo = await dataService.instance();
+
         let showedNonRetryableErrorToast = false;
         // Listen for non-retry-able errors on failed server heartbeats.
         // These can happen on compass web when:
@@ -1765,7 +1775,7 @@ const connectWithOptions = (
               { dataLake, genuineMongoDB, host, build, isAtlas, isLocalAtlas },
               [extraInfo, resolvedHostname],
             ] = await Promise.all([
-              dataService.instance(),
+              instanceInfo,
               getExtraConnectionData(connectionInfo),
             ]);
 
@@ -1810,44 +1820,29 @@ const connectWithOptions = (
         connectionsEventEmitter.emit(
           'connected',
           connectionInfo.id,
-          connectionInfo
+          connectionInfo,
+          instanceInfo
         );
 
         dispatch({
           type: ActionTypes.ConnectionAttemptSuccess,
           connectionId: connectionInfo.id,
         });
 
-        const { networkTraffic, showEndOfLifeConnectionModal } =
-          preferences.getPreferences();
+        const { showEndOfLifeConnectionModal } = preferences.getPreferences();
 
         if (
           getGenuineMongoDB(connectionInfo.connectionOptions.connectionString)
             .isGenuine === false
         ) {
           dispatch(showNonGenuineMongoDBWarningModal(connectionInfo.id));
         } else if (showEndOfLifeConnectionModal) {
-          void dataService
-            .instance()
-            .then(async (instance) => {
-              const { version } = instance.build;
-              const latestEndOfLifeServerVersion =
-                await getLatestEndOfLifeServerVersion(networkTraffic);
-              if (isEndOfLifeVersion(version, latestEndOfLifeServerVersion)) {
-                dispatch(
-                  showEndOfLifeMongoDBWarningModal(
-                    connectionInfo.id,
-                    instance.build.version
-                  )
-                );
-              }
-            })
-            .catch((err) => {
-              debug(
-                'failed to get instance details to determine if the server version is end-of-life',
-                err
-              );
-            });
+          void dispatch(
+            showEndOfLifeMongoDBWarningModal(
+              connectionInfo.id,
+              instanceInfo.build.version
+            )
+          );
         }
       } catch (err) {
         dispatch(connectionAttemptError(connectionInfo, err));
@@ -2175,11 +2170,31 @@ export const showNonGenuineMongoDBWarningModal = (
 export const showEndOfLifeMongoDBWarningModal = (
   connectionId: string,
   version: string
-): ConnectionsThunkAction<void> => {
-  return (_dispatch, getState, { track }) => {
-    const connectionInfo = getCurrentConnectionInfo(getState(), connectionId);
-    track('Screen', { name: 'end_of_life_mongodb_modal' }, connectionInfo);
-    void _showEndOfLifeMongoDBWarningModal(connectionInfo, version);
+): ConnectionsThunkAction<Promise<void>> => {
+  return async (
+    _dispatch,
+    getState,
+    { track, logger: { debug }, preferences }
+  ) => {
+    try {
+      const latestEndOfLifeServerVersion =
+        await getLatestEndOfLifeServerVersion(
+          preferences.getPreferences().networkTraffic
+        );
+      if (isEndOfLifeVersion(version, latestEndOfLifeServerVersion)) {
+        const connectionInfo = getCurrentConnectionInfo(
+          getState(),
+          connectionId
+        );
+        track('Screen', { name: 'end_of_life_mongodb_modal' }, connectionInfo);
+        void _showEndOfLifeMongoDBWarningModal(connectionInfo, version);
+      }
+    } catch (err) {
+      debug(
+        'failed to get instance details to determine if the server version is end-of-life',
+        err
+      );
+    }
   };
 };
 

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

@@ -310,6 +310,8 @@ export interface DataService {
 
   /**
    * Get the current instance details.
+   *
+   * @deprecated avoid using `instance` directly and use `InstanceModel` instead
    */
   instance(): Promise<InstanceDetails>;
 
@@ -340,6 +342,9 @@ export interface DataService {
 
   /**
    * List all collections for a database.
+   *
+   * @deprecated avoid using `listCollections` directly and use
+   * `CollectionModel` instead
    */
   listCollections(
     databaseName: string,
@@ -448,6 +453,9 @@ export interface DataService {
 
   /**
    * List all databases on the currently connected instance.
+   *
+   * @deprecated avoid using `listDatabases` directly and use `DatabaseModel`
+   * instead
    */
   listDatabases(options?: {
     nameOnly?: true;