feat(NODE-4810): define the new Logger

src/connection_string.ts

@@ -33,11 +33,12 @@ import {
   DEFAULT_PK_FACTORY,
   emitWarning,
   emitWarningOnce,
-  getInt,
-  getUint,
+  getInt as getIntFromOptions,
+  getUint as getUIntFromOptions,
   HostAddress,
   isRecord,
   makeClientMetadata,
+  parseInt,
   setDifference
 } from './utils';
 import { W, WriteConcern } from './write_concern';
@@ -202,6 +203,22 @@ function getBoolean(name: string, value: unknown): boolean {
   throw new MongoParseError(`Expected ${name} to be stringified boolean value, got: ${value}`);
 }
 
+function getIntFromOptions(name: string, value: unknown): number {
+  const parsedInt = parseInt(value);
+  if (parsedInt != null) {
+    return parsedInt;
+  }
+  throw new MongoParseError(`Expected ${name} to be stringified int value, got: ${value}`);
+}
+
+function getUIntFromOptions(name: string, value: unknown): number {
+  const parsedValue = getIntFromOptions(name, value);
+  if (parsedValue < 0) {
+    throw new MongoParseError(`${name} can only be a positive int value, got: ${value}`);
+  }
+  return parsedValue;
+}
+
 function* entriesFromString(value: string): Generator<[string, string]> {
   const keyValuePairs = value.split(',');
   for (const keyValue of keyValuePairs) {
@@ -573,10 +590,10 @@ function setOption(
       mongoOptions[name] = getBoolean(name, values[0]);
       break;
     case 'int':
-      mongoOptions[name] = getInt(name, values[0]);
+      mongoOptions[name] = getIntFromOptions(name, values[0]);
       break;
     case 'uint':
-      mongoOptions[name] = getUint(name, values[0]);
+      mongoOptions[name] = getUIntFromOptions(name, values[0]);
       break;
     case 'string':
       if (values[0] == null) {
@@ -782,7 +799,7 @@ export const OPTIONS = {
   enableUtf8Validation: { type: 'boolean', default: true },
   family: {
     transform({ name, values: [value] }): 4 | 6 {
-      const transformValue = getInt(name, value);
+      const transformValue = getIntFromOptions(name, value);
       if (transformValue === 4 || transformValue === 6) {
         return transformValue;
       }
@@ -881,7 +898,7 @@ export const OPTIONS = {
   maxConnecting: {
     default: 2,
     transform({ name, values: [value] }): number {
-      const maxConnecting = getUint(name, value);
+      const maxConnecting = getUIntFromOptions(name, value);
       if (maxConnecting === 0) {
         throw new MongoInvalidArgumentError('maxConnecting must be > 0 if specified');
       }
@@ -899,7 +916,7 @@ export const OPTIONS = {
   maxStalenessSeconds: {
     target: 'readPreference',
     transform({ name, options, values: [value] }) {
-      const maxStalenessSeconds = getUint(name, value);
+      const maxStalenessSeconds = getUIntFromOptions(name, value);
       if (options.readPreference) {
         return ReadPreference.fromOptions({
           readPreference: { ...options.readPreference, maxStalenessSeconds }
@@ -1218,7 +1235,7 @@ export const OPTIONS = {
       const wc = WriteConcern.fromOptions({
         writeConcern: {
           ...options.writeConcern,
-          wtimeout: getUint('wtimeout', value)
+          wtimeout: getUIntFromOptions('wtimeout', value)
         }
       });
       if (wc) return wc;
@@ -1231,7 +1248,7 @@ export const OPTIONS = {
       const wc = WriteConcern.fromOptions({
         writeConcern: {
           ...options.writeConcern,
-          wtimeoutMS: getUint('wtimeoutMS', value)
+          wtimeoutMS: getUIntFromOptions('wtimeoutMS', value)
         }
       });
       if (wc) return wc;

src/mongo_logger.ts

@@ -1,6 +1,6 @@
 import { Writable } from 'stream';
 
-import { getUint } from './utils';
+import { getUint, parseUInt } from './utils';
 
 /** @internal */
 export const SeverityLevel = Object.freeze({
@@ -93,21 +93,6 @@ function parseSeverityFromString(s?: string): SeverityLevel | null {
   return null;
 }
 
-/**
- * Parses a string to be a number greater than or equal to 0 for maxDocumentLength.
- *
- * @param s - the value to be parsed
- * @returns the int value parsed or 1000 if the value could not be parsed
- */
-function parseMaxDocumentLength(s?: string): number {
-  try {
-    const maxDocumentLength = getUint('MONGODB_LOG_MAX_DOCUMENT_LENGTH', s);
-    return maxDocumentLength;
-  } catch {
-    return 1000;
-  }
-}
-
 /**
  * resolves the MONGODB_LOG_PATH and mongodbLogPath options from the environment and the
  * mongo client options respectively.
@@ -128,7 +113,7 @@ function resolveLogPath(
     return mongodbLogPath.toLowerCase() === 'stderr' ? process.stderr : process.stdout;
   }
 
-  // TODO(NODE-4886): check for minimal interface instead of instanceof Writable
+  // TODO(NODE-4813): check for minimal interface instead of instanceof Writable
   if (typeof mongodbLogPath === 'object' && mongodbLogPath instanceof Writable) {
     return mongodbLogPath;
   }
@@ -208,7 +193,7 @@ export class MongoLogger {
           parseSeverityFromString(combinedOptions.MONGODB_LOG_CONNECTION) ?? defaultSeverity,
         default: defaultSeverity
       },
-      maxDocumentLength: parseMaxDocumentLength(combinedOptions.MONGODB_LOG_MAX_DOCUMENT_LENGTH),
+      maxDocumentLength: parseUInt(combinedOptions.MONGODB_LOG_MAX_DOCUMENT_LENGTH) ?? 1000,
       logDestination: combinedOptions.mongodbLogPath
     };
   }

src/utils.ts

@@ -1422,17 +1422,15 @@ export function compareObjectId(oid1?: ObjectId | null, oid2?: ObjectId | null):
   return oid1.id.compare(oid2.id);
 }
 
-export function getInt(name: string, value: unknown): number {
+export function parseInt(value: unknown): number | null {
   if (typeof value === 'number') return Math.trunc(value);
   const parsedValue = Number.parseInt(String(value), 10);
-  if (!Number.isNaN(parsedValue)) return parsedValue;
-  throw new MongoParseError(`Expected ${name} to be stringified int value, got: ${value}`);
+
+  return Number.isNaN(parsedValue) ? null : parsedValue;
 }
 
-export function getUint(name: string, value: unknown): number {
-  const parsedValue = getInt(name, value);
-  if (parsedValue < 0) {
-    throw new MongoParseError(`${name} can only be a positive int value, got: ${value}`);
-  }
-  return parsedValue;
+export function parseUInt(value: unknown): number | null {
+  const parsedInt = parseInt(value);
+
+  return parsedInt != null && parsedInt >= 0 ? parsedInt : null;
 }