feat(NODE-4814): implement remaining severity logging methods (#3629)

Author: W-A-James

src/mongo_logger.ts

@@ -442,14 +442,38 @@ export class MongoLogger {
   maxDocumentLength: number;
   logDestination: MongoDBLogWritable | Writable;
 
+  /**
+   * This method should be used when logging errors that do not have a public driver API for
+   * reporting errors.
+   */
+  error = this.log.bind(this, 'error');
+  /**
+   * This method should be used to log situations where undesirable application behaviour might
+   * occur. For example, failing to end sessions on `MongoClient.close`.
+   */
+  warn = this.log.bind(this, 'warn');
+  /**
+   * This method should be used to report high-level information about normal driver behaviour.
+   * For example, the creation of a `MongoClient`.
+   */
+  info = this.log.bind(this, 'info');
+  /**
+   * This method should be used to report information that would be helpful when debugging an
+   * application. For example, a command starting, succeeding or failing.
+   */
+  debug = this.log.bind(this, 'debug');
+  /**
+   * This method should be used to report fine-grained details related to logic flow. For example,
+   * entering and exiting a function body.
+   */
+  trace = this.log.bind(this, 'trace');
+
   constructor(options: MongoLoggerOptions) {
     this.componentSeverities = options.componentSeverities;
     this.maxDocumentLength = options.maxDocumentLength;
     this.logDestination = options.logDestination;
   }
 
-  emergency = this.log.bind(this, 'emergency');
-
   private log(
     severity: SeverityLevel,
     component: MongoLoggableComponent,

test/unit/mongo_logger.test.ts

@@ -24,7 +24,6 @@ import {
   MongoDBLogWritable,
   MongoLogger,
   MongoLoggerOptions,
-  SEVERITY_LEVEL_MAP,
   SeverityLevel,
   stringifyWithMaxLen
 } from '../mongodb';
@@ -81,11 +80,11 @@ describe('class MongoLogger', function () {
           }
         } as { buffer: any[]; write: (log: Log) => void };
         const logger = new MongoLogger({
-          componentSeverities: { command: 'emergency' } as any,
+          componentSeverities: { command: 'error' } as any,
           logDestination
         } as any);
 
-        logger.emergency('command', 'Hello world!');
+        logger.error('command', 'Hello world!');
         expect(logDestination.buffer).to.have.lengthOf(1);
       });
     });
@@ -101,11 +100,11 @@ describe('class MongoLogger', function () {
         });
 
         const logger = new MongoLogger({
-          componentSeverities: { command: 'emergency' } as any,
+          componentSeverities: { command: 'error' } as any,
           logDestination
         } as any);
 
-        logger.emergency('command', 'Hello world!');
+        logger.error('command', 'Hello world!');
         expect(buffer).to.have.lengthOf(1);
       });
     });
