mongodb 6.12.0 → 6.13.0-dev.20250201.sha.35c703e3

package/src/mongo_logger.ts

@@ -1,6 +1,24 @@
 import { inspect, promisify } from 'util';
+import { isUint8Array } from 'util/types';
 
-import { type Document, EJSON, type EJSONOptions, type ObjectId } from './bson';
+import {
+  type Binary,
+  type BSONRegExp,
+  type BSONSymbol,
+  type Code,
+  type DBRef,
+  type Decimal128,
+  type Document,
+  type Double,
+  EJSON,
+  type EJSONOptions,
+  type Int32,
+  type Long,
+  type MaxKey,
+  type MinKey,
+  type ObjectId,
+  type Timestamp
+} from './bson';
 import type { CommandStartedEvent } from './cmap/command_monitoring_events';
 import type {
   ConnectionCheckedInEvent,
@@ -59,7 +77,11 @@ import type {
 } from './sdam/server_selection_events';
 import { HostAddress, isPromiseLike, parseUnsignedInteger } from './utils';
 
-/** @internal */
+/**
+ * @public
+ * Severity levels align with unix syslog.
+ * Most typical driver functions will log to debug.
+ */
 export const SeverityLevel = Object.freeze({
   EMERGENCY: 'emergency',
   ALERT: 'alert',
@@ -75,7 +97,7 @@ export const SeverityLevel = Object.freeze({
 
 /** @internal */
 export const DEFAULT_MAX_DOCUMENT_LENGTH = 1000;
-/** @internal */
+/** @public */
 export type SeverityLevel = (typeof SeverityLevel)[keyof typeof SeverityLevel];
 
 /** @internal */
@@ -113,7 +135,7 @@ export const SEVERITY_LEVEL_MAP = new SeverityLevelMap([
   [SeverityLevel.TRACE, 8]
 ]);
 
-/** @internal */
+/** @public */
 export const MongoLoggableComponent = Object.freeze({
   COMMAND: 'command',
   TOPOLOGY: 'topology',
@@ -122,7 +144,7 @@ export const MongoLoggableComponent = Object.freeze({
   CLIENT: 'client'
 } as const);
 
-/** @internal */
+/** @public */
 export type MongoLoggableComponent =
   (typeof MongoLoggableComponent)[keyof typeof MongoLoggableComponent];
 
@@ -146,13 +168,13 @@ export interface MongoLoggerEnvOptions {
   MONGODB_LOG_PATH?: string;
 }
 
-/** @internal */
+/** @public */
 export interface LogComponentSeveritiesClientOptions {
   /** Optional severity level for command component */
   command?: SeverityLevel;
   /** Optional severity level for topology component */
   topology?: SeverityLevel;
-  /** Optionsl severity level for server selection component */
+  /** Optional severity level for server selection component */
   serverSelection?: SeverityLevel;
   /** Optional severity level for connection component */
   connection?: SeverityLevel;
@@ -274,7 +296,7 @@ function resolveSeverityConfiguration(
   );
 }
 
-/** @internal */
+/** @public */
 export interface Log extends Record<string, any> {
   t: Date;
   c: MongoLoggableComponent;
@@ -283,10 +305,27 @@ export interface Log extends Record<string, any> {
 }
 
 /**
- * @internal
- * TODO: NODE-5671 - remove internal flag and add API comments
+ * @public
+ *
+ * A custom destination for structured logging messages.
  */
 export interface MongoDBLogWritable {
+  /**
+   * This function will be called for every enabled log message.
+   *
+   * It can be sync or async:
+   * - If it is synchronous it will block the driver from proceeding until this method returns.
+   * - If it is asynchronous the driver will not await the returned promise. It will attach fulfillment handling (`.then`).
+   *   If the promise rejects the logger will write an error message to stderr and stop functioning.
+   *   If the promise resolves the driver proceeds to the next log message (or waits for new ones to occur).
+   *
+   * Tips:
+   * - We recommend writing an async `write` function that _never_ rejects.
+   *   Instead handle logging errors as necessary to your use case and make the write function a noop, until it can be recovered.
+   * - The Log messages are structured but **subject to change** since the intended purpose is informational.
+   *   Program against this defensively and err on the side of stringifying whatever is passed in to write in some form or another.
+   *
+   */
   write(log: Log): PromiseLike<unknown> | unknown;
 }
 
@@ -413,6 +452,20 @@ export interface LogConvertible extends Record<string, any> {
   toLog(): Record<string, any>;
 }
 
+type BSONObject =
+  | BSONRegExp
+  | BSONSymbol
+  | Code
+  | DBRef
+  | Decimal128
+  | Double
+  | Int32
+  | Long
+  | MaxKey
+  | MinKey
+  | ObjectId
+  | Timestamp
+  | Binary;
 /** @internal */
 export function stringifyWithMaxLen(
   value: any,
@@ -421,13 +474,107 @@ export function stringifyWithMaxLen(
 ): string {
   let strToTruncate = '';
 
+  let currentLength = 0;
+  const maxDocumentLengthEnsurer = function maxDocumentLengthEnsurer(key: string, value: any) {
+    if (currentLength >= maxDocumentLength) {
+      return undefined;
+    }
+    // Account for root document
+    if (key === '') {
+      // Account for starting brace
+      currentLength += 1;
+      return value;
+    }
+
+    // +4 accounts for 2 quotation marks, colon and comma after value
+    // Note that this potentially undercounts since it does not account for escape sequences which
+    // will have an additional backslash added to them once passed through JSON.stringify.
+    currentLength += key.length + 4;
+
+    if (value == null) return value;
+
+    switch (typeof value) {
+      case 'string':
+        // +2 accounts for quotes
+        // Note that this potentially undercounts similarly to the key length calculation
+        currentLength += value.length + 2;
+        break;
+      case 'number':
+      case 'bigint':
+        currentLength += String(value).length;
+        break;
+      case 'boolean':
+        currentLength += value ? 4 : 5;
+        break;
+      case 'object':
+        if (isUint8Array(value)) {
+          // '{"$binary":{"base64":"<base64 string>","subType":"XX"}}'
+          // This is an estimate based on the fact that the base64 is approximately 1.33x the length of
+          // the actual binary sequence https://en.wikipedia.org/wiki/Base64
+          currentLength += (22 + value.byteLength + value.byteLength * 0.33 + 18) | 0;
+        } else if ('_bsontype' in value) {
+          const v = value as BSONObject;
+          switch (v._bsontype) {
+            case 'Int32':
+              currentLength += String(v.value).length;
+              break;
+            case 'Double':
+              // Account for representing integers as <value>.0
+              currentLength +=
+                (v.value | 0) === v.value ? String(v.value).length + 2 : String(v.value).length;
+              break;
+            case 'Long':
+              currentLength += v.toString().length;
+              break;
+            case 'ObjectId':
+              // '{"$oid":"XXXXXXXXXXXXXXXXXXXXXXXX"}'
+              currentLength += 35;
+              break;
+            case 'MaxKey':
+            case 'MinKey':
+              // '{"$maxKey":1}' or '{"$minKey":1}'
+              currentLength += 13;
+              break;
+            case 'Binary':
+              // '{"$binary":{"base64":"<base64 string>","subType":"XX"}}'
+              // This is an estimate based on the fact that the base64 is approximately 1.33x the length of
+              // the actual binary sequence https://en.wikipedia.org/wiki/Base64
+              currentLength += (22 + value.position + value.position * 0.33 + 18) | 0;
+              break;
+            case 'Timestamp':
+              // '{"$timestamp":{"t":<t>,"i":<i>}}'
+              currentLength += 19 + String(v.t).length + 5 + String(v.i).length + 2;
+              break;
+            case 'Code':
+              // '{"$code":"<code>"}' or '{"$code":"<code>","$scope":<scope>}'
+              if (v.scope == null) {
+                currentLength += v.code.length + 10 + 2;
+              } else {
+                // Ignoring actual scope object, so this undercounts by a significant amount
+                currentLength += v.code.length + 10 + 11;
+              }
+              break;
+            case 'BSONRegExp':
+              // '{"$regularExpression":{"pattern":"<pattern>","options":"<options>"}}'
+              currentLength += 34 + v.pattern.length + 13 + v.options.length + 3;
+              break;
+          }
+        }
+    }
+    return value;
+  };
+
   if (typeof value === 'string') {
     strToTruncate = value;
   } else if (typeof value === 'function') {
     strToTruncate = value.name;
   } else {
     try {
-      strToTruncate = EJSON.stringify(value, options);
+      if (maxDocumentLength !== 0) {
+        strToTruncate = EJSON.stringify(value, maxDocumentLengthEnsurer, 0, options);
+      } else {
+        strToTruncate = EJSON.stringify(value, options);
+      }
     } catch (e) {
       strToTruncate = `Extended JSON serialization failed with: ${e.message}`;
     }

package/src/mongo_types.ts

@@ -474,6 +474,44 @@ export class TypedEventEmitter<Events extends EventsDescription> extends EventEm
 /** @public */
 export class CancellationToken extends TypedEventEmitter<{ cancel(): void }> {}
 
+/** @public */
+export type Abortable = {
+  /**
+   * @experimental
+   * When provided, the corresponding `AbortController` can be used to abort an asynchronous action.
+   *
+   * The `signal.reason` value is used as the error thrown.
+   *
+   * @remarks
+   * **NOTE:** If an abort signal aborts an operation while the driver is writing to the underlying
+   * socket or reading the response from the server, the socket will be closed.
+   * If signals are aborted at a high rate during socket read/writes this can lead to a high rate of connection reestablishment.
+   *
+   * We plan to mitigate this in a future release, please follow NODE-6062 (`timeoutMS` expiration suffers the same limitation).
+   *
+   * AbortSignals are likely a best fit for human interactive interruption (ex. ctrl-C) where the frequency
+   * of cancellation is reasonably low. If a signal is programmatically aborted for 100s of operations you can empty
+   * the driver's connection pool.
+   *
+   * @example
+   * ```js
+   * const controller = new AbortController();
+   * const { signal } = controller;
+   * process.on('SIGINT', () => controller.abort(new Error('^C pressed')));
+   *
+   * try {
+   *   const res = await fetch('...', { signal });
+   *   await collection.findOne(await res.json(), { signal });
+   * catch (error) {
+   *   if (error === signal.reason) {
+   *     // signal abort error handling
+   *   }
+   * }
+   * ```
+   */
+  signal?: AbortSignal | undefined;
+};
+
 /**
  * Helper types for dot-notation filter attributes
  */

package/src/operations/execute_operation.ts

@@ -25,7 +25,7 @@ import {
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import { TimeoutContext } from '../timeout';
-import { supportsRetryableWrites } from '../utils';
+import { abortable, supportsRetryableWrites } from '../utils';
 import { AbstractOperation, Aspect } from './operation';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
@@ -64,7 +64,10 @@ export async function executeOperation<
     throw new MongoRuntimeError('This method requires a valid operation instance');
   }
 
-  const topology = await autoConnect(client);
+  const topology =
+    client.topology == null
+      ? await abortable(autoConnect(client), operation.options)
+      : client.topology;
 
   // The driver sessions spec mandates that we implicitly create sessions for operations
   // that are not explicitly provided with a session.
@@ -131,7 +134,7 @@ async function autoConnect(client: MongoClient): Promise<Topology> {
     if (client.s.hasBeenClosed) {
       throw new MongoNotConnectedError('Client must be connected before running operations');
     }
-    client.s.options[Symbol.for('@@mdb.skipPingOnConnect')] = true;
+    client.s.options.__skipPingOnConnect = true;
     try {
       await client.connect();
       if (client.topology == null) {
@@ -141,7 +144,7 @@ async function autoConnect(client: MongoClient): Promise<Topology> {
       }
       return client.topology;
     } finally {
-      delete client.s.options[Symbol.for('@@mdb.skipPingOnConnect')];
+      delete client.s.options.__skipPingOnConnect;
     }
   }
   return client.topology;
@@ -198,7 +201,8 @@ async function tryOperation<
   let server = await topology.selectServer(selector, {
     session,
     operationName: operation.commandName,
-    timeoutContext
+    timeoutContext,
+    signal: operation.options.signal
   });
 
   const hasReadAspect = operation.hasAspect(Aspect.READ_OPERATION);
@@ -260,7 +264,8 @@ async function tryOperation<
       server = await topology.selectServer(selector, {
         session,
         operationName: operation.commandName,
-        previousServer
+        previousServer,
+        signal: operation.options.signal
       });
 
       if (hasWriteAspect && !supportsRetryableWrites(server)) {

package/src/operations/list_collections.ts

@@ -2,6 +2,7 @@ import type { Binary, Document } from '../bson';
 import { CursorResponse } from '../cmap/wire_protocol/responses';
 import { type CursorTimeoutContext, type CursorTimeoutMode } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
+import { type Abortable } from '../mongo_types';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
@@ -10,7 +11,9 @@ import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
-export interface ListCollectionsOptions extends Omit<CommandOperationOptions, 'writeConcern'> {
+export interface ListCollectionsOptions
+  extends Omit<CommandOperationOptions, 'writeConcern'>,
+    Abortable {
   /** Since 4.0: If true, will only return the collection name in the response, and will omit additional info */
   nameOnly?: boolean;
   /** Since 4.0: If true and nameOnly is true, allows a user without the required privilege (i.e. listCollections action on the database) to run the command when access control is enforced. */

package/src/operations/operation.ts

@@ -1,4 +1,5 @@
 import { type BSONSerializeOptions, type Document, resolveBSONOptions } from '../bson';
+import { type Abortable } from '../mongo_types';
 import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
@@ -42,9 +43,6 @@ export interface OperationOptions extends BSONSerializeOptions {
   timeoutMS?: number;
 }
 
-/** @internal */
-const kSession = Symbol('session');
-
 /**
  * This class acts as a parent class for any operation and is responsible for setting this.options,
  * as well as setting and getting a session.
@@ -62,16 +60,16 @@ export abstract class AbstractOperation<TResult = any> {
   // BSON serialization options
   bsonOptions?: BSONSerializeOptions;
 
-  options: OperationOptions;
+  options: OperationOptions & Abortable;
 
   /** Specifies the time an operation will run until it throws a timeout error. */
   timeoutMS?: number;
 
-  [kSession]: ClientSession | undefined;
+  private _session: ClientSession | undefined;
 
   static aspects?: Set<symbol>;
 
-  constructor(options: OperationOptions = {}) {
+  constructor(options: OperationOptions & Abortable = {}) {
     this.readPreference = this.hasAspect(Aspect.WRITE_OPERATION)
       ? ReadPreference.primary
       : (ReadPreference.fromOptions(options) ?? ReadPreference.primary);
@@ -79,7 +77,7 @@ export abstract class AbstractOperation<TResult = any> {
     // Pull the BSON serialize options from the already-resolved options
     this.bsonOptions = resolveBSONOptions(options);
 
-    this[kSession] = options.session != null ? options.session : undefined;
+    this._session = options.session != null ? options.session : undefined;
 
     this.options = options;
     this.bypassPinningCheck = !!options.bypassPinningCheck;
@@ -105,12 +103,13 @@ export abstract class AbstractOperation<TResult = any> {
     return ctor.aspects.has(aspect);
   }
 
+  // Make sure the session is not writable from outside this class.
   get session(): ClientSession | undefined {
-    return this[kSession];
+    return this._session;
   }
 
   clearSession() {
-    this[kSession] = undefined;
+    this._session = undefined;
   }
 
   resetBatch(): boolean {

package/src/sdam/monitor.ts

@@ -25,13 +25,6 @@ import {
 import { Server } from './server';
 import type { TopologyVersion } from './server_description';
 
-/** @internal */
-const kServer = Symbol('server');
-/** @internal */
-const kMonitorId = Symbol('monitorId');
-/** @internal */
-const kCancellationToken = Symbol('cancellationToken');
-
 const STATE_IDLE = 'idle';
 const STATE_MONITORING = 'monitoring';
 const stateTransition = makeStateMachine({
@@ -96,11 +89,11 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
   >;
   connectOptions: ConnectionOptions;
   isRunningInFaasEnv: boolean;
-  [kServer]: Server;
+  server: Server;
   connection: Connection | null;
-  [kCancellationToken]: CancellationToken;
+  cancellationToken: CancellationToken;
   /** @internal */
-  [kMonitorId]?: MonitorInterval;
+  monitorId?: MonitorInterval;
   rttPinger?: RTTPinger;
   /** @internal */
   override component = MongoLoggableComponent.TOPOLOGY;
@@ -110,11 +103,11 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
   constructor(server: Server, options: MonitorOptions) {
     super();
 
-    this[kServer] = server;
+    this.server = server;
     this.connection = null;
-    this[kCancellationToken] = new CancellationToken();
-    this[kCancellationToken].setMaxListeners(Infinity);
-    this[kMonitorId] = undefined;
+    this.cancellationToken = new CancellationToken();
+    this.cancellationToken.setMaxListeners(Infinity);
+    this.monitorId = undefined;
     this.s = {
       state: STATE_CLOSED
     };
@@ -126,10 +119,10 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
       serverMonitoringMode: options.serverMonitoringMode
     });
     this.isRunningInFaasEnv = getFAASEnv() != null;
-    this.mongoLogger = this[kServer].topology.client?.mongoLogger;
+    this.mongoLogger = this.server.topology.client?.mongoLogger;
     this.rttSampler = new RTTSampler(10);
 
-    const cancellationToken = this[kCancellationToken];
+    const cancellationToken = this.cancellationToken;
     // TODO: refactor this to pull it directly from the pool, requires new ConnectionPool integration
     const connectOptions = {
       id: '<monitor>' as const,
@@ -162,7 +155,7 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
     // start
     const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS;
     const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS;
-    this[kMonitorId] = new MonitorInterval(monitorServer(this), {
+    this.monitorId = new MonitorInterval(monitorServer(this), {
       heartbeatFrequencyMS: heartbeatFrequencyMS,
       minHeartbeatFrequencyMS: minHeartbeatFrequencyMS,
       immediate: true
@@ -174,11 +167,11 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
       return;
     }
 
-    this[kMonitorId]?.wake();
+    this.monitorId?.wake();
   }
 
   reset(): void {
-    const topologyVersion = this[kServer].description.topologyVersion;
+    const topologyVersion = this.server.description.topologyVersion;
     if (isInCloseState(this) || topologyVersion == null) {
       return;
     }
@@ -192,7 +185,7 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
     // restart monitoring
     const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS;
     const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS;
-    this[kMonitorId] = new MonitorInterval(monitorServer(this), {
+    this.monitorId = new MonitorInterval(monitorServer(this), {
       heartbeatFrequencyMS: heartbeatFrequencyMS,
       minHeartbeatFrequencyMS: minHeartbeatFrequencyMS
     });
@@ -233,13 +226,13 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
 }
 
 function resetMonitorState(monitor: Monitor) {
-  monitor[kMonitorId]?.stop();
-  monitor[kMonitorId] = undefined;
+  monitor.monitorId?.stop();
+  monitor.monitorId = undefined;
 
   monitor.rttPinger?.close();
   monitor.rttPinger = undefined;
 
-  monitor[kCancellationToken].emit('cancel');
+  monitor.cancellationToken.emit('cancel');
 
   monitor.connection?.destroy();
   monitor.connection = null;
@@ -266,11 +259,11 @@ function useStreamingProtocol(monitor: Monitor, topologyVersion: TopologyVersion
 function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
   let start: number;
   let awaited: boolean;
-  const topologyVersion = monitor[kServer].description.topologyVersion;
+  const topologyVersion = monitor.server.description.topologyVersion;
   const isAwaitable = useStreamingProtocol(monitor, topologyVersion);
   monitor.emitAndLogHeartbeat(
     Server.SERVER_HEARTBEAT_STARTED,
-    monitor[kServer].topology.s.id,
+    monitor.server.topology.s.id,
     undefined,
     new ServerHeartbeatStartedEvent(monitor.address, isAwaitable)
   );
@@ -280,7 +273,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
     monitor.connection = null;
     monitor.emitAndLogHeartbeat(
       Server.SERVER_HEARTBEAT_FAILED,
-      monitor[kServer].topology.s.id,
+      monitor.server.topology.s.id,
       undefined,
       new ServerHeartbeatFailedEvent(monitor.address, calculateDurationInMs(start), err, awaited)
     );
@@ -315,7 +308,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
 
     monitor.emitAndLogHeartbeat(
       Server.SERVER_HEARTBEAT_SUCCEEDED,
-      monitor[kServer].topology.s.id,
+      monitor.server.topology.s.id,
       hello.connectionId,
       new ServerHeartbeatSucceededEvent(monitor.address, duration, hello, isAwaitable)
     );
@@ -325,7 +318,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
       // event, otherwise the "check" is complete and return to the main monitor loop
       monitor.emitAndLogHeartbeat(
         Server.SERVER_HEARTBEAT_STARTED,
-        monitor[kServer].topology.s.id,
+        monitor.server.topology.s.id,
         undefined,
         new ServerHeartbeatStartedEvent(monitor.address, true)
       );
@@ -378,7 +371,6 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
     awaited = false;
     connection
       .command(ns('admin.$cmd'), cmd, options)
-
       .then(onHeartbeatSucceeded, onHeartbeatFailed);
 
     return;
@@ -409,7 +401,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
       monitor.connection = connection;
       monitor.emitAndLogHeartbeat(
         Server.SERVER_HEARTBEAT_SUCCEEDED,
-        monitor[kServer].topology.s.id,
+        monitor.server.topology.s.id,
         connection.hello?.connectionId,
         new ServerHeartbeatSucceededEvent(
           monitor.address,
@@ -447,7 +439,7 @@ function monitorServer(monitor: Monitor) {
     checkServer(monitor, (err, hello) => {
       if (err) {
         // otherwise an error occurred on initial discovery, also bail
-        if (monitor[kServer].description.type === ServerType.Unknown) {
+        if (monitor.server.description.type === ServerType.Unknown) {
           return done();
         }
       }
@@ -456,7 +448,7 @@ function monitorServer(monitor: Monitor) {
       if (useStreamingProtocol(monitor, hello?.topologyVersion)) {
         setTimeout(() => {
           if (!isInCloseState(monitor)) {
-            monitor[kMonitorId]?.wake();
+            monitor.monitorId?.wake();
           }
         }, 0);
       }
@@ -484,9 +476,9 @@ export interface RTTPingerOptions extends ConnectionOptions {
 export class RTTPinger {
   connection?: Connection;
   /** @internal */
-  [kCancellationToken]: CancellationToken;
+  cancellationToken: CancellationToken;
   /** @internal */
-  [kMonitorId]: NodeJS.Timeout;
+  monitorId: NodeJS.Timeout;
   /** @internal */
   monitor: Monitor;
   closed: boolean;
@@ -495,13 +487,13 @@ export class RTTPinger {
 
   constructor(monitor: Monitor) {
     this.connection = undefined;
-    this[kCancellationToken] = monitor[kCancellationToken];
+    this.cancellationToken = monitor.cancellationToken;
     this.closed = false;
     this.monitor = monitor;
     this.latestRtt = monitor.latestRtt ?? undefined;
 
     const heartbeatFrequencyMS = monitor.options.heartbeatFrequencyMS;
-    this[kMonitorId] = setTimeout(() => this.measureRoundTripTime(), heartbeatFrequencyMS);
+    this.monitorId = setTimeout(() => this.measureRoundTripTime(), heartbeatFrequencyMS);
   }
 
   get roundTripTime(): number {
@@ -514,7 +506,7 @@ export class RTTPinger {
 
   close(): void {
     this.closed = true;
-    clearTimeout(this[kMonitorId]);
+    clearTimeout(this.monitorId);
 
     this.connection?.destroy();
     this.connection = undefined;
@@ -531,7 +523,7 @@ export class RTTPinger {
     }
 
     this.latestRtt = calculateDurationInMs(start);
-    this[kMonitorId] = setTimeout(
+    this.monitorId = setTimeout(
       () => this.measureRoundTripTime(),
       this.monitor.options.heartbeatFrequencyMS
     );