feat(cli-repl): add dependency info to --build-info MONGOSH-1286 (#1492)

… and add a built-in `builtInfo()` function that also returns
this information.

Author: addaleax

packages/cli-repl/src/build-info.ts

@@ -1,7 +1,13 @@
-export type BuildInfo = {
+import os from 'os';
+import { CliServiceProvider } from '@mongosh/service-provider-server';
+import { getCryptLibraryPaths } from './crypt-library-paths';
+
+export interface BuildInfo {
   version: string;
   nodeVersion: string;
   distributionKind: 'unpackaged' | 'packaged' | 'compiled';
+  runtimeArch: typeof process['arch'];
+  runtimePlatform: typeof process['platform'];
   buildArch: typeof process['arch'];
   buildPlatform: typeof process['platform'];
   buildTarget: string;
@@ -10,18 +16,64 @@ export type BuildInfo = {
   opensslVersion: string;
   sharedOpenssl: boolean;
   segmentApiKey?: string;
-};
+  deps: ReturnType<typeof CliServiceProvider.getVersionInformation> & {
+    cryptSharedLibraryVersion?: string;
+  }
+}
+
+function getSystemArch(): typeof process['arch'] {
+  return process.platform === 'darwin'
+    ? os.cpus().some((cpu) => {
+      // process.arch / os.arch() will return the arch for which the node
+      // binary was compiled. Checking if one of the CPUs has Apple in its
+      // name is the way to check (there is slight difference between the
+      // earliest models naming and a current one, so we check only for
+      // Apple in the name)
+      return /Apple/.test(cpu.model);
+    })
+      ? 'arm64'
+      : 'x64'
+    : process.arch;
+}
 
 /**
  * Return an object with information about this mongosh instance,
  * in particular, when it was built and how.
  */
-export function buildInfo({ withSegmentApiKey }: { withSegmentApiKey?: boolean } = {}): BuildInfo {
+export async function buildInfo({
+  withSegmentApiKey,
+  withCryptSharedVersionInfo,
+}: {
+  withSegmentApiKey?: boolean,
+  withCryptSharedVersionInfo?: boolean,
+} = {}): Promise<BuildInfo> {
+  const dependencyVersionInfo: BuildInfo['deps'] = {
+    ...CliServiceProvider.getVersionInformation()
+  };
+  try {
+    if (withCryptSharedVersionInfo) {
+      const version = (await getCryptLibraryPaths()).expectedVersion?.versionStr;
+      if (version) {
+        dependencyVersionInfo.cryptSharedLibraryVersion = version;
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+
   const runtimeData = {
     nodeVersion: process.version,
     opensslVersion: process.versions.openssl,
-    sharedOpenssl: !!process.config.variables.node_shared_openssl
+    sharedOpenssl: !!process.config.variables.node_shared_openssl,
+    // Runtime arch can differ e.g. because x64 binaries can run
+    // on M1 cpus
+    runtimeArch: getSystemArch(),
+    // Runtime platform can differ e.g. because homebrew on macOS uses
+    // npm packages published from Linux
+    runtimePlatform: process.platform,
+    deps: { ...dependencyVersionInfo }
   };
+
   try {
     const buildInfo = { ...require('./build-info.json'), ...runtimeData };
     if (!withSegmentApiKey) {

packages/cli-repl/src/cli-repl.ts

@@ -229,12 +229,12 @@ export class CliRepl implements MongoshIOProvider {
     logger.info('MONGOSH', mongoLogId(1_000_000_000), 'log', 'Starting log', {
       execPath: process.execPath,
       envInfo: redactSensitiveData(this.getLoggedEnvironmentVariables()),
-      ...buildInfo()
+      ...await buildInfo({ withCryptSharedVersionInfo: true })
     });
 
     let analyticsSetupError: Error | null = null;
     try {
-      this.setupAnalytics();
+      await this.setupAnalytics();
     } catch (err: any) {
       // Need to delay emitting the error on the bus so that logging is in place
       // as well
@@ -304,6 +304,7 @@ export class CliRepl implements MongoshIOProvider {
       throw err;
     }
     const initialized = await this.mongoshRepl.initialize(initialServiceProvider);
+    this.injectReplFunctions();
 
     const commandLineLoadFiles = this.cliOptions.fileNames ?? [];
     const evalScripts = this.cliOptions.eval ?? [];
@@ -372,12 +373,28 @@ export class CliRepl implements MongoshIOProvider {
     await this.mongoshRepl.startRepl(initialized);
   }
 
-  setupAnalytics(): void {
+  injectReplFunctions(): void {
+    const functions = {
+      async buildInfo() {
+        return await buildInfo({ withCryptSharedVersionInfo: true });
+      }
+    } as const;
+    const { context } = this.mongoshRepl.runtimeState().repl;
+    for (const [name, impl] of Object.entries(functions)) {
+      context[name] = (...args: Parameters<typeof impl>) => {
+        return Object.assign(impl(...args), {
+          [Symbol.for('@@mongosh.syntheticPromise')]: true
+        });
+      };
+    }
+  }
+
+  async setupAnalytics(): Promise<void> {
     if (process.env.IS_MONGOSH_EVERGREEN_CI && !this.analyticsOptions?.alwaysEnable) {
       throw new Error('no analytics setup for the mongosh CI environment');
     }
     // build-info.json is created as a part of the release process
-    const apiKey = this.analyticsOptions?.apiKey ?? buildInfo({ withSegmentApiKey: true }).segmentApiKey;
+    const apiKey = this.analyticsOptions?.apiKey ?? (await buildInfo({ withSegmentApiKey: true })).segmentApiKey;
     if (!apiKey) {
       throw new Error('no analytics API key defined');
     }

packages/cli-repl/src/crypt-library-paths.ts

@@ -1,3 +1,4 @@
+/* eslint-disable chai-friendly/no-unused-expressions */
 import path from 'path';
 import { promises as fs, constants as fsConstants } from 'fs';
 import type { MongoshBus } from '@mongosh/types';
@@ -17,7 +18,7 @@ export interface CryptLibraryPathResult {
  * that we are supposed to use.
  */
 export async function getCryptLibraryPaths(
-  bus: MongoshBus,
+  bus: MongoshBus | undefined = undefined,
   pretendProcessExecPathForTesting: string | undefined = undefined): Promise<CryptLibraryPathResult> {
   const execPath = pretendProcessExecPathForTesting ?? process.execPath;
 
@@ -41,7 +42,7 @@ export async function getCryptLibraryPaths(
       try {
         const permissionsMismatch = await ensureMatchingPermissions(libraryCandidate, execPathStat);
         if (permissionsMismatch) {
-          bus.emit('mongosh:crypt-library-load-skip', {
+          bus?.emit?.('mongosh:crypt-library-load-skip', {
             cryptSharedLibPath: libraryCandidate,
             reason: 'permissions mismatch',
             details: permissionsMismatch
@@ -54,17 +55,17 @@ export async function getCryptLibraryPaths(
           cryptSharedLibPath: libraryCandidate,
           expectedVersion: version
         };
-        bus.emit('mongosh:crypt-library-load-found', result);
+        bus?.emit?.('mongosh:crypt-library-load-found', result);
         return result;
       } catch (err: any) {
-        bus.emit('mongosh:crypt-library-load-skip', {
+        bus?.emit?.('mongosh:crypt-library-load-skip', {
           cryptSharedLibPath: libraryCandidate,
           reason: err.message
         });
       }
     }
   } else {
-    bus.emit('mongosh:crypt-library-load-skip', {
+    bus?.emit?.('mongosh:crypt-library-load-skip', {
       cryptSharedLibPath: '',
       reason: 'Skipping CSFLE library searching because this is not a single-executable mongosh'
     });

packages/cli-repl/src/run.ts

@@ -72,12 +72,12 @@ import net from 'net';
 
     if (options.version) {
       // eslint-disable-next-line no-console
-      console.log(buildInfo().version);
+      console.log((await buildInfo()).version);
       return;
     }
     if (options.buildInfo) {
       // eslint-disable-next-line no-console
-      console.log(JSON.stringify(buildInfo(), null, '  '));
+      console.log(JSON.stringify(await buildInfo({ withCryptSharedVersionInfo: true }), null, '  '));
       return;
     }
     if (options.smokeTests) {

packages/cli-repl/src/smoke-tests.ts

@@ -21,7 +21,7 @@ export async function runSmokeTests(smokeTestServer: string | undefined, executa
     assert(!!smokeTestServer, 'Make sure MONGOSH_SMOKE_TEST_SERVER is set in CI');
   }
 
-  const expectFipsSupport = !!process.env.MONGOSH_SMOKE_TEST_OS_HAS_FIPS_SUPPORT && buildInfo().sharedOpenssl;
+  const expectFipsSupport = !!process.env.MONGOSH_SMOKE_TEST_OS_HAS_FIPS_SUPPORT && (await buildInfo()).sharedOpenssl;
   console.log('FIPS support required to pass?', { expectFipsSupport });
 
   for (const { input, output, testArgs, includeStderr, exitCode } of [{

packages/cli-repl/test/e2e.spec.ts

@@ -40,14 +40,17 @@ describe('e2e', function() {
       expect(Object.keys(data)).to.deep.equal([
         'version', 'distributionKind', 'buildArch', 'buildPlatform',
         'buildTarget', 'buildTime', 'gitVersion', 'nodeVersion',
-        'opensslVersion', 'sharedOpenssl'
+        'opensslVersion', 'sharedOpenssl', 'runtimeArch', 'runtimePlatform',
+        'deps'
       ]);
       expect(data.version).to.be.a('string');
       expect(data.nodeVersion).to.be.a('string');
       expect(data.distributionKind).to.be.a('string');
       expect(['unpackaged', 'packaged', 'compiled'].includes(data.distributionKind)).to.be.true;
       expect(data.buildArch).to.be.a('string');
       expect(data.buildPlatform).to.be.a('string');
+      expect(data.runtimeArch).to.be.a('string');
+      expect(data.runtimePlatform).to.be.a('string');
       expect(data.opensslVersion).to.be.a('string');
       expect(data.sharedOpenssl).to.be.a('boolean');
       if (data.distributionKind !== 'unpackaged') {
@@ -57,6 +60,19 @@ describe('e2e', function() {
         expect(data.buildTime).to.equal(null);
         expect(data.gitVersion).to.equal(null);
       }
+      expect(data.deps.nodeDriverVersion).to.be.a('string');
+      expect(data.deps.libmongocryptVersion).to.be.a('string');
+      expect(data.deps.libmongocryptNodeBindingsVersion).to.be.a('string');
+    });
+
+    it('provides build info via the buildInfo() builtin', async() => {
+      const shell = TestShell.start({ args: [ '--quiet', '--eval', 'JSON.stringify(buildInfo().deps)', '--nodb' ] });
+      await shell.waitForExit();
+      shell.assertNoErrors();
+      const deps = JSON.parse(shell.output);
+      expect(deps.nodeDriverVersion).to.be.a('string');
+      expect(deps.libmongocryptVersion).to.be.a('string');
+      expect(deps.libmongocryptNodeBindingsVersion).to.be.a('string');
     });
   });
 

packages/service-provider-server/src/cli-service-provider.ts

@@ -151,6 +151,12 @@ function normalizeEndpointAndAuthConfiguration(
   ];
 }
 
+interface DependencyVersionInfo {
+  nodeDriverVersion?: string;
+  libmongocryptVersion?: string;
+  libmongocryptNodeBindingsVersion?: string;
+}
+
 /**
    * Encapsulates logic for the service provider for the mongosh CLI.
  */
@@ -242,15 +248,32 @@ class CliServiceProvider extends ServiceProviderCore implements ServiceProvider
     this.currentClientOptions = clientOptions;
     this.baseCmdOptions = { ... DEFAULT_BASE_OPTIONS }; // currently do not have any user-specified connection-wide command options, but I imagine we will eventually
     this.dbcache = new WeakMap();
+    this.fle = CliServiceProvider.getLibmongocryptBindings();
+  }
+
+  private static getLibmongocryptBindings(): FLE | undefined {
     try {
       // The .extension() call may seem unnecessary, since that is the default
       // for the top-level exports from mongodb-client-encryption anyway.
       // However, for the browser runtime, we externalize mongodb-client-encryption
       // since it is a native addon package; that means that if 'mongodb' is
       // included in the bundle, it won't be able to find it, and instead needs
       // to receive it as an explicitly passed dependency.
-      this.fle = require('mongodb-client-encryption').extension(require('mongodb'));
-    } catch { /* not empty */ }
+      return require('mongodb-client-encryption').extension(require('mongodb'));
+    } catch {
+      return undefined;
+    }
+  }
+
+  static getVersionInformation(): DependencyVersionInfo {
+    function tryCall<Fn extends() => any>(fn: Fn): ReturnType<Fn> | undefined {
+      try { return fn(); } catch { return; }
+    }
+    return {
+      nodeDriverVersion: tryCall(() => require('mongodb/package.json').version),
+      libmongocryptVersion: tryCall(() => this.getLibmongocryptBindings()?.ClientEncryption.libmongocryptVersion),
+      libmongocryptNodeBindingsVersion: tryCall(() => require('mongodb-client-encryption/package.json').version),
+    };
   }
 
   async getNewConnection(uri: string, options: Partial<DevtoolsConnectOptions> = {}): Promise<CliServiceProvider> {