mongodb 4.4.1 → 4.6.0

package/src/sdam/server.ts

@@ -1,11 +1,5 @@
 import type { Document, Long } from '../bson';
-import {
-  CommandOptions,
-  Connection,
-  DestroyOptions,
-  GetMoreOptions,
-  QueryOptions
-} from '../cmap/connection';
+import { CommandOptions, Connection, DestroyOptions, GetMoreOptions } from '../cmap/connection';
 import {
   ConnectionPool,
   ConnectionPoolEvents,
@@ -27,14 +21,16 @@ import type { AutoEncrypter } from '../deps';
 import {
   isNetworkErrorBeforeHandshake,
   isNodeShuttingDownError,
-  isRetryableWriteError,
   isSDAMUnrecoverableError,
   MongoCompatibilityError,
   MongoError,
+  MongoErrorLabel,
   MongoInvalidArgumentError,
   MongoNetworkError,
   MongoNetworkTimeoutError,
-  MongoServerClosedError
+  MongoServerClosedError,
+  MongoUnexpectedServerResponseError,
+  needsRetryableWriteLabel
 } from '../error';
 import { Logger } from '../logger';
 import type { ServerApi } from '../mongo_client';
@@ -43,7 +39,6 @@ import type { ClientSession } from '../sessions';
 import { isTransactionCommand } from '../transactions';
 import {
   Callback,
-  CallbackWithType,
   collationNotSupported,
   EventEmitterWithState,
   makeStateMachine,
@@ -98,6 +93,8 @@ export interface ServerPrivate {
   pool: ConnectionPool;
   /** MongoDB server API version */
   serverApi?: ServerApi;
+  /** A count of the operations currently running against the server. */
+  operationCount: number;
 }
 
 /** @public */
@@ -119,7 +116,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   s: ServerPrivate;
   serverApi?: ServerApi;
   hello?: Document;
-  [kMonitor]: Monitor;
+  [kMonitor]: Monitor | null;
 
   /** @event */
   static readonly SERVER_HEARTBEAT_STARTED = SERVER_HEARTBEAT_STARTED;
@@ -152,7 +149,8 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       logger: new Logger('Server'),
       state: STATE_CLOSED,
       topology,
-      pool: new ConnectionPool(poolOptions)
+      pool: new ConnectionPool(poolOptions),
+      operationCount: 0
     };
 
     for (const event of [...CMAP_EVENTS, ...APM_EVENTS]) {
@@ -163,22 +161,27 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       this.clusterTime = clusterTime;
     });
 
-    // monitoring is disabled in load balancing mode
-    if (this.loadBalanced) return;
+    if (this.loadBalanced) {
+      this[kMonitor] = null;
+      // monitoring is disabled in load balancing mode
+      return;
+    }
 
     // create the monitor
-    this[kMonitor] = new Monitor(this, this.s.options);
+    // TODO(NODE-4144): Remove new variable for type narrowing
+    const monitor = new Monitor(this, this.s.options);
+    this[kMonitor] = monitor;
 
     for (const event of HEARTBEAT_EVENTS) {
-      this[kMonitor].on(event, (e: any) => this.emit(event, e));
+      monitor.on(event, (e: any) => this.emit(event, e));
     }
 