@@ -121,8 +120,8 @@ describe('class MongoLogger', function () {
       ]);
 
       function* makeValidOptions(): Generator<[string, string]> {
-        const validOptions = Object.values(SeverityLevel).filter(
-          option => option !== SeverityLevel.OFF
+        const validOptions = Object.values(SeverityLevel).filter(option =>
+          ['error', 'warn', 'info', 'debug', 'trace'].includes(option)
         );
         for (const option of validOptions) {
           yield [option, option];
@@ -429,11 +428,11 @@ describe('class MongoLogger', function () {
                 const options = MongoLogger.resolveOptions(
                   {
                     MONGODB_LOG_PATH: unsetEnvironmentOption,
-                    MONGODB_LOG_COMMAND: 'emergency'
+                    MONGODB_LOG_COMMAND: 'error'
                   },
                   { mongodbLogPath: unsetOption as any }
                 );
-                const log: Log = { t: new Date(), c: 'command', s: 'emergency' };
+                const log: Log = { t: new Date(), c: 'command', s: 'error' };
                 options.logDestination.write(log);
 
                 expect(stderrStub.write).to.have.been.calledOnceWith(
@@ -451,11 +450,11 @@ describe('class MongoLogger', function () {
                 const options = MongoLogger.resolveOptions(
                   {
                     MONGODB_LOG_PATH: unsetEnvironmentOption,
-                    MONGODB_LOG_COMMAND: 'emergency'
+                    MONGODB_LOG_COMMAND: 'error'
                   },
                   { mongodbLogPath: invalidOption as any }
                 );
-                const log: Log = { t: new Date(), c: 'command', s: 'emergency' };
+                const log: Log = { t: new Date(), c: 'command', s: 'error' };
                 options.logDestination.write(log);
 
                 expect(stderrStub.write).to.have.been.calledOnceWith(
@@ -473,12 +472,12 @@ describe('class MongoLogger', function () {
                 const options = MongoLogger.resolveOptions(
                   {
                     MONGODB_LOG_PATH: unsetEnvironmentOption,
-                    MONGODB_LOG_COMMAND: 'emergency'
+                    MONGODB_LOG_COMMAND: 'error'
                   },
                   { mongodbLogPath: validOption as any }
                 );
 
-                const log: Log = { t: new Date(), c: 'command', s: 'emergency' };
+                const log: Log = { t: new Date(), c: 'command', s: 'error' };
                 options.logDestination.write(log);
                 const correctDestination = validOptions.get(validOption);
                 expect(correctDestination?.write).to.have.been.calledOnce;
@@ -498,11 +497,11 @@ describe('class MongoLogger', function () {
                   const options = MongoLogger.resolveOptions(
                     {
                       MONGODB_LOG_PATH: invalidEnvironmentOption,
-                      MONGODB_LOG_COMMAND: 'emergency'
+                      MONGODB_LOG_COMMAND: 'error'
                     },
                     { mongodbLogPath: unsetClientOption as any }
                   );
-                  const log: Log = { t: new Date(), c: 'command', s: 'emergency' };
+                  const log: Log = { t: new Date(), c: 'command', s: 'error' };
                   options.logDestination.write(log);
 
                   expect(stderrStub.write).to.have.been.calledOnceWith(
@@ -522,11 +521,11 @@ describe('class MongoLogger', function () {
                     const options = MongoLogger.resolveOptions(
                       {
                         MONGODB_LOG_PATH: invalidEnvironmentOption,
-                        MONGODB_LOG_COMMAND: 'emergency'
+                        MONGODB_LOG_COMMAND: 'error'
                       },
                       { mongodbLogPath: invalidOption as any }
                     );
-                    const log: Log = { t: new Date(), c: 'command', s: 'emergency' };
+                    const log: Log = { t: new Date(), c: 'command', s: 'error' };
                     options.logDestination.write(log);
 
                     expect(stderrStub.write).to.have.been.calledOnceWith(
@@ -545,12 +544,12 @@ describe('class MongoLogger', function () {
                   const options = MongoLogger.resolveOptions(
                     {
                       MONGODB_LOG_PATH: invalidEnvironmentOption,
-                      MONGODB_LOG_COMMAND: 'emergency'
+                      MONGODB_LOG_COMMAND: 'error'
                     },
                     { mongodbLogPath: validOption as any }
                   );
                   const correctDestination = validOptions.get(validOption);
-                  const log: Log = { t: new Date(), c: 'command', s: 'emergency' };
+                  const log: Log = { t: new Date(), c: 'command', s: 'error' };
                   options.logDestination.write(log);
                   expect(correctDestination?.write).to.have.been.calledOnce;
                 });
@@ -568,12 +567,12 @@ describe('class MongoLogger', function () {
                 const options = MongoLogger.resolveOptions(
                   {
                     MONGODB_LOG_PATH: validEnvironmentOption,
-                    MONGODB_LOG_COMMAND: 'emergency'
+                    MONGODB_LOG_COMMAND: 'error'
                   },
                   { mongodbLogPath: unsetOption as any }
                 );
                 const correctDestination = validOptions.get(validEnvironmentOption);
-                options.logDestination.write({ t: new Date(), c: 'command', s: 'emergency' });
+                options.logDestination.write({ t: new Date(), c: 'command', s: 'error' });
 
                 expect(correctDestination?.write).to.have.been.calledOnce;
               });
@@ -590,13 +589,13 @@ describe('class MongoLogger', function () {
                   const options = MongoLogger.resolveOptions(
                     {
                       MONGODB_LOG_PATH: validEnvironmentOption,
-                      MONGODB_LOG_COMMAND: 'emergency'
+                      MONGODB_LOG_COMMAND: 'error'
                     },
                     { mongodbLogPath: invalidValue as any }
                   );
 
                   const correctDestination = validOptions.get(validEnvironmentOption);
-                  const log: Log = { t: new Date(), c: 'command', s: 'emergency' };
+                  const log: Log = { t: new Date(), c: 'command', s: 'error' };
                   options.logDestination.write(log);
 
                   expect(correctDestination?.write).to.have.been.calledOnce;
@@ -617,12 +616,12 @@ describe('class MongoLogger', function () {
                 const options = MongoLogger.resolveOptions(
                   {
                     MONGODB_LOG_PATH: validEnvironmentOption,
-                    MONGODB_LOG_COMMAND: 'emergency'
+                    MONGODB_LOG_COMMAND: 'error'
                   },
                   { mongodbLogPath: validValue as any }
                 );
                 const correctDestination = validOptions.get(validValue);
-                options.logDestination.write({ t: new Date(), c: 'command', s: 'emergency' });
+                options.logDestination.write({ t: new Date(), c: 'command', s: 'error' });
                 expect(correctDestination?.write).to.have.been.calledOnce;
               });
             }
@@ -633,9 +632,10 @@ describe('class MongoLogger', function () {
   });
 
   describe('severity helpers', function () {
-    // TODO(NODE-4814): Ensure we test on all valid severity levels
-    const severities = Object.values(SeverityLevel).filter(severity => severity === 'emergency');
-    for (const severityLevel of severities) {
+    const severities: SeverityLevel[] = Object.values(SeverityLevel).filter(severity =>
+      ['error', 'warn', 'info', 'debug', 'trace'].includes(severity)
+    );
+    for (const [index, severityLevel] of severities.entries()) {
       describe(`${severityLevel}()`, function () {
         it('does not log when logging for the component is disabled', () => {
           const stream = new BufferingStream();
@@ -650,8 +650,7 @@ describe('class MongoLogger', function () {
           expect(stream.buffer).to.have.lengthOf(0);
         });
 
-        // TODO(NODE-4814): Unskip this test
-        context.skip('when the log severity is greater than what was configured', function () {
+        context('when the log severity is greater than what was configured', function () {
           it('does not write to logDestination', function () {
             const stream = new BufferingStream();
             const logger = new MongoLogger({
@@ -661,14 +660,9 @@ describe('class MongoLogger', function () {
               logDestination: stream
             } as any);
 
-            const TRACE = 8;
-            for (
-              let l = SEVERITY_LEVEL_MAP.getNumericSeverityLevel(severityLevel) + 1;
-              l <= TRACE;
-              l++
-            ) {
-              const severity = SEVERITY_LEVEL_MAP.getSeverityLevelName(l);
-              logger[severity as SeverityLevel]('command', 'Hello');
+            for (let i = index + 1; i < severities.length; i++) {
+              const severity = severities[i];
+              logger[severity]('command', 'Hello');
             }
 
             expect(stream.buffer).to.have.lengthOf(0);
@@ -685,20 +679,13 @@ describe('class MongoLogger', function () {
               logDestination: stream
             } as any);
 
-            const EMERGENCY = 0;
             // Calls all severity logging methods with a level less than or equal to what severityLevel
-            for (
-              let l = SEVERITY_LEVEL_MAP.getNumericSeverityLevel(severityLevel);
-              l >= EMERGENCY;
-              l--
-            ) {
-              const severity = SEVERITY_LEVEL_MAP.getSeverityLevelName(l);
-              logger[severity as SeverityLevel]('command', 'Hello');
+            for (let i = index; i >= 0; i--) {
+              const severity = severities[i];
+              logger[severity]('command', 'Hello');
             }
 
-            expect(stream.buffer).to.have.lengthOf(
-              SEVERITY_LEVEL_MAP.getNumericSeverityLevel(severityLevel) + 1
-            );
+            expect(stream.buffer).to.have.lengthOf(index + 1);
           });
         });