willLog precomputed

Author: aditi-khare-mongoDB

src/mongo_logger.ts

@@ -728,7 +728,10 @@ export class MongoLogger {
   logDestination: MongoDBLogWritable;
   logDestinationIsStdErr: boolean;
   pendingLog: PromiseLike<unknown> | unknown = null;
-  willLog: any; //Record<MongoLoggableComponent, Record<SeverityLevel, boolean>>;
+  willLog: Record<MongoLoggableComponent, Record<SeverityLevel, boolean>> = {} as Record<
+    MongoLoggableComponent,
+    Record<SeverityLevel, boolean>
+  >;
 
   /**
    * This method should be used when logging errors that do not have a public driver API for
@@ -761,25 +764,26 @@ export class MongoLogger {
     this.maxDocumentLength = options.maxDocumentLength;
     this.logDestination = options.logDestination;
     this.logDestinationIsStdErr = options.logDestinationIsStdErr;
-    this.willLog = this.createWillLog();
+    this.createWillLog();
   }
 
   createWillLog() {
-    const to_return = {};
-    console.log(Object.values(SEVERITY_LEVEL_MAP))
     for (const component of Object.values(MongoLoggableComponent)) {
-      const componentSeverityNum = SEVERITY_LEVEL_MAP.getNumericSeverityLevel(this.componentSeverities[component]);
-      for (const severityLevel of Object.entries(SEVERITY_LEVEL_MAP)) {
-        
-      } 
-   
+      this.willLog[component] = Object.fromEntries(
+        Object.entries(SeverityLevel).map(([_key, value]) => [
+          value as SeverityLevel,
+          compareSeverity(value, this.componentSeverities[component]) <= 0
+        ])
+      ) as Record<SeverityLevel, boolean>;
     }
-    return to_return;
   }
 
   turnOffSeverities() {
-    for (const key of Object.values(MongoLoggableComponent)) {
-      this.componentSeverities[key as MongoLoggableComponent] = SeverityLevel.OFF;
+    for (const component of Object.values(MongoLoggableComponent)) {
+      this.componentSeverities[component] = SeverityLevel.OFF;
+      for (const severityLevel of Object.values(SeverityLevel)) {
+        this.willLog[component][severityLevel] = false;
+      }
     }
   }
 
@@ -813,7 +817,7 @@ export class MongoLogger {
     component: MongoLoggableComponent,
     message: Loggable | string
   ): void {
-    if (!this.willLog(severity, component)) return;
+    if (!this.willLog[component][severity]) return;
 
     let logMessage: Log = { t: new Date(), c: component, s: severity };
     if (typeof message === 'string') {

test/unit/cmap/connection_pool.test.js

@@ -7,7 +7,7 @@ const sinon = require('sinon');
 const { expect } = require('chai');
 const { setImmediate } = require('timers');
 const { promisify } = require('util');
-const { ns, isHello } = require('../../mongodb');
+const { ns, isHello, MongoLoggableComponent } = require('../../mongodb');
 const { LEGACY_HELLO_COMMAND } = require('../../mongodb');
 const { createTimerSandbox } = require('../timer_sandbox');
 const { topologyWithPlaceholderClient } = require('../../tools/utils');
@@ -19,7 +19,9 @@ describe('Connection Pool', function () {
       client: {
         mongoLogger: {
           debug: () => null,
-          willLog: () => null
+          willLog: Object.fromEntries(
+            Object.values(MongoLoggableComponent).map(([value]) => [value, {}])
+          )
         }
       }
     }

test/unit/mongo_logger.test.ts

@@ -23,6 +23,7 @@ import {
   DEFAULT_MAX_DOCUMENT_LENGTH,
   type Log,
   type MongoDBLogWritable,
+  MongoLoggableComponent,
   MongoLogger,
   type MongoLoggerOptions,
   parseSeverityFromString,
@@ -114,6 +115,61 @@ describe('class MongoLogger', async function () {
         expect(buffer).to.have.lengthOf(1);
       });
     });
+
+    describe('willLog', function () {
+      const expectedWillLog = {};
+      const errorWillLogRow = {
+        off: true,
+        emergency: true,
+        alert: true,
+        critical: true,
+        error: true,
+        warn: false,
+        notice: false,
+        info: false,
+        debug: false,
+        trace: false
+      };
+      const debugWillLogRow = {
+        off: true,
+        emergency: true,
+        alert: true,
+        critical: true,
+        error: true,
+        warn: true,
+        notice: true,
+        info: true,
+        debug: true,
+        trace: false
+      };
+
+      for (const component of Object.values(MongoLoggableComponent)) {
+        context(`when component is ${component}`, function () {
+          it(`willLog[${component}] object should only return true for values <= its componentSeverity `, function () {
+            // generate component severities, set default severity to 'error' and relevant component severity to 'debug'
+            const componentSeverities = Object.fromEntries(
+              Object.entries(MongoLoggableComponent).map(([_key, value]) =>
+                value === component ? [value, 'debug'] : [value, 'error']
+              )
+            );
+
+            // create expected willLog
+            for (const component2 of Object.values(MongoLoggableComponent)) {
+              expectedWillLog[component2] =
+                component2 === component ? debugWillLogRow : errorWillLogRow;
+            }
+
+            const logger = new MongoLogger({
+              componentSeverities: componentSeverities,
+              logDestination: createStdioLogger(process.stderr),
+              logDestinationIsStdErr: true
+            } as any);
+
+            expect(logger.willLog).to.deep.equal(expectedWillLog);
+          });
+        });
+      }
+    });
   });
 
   describe('static #resolveOptions()', function () {