feat(cli-repl): add option to disable logging MONGOSH-1988

Some tests still need to be fixed

Author: gagik

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

@@ -31,6 +31,9 @@ import { CliRepl } from './cli-repl';
 import { CliReplErrors } from './error-codes';
 import type { DevtoolsConnectOptions } from '@mongosh/service-provider-node-driver';
 import type { AddressInfo } from 'net';
+import sinon from 'sinon';
+import type { CliUserConfig } from '@mongosh/types';
+import { MongoLogWriter } from 'mongodb-log-writer';
 const { EJSON } = bson;
 
 const delay = promisify(setTimeout);
@@ -297,7 +300,8 @@ describe('CliRepl', function () {
           'oidcTrustedEndpoints',
           'browser',
           'updateURL',
-        ]);
+          'disableLogging',
+        ] satisfies (keyof CliUserConfig)[]);
       });
 
       it('fails when trying to overwrite mongosh-owned config settings', async function () {
@@ -1310,6 +1314,36 @@ describe('CliRepl', function () {
       hasDatabaseNames: true,
     });
 
+    context('logging configuration', function () {
+      afterEach(function () {
+        sinon.restore();
+      });
+
+      it('start logging when it is not disabled', async function () {
+        const emitSpy = sinon.spy(cliRepl.bus, 'emit');
+
+        await cliRepl.start(await testServer.connectionString(), {});
+
+        expect(cliRepl.getConfig('disableLogging')).is.false;
+
+        expect(emitSpy).calledWith('mongosh:log-initialized');
+        expect(cliRepl.logWriter).is.instanceOf(MongoLogWriter);
+      });
+
+      it('does not start logging when it is disabled', async function () {
+        const emitSpy = sinon.spy(cliRepl.bus, 'emit');
+        cliRepl.config.disableLogging = true;
+
+        await cliRepl.start(await testServer.connectionString(), {});
+
+        expect(cliRepl.getConfig('disableLogging')).is.true;
+
+        expect(emitSpy).called;
+        expect(emitSpy).not.calledWith('mongosh:log-initialized');
+        expect(cliRepl.logWriter).is.undefined;
+      });
+    });
+
     context('analytics integration', function () {
       context('with network connectivity', function () {
         let srv: http.Server;
@@ -1333,6 +1367,7 @@ describe('CliRepl', function () {
                 .on('data', (chunk) => {
                   body += chunk;
                 })
+                // eslint-disable-next-line @typescript-eslint/no-misused-promises
                 .on('end', async () => {
                   requests.push({ req, body });
                   totalEventsTracked += JSON.parse(body).batch.length;
@@ -1343,7 +1378,7 @@ describe('CliRepl', function () {
             })
             .listen(0);
           await once(srv, 'listening');
-          host = `http://localhost:${(srv.address() as any).port}`;
+          host = `http://localhost:${(srv.address() as AddressInfo).port}`;
           cliReplOptions.analyticsOptions = {
             host,
             apiKey: '🔑',

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

@@ -53,6 +53,7 @@ import type {
   DevtoolsProxyOptions,
 } from '@mongodb-js/devtools-proxy-support';
 import { useOrCreateAgent } from '@mongodb-js/devtools-proxy-support';
+import { setupMongoLogWriter } from '@mongosh/logging/lib/setup-logger-and-telemetry';
 
 /**
  * Connecting text key.
@@ -256,6 +257,32 @@ export class CliRepl implements MongoshIOProvider {
     );
   }
 
+  /** Setup log writer and start logging. */
+  private async startLogging() {
+    await this.logManager.cleanupOldLogFiles();
+    markTime(TimingCategories.Logging, 'cleaned up log files');
+    const logger = await this.logManager.createLogWriter();
+    const { quiet } = CliRepl.getFileAndEvalInfo(this.cliOptions);
+    if (!quiet) {
+      this.output.write(`Current Mongosh Log ID:\t${logger.logId}\n`);
+    }
+
+    this.logWriter = logger;
+    this.logWriter = logger;
+    setupMongoLogWriter(logger);
+    this.logWriter = logger;
+    setupMongoLogWriter(logger);
+    markTime(TimingCategories.Logging, 'instantiated log writer');
+    setupMongoLogWriter(logger);
+    this.bus.emit('mongosh:log-initialized');
+    logger.info('MONGOSH', mongoLogId(1_000_000_000), 'log', 'Starting log', {
+      execPath: process.execPath,
+      envInfo: redactSensitiveData(this.getLoggedEnvironmentVariables()),
+      ...(await buildInfo()),
+    });
+    markTime(TimingCategories.Logging, 'logged initial message');
+  }
+
   /**
    * Setup CLI environment: serviceProvider, ShellEvaluator, log connection
    * information, external editor, and finally start the repl.
@@ -267,7 +294,8 @@ export class CliRepl implements MongoshIOProvider {
     driverUri: string,
     driverOptions: DevtoolsConnectOptions
   ): Promise<void> {
-    const { version } = require('../package.json');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { version }: { version: string } = require('../package.json');
     await this.verifyNodeVersion();
     markTime(TimingCategories.REPLInstantiation, 'verified node version');
 
@@ -302,41 +330,24 @@ export class CliRepl implements MongoshIOProvider {
 
     try {
       await this.shellHomeDirectory.ensureExists();
-    } catch (err: any) {
-      this.warnAboutInaccessibleFile(err);
+    } catch (err: unknown) {
+      this.warnAboutInaccessibleFile(err as Error);
     }
     markTime(TimingCategories.REPLInstantiation, 'ensured shell homedir');
 
-    await this.logManager.cleanupOldLogFiles();
-    markTime(TimingCategories.Logging, 'cleaned up log files');
-    const logger = await this.logManager.createLogWriter();
-    const { quiet } = CliRepl.getFileAndEvalInfo(this.cliOptions);
-    if (!quiet) {
-      this.output.write(`Current Mongosh Log ID:\t${logger.logId}\n`);
-    }
-    this.logWriter = logger;
-    markTime(TimingCategories.Logging, 'instantiated log writer');
-
-    logger.info('MONGOSH', mongoLogId(1_000_000_000), 'log', 'Starting log', {
-      execPath: process.execPath,
-      envInfo: redactSensitiveData(this.getLoggedEnvironmentVariables()),
-      ...(await buildInfo()),
-    });
-    markTime(TimingCategories.Logging, 'logged initial message');
-
     let analyticsSetupError: Error | null = null;
     try {
       await this.setupAnalytics();
-    } catch (err: any) {
+    } catch (err: unknown) {
       // Need to delay emitting the error on the bus so that logging is in place
       // as well
-      analyticsSetupError = err;
+      analyticsSetupError = err as Error;
     }
 
     markTime(TimingCategories.Telemetry, 'created analytics instance');
+
     setupLoggerAndTelemetry(
       this.bus,
-      logger,
       this.toggleableAnalytics,
       {
         platform: process.platform,
@@ -352,17 +363,23 @@ export class CliRepl implements MongoshIOProvider {
       this.bus.emit('mongosh:error', analyticsSetupError, 'analytics');
     }
 
+    // Read local and global configuration
     try {
       this.config = await this.configDirectory.generateOrReadConfig(
         this.config
       );
-    } catch (err: any) {
-      this.warnAboutInaccessibleFile(err);
+    } catch (err: unknown) {
+      this.warnAboutInaccessibleFile(err as Error);
     }
 
     this.globalConfig = await this.loadGlobalConfigFile();
     markTime(TimingCategories.UserConfigLoading, 'read global config files');
 
+    const disableLogging = this.getConfig('disableLogging');
+    if (disableLogging !== true) {
+      await this.startLogging();
+    }
+
     // Needs to happen after loading the mongosh config file(s)
     void this.fetchMongoshUpdateUrl();
 
@@ -483,7 +500,7 @@ export class CliRepl implements MongoshIOProvider {
       if (!this.cliOptions.shell) {
         // We flush the telemetry data as part of exiting. Make sure we have
         // the right config value.
-        this.setTelemetryEnabled(await this.getConfig('enableTelemetry'));
+        this.setTelemetryEnabled(this.getConfig('enableTelemetry'));
         await this.exit(0);
         return;
       }
@@ -516,10 +533,11 @@ export class CliRepl implements MongoshIOProvider {
 
     // We only enable/disable here, since the rc file/command line scripts
     // can disable the telemetry setting.
-    this.setTelemetryEnabled(await this.getConfig('enableTelemetry'));
+    this.setTelemetryEnabled(this.getConfig('enableTelemetry'));
     this.bus.emit('mongosh:start-mongosh-repl', { version });
     markTime(TimingCategories.REPLInstantiation, 'starting repl');
     await this.mongoshRepl.startRepl(initialized);
+
     this.bus.emit('mongosh:start-session', {
       isInteractive: true,
       jsContext: this.mongoshRepl.jsContext(),
@@ -624,7 +642,7 @@ export class CliRepl implements MongoshIOProvider {
     files: string[],
     evalScripts: string[]
   ): Promise<number> {
-    let lastEvalResult: any;
+    let lastEvalResult: unknown;
     let exitCode = 0;
     try {
       markTime(TimingCategories.Eval, 'start eval scripts');
@@ -856,9 +874,7 @@ export class CliRepl implements MongoshIOProvider {
    * Implements getConfig from the {@link ConfigProvider} interface.
    */
   // eslint-disable-next-line @typescript-eslint/require-await
-  async getConfig<K extends keyof CliUserConfig>(
-    key: K
-  ): Promise<CliUserConfig[K]> {
+  getConfig<K extends keyof CliUserConfig>(key: K): CliUserConfig[K] {
     return (
       (this.config as CliUserConfig)[key] ??
       (this.globalConfig as CliUserConfig)?.[key] ??
@@ -1259,7 +1275,7 @@ export class CliRepl implements MongoshIOProvider {
     }
 
     try {
-      const updateURL = (await this.getConfig('updateURL')).trim();
+      const updateURL = this.getConfig('updateURL').trim();
       if (!updateURL) return;
 
       const localFilePath = this.shellHomeDirectory.localPath(
@@ -1284,7 +1300,8 @@ export class CliRepl implements MongoshIOProvider {
   }
 
   async getMoreRecentMongoshVersion(): Promise<string | null> {
-    const { version } = require('../package.json');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { version }: { version: string } = require('../package.json');
     return await this.updateNotificationManager.getLatestVersionIfMoreRecent(
       process.env
         .MONGOSH_ASSUME_DIFFERENT_VERSION_FOR_UPDATE_NOTIFICATION_TEST ||

packages/logging/src/analytics-helpers.ts

@@ -11,7 +11,7 @@ export type MongoshAnalyticsIdentity =
       anonymousId: string;
     };
 
-type AnalyticsIdentifyMessage = MongoshAnalyticsIdentity & {
+export type AnalyticsIdentifyMessage = MongoshAnalyticsIdentity & {
   traits: { platform: string; session_id: string };
   timestamp?: Date;
 };

packages/logging/src/multi-set.ts

@@ -0,0 +1,49 @@
+/**
+ * A helper class for keeping track of how often specific events occurred.
+ */
+export class MultiSet<T extends Record<string, unknown>> {
+  _entries: Map<string, number> = new Map();
+
+  add(entry: T): void {
+    const key = JSON.stringify(Object.entries(entry).sort());
+    this._entries.set(key, (this._entries.get(key) ?? 0) + 1);
+  }
+
+  clear(): void {
+    this._entries.clear();
+  }
+
+  *[Symbol.iterator](): Iterator<[T, number]> {
+    for (const [key, count] of this._entries) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      yield [Object.fromEntries(JSON.parse(key)) as T, count];
+    }
+  }
+}
+
+/**
+ * It transforms a random string into snake case. Snake case is completely
+ * lowercase and uses '_' to separate words. For example:
+ *
+ * This function defines a "word" as a sequence of characters until the next `.` or capital letter.
+ *
+ * 'Random String' => 'random_string'
+ *
+ * It will also remove any non alphanumeric characters to ensure the string
+ * is compatible with Segment. For example:
+ *
+ * 'Node.js REPL Instantiation' => 'node_js_repl_instantiation'
+ *
+ * @param str Any non snake-case formatted string
+ * @returns The snake-case formatted string
+ */
+export function toSnakeCase(str: string): string {
+  const matches = str.match(
+    /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g
+  );
+  if (!matches) {
+    return str;
+  }
+
+  return matches.map((x) => x.toLowerCase()).join('_');
+}