mongodb 7.0.0 → 7.1.0-dev.20260205.sha.d2ad07f2

package/src/sdam/monitor.ts

@@ -14,8 +14,8 @@ import {
   type EventEmitterWithState,
   makeStateMachine,
   noop,
-  now,
-  ns
+  ns,
+  processTimeMS
 } from '../utils';
 import { ServerType, STATE_CLOSED, STATE_CLOSING } from './common';
 import {
@@ -326,7 +326,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
       );
       // We have not actually sent an outgoing handshake, but when we get the next response we
       // want the duration to reflect the time since we last heard from the server
-      start = now();
+      start = processTimeMS();
     } else {
       monitor.rttPinger?.close();
       monitor.rttPinger = undefined;
@@ -360,7 +360,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
     }
 
     // Record new start time before sending handshake
-    start = now();
+    start = processTimeMS();
 
     if (isAwaitable) {
       awaited = true;
@@ -383,7 +383,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
     const socket = await makeSocket(monitor.connectOptions);
     const connection = makeConnection(monitor.connectOptions, socket);
     // The start time is after socket creation but before the handshake
-    start = now();
+    start = processTimeMS();
     try {
       await performInitialHandshake(connection, monitor.connectOptions);
       return connection;
@@ -426,7 +426,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
 function monitorServer(monitor: Monitor) {
   return (callback: Callback) => {
     if (monitor.s.state === STATE_MONITORING) {
-      process.nextTick(callback);
+      queueMicrotask(callback);
       return;
     }
     stateTransition(monitor, STATE_MONITORING);
@@ -532,7 +532,7 @@ export class RTTPinger {
   }
 
   private measureRoundTripTime() {
-    const start = now();
+    const start = processTimeMS();
 
     if (this.closed) {
       return;
@@ -607,7 +607,7 @@ export class MonitorInterval {
   }
 
   wake() {
-    const currentTime = now();
+    const currentTime = processTimeMS();
     const timeSinceLastCall = currentTime - this.lastExecutionEnded;
 
     // TODO(NODE-4674): Add error handling and logging to the monitor
@@ -651,7 +651,7 @@ export class MonitorInterval {
   }
 
   toJSON() {
-    const currentTime = now();
+    const currentTime = processTimeMS();
     const timeSinceLastCall = currentTime - this.lastExecutionEnded;
     return {
       timerId: this.timerId != null ? 'set' : 'cleared',
@@ -684,7 +684,7 @@ export class MonitorInterval {
     this.isExecutionInProgress = true;
 
     this.fn(() => {
-      this.lastExecutionEnded = now();
+      this.lastExecutionEnded = processTimeMS();
       this.isExecutionInProgress = false;
       this._reschedule(this.heartbeatFrequencyMS);
     });

package/src/sdam/server.ts

@@ -22,12 +22,13 @@ import {
 import {
   type AnyError,
   isNodeShuttingDownError,
-  isSDAMUnrecoverableError,
+  isStateChangeError,
   MONGODB_ERROR_CODES,
   MongoError,
   MongoErrorLabel,
   MongoNetworkError,
   MongoNetworkTimeoutError,
+  MongoParseError,
   MongoRuntimeError,
   MongoServerClosedError,
   type MongoServerError,
@@ -356,7 +357,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     } catch (operationError) {
       if (
         operationError instanceof MongoError &&
-        operationError.code === MONGODB_ERROR_CODES.Reauthenticate
+        operationError.code?.valueOf() === MONGODB_ERROR_CODES.Reauthenticate
       ) {
         reauthPromise = this.pool.reauthenticate(conn);
         reauthPromise.then(undefined, error => {
@@ -391,9 +392,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       return;
     }
 
-    const isStaleError =
-      error.connectionGeneration && error.connectionGeneration < this.pool.generation;
-    if (isStaleError) {
+    if (isStaleError(this, error)) {
       return;
     }
 
@@ -401,33 +400,46 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       error instanceof MongoNetworkError && !(error instanceof MongoNetworkTimeoutError);
     const isNetworkTimeoutBeforeHandshakeError =
       error instanceof MongoNetworkError && error.beforeHandshake;
-    const isAuthHandshakeError = error.hasErrorLabel(MongoErrorLabel.HandshakeError);
-    if (isNetworkNonTimeoutError || isNetworkTimeoutBeforeHandshakeError || isAuthHandshakeError) {
-      // In load balanced mode we never mark the server as unknown and always
-      // clear for the specific service id.
+    const isAuthOrEstablishmentHandshakeError = error.hasErrorLabel(MongoErrorLabel.HandshakeError);
+    const isSystemOverloadError = error.hasErrorLabel(MongoErrorLabel.SystemOverloadedError);
+
+    // Perhaps questionable and divergent from the spec, but considering MongoParseErrors like state change errors was legacy behavior.
+    if (isStateChangeError(error) || error instanceof MongoParseError) {
+      const shouldClearPool = isNodeShuttingDownError(error);
+
+      // from the SDAM spec: The driver MUST synchronize clearing the pool with updating the topology.
+      // In load balanced mode: there is no monitoring, so there is no topology to update.  We simply clear the pool.
+      // For other topologies: the `ResetPool` label instructs the topology to clear the server's pool in `updateServer()`.
+      if (!this.loadBalanced) {
+        if (shouldClearPool) {
+          error.addErrorLabel(MongoErrorLabel.ResetPool);
+        }
+        markServerUnknown(this, error);
+        queueMicrotask(() => this.requestCheck());
+        return;
+      }
+
+      if (connection && shouldClearPool) {
+        this.pool.clear({ serviceId: connection.serviceId });
+      }
+    } else if (
+      isNetworkNonTimeoutError ||
+      isNetworkTimeoutBeforeHandshakeError ||
+      isAuthOrEstablishmentHandshakeError
+    ) {
+      // Do NOT clear the pool if we encounter a system overloaded error.
+      if (isSystemOverloadError) {
+        return;
+      }
+      // from the SDAM spec: The driver MUST synchronize clearing the pool with updating the topology.
+      // In load balanced mode: there is no monitoring, so there is no topology to update.  We simply clear the pool.
+      // For other topologies: the `ResetPool` label instructs the topology to clear the server's pool in `updateServer()`.
       if (!this.loadBalanced) {
         error.addErrorLabel(MongoErrorLabel.ResetPool);
         markServerUnknown(this, error);
       } else if (connection) {
         this.pool.clear({ serviceId: connection.serviceId });
       }
-    } else {
-      if (isSDAMUnrecoverableError(error)) {
-        if (shouldHandleStateChangeError(this, error)) {
-          const shouldClearPool = isNodeShuttingDownError(error);
-          if (this.loadBalanced && connection && shouldClearPool) {
-            this.pool.clear({ serviceId: connection.serviceId });
-          }
-
-          if (!this.loadBalanced) {
-            if (shouldClearPool) {
-              error.addErrorLabel(MongoErrorLabel.ResetPool);
-            }
-            markServerUnknown(this, error);
-            process.nextTick(() => this.requestCheck());
-          }
-        }
-      }
     }
   }
 
@@ -560,12 +572,6 @@ function connectionIsStale(pool: ConnectionPool, connection: Connection) {
   return connection.generation !== pool.generation;
 }
 
-function shouldHandleStateChangeError(server: Server, err: MongoError) {
-  const etv = err.topologyVersion;
-  const stv = server.description.topologyVersion;
-  return compareTopologyVersion(stv, etv) < 0;
-}
-
 function inActiveTransaction(session: ClientSession | undefined, cmd: Document) {
   return session && session.inTransaction() && !isTransactionCommand(cmd);
 }
@@ -575,3 +581,15 @@ function inActiveTransaction(session: ClientSession | undefined, cmd: Document)
 function isRetryableWritesEnabled(topology: Topology) {
   return topology.s.options.retryWrites !== false;
 }
+
+function isStaleError(server: Server, error: MongoError): boolean {
+  const currentGeneration = server.pool.generation;
+  const generation = error.connectionGeneration;
+
+  if (generation && generation < currentGeneration) {
+    return true;
+  }
+
+  const currentTopologyVersion = server.description.topologyVersion;
+  return compareTopologyVersion(currentTopologyVersion, error.topologyVersion) >= 0;
+}

package/src/sdam/server_description.ts

@@ -1,6 +1,12 @@
 import { type Document, Long, type ObjectId } from '../bson';
 import { type MongoError, MongoRuntimeError } from '../error';
-import { arrayStrictEqual, compareObjectId, errorStrictEqual, HostAddress, now } from '../utils';
+import {
+  arrayStrictEqual,
+  compareObjectId,
+  errorStrictEqual,
+  HostAddress,
+  processTimeMS
+} from '../utils';
 import { type ClusterTime, ServerType } from './common';
 
 const WRITABLE_SERVER_TYPES = new Set<ServerType>([
@@ -110,7 +116,7 @@ export class ServerDescription {
     this.maxWireVersion = hello?.maxWireVersion ?? 0;
     this.roundTripTime = options?.roundTripTime ?? -1;
     this.minRoundTripTime = options?.minRoundTripTime ?? 0;
-    this.lastUpdateTime = now();
+    this.lastUpdateTime = processTimeMS();
     this.lastWriteDate = hello?.lastWrite?.lastWriteDate ?? 0;
     // NOTE: This actually builds the stack string instead of holding onto the getter and all its
     // associated references. This is done to prevent a memory leak.

package/src/sdam/server_selection.ts

@@ -1,4 +1,4 @@
-import { MongoInvalidArgumentError } from '../error';
+import { MongoInvalidArgumentError, MongoRuntimeError } from '../error';
 import { ReadPreference } from '../read_preference';
 import { ServerType, TopologyType } from './common';
 import type { ServerDescription, TagSet } from './server_description';
@@ -15,21 +15,52 @@ export const MIN_SECONDARY_WRITE_WIRE_VERSION = 13;
 export type ServerSelector = (
   topologyDescription: TopologyDescription,
   servers: ServerDescription[],
-  deprioritized?: ServerDescription[]
+  deprioritized: DeprioritizedServers
 ) => ServerDescription[];
 
+/** @internal */
+export class DeprioritizedServers {
+  private deprioritized: Set<string> = new Set();
+
+  constructor(descriptions?: Iterable<ServerDescription>) {
+    for (const description of descriptions ?? []) {
+      this.add(description);
+    }
+  }
+
+  add({ address }: ServerDescription) {
+    this.deprioritized.add(address);
+  }
+
+  has({ address }: ServerDescription): boolean {
+    return this.deprioritized.has(address);
+  }
+}
+
+function filterDeprioritized(
+  candidates: ServerDescription[],
+  deprioritized: DeprioritizedServers
+): ServerDescription[] {
+  const filtered = candidates.filter(candidate => !deprioritized.has(candidate));
+
+  return filtered.length ? filtered : candidates;
+}
+
 /**
  * Returns a server selector that selects for writable servers
  */
 export function writableServerSelector(): ServerSelector {
   return function writableServer(
     topologyDescription: TopologyDescription,
-    servers: ServerDescription[]
+    servers: ServerDescription[],
+    deprioritized: DeprioritizedServers
   ): ServerDescription[] {
-    return latencyWindowReducer(
-      topologyDescription,
-      servers.filter((s: ServerDescription) => s.isWritable)
+    const eligibleServers = filterDeprioritized(
+      servers.filter(({ isWritable }) => isWritable),
+      deprioritized
     );
+
+    return latencyWindowReducer(topologyDescription, eligibleServers);
   };
 }
 
@@ -39,8 +70,9 @@ export function writableServerSelector(): ServerSelector {
  */
 export function sameServerSelector(description?: ServerDescription): ServerSelector {
   return function sameServerSelector(
-    topologyDescription: TopologyDescription,
-    servers: ServerDescription[]
+    _topologyDescription: TopologyDescription,
+    servers: ServerDescription[],
+    _deprioritized: DeprioritizedServers
   ): ServerDescription[] {
     if (!description) return [];
     // Filter the servers to match the provided description only if
@@ -56,7 +88,7 @@ export function sameServerSelector(description?: ServerDescription): ServerSelec
  * server potentially for a write on a secondary.
  */
 export function secondaryWritableServerSelector(
-  wireVersion?: number,
+  wireVersion: number,
   readPreference?: ReadPreference
 ): ServerSelector {
   // If server version < 5.0, read preference always primary.
@@ -113,7 +145,7 @@ function maxStalenessReducer(
       primaryFilter
     )[0];
 
-    return servers.reduce((result: ServerDescription[], server: ServerDescription) => {
+    return servers.filter((server: ServerDescription) => {
       const stalenessMS =
         server.lastUpdateTime -
         server.lastWriteDate -
@@ -122,12 +154,8 @@ function maxStalenessReducer(
 
       const staleness = stalenessMS / 1000;
       const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0;
-      if (staleness <= maxStalenessSeconds) {
-        result.push(server);
-      }
-
-      return result;
-    }, []);
+      return staleness <= maxStalenessSeconds;
+    });
   }
 
   if (topologyDescription.type === TopologyType.ReplicaSetNoPrimary) {
@@ -139,40 +167,38 @@ function maxStalenessReducer(
       s.lastWriteDate > max.lastWriteDate ? s : max
     );
 
-    return servers.reduce((result: ServerDescription[], server: ServerDescription) => {
+    return servers.filter((server: ServerDescription) => {
       const stalenessMS =
         sMax.lastWriteDate - server.lastWriteDate + topologyDescription.heartbeatFrequencyMS;
 
       const staleness = stalenessMS / 1000;
       const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0;
-      if (staleness <= maxStalenessSeconds) {
-        result.push(server);
-      }
-
-      return result;
-    }, []);
+      return staleness <= maxStalenessSeconds;
+    });
   }
 
   return servers;
 }
 
 /**
- * Determines whether a server's tags match a given set of tags
+ * Determines whether a server's tags match a given set of tags.
+ *
+ * A tagset matches the server's tags if every k-v pair in the tagset
+ * is also in the server's tagset.
+ *
+ * Note that this does not requires that every k-v pair in the server's tagset is also
+ * in the client's tagset.  The server's tagset is required only to be a superset of the
+ * client's tags.
+ *
+ * @see https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.md#tag_sets
  *
  * @param tagSet - The requested tag set to match
  * @param serverTags - The server's tags
  */
 function tagSetMatch(tagSet: TagSet, serverTags: TagSet) {
-  const keys = Object.keys(tagSet);
-  const serverTagKeys = Object.keys(serverTags);
-  for (let i = 0; i < keys.length; ++i) {
-    const key = keys[i];
-    if (serverTagKeys.indexOf(key) === -1 || serverTags[key] !== tagSet[key]) {
-      return false;
-    }
-  }
-
-  return true;
+  return Object.entries(tagSet).every(
+    ([key, value]) => serverTags[key] != null && serverTags[key] === value
+  );
 }
 
 /**
@@ -183,24 +209,17 @@ function tagSetMatch(tagSet: TagSet, serverTags: TagSet) {
  * @returns The list of servers matching the requested tags
  */
 function tagSetReducer(
-  readPreference: ReadPreference,
+  { tags }: ReadPreference,
   servers: ServerDescription[]
 ): ServerDescription[] {
-  if (
-    readPreference.tags == null ||
-    (Array.isArray(readPreference.tags) && readPreference.tags.length === 0)
-  ) {
+  if (tags == null || tags.length === 0) {
+    // empty tag sets match all servers
     return servers;
   }
 
-  for (let i = 0; i < readPreference.tags.length; ++i) {
-    const tagSet = readPreference.tags[i];
-    const serversMatchingTagset = servers.reduce(
-      (matched: ServerDescription[], server: ServerDescription) => {
-        if (tagSetMatch(tagSet, server.tags)) matched.push(server);
-        return matched;
-      },
-      []
+  for (const tagSet of tags) {
+    const serversMatchingTagset = servers.filter((s: ServerDescription) =>
+      tagSetMatch(tagSet, s.tags)
     );
 
     if (serversMatchingTagset.length) {
@@ -231,10 +250,7 @@ function latencyWindowReducer(
   );
 
   const high = low + topologyDescription.localThresholdMS;
-  return servers.reduce((result: ServerDescription[], server: ServerDescription) => {
-    if (server.roundTripTime <= high && server.roundTripTime >= low) result.push(server);
-    return result;
-  }, []);
+  return servers.filter(server => server.roundTripTime <= high && server.roundTripTime >= low);
 }
 
 // filters
@@ -258,6 +274,107 @@ function loadBalancerFilter(server: ServerDescription): boolean {
   return server.type === ServerType.LoadBalancer;
 }
 
+function isDeprioritizedFactory(
+  deprioritized: DeprioritizedServers
+): (server: ServerDescription) => boolean {
+  return server =>
+    // if any deprioritized servers equal the server, here we are.
+    !deprioritized.has(server);
+}
+
+function secondarySelector(
+  readPreference: ReadPreference,
+  topologyDescription: TopologyDescription,
+  servers: ServerDescription[],
+  deprioritized: DeprioritizedServers
+) {
+  const mode = readPreference.mode;
+  switch (mode) {
+    case 'primary':
+      // Note: no need to filter for deprioritized servers.  A replica set has only one primary; that means that
+      // we are in one of two scenarios:
+      // 1. deprioritized servers is empty - return the primary.
+      // 2. deprioritized servers contains the primary - return the primary.
+      return servers.filter(primaryFilter);
+    case 'primaryPreferred': {
+      const primary = servers.filter(primaryFilter);
+
+      // If there is a primary and it is not deprioritized, use the primary.  Otherwise,
+      // check for secondaries.
+      const eligiblePrimary = primary.filter(isDeprioritizedFactory(deprioritized));
+      if (eligiblePrimary.length) {
+        return eligiblePrimary;
+      }
+
+      // If we make it here, we either have:
+      // 1. a deprioritized primary
+      // 2. no eligible primary
+      // secondaries take precedence of deprioritized primaries.
+      const secondaries = tagSetReducer(
+        readPreference,
+        maxStalenessReducer(readPreference, topologyDescription, servers.filter(secondaryFilter))
+      );
+
+      const eligibleSecondaries = secondaries.filter(isDeprioritizedFactory(deprioritized));
+      if (eligibleSecondaries.length) {
+        return latencyWindowReducer(topologyDescription, eligibleSecondaries);
+      }
+
+      // if we make it here, we have no primaries or secondaries that not deprioritized.
+      // prefer the primary (which may not exist, if the topology has no primary).
+      // otherwise, return the secondaries (which also may not exist, but there is nothing else to check here).
+      return primary.length ? primary : latencyWindowReducer(topologyDescription, secondaries);
+    }
+    case 'nearest': {
+      const eligible = filterDeprioritized(
+        tagSetReducer(
+          readPreference,
+          maxStalenessReducer(readPreference, topologyDescription, servers.filter(nearestFilter))
+        ),
+        deprioritized
+      );
+      return latencyWindowReducer(topologyDescription, eligible);
+    }
+    case 'secondary':
+    case 'secondaryPreferred': {
+      const secondaries = tagSetReducer(
+        readPreference,
+        maxStalenessReducer(readPreference, topologyDescription, servers.filter(secondaryFilter))
+      );
+      const eligibleSecondaries = secondaries.filter(isDeprioritizedFactory(deprioritized));
+
+      if (eligibleSecondaries.length) {
+        return latencyWindowReducer(topologyDescription, eligibleSecondaries);
+      }
+
+      // we have no eligible secondaries, try for a primary if we can.
+      if (mode === ReadPreference.SECONDARY_PREFERRED) {
+        const primary = servers.filter(primaryFilter);
+
+        // unlike readPreference=primary, here we do filter for deprioritized servers.
+        // if the primary is deprioritized, deprioritized secondaries take precedence.
+        const eligiblePrimary = primary.filter(isDeprioritizedFactory(deprioritized));
+        if (eligiblePrimary.length) return eligiblePrimary;
+
+        // we have no eligible primary nor secondaries that have not been deprioritized
+        return secondaries.length
+          ? latencyWindowReducer(topologyDescription, secondaries)
+          : primary;
+      }
+
+      // return all secondaries in the latency window.
+      return latencyWindowReducer(topologyDescription, secondaries);
+    }
+
+    default: {
+      const _exhaustiveCheck: never = mode;
+      throw new MongoRuntimeError(
+        `unexpected readPreference=${mode} (should never happen).  Please report a bug in the Node driver Jira project.`
+      );
+    }
+  }
+}
+
 /**
  * Returns a function which selects servers based on a provided read preference
  *
@@ -271,53 +388,28 @@ export function readPreferenceServerSelector(readPreference: ReadPreference): Se
   return function readPreferenceServers(
     topologyDescription: TopologyDescription,
     servers: ServerDescription[],
-    deprioritized: ServerDescription[] = []
+    deprioritized: DeprioritizedServers
   ): ServerDescription[] {
-    if (topologyDescription.type === TopologyType.LoadBalanced) {
-      return servers.filter(loadBalancerFilter);
-    }
-
-    if (topologyDescription.type === TopologyType.Unknown) {
-      return [];
-    }
-
-    if (topologyDescription.type === TopologyType.Single) {
-      return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
-    }
-
-    if (topologyDescription.type === TopologyType.Sharded) {
-      const filtered = servers.filter(server => {
-        return !deprioritized.includes(server);
-      });
-      const selectable = filtered.length > 0 ? filtered : deprioritized;
-      return latencyWindowReducer(topologyDescription, selectable.filter(knownFilter));
-    }
-
-    const mode = readPreference.mode;
-    if (mode === ReadPreference.PRIMARY) {
-      return servers.filter(primaryFilter);
-    }
-
-    if (mode === ReadPreference.PRIMARY_PREFERRED) {
-      const result = servers.filter(primaryFilter);
-      if (result.length) {
-        return result;
+    switch (topologyDescription.type) {
+      case 'Single':
+        return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
+      case 'ReplicaSetNoPrimary':
+      case 'ReplicaSetWithPrimary':
+        return secondarySelector(readPreference, topologyDescription, servers, deprioritized);
+      case 'Sharded': {
+        const selectable = filterDeprioritized(servers, deprioritized);
+        return latencyWindowReducer(topologyDescription, selectable.filter(knownFilter));
+      }
+      case 'Unknown':
+        return [];
+      case 'LoadBalanced':
+        return servers.filter(loadBalancerFilter);
+      default: {
+        const _exhaustiveCheck: never = topologyDescription.type;
+        throw new MongoRuntimeError(
+          `unexpected topology type: ${topologyDescription.type} (this should never happen).  Please file a bug in the Node driver Jira project.`
+        );
       }
     }
-
-    const filter = mode === ReadPreference.NEAREST ? nearestFilter : secondaryFilter;
-    const selectedServers = latencyWindowReducer(
-      topologyDescription,
-      tagSetReducer(
-        readPreference,
-        maxStalenessReducer(readPreference, topologyDescription, servers.filter(filter))
-      )
-    );
-
-    if (mode === ReadPreference.SECONDARY_PREFERRED && selectedServers.length === 0) {
-      return servers.filter(primaryFilter);
-    }
-
-    return selectedServers;
   };
 }