feat(mongodb-log-writer): add ability to disable and enable logging

Adds a new isDisabled field to disable the writing of logs. This can be modified using the new enable() and disable() methods.

Author: gagik

packages/mongodb-log-writer/src/mongo-log-writer.spec.ts

@@ -5,11 +5,107 @@ import stream from 'stream';
 import { inspect } from 'util';
 import chai, { expect } from 'chai';
 import sinonChai from 'sinon-chai';
+import sinon from 'sinon';
 chai.use(sinonChai);
 
 describe('MongoLogWriter', function () {
+  const now = new Date(1628591965386);
+
+  describe('enabling and disabling', function () {
+    let writer: MongoLogWriter;
+    let target: stream.PassThrough;
+    let writeSpy: sinon.SinonSpy;
+
+    const SEVERITIES_COUNT = 5;
+
+    function logAllSeverities(writer: MongoLogWriter) {
+      writer.info('component', mongoLogId(12345), 'context', 'message', {});
+      writer.warn('component', mongoLogId(12345), 'context', 'message', {});
+      writer.error('component', mongoLogId(12345), 'context', 'message', {});
+      writer.debug('component', mongoLogId(12345), 'context', 'message', {});
+      writer.fatal('component', mongoLogId(12345), 'context', 'message', {});
+    }
+
+    beforeEach(function () {
+      target = new stream.PassThrough().setEncoding('utf8');
+      writer = new MongoLogWriter('logid', null, target, () => now);
+      writeSpy = sinon.spy(writer, 'write');
+    });
+
+    afterEach(function () {
+      sinon.restore();
+    });
+
+    it('is enabled by default', async function () {
+      expect(writer.isDisabled).to.equal(false);
+
+      writer.info('component', mongoLogId(12345), 'context', 'message', {});
+
+      await writer.flush();
+
+      expect(target.read()).is.not.null;
+      expect(writeSpy).callCount(1);
+    });
+
+    it('can be disabled on initialization', async function () {
+      const disabledWriter = new MongoLogWriter(
+        'logid',
+        null,
+        target,
+        () => now,
+        {
+          isDisabled: true,
+        }
+      );
+
+      expect(disabledWriter.isDisabled).to.equal(true);
+      logAllSeverities(disabledWriter);
+
+      await disabledWriter.flush();
+
+      expect(target.read()).is.null;
+      expect(writeSpy).not.called;
+    });
+
+    it('can run disable() to disable logging across all severities', function () {
+      expect(writer.isDisabled).to.equal(false);
+
+      logAllSeverities(writer);
+
+      expect(writeSpy).callCount(SEVERITIES_COUNT);
+
+      writer.disable();
+
+      expect(writer.isDisabled).to.equal(true);
+
+      logAllSeverities(writer);
+
+      expect(writeSpy).callCount(SEVERITIES_COUNT);
+    });
+
+    it('can run enable() after being disabled', async function () {
+      expect(writer.isDisabled).to.equal(false);
+
+      writer.disable();
+      expect(writer.isDisabled).to.equal(true);
+
+      logAllSeverities(writer);
+
+      expect(writeSpy).not.called;
+
+      writer.enable();
+      expect(writer.isDisabled).to.equal(false);
+
+      logAllSeverities(writer);
+
+      await writer.flush();
+
+      expect(target.read()).not.null;
+      expect(writeSpy).callCount(SEVERITIES_COUNT);
+    });
+  });
+
   it('allows writing log messages to a stream', async function () {
-    const now = new Date(1628591965386);
     const target = new stream.PassThrough().setEncoding('utf8');
     const writer = new MongoLogWriter('logid', null, target, () => now);
     const logEvents: MongoLogEntry[] = [];

packages/mongodb-log-writer/src/mongo-log-writer.ts

@@ -63,6 +63,10 @@ function validateLogEntry(info: MongoLogEntry): Error | null {
   return null;
 }
 
+export type MongoLogWriterOptions = {
+  isDisabled?: boolean;
+};
+
 /**
  * A helper class for writing formatted log information to an output stream.
  * This class itself is an object-mode Writable stream to which
@@ -72,10 +76,11 @@ function validateLogEntry(info: MongoLogEntry): Error | null {
  * the target stream.
  */
 export class MongoLogWriter extends Writable {
-  _logId: string;
-  _logFilePath: string | null;
-  _target: PlainWritable;
-  _now: () => Date;
+  private _logId: string;
+  private _logFilePath: string | null;
+  private _target: PlainWritable;
+  private _now: () => Date;
+  private _isDisabled: boolean;
 
   /**
    * @param logId A unique identifier for this log file. This is not used outside the `logId` getter.
@@ -87,13 +92,15 @@ export class MongoLogWriter extends Writable {
     logId: string,
     logFilePath: string | null,
     target: PlainWritable,
-    now?: () => Date
+    now?: () => Date,
+    { isDisabled = false }: MongoLogWriterOptions = {}
   ) {
     super({ objectMode: true });
     this._logId = logId;
     this._logFilePath = logFilePath;
     this._target = target;
     this._now = now ?? (() => new Date());
+    this._isDisabled = isDisabled;
   }
 
   /** Return the logId passed to the constructor. */
@@ -111,6 +118,21 @@ export class MongoLogWriter extends Writable {
     return this._target;
   }
 
+  /**
+   * Return whether the logger is currently disabled.
+   */
+  get isDisabled() {
+    return this._isDisabled;
+  }
+
+  disable(): void {
+    this._isDisabled = true;
+  }
+
+  enable(): void {
+    this._isDisabled = false;
+  }
+
   _write(
     info: MongoLogEntry,
     encoding: unknown,
@@ -186,6 +208,13 @@ export class MongoLogWriter extends Writable {
     await new Promise((resolve) => this._target.write('', resolve));
   }
 
+  writeIfEnabled(chunk: Parameters<typeof this.write>[0]): void {
+    if (this._isDisabled) {
+      return;
+    }
+    this.write(chunk);
+  }
+
   /**
    * Write a log entry with severity 'I'.
    */
@@ -204,7 +233,7 @@ export class MongoLogWriter extends Writable {
       msg: message,
       attr: attr,
     };
-    this.write(logEntry);
+    this.writeIfEnabled(logEntry);
   }
 
   /**
@@ -225,7 +254,7 @@ export class MongoLogWriter extends Writable {
       msg: message,
       attr: attr,
     };
-    this.write(logEntry);
+    this.writeIfEnabled(logEntry);
   }
 
   /**
@@ -246,7 +275,7 @@ export class MongoLogWriter extends Writable {
       msg: message,
       attr: attr,
     };
-    this.write(logEntry);
+    this.writeIfEnabled(logEntry);
   }
 
   /**
@@ -267,7 +296,7 @@ export class MongoLogWriter extends Writable {
       msg: message,
       attr: attr,
     };
-    this.write(logEntry);
+    this.writeIfEnabled(logEntry);
   }
 
   /**
@@ -289,7 +318,7 @@ export class MongoLogWriter extends Writable {
       msg: message,
       attr: attr,
     };
-    this.write(logEntry);
+    this.writeIfEnabled(logEntry);
   }
 
   /**