feat(NODE-4815): add maybeTruncate

Author: W-A-James

src/mongo_logger.ts

@@ -53,6 +53,8 @@ export const SeverityLevel = Object.freeze({
   OFF: 'off'
 } as const);
 
+/** @internal */
+export const DEFAULT_MAX_DOCUMENT_LENGTH = 1000;
 /** @internal */
 export type SeverityLevel = (typeof SeverityLevel)[keyof typeof SeverityLevel];
 
@@ -254,6 +256,18 @@ export interface LogConvertible extends Record<string, any> {
   toLog(): Record<string, any>;
 }
 
+/** @internal */
+export function maybeTruncate(
+  ejson: string,
+  maxDocumentLength: number = DEFAULT_MAX_DOCUMENT_LENGTH
+): string {
+  if (maxDocumentLength === 0) {
+    return ejson;
+  }
+
+  return ejson.length > maxDocumentLength ? `${ejson.slice(0, maxDocumentLength)}...` : ejson;
+}
+
 /** @internal */
 export type Loggable = LoggableEvent | LogConvertible;
 
@@ -292,22 +306,23 @@ function attachConnectionFields(
 }
 
 function defaultLogTransform(
-  logObject: LoggableEvent | Record<string, any>
+  logObject: LoggableEvent | Record<string, any>,
+  maxDocumentLength: number = DEFAULT_MAX_DOCUMENT_LENGTH
 ): Omit<Log, 's' | 't' | 'c'> {
   let log: Omit<Log, 's' | 't' | 'c'> = Object.create(null);
 
   switch (logObject.name) {
     case COMMAND_STARTED:
       log = attachCommandFields(log, logObject);
       log.message = 'Command started';
-      log.command = EJSON.stringify(logObject.command);
+      log.command = maybeTruncate(EJSON.stringify(logObject.command), maxDocumentLength);
       log.databaseName = logObject.databaseName;
       return log;
     case COMMAND_SUCCEEDED:
       log = attachCommandFields(log, logObject);
       log.message = 'Command succeeded';
       log.durationMS = logObject.duration;
-      log.reply = EJSON.stringify(logObject.reply);
+      log.reply = maybeTruncate(EJSON.stringify(logObject.reply), maxDocumentLength);
       return log;
     case COMMAND_FAILED:
       log = attachCommandFields(log, logObject);
@@ -452,7 +467,7 @@ export class MongoLogger {
       if (isLogConvertible(message)) {
         logMessage = { ...logMessage, ...message.toLog() };
       } else {
-        logMessage = { ...logMessage, ...defaultLogTransform(message) };
+        logMessage = { ...logMessage, ...defaultLogTransform(message, this.maxDocumentLength) };
       }
     }
     this.logDestination.write(logMessage);

test/unit/mongo_logger.test.ts

@@ -19,7 +19,9 @@ import {
   CONNECTION_POOL_CREATED,
   CONNECTION_POOL_READY,
   CONNECTION_READY,
+  DEFAULT_MAX_DOCUMENT_LENGTH,
   Log,
+  maybeTruncate,
   MongoDBLogWritable,
   MongoLogger,
   MongoLoggerOptions,
@@ -1239,4 +1241,50 @@ describe('class MongoLogger', function () {
       });
     }
   });
+
+  describe('maybeTruncate', function () {
+    let largeEjsonString: string;
+    let smallEjsonString: string;
+    before(function () {
+      const largeDoc = {};
+      for (let i = 0; i < DEFAULT_MAX_DOCUMENT_LENGTH; i++) {
+        largeDoc[`test${i}`] = `Hello_${i}`;
+      }
+      largeEjsonString = EJSON.stringify(largeDoc);
+      const smallDoc = { test: 'Hello' };
+      smallEjsonString = EJSON.stringify(smallDoc);
+    });
+
+    context('when maxDocumentLength = 0', function () {
+      it('does not truncate document', function () {
+        expect(maybeTruncate(largeEjsonString, 0)).to.equal(largeEjsonString);
+      });
+    });
+
+    context('when maxDocumentLength is non-zero', function () {
+      context('when document has length greater than maxDocumentLength', function () {
+        it('truncates ejson string to length of maxDocumentLength + 3', function () {
+          expect(maybeTruncate(largeEjsonString)).to.have.lengthOf(DEFAULT_MAX_DOCUMENT_LENGTH + 3);
+        });
+        it('ends with "..."', function () {
+          expect(maybeTruncate(largeEjsonString)).to.match(/^.*\.\.\.$/);
+        });
+      });
+
+      context('when document has length less than or equal to maxDocumentLength', function () {
+        it('does not truncate document', function () {
+          expect(maybeTruncate(smallEjsonString)).to.equal(smallEjsonString);
+        });
+        it('does not end with "..."', function () {
+          expect(maybeTruncate(smallEjsonString)).to.not.match(/^.*\.\.\./);
+        });
+
+        it('produces valid relaxed EJSON', function () {
+          expect(() => {
+            EJSON.parse(maybeTruncate(smallEjsonString));
+          }).to.not.throw();
+        });
+      });
+    });
+  });
 });