changes!

Author: baileympearson

src/cmap/connect.ts

@@ -35,6 +35,11 @@ import {
 /** @public */
 export type Stream = Socket | TLSSocket;
 
+function applyBackpressureLabels(error: MongoError) {
+  error.addErrorLabel(MongoErrorLabel.SystemOverloadedError);
+  error.addErrorLabel(MongoErrorLabel.RetryableError);
+}
+
 export async function connect(options: ConnectionOptions): Promise<Connection> {
   let connection: Connection | null = null;
   try {
@@ -103,6 +108,8 @@ export async function performInitialHandshake(
   const authContext = new AuthContext(conn, credentials, options);
   conn.authContext = authContext;
 
+  // If we encounter an error preparing the handshake document, do NOT apply backpressure labels.  Errors
+  // encountered building the handshake document are all client-side, and do not indicate an overloaded server.
   const handshakeDoc = await prepareHandshakeDocument(authContext);
 
   // @ts-expect-error: TODO(NODE-5141): The options need to be filtered properly, Connection options differ from Command options
@@ -162,13 +169,19 @@ export async function performInitialHandshake(
 
     try {
       await provider.auth(authContext);
-    } catch (error) {
-      if (error instanceof MongoError) {
-        error.addErrorLabel(MongoErrorLabel.HandshakeError);
-        if (needsRetryableWriteLabel(error, response.maxWireVersion, conn.description.type)) {
-          error.addErrorLabel(MongoErrorLabel.RetryableWriteError);
-        }
+    } catch (cause) {
+      // If we encounter an error authenticating a connection, do NOT apply backpressure labels.
+
+      const error =
+        cause instanceof MongoError
+          ? cause
+          : new MongoRuntimeError('unexpected error during authentication', cause);
+
+      error.addErrorLabel(MongoErrorLabel.HandshakeError);
+      if (needsRetryableWriteLabel(error, response.maxWireVersion, conn.description.type)) {
+        error.addErrorLabel(MongoErrorLabel.RetryableWriteError);
       }
+
       throw error;
     }
   }
@@ -189,6 +202,9 @@ export async function performInitialHandshake(
       if (error instanceof MongoError) {
         error.addErrorLabel(MongoErrorLabel.HandshakeError);
       }
+      // If we encounter an error executing the initial handshake, apply backpressure labels.
+      applyBackpressureLabels(error);
+
       throw error;
     }
   }
@@ -424,6 +440,8 @@ export async function makeSocket(options: MakeConnectionOptions): Promise<Stream
     socket = await connectedSocket;
     return socket;
   } catch (error) {
+    // If we encounter a SystemOverloaded error while establishing a socket, apply the backpressure labels to it.
+    applyBackpressureLabels(error);
     socket.destroy();
     throw error;
   } finally {

src/error.ts

@@ -99,7 +99,9 @@ export const MongoErrorLabel = Object.freeze({
   ResetPool: 'ResetPool',
   PoolRequestedRetry: 'PoolRequestedRetry',
   InterruptInUseConnections: 'InterruptInUseConnections',
-  NoWritesPerformed: 'NoWritesPerformed'
+  NoWritesPerformed: 'NoWritesPerformed',
+  RetryableError: 'RetryableError',
+  SystemOverloadedError: 'SystemOverloadedError'
 } as const);
 
 /** @public */

src/sdam/server.ts

@@ -400,7 +400,8 @@ 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);
+    const isAuthOrEstablishmentHandshakeError = error.hasErrorLabel(MongoErrorLabel.HandshakeError);
+    const isSystemOverloadError = error.hasErrorLabel(MongoErrorLabel.SystemOverloadedError);
 
     // TODO: considering parse errors as SDAM unrecoverable errors seem
     // questionable.  What if the parse error only comes from an application connection,
@@ -430,8 +431,12 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     } else if (
       isNetworkNonTimeoutError ||
       isNetworkTimeoutBeforeHandshakeError ||
-      isAuthHandshakeError
+      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()`.