-    this[kMonitor].on('resetConnectionPool', () => {
+    monitor.on('resetConnectionPool', () => {
       this.s.pool.clear();
     });
 
-    this[kMonitor].on('resetServer', (error: MongoError) => markServerUnknown(this, error));
-    this[kMonitor].on(Server.SERVER_HEARTBEAT_SUCCEEDED, (event: ServerHeartbeatSucceededEvent) => {
+    monitor.on('resetServer', (error: MongoError) => markServerUnknown(this, error));
+    monitor.on(Server.SERVER_HEARTBEAT_SUCCEEDED, (event: ServerHeartbeatSucceededEvent) => {
       this.emit(
         Server.DESCRIPTION_RECEIVED,
         new ServerDescription(this.description.hostAddress, event.reply, {
@@ -213,6 +216,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     if (this.s.options && this.s.options.autoEncrypter) {
       return this.s.options.autoEncrypter;
     }
+    return;
   }
 
   get loadBalanced(): boolean {
@@ -233,7 +237,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     // a load balancer. It never transitions out of this state and
     // has no monitor.
     if (!this.loadBalanced) {
-      this[kMonitor].connect();
+      this[kMonitor]?.connect();
     } else {
       stateTransition(this, STATE_CONNECTED);
       this.emit(Server.CONNECT, this);
@@ -256,7 +260,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     stateTransition(this, STATE_CLOSING);
 
     if (!this.loadBalanced) {
-      this[kMonitor].close();
+      this[kMonitor]?.close();
     }
 
     this.s.pool.close(options, err => {
@@ -274,7 +278,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
    */
   requestCheck(): void {
     if (!this.loadBalanced) {
-      this[kMonitor].requestCheck();
+      this[kMonitor]?.requestCheck();
     }
   }
 
@@ -282,24 +286,12 @@ export class Server extends TypedEventEmitter<ServerEvents> {
    * Execute a command
    * @internal
    */
-  command(ns: MongoDBNamespace, cmd: Document, callback: Callback): void;
-  /** @internal */
   command(
     ns: MongoDBNamespace,
     cmd: Document,
     options: CommandOptions,
     callback: Callback<Document>
-  ): void;
-  command(
-    ns: MongoDBNamespace,
-    cmd: Document,
-    options?: CommandOptions | Callback<Document>,
-    callback?: Callback<Document>
   ): void {
-    if (typeof options === 'function') {
-      (callback = options), (options = {}), (options = options ?? {});
-    }
-
     if (callback == null) {
       throw new MongoInvalidArgumentError('Callback must be provided');
     }
@@ -336,6 +328,15 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     // NOTE: This is a hack! We can't retrieve the connections used for executing an operation
     //       (and prevent them from being checked back in) at the point of operation execution.
     //       This should be considered as part of the work for NODE-2882
+    // NOTE:
+    //       When incrementing operation count, it's important that we increment it before we
+    //       attempt to check out a connection from the pool.  This ensures that operations that
+    //       are waiting for a connection are included in the operation count.  Load balanced
+    //       mode will only ever have a single server, so the operation count doesn't matter.
+    //       Incrementing the operation count above the logic to handle load balanced mode would
+    //       require special logic to decrement it again, or would double increment (the load
+    //       balanced code makes a recursive call).  Instead, we increment the count after this
+    //       check.
     if (this.loadBalanced && session && conn == null && isPinnableCommand(cmd, session)) {
       this.s.pool.checkOut((err, checkedOut) => {
         if (err || checkedOut == null) {
@@ -344,16 +345,18 @@ export class Server extends TypedEventEmitter<ServerEvents> {
         }
 
         session.pin(checkedOut);
-        this.command(ns, cmd, finalOptions, callback as Callback<Document>);
+        this.command(ns, cmd, finalOptions, callback);
       });
-
       return;
     }
 
+    this.s.operationCount += 1;
+
     this.s.pool.withConnection(
       conn,
       (err, conn, cb) => {
         if (err || !conn) {
+          this.s.operationCount -= 1;
           markServerUnknown(this, err);
           return cb(err);
         }
@@ -362,36 +365,10 @@ export class Server extends TypedEventEmitter<ServerEvents> {
           ns,
           cmd,
           finalOptions,
-          makeOperationHandler(this, conn, cmd, finalOptions, cb) as Callback<Document>
-        );
-      },
-      callback
-    );
-  }
-
-  /**
-   * Execute a query against the server
-   * @internal
-   */
-  query(ns: MongoDBNamespace, cmd: Document, options: QueryOptions, callback: Callback): void {
-    if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
-      callback(new MongoServerClosedError());
-      return;
-    }
-
-    this.s.pool.withConnection(
-      undefined,
-      (err, conn, cb) => {
-        if (err || !conn) {
-          markServerUnknown(this, err);
-          return cb(err);
-        }
-
-        conn.query(
-          ns,
-          cmd,
-          options,
-          makeOperationHandler(this, conn, cmd, options, cb) as Callback
+          makeOperationHandler(this, conn, cmd, finalOptions, (error, response) => {
+            this.s.operationCount -= 1;
+            cb(error, response);
+          })
         );
       },
       callback
@@ -413,10 +390,13 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       return;
     }
 
+    this.s.operationCount += 1;
+
     this.s.pool.withConnection(
       options.session?.pinnedConnection,
       (err, conn, cb) => {
         if (err || !conn) {
+          this.s.operationCount -= 1;
           markServerUnknown(this, err);
           return cb(err);
         }
@@ -425,7 +405,10 @@ export class Server extends TypedEventEmitter<ServerEvents> {
           ns,
           cursorId,
           options,
-          makeOperationHandler(this, conn, {}, options, cb) as Callback
+          makeOperationHandler(this, conn, {}, options, (error, response) => {
+            this.s.operationCount -= 1;
+            cb(error, response);
+          })
         );
       },
       callback
@@ -450,10 +433,12 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       return;
     }
 
+    this.s.operationCount += 1;
     this.s.pool.withConnection(
       options.session?.pinnedConnection,
       (err, conn, cb) => {
         if (err || !conn) {
+          this.s.operationCount -= 1;
           markServerUnknown(this, err);
           return cb(err);
         }
@@ -462,7 +447,10 @@ export class Server extends TypedEventEmitter<ServerEvents> {
           ns,
           cursorIds,
           options,
-          makeOperationHandler(this, conn, {}, undefined, cb) as Callback
+          makeOperationHandler(this, conn, {}, undefined, (error, response) => {
+            this.s.operationCount -= 1;
+            cb(error, response);
+          })
         );
       },
       callback
@@ -486,7 +474,7 @@ function markServerUnknown(server: Server, error?: MongoError) {
   }
 
   if (error instanceof MongoNetworkError && !(error instanceof MongoNetworkTimeoutError)) {
-    server[kMonitor].reset();
+    server[kMonitor]?.reset();
   }
 
   server.emit(
@@ -546,67 +534,87 @@ function makeOperationHandler(
   cmd: Document,
   options: CommandOptions | GetMoreOptions | undefined,
   callback: Callback
-): CallbackWithType<MongoError, Document> {
+): Callback {
   const session = options?.session;
-  return function handleOperationResult(err, result) {
-    if (err && !connectionIsStale(server.s.pool, connection)) {
-      if (err instanceof MongoNetworkError) {
-        if (session && !session.hasEnded && session.serverSession) {
-          session.serverSession.isDirty = true;
-        }
+  return function handleOperationResult(error, result) {
+    if (result != null) {
+      return callback(undefined, result);
+    }
 
-        // inActiveTransaction check handles commit and abort.
-        if (inActiveTransaction(session, cmd) && !err.hasErrorLabel('TransientTransactionError')) {
-          err.addErrorLabel('TransientTransactionError');
-        }
+    if (!error) {
+      return callback(new MongoUnexpectedServerResponseError('Empty response with no error'));
+    }
 
-        if (
-          (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
-          supportsRetryableWrites(server) &&
-          !inActiveTransaction(session, cmd)
-        ) {
-          err.addErrorLabel('RetryableWriteError');
-        }
+    if (!(error instanceof MongoError)) {
+      // Node.js or some other error we have not special handling for
+      return callback(error);
+    }
 
-        if (!(err instanceof MongoNetworkTimeoutError) || isNetworkErrorBeforeHandshake(err)) {
-          // In load balanced mode we never mark the server as unknown and always
-          // clear for the specific service id.
+    if (connectionIsStale(server.s.pool, connection)) {
+      return callback(error);
+    }
 
-          server.s.pool.clear(connection.serviceId);
-          if (!server.loadBalanced) {
-            markServerUnknown(server, err);
-          }
-        }
-      } else {
-        // if pre-4.4 server, then add error label if its a retryable write error
-        if (
-          (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
-          maxWireVersion(server) < 9 &&
-          isRetryableWriteError(err) &&
-          !inActiveTransaction(session, cmd)
-        ) {
-          err.addErrorLabel('RetryableWriteError');
+    if (error instanceof MongoNetworkError) {
+      if (session && !session.hasEnded && session.serverSession) {
+        session.serverSession.isDirty = true;
+      }
+
+      // inActiveTransaction check handles commit and abort.
+      if (
+        inActiveTransaction(session, cmd) &&
+        !error.hasErrorLabel(MongoErrorLabel.TransientTransactionError)
+      ) {
+        error.addErrorLabel(MongoErrorLabel.TransientTransactionError);
+      }
+
+      if (
+        (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
+        supportsRetryableWrites(server) &&
+        !inActiveTransaction(session, cmd)
+      ) {
+        error.addErrorLabel(MongoErrorLabel.RetryableWriteError);
+      }
+
+      if (!(error instanceof MongoNetworkTimeoutError) || isNetworkErrorBeforeHandshake(error)) {
+        // In load balanced mode we never mark the server as unknown and always
+        // clear for the specific service id.
+
+        server.s.pool.clear(connection.serviceId);
+        if (!server.loadBalanced) {
+          markServerUnknown(server, error);
         }
+      }
+    } else {
+      if (
+        (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
+        needsRetryableWriteLabel(error, maxWireVersion(server)) &&
+        !inActiveTransaction(session, cmd)
+      ) {
+        error.addErrorLabel(MongoErrorLabel.RetryableWriteError);
+      }
 
-        if (isSDAMUnrecoverableError(err)) {
-          if (shouldHandleStateChangeError(server, err)) {
-            if (maxWireVersion(server) <= 7 || isNodeShuttingDownError(err)) {
-              server.s.pool.clear(connection.serviceId);
-            }
+      if (isSDAMUnrecoverableError(error)) {
+        if (shouldHandleStateChangeError(server, error)) {
+          if (maxWireVersion(server) <= 7 || isNodeShuttingDownError(error)) {
+            server.s.pool.clear(connection.serviceId);
+          }
 
-            if (!server.loadBalanced) {
-              markServerUnknown(server, err);
-              process.nextTick(() => server.requestCheck());
-            }
+          if (!server.loadBalanced) {
+            markServerUnknown(server, error);
+            process.nextTick(() => server.requestCheck());
           }
         }
       }
+    }
 
-      if (session && session.isPinned && err.hasErrorLabel('TransientTransactionError')) {
-        session.unpin({ force: true });
-      }
+    if (
+      session &&
+      session.isPinned &&
+      error.hasErrorLabel(MongoErrorLabel.TransientTransactionError)
+    ) {
+      session.unpin({ force: true });
     }
 
-    callback(err, result);
+    return callback(error);
   };
 }

package/src/sdam/topology.ts

@@ -4,7 +4,7 @@ import { deserialize, serialize } from '../bson';
 import type { MongoCredentials } from '../cmap/auth/mongo_credentials';
 import type { ConnectionEvents, DestroyOptions } from '../cmap/connection';
 import type { CloseOptions, ConnectionPoolEvents } from '../cmap/connection_pool';
-import { DEFAULT_OPTIONS } from '../connection_string';
+import { DEFAULT_OPTIONS, FEATURE_FLAGS } from '../connection_string';
 import {
   CLOSE,
   CONNECT,
@@ -50,7 +50,6 @@ import {
 } from '../utils';
 import {
   _advanceClusterTime,
-  clearAndRemoveTimerFrom,
   ClusterTime,
   drainTimerQueue,
   ServerType,
@@ -154,6 +153,8 @@ export interface TopologyOptions extends BSONSerializeOptions, ServerOptions {
   metadata: ClientMetadata;
   /** MongoDB server API version */
   serverApi?: ServerApi;
+  /** @internal */
+  [featureFlag: symbol]: any;
 }
 
 /** @public */
@@ -249,22 +250,8 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     // Options should only be undefined in tests, MongoClient will always have defined options
     options = options ?? {
       hosts: [HostAddress.fromString('localhost:27017')],
-      retryReads: DEFAULT_OPTIONS.get('retryReads'),
-      retryWrites: DEFAULT_OPTIONS.get('retryWrites'),
-      serverSelectionTimeoutMS: DEFAULT_OPTIONS.get('serverSelectionTimeoutMS'),
-      directConnection: DEFAULT_OPTIONS.get('directConnection'),
-      loadBalanced: DEFAULT_OPTIONS.get('loadBalanced'),
-      metadata: DEFAULT_OPTIONS.get('metadata'),
-      monitorCommands: DEFAULT_OPTIONS.get('monitorCommands'),
-      tls: DEFAULT_OPTIONS.get('tls'),
-      maxPoolSize: DEFAULT_OPTIONS.get('maxPoolSize'),
-      minPoolSize: DEFAULT_OPTIONS.get('minPoolSize'),
-      waitQueueTimeoutMS: DEFAULT_OPTIONS.get('waitQueueTimeoutMS'),
-      connectionType: DEFAULT_OPTIONS.get('connectionType'),
-      connectTimeoutMS: DEFAULT_OPTIONS.get('connectTimeoutMS'),
-      maxIdleTimeMS: DEFAULT_OPTIONS.get('maxIdleTimeMS'),
-      heartbeatFrequencyMS: DEFAULT_OPTIONS.get('heartbeatFrequencyMS'),
-      minHeartbeatFrequencyMS: DEFAULT_OPTIONS.get('minHeartbeatFrequencyMS')
+      ...Object.fromEntries(DEFAULT_OPTIONS.entries()),
+      ...Object.fromEntries(FEATURE_FLAGS.entries())
     };
 
     if (typeof seeds === 'string') {
@@ -334,7 +321,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
       // timer management
       connectionTimers: new Set<NodeJS.Timeout>(),
-
       detectShardedTopology: ev => this.detectShardedTopology(ev),
       detectSrvRecords: ev => this.detectSrvRecords(ev)
     };
@@ -435,7 +421,12 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
     // connect all known servers, then attempt server selection to connect
     const serverDescriptions = Array.from(this.s.description.servers.values());
-    connectServers(this, serverDescriptions);
+    this.s.servers = new Map(
+      serverDescriptions.map(serverDescription => [
+        serverDescription.address,
+        createAndConnectServer(this, serverDescription)
+      ])
+    );
 
     // In load balancer mode we need to fake a server description getting
     // emitted from the monitor, since the monitor doesn't exist.
@@ -458,8 +449,9 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       }
 
       // TODO: NODE-2471
-      if (server && this.s.credentials) {
-        server.command(ns('admin.$cmd'), { ping: 1 }, err => {
+      const skipPingOnConnect = this.s.options[Symbol.for('@@mdb.skipPingOnConnect')] === true;
+      if (!skipPingOnConnect && server && this.s.credentials) {
+        server.command(ns('admin.$cmd'), { ping: 1 }, {}, err => {
           if (err) {
             typeof callback === 'function' ? callback(err) : this.emit(Topology.ERROR, err);
             return;
@@ -549,27 +541,11 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
    * @param callback - The callback used to indicate success or failure
    * @returns An instance of a `Server` meeting the criteria of the predicate provided
    */
-  selectServer(options: SelectServerOptions, callback: Callback<Server>): void;
-  selectServer(
-    selector: string | ReadPreference | ServerSelector,
-    callback: Callback<Server>
-  ): void;
   selectServer(
     selector: string | ReadPreference | ServerSelector,
     options: SelectServerOptions,
     callback: Callback<Server>
-  ): void;
-  selectServer(
-    selector: string | ReadPreference | ServerSelector | SelectServerOptions,
-    _options?: SelectServerOptions | Callback<Server>,
-    _callback?: Callback<Server>
   ): void {
-    let options = _options as SelectServerOptions;
-    const callback = (_callback ?? _options) as Callback<Server>;
-    if (typeof options === 'function') {
-      options = {};
-    }
-
     let serverSelector;
     if (typeof selector !== 'function') {
       if (typeof selector === 'string') {
@@ -667,6 +643,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
     this.selectServer(
       readPreferenceServerSelector(ReadPreference.primaryPreferred),
+      {},
       (err, server) => {
         if (err || !server) {
           if (typeof callback === 'function') callback(err);
@@ -866,22 +843,13 @@ function topologyTypeFromOptions(options?: TopologyOptions) {
   return TopologyType.Unknown;
 }
 
-function randomSelection(array: ServerDescription[]): ServerDescription {
-  return array[Math.floor(Math.random() * array.length)];
-}
-
 /**
  * Creates new server instances and attempts to connect them
  *
  * @param topology - The topology that this server belongs to
  * @param serverDescription - The description for the server to initialize and connect to
- * @param connectDelay - Time to wait before attempting initial connection
  */
-function createAndConnectServer(
-  topology: Topology,
-  serverDescription: ServerDescription,
-  connectDelay?: number
-) {
+function createAndConnectServer(topology: Topology, serverDescription: ServerDescription) {
   topology.emit(
     Topology.SERVER_OPENING,
     new ServerOpeningEvent(topology.s.id, serverDescription.address)
@@ -894,38 +862,10 @@ function createAndConnectServer(
 
   server.on(Server.DESCRIPTION_RECEIVED, description => topology.serverUpdateHandler(description));
 
-  if (connectDelay) {
-    const connectTimer = setTimeout(() => {
-      clearAndRemoveTimerFrom(connectTimer, topology.s.connectionTimers);
-      server.connect();
-    }, connectDelay);
-
-    topology.s.connectionTimers.add(connectTimer);
-    return server;
-  }
-
   server.connect();
   return server;
 }
 
-/**
- * Create `Server` instances for all initially known servers, connect them, and assign
- * them to the passed in `Topology`.
- *
- * @param topology - The topology responsible for the servers
- * @param serverDescriptions - A list of server descriptions to connect
- */
-function connectServers(topology: Topology, serverDescriptions: ServerDescription[]) {
-  topology.s.servers = serverDescriptions.reduce(
-    (servers: Map<string, Server>, serverDescription: ServerDescription) => {
-      const server = createAndConnectServer(topology, serverDescription);
-      servers.set(serverDescription.address, server);
-      return servers;
-    },
-    new Map<string, Server>()
-  );
-}
-
 /**
  * @param topology - Topology to update.
  * @param incomingServerDescription - New server description.
@@ -1019,13 +959,34 @@ function processWaitQueue(topology: Topology) {
       continue;
     }
 
+    let selectedServer;
     if (selectedDescriptions.length === 0) {
       topology[kWaitQueue].push(waitQueueMember);
       continue;
+    } else if (selectedDescriptions.length === 1) {
+      selectedServer = topology.s.servers.get(selectedDescriptions[0].address);
+    } else {
+      // don't shuffle the array if there are only two elements
+      const descriptions =
+        selectedDescriptions.length === 2 ? selectedDescriptions : shuffle(selectedDescriptions, 2);
+      const server1 = topology.s.servers.get(descriptions[0].address);
+      const server2 = topology.s.servers.get(descriptions[1].address);
+
+      selectedServer =
+        server1 && server2 && server1.s.operationCount < server2.s.operationCount
+          ? server1
+          : server2;
     }
 
-    const selectedServerDescription = randomSelection(selectedDescriptions);
-    const selectedServer = topology.s.servers.get(selectedServerDescription.address);
+    if (!selectedServer) {
+      waitQueueMember.callback(
+        new MongoServerSelectionError(
+          'server selection returned a server description but the server was not found in the topology',
+          topology.description
+        )
+      );
+      return;
+    }
     const transaction = waitQueueMember.transaction;
     if (isSharded && transaction && transaction.isActive && selectedServer) {
       transaction.pinServer(selectedServer);

package/src/sdam/topology_description.ts

@@ -58,15 +58,12 @@ export class TopologyDescription {
   ) {
     options = options ?? {};
 
-    // TODO: consider assigning all these values to a temporary value `s` which
-    //       we use `Object.freeze` on, ensuring the internal state of this type
-    //       is immutable.
     this.type = topologyType ?? TopologyType.Unknown;
     this.servers = serverDescriptions ?? new Map();
     this.stale = false;
     this.compatible = true;
     this.heartbeatFrequencyMS = options.heartbeatFrequencyMS ?? 0;
-    this.localThresholdMS = options.localThresholdMS ?? 0;
+    this.localThresholdMS = options.localThresholdMS ?? 15;
 
     if (setName) {
       this.setName = setName;
@@ -204,6 +201,7 @@ export class TopologyDescription {
     let { type: topologyType, setName, maxSetVersion, maxElectionId, commonWireVersion } = this;
 
     if (serverDescription.setName && setName && serverDescription.setName !== setName) {
+      // TODO(NODE-4159): servers with an incorrect setName should be removed not marked Unknown
       serverDescription = new ServerDescription(address, undefined);
     }
 
@@ -321,6 +319,7 @@ export class TopologyDescription {
     if (descriptionsWithError.length > 0) {
       return descriptionsWithError[0].error;
     }
+    return;
   }
 
   /**