feat(NODE-4878): Add remaining log configurable client options

src/connection_string.ts

@@ -530,7 +530,9 @@ export function parseOptions(
       ...mongoOptions[Symbol.for('@@mdb.internalLoggerConfig')]
     };
     loggerClientOptions = {
-      mongodbLogPath: mongoOptions.mongodbLogPath
+      mongodbLogPath: mongoOptions.mongodbLogPath,
+      mongodbLogComponentSeverities: mongoOptions.mongodbLogComponentSeverities,
+      mongodblogMaxDocumentLength: mongoOptions.mongodbLogMaxDocumentLength
     };
   }
   mongoOptions.mongoLoggerOptions = MongoLogger.resolveOptions(
@@ -1229,7 +1231,17 @@ export const OPTIONS = {
    * @internal
    * TODO: NODE-5671 - remove internal flag
    */
-  mongodbLogPath: { type: 'any' }
+  mongodbLogPath: { type: 'any' },
+  /**
+   * @internal
+   * TODO: NODE-5671 - remove internal flag
+   */
+  mongodbLogComponentSeverities: { type: 'any' },
+  /**
+   * @internal
+   * TODO: NODE-5671 - remove internal flag
+   */
+  mongodbLogMaxDocumentLength: { type: 'string' }
 } as Record<keyof MongoClientOptions, OptionDescriptor>;
 
 export const DEFAULT_OPTIONS = new CaseInsensitiveMap(

src/index.ts

@@ -348,6 +348,7 @@ export type {
 } from './mongo_client';
 export type {
   Log,
+  LogComponentSeveritiesClientOptions,
   LogConvertible,
   Loggable,
   LoggableEvent,

src/mongo_client.ts

@@ -21,7 +21,12 @@ import { MONGO_CLIENT_EVENTS } from './constants';
 import { Db, type DbOptions } from './db';
 import type { Encrypter } from './encrypter';
 import { MongoInvalidArgumentError } from './error';
-import { type MongoDBLogWritable, MongoLogger, type MongoLoggerOptions } from './mongo_logger';
+import {
+  type LogComponentSeveritiesClientOptions,
+  type MongoDBLogWritable,
+  MongoLogger,
+  type MongoLoggerOptions
+} from './mongo_logger';
 import { TypedEventEmitter } from './mongo_types';
 import { executeOperation } from './operations/execute_operation';
 import { RunAdminCommandOperation } from './operations/run_command';
@@ -262,6 +267,16 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
    * TODO: NODE-5671 - remove internal flag
    */
   mongodbLogPath?: 'stderr' | 'stdout' | MongoDBLogWritable;
+  /**
+   * @internal
+   * TODO: NODE-5671 - remove internal flag
+   */
+  mongodbLogComponentSeverities?: LogComponentSeveritiesClientOptions;
+  /**
+   * @internal
+   * TODO: NODE-5671 - remove internal flag
+   */
+  mongodbLogMaxDocumentLength?: string;
 
   /** @internal */
   [featureFlag: symbol]: any;

src/mongo_logger.ts

@@ -126,10 +126,30 @@ export interface MongoLoggerEnvOptions {
   MONGODB_LOG_PATH?: string;
 }
 
+/** @internal */
+export interface LogComponentSeveritiesClientOptions {
+  /** Optional severity level for command component */
+  command?: SeverityLevel;
+  /** Optional severity level for topology component */
+  topology?: SeverityLevel;
+  /** Optionsl severity level for server selection component */
+  serverSelection?: SeverityLevel;
+  /** Optional severity level for connection component */
+  connection?: SeverityLevel;
+  /** Optional severity level for client component */
+  client?: SeverityLevel;
+  /** Optional default severity level to be used if any of the above are unset */
+  default?: SeverityLevel;
+}
+
 /** @internal */
 export interface MongoLoggerMongoClientOptions {
   /** Destination for log messages */
   mongodbLogPath?: 'stdout' | 'stderr' | MongoDBLogWritable;
+  /** Severity levels for logger components */
+  mongodbLogComponentSeverities?: LogComponentSeveritiesClientOptions;
+  /** Max length of embedded EJSON docs. Setting to 0 disables truncation. Defaults to 1000. */
+  mongodblogMaxDocumentLength?: string;
 }
 
 /** @internal */
@@ -219,6 +239,18 @@ function resolveLogPath(
   return createStdioLogger(process.stderr);
 }
 
+function resolveSeverityConfiguration(
+  clientOption: string | undefined,
+  environmentOption: string | undefined,
+  defaultSeverity: SeverityLevel
+): SeverityLevel {
+  return (
+    parseSeverityFromString(clientOption) ??
+    parseSeverityFromString(environmentOption) ??
+    defaultSeverity
+  );
+}
+
 /** @internal */
 export interface Log extends Record<string, any> {
   t: Date;
@@ -522,22 +554,45 @@ export class MongoLogger {
       ...clientOptions,
       mongodbLogPath: resolveLogPath(envOptions, clientOptions)
     };
-    const defaultSeverity =
-      parseSeverityFromString(combinedOptions.MONGODB_LOG_ALL) ?? SeverityLevel.OFF;
+    const defaultSeverity = resolveSeverityConfiguration(
+      combinedOptions.mongodbLogComponentSeverities?.default,
+      combinedOptions.MONGODB_LOG_ALL,
+      SeverityLevel.OFF
+    );
 
     return {
       componentSeverities: {
-        command: parseSeverityFromString(combinedOptions.MONGODB_LOG_COMMAND) ?? defaultSeverity,
-        topology: parseSeverityFromString(combinedOptions.MONGODB_LOG_TOPOLOGY) ?? defaultSeverity,
-        serverSelection:
-          parseSeverityFromString(combinedOptions.MONGODB_LOG_SERVER_SELECTION) ?? defaultSeverity,
-        connection:
-          parseSeverityFromString(combinedOptions.MONGODB_LOG_CONNECTION) ?? defaultSeverity,
-        client: parseSeverityFromString(combinedOptions.MONGODB_LOG_CLIENT) ?? defaultSeverity,
+        command: resolveSeverityConfiguration(
+          combinedOptions.mongodbLogComponentSeverities?.command,
+          combinedOptions.MONGODB_LOG_COMMAND,
+          defaultSeverity
+        ),
+        topology: resolveSeverityConfiguration(
+          combinedOptions.mongodbLogComponentSeverities?.topology,
+          combinedOptions.MONGODB_LOG_TOPOLOGY,
+          defaultSeverity
+        ),
+        serverSelection: resolveSeverityConfiguration(
+          combinedOptions.mongodbLogComponentSeverities?.serverSelection,
+          combinedOptions.MONGODB_LOG_SERVER_SELECTION,
+          defaultSeverity
+        ),
+        connection: resolveSeverityConfiguration(
+          combinedOptions.mongodbLogComponentSeverities?.connection,
+          combinedOptions.MONGODB_LOG_CONNECTION,
+          defaultSeverity
+        ),
+        client: resolveSeverityConfiguration(
+          combinedOptions.mongodbLogComponentSeverities?.client,
+          combinedOptions.MONGODB_LOG_CLIENT,
+          defaultSeverity
+        ),
         default: defaultSeverity
       },
       maxDocumentLength:
-        parseUnsignedInteger(combinedOptions.MONGODB_LOG_MAX_DOCUMENT_LENGTH) ?? 1000,
+        parseUnsignedInteger(combinedOptions.mongodblogMaxDocumentLength) ??
+        parseUnsignedInteger(combinedOptions.MONGODB_LOG_MAX_DOCUMENT_LENGTH) ??
+        1000,
       logDestination: combinedOptions.mongodbLogPath
     };
   }

test/unit/mongo_client.test.js

@@ -13,6 +13,8 @@ const { ReadPreference } = require('../mongodb');
 const { MongoCredentials } = require('../mongodb');
 const { MongoClient, MongoParseError, ServerApiVersion } = require('../mongodb');
 const { MongoLogger } = require('../mongodb');
+// eslint-disable-next-line no-restricted-modules
+const { SeverityLevel, MongoLoggableComponent } = require('../../src/mongo_logger');
 const sinon = require('sinon');
 const { Writable } = require('stream');
 
@@ -817,71 +819,162 @@ describe('MongoOptions', function () {
     });
   });
 
-  context('when mongodbLogPath is in options', function () {
+  describe('logging client options', function () {
     const loggerFeatureFlag = Symbol.for('@@mdb.enableMongoLogger');
+    context('when mongodbLogPath is in options', function () {
+      let stderrStub;
+      let stdoutStub;
 
-    let stderrStub;
-    let stdoutStub;
+      beforeEach(() => {
+        stdoutStub = sinon.stub(process.stdout);
+        stderrStub = sinon.stub(process.stderr);
+      });
 
-    beforeEach(() => {
-      stdoutStub = sinon.stub(process.stdout);
-      stderrStub = sinon.stub(process.stderr);
-    });
+      afterEach(() => {
+        sinon.restore();
+      });
 
-    afterEach(() => {
-      sinon.restore();
-    });
+      context('when option is `stderr`', function () {
+        it('it is accessible through mongoLogger.logDestination', function () {
+          const client = new MongoClient('mongodb://a/', {
+            [loggerFeatureFlag]: true,
+            mongodbLogPath: 'stderr'
+          });
+          const log = { t: new Date(), c: 'constructorStdErr', s: 'error' };
+          client.options.mongoLoggerOptions.logDestination.write(log);
+          expect(stderrStub.write).calledWith(
+            inspect(log, { breakLength: Infinity, compact: true })
+          );
+        });
+      });
 
-    context('when option is `stderr`', function () {
-      it('it is accessible through mongoLogger.logDestination', function () {
-        const client = new MongoClient('mongodb://a/', {
-          [loggerFeatureFlag]: true,
-          mongodbLogPath: 'stderr'
+      context('when option is a MongoDBLogWritable stream', function () {
+        it('it is accessible through mongoLogger.logDestination', function () {
+          const writable = {
+            buffer: [],
+            write(log) {
+              this.buffer.push(log);
+            }
+          };
+          const client = new MongoClient('mongodb://a/', {
+            [loggerFeatureFlag]: true,
+            mongodbLogPath: writable
+          });
+          expect(client.options.mongoLoggerOptions.logDestination).to.deep.equal(writable);
         });
-        const log = { t: new Date(), c: 'constructorStdErr', s: 'error' };
-        client.options.mongoLoggerOptions.logDestination.write(log);
-        expect(stderrStub.write).calledWith(inspect(log, { breakLength: Infinity, compact: true }));
       });
-    });
 
-    context('when option is a MongoDBLogWritable stream', function () {
-      it('it is accessible through mongoLogger.logDestination', function () {
-        const writable = {
-          buffer: [],
-          write(log) {
-            this.buffer.push(log);
-          }
-        };
-        const client = new MongoClient('mongodb://a/', {
-          [loggerFeatureFlag]: true,
-          mongodbLogPath: writable
+      context('when option is `stdout`', function () {
+        it('it is accessible through mongoLogger.logDestination', function () {
+          const client = new MongoClient('mongodb://a/', {
+            [loggerFeatureFlag]: true,
+            mongodbLogPath: 'stdout'
+          });
+          const log = { t: new Date(), c: 'constructorStdOut', s: 'error' };
+          client.options.mongoLoggerOptions.logDestination.write(log);
+          expect(stdoutStub.write).calledWith(
+            inspect(log, { breakLength: Infinity, compact: true })
+          );
         });
-        expect(client.options.mongoLoggerOptions.logDestination).to.deep.equal(writable);
       });
-    });
 
-    context('when option is `stdout`', function () {
-      it('it is accessible through mongoLogger.logDestination', function () {
-        const client = new MongoClient('mongodb://a/', {
-          [loggerFeatureFlag]: true,
-          mongodbLogPath: 'stdout'
+      context('when option is invalid', function () {
+        it('it defaults to stderr', function () {
+          const invalidOption = 'stdnothing';
+          const client = new MongoClient('mongodb://a/', {
+            [loggerFeatureFlag]: true,
+            mongodbLogPath: invalidOption
+          });
+          const log = { t: new Date(), c: 'constructorInvalidOption', s: 'error' };
+          client.options.mongoLoggerOptions.logDestination.write(log);
+          expect(stderrStub.write).calledWith(
+            inspect(log, { breakLength: Infinity, compact: true })
+          );
         });
-        const log = { t: new Date(), c: 'constructorStdOut', s: 'error' };
-        client.options.mongoLoggerOptions.logDestination.write(log);
-        expect(stdoutStub.write).calledWith(inspect(log, { breakLength: Infinity, compact: true }));
       });
     });
-
-    context('when option is invalid', function () {
-      it('it defaults to stderr', function () {
-        const invalidOption = 'stdnothing';
-        const client = new MongoClient('mongodb://a/', {
-          [loggerFeatureFlag]: true,
-          mongodbLogPath: invalidOption
+    describe('component severities', function () {
+      const components = Object.values(MongoLoggableComponent);
+      const env_component_names = [
+        'MONGODB_LOG_COMMAND',
+        'MONGODB_LOG_TOPOLOGY',
+        'MONGODB_LOG_SERVER_SELECTION',
+        'MONGODB_LOG_CONNECTION',
+        'MONGODB_LOG_CLIENT'
+      ];
+      context('when only client option is provided for', function () {
+        for (let i = 0; i < components.length; i++) {
+          it(`it stores severity levels for ${components[i]} component correctly`, function () {
+            for (const severityLevel of Object.values(SeverityLevel)) {
+              const client = new MongoClient('mongodb://a/', {
+                [loggerFeatureFlag]: true,
+                mongodbLogComponentSeverities: {
+                  [components[i]]: severityLevel
+                }
+              });
+              for (const [curComponent, curSeverity] of Object.entries(
+                client.options.mongoLoggerOptions.componentSeverities
+              )) {
+                if (curComponent === components[i]) {
+                  expect(curSeverity).to.equal(severityLevel);
+                } else {
+                  expect(curSeverity).to.equal(SeverityLevel.OFF);
+                }
+              }
+            }
+          });
+        }
+      });
+      context('when both client and environment option is provided', function () {
+        for (let i = 0; i < components.length; i++) {
+          it(`it stores severity level for ${components[i]} component correctly (client options have precedence)`, function () {
+            process.env[env_component_names[i]] = 'emergency';
+            for (const severityLevel of Object.values(SeverityLevel)) {
+              const client = new MongoClient('mongodb://a/', {
+                [loggerFeatureFlag]: true,
+                mongodbLogComponentSeverities: {
+                  [components[i]]: severityLevel
+                }
+              });
+              for (const [curComponent, curSeverity] of Object.entries(
+                client.options.mongoLoggerOptions.componentSeverities
+              )) {
+                if (curComponent === components[i]) {
+                  expect(curSeverity).to.equal(severityLevel);
+                } else {
+                  expect(curSeverity).to.equal(SeverityLevel.OFF);
+                }
+              }
+              process.env[env_component_names[i]] = undefined;
+            }
+          });
+        }
+      });
+      context('when default is provided', function () {
+        it('unspecified components have default value, while specified components retain value', function () {
+          for (let i = 0; i < components.length; i++) {
+            for (const severityLevel of Object.values(SeverityLevel)) {
+              for (const severityLevel2 of Object.values(SeverityLevel)) {
+                const client = new MongoClient('mongodb://a/', {
+                  [loggerFeatureFlag]: true,
+                  mongodbLogComponentSeverities: {
+                    [components[i]]: severityLevel,
+                    default: severityLevel2
+                  }
+                });
+                for (const [curComponent, curSeverity] of Object.entries(
+                  client.options.mongoLoggerOptions.componentSeverities
+                )) {
+                  if (curComponent === components[i]) {
+                    expect(curSeverity).to.equal(severityLevel);
+                  } else {
+                    expect(curSeverity).to.equal(severityLevel2);
+                  }
+                }
+              }
+            }
+          }
         });
-        const log = { t: new Date(), c: 'constructorInvalidOption', s: 'error' };
-        client.options.mongoLoggerOptions.logDestination.write(log);
-        expect(stderrStub.write).calledWith(inspect(log, { breakLength: Infinity, compact: true }));
       });
     });
   });