diff --git a/source/client-backpressure/client-backpressure.md b/source/client-backpressure/client-backpressure.md
new file mode 100644
index 0000000000..39613c224d
--- /dev/null
+++ b/source/client-backpressure/client-backpressure.md
@@ -0,0 +1,435 @@
+# Client Backpressure
+
+- Status: Accepted
+- Minimum Server Version: N/A
+
+______________________________________________________________________
+
+## Abstract
+
+This specification adds the ability for drivers to automatically retry requests that fail due to server overload errors
+while applying backpressure to avoid further overloading the server.
+
+## META
+
+The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and
+"OPTIONAL" in this document are to be interpreted as described in [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt).
+
+## Specification
+
+### Terms
+
+#### Ingress Connection Rate Limiter
+
+A token-bucket based system introduced in MongoDB 8.2 to admit, reject or queue connection requests. It aims to prevent
+connection spikes from overloading the system.
+
+#### Ingress Request Rate Limiter
+
+A token bucket based system introduced in MongoDB 8.2 to admit an operation or reject it with a System Overload Error at
+the front door of a mongod/s. It aims to prevent operations spikes from overloading the system.
+
+#### MongoTune
+
+Mongotune is a policy engine outside the server (mongod or mongos) which monitors a set of metrics (MongoDB or system
+host) to dynamically configure MongoDB settings. MongoTune is deployed to Atlas clusters and will dynamically configure
+the connection and request rate limiters to prevent and mitigate overloading the system.
+
+#### RetryableError label
+
+An error is considered retryable if it includes the "RetryableError" label. This error label indicates that an operation
+is safely retryable regardless of the type of operation, its metadata, or any of its arguments.
+
+#### SystemOverloadedError label
+
+An error is considered overloaded if it includes the "SystemOverloadError" label. This error label indicates that the
+server is overloaded. If this error label is present, drivers will backoff before attempting a retry.
+
+#### Overload Errors
+
+An overload error is any command or network error that occurs due to a server overload. For example, when a request
+exceeds the ingress request rate limit:
+
+```js
+{
+  'ok': 0.0,
+  'errmsg': "Rate limiter 'ingressRequestRateLimiter' rate exceeded",
+  'code': 462,
+  'codeName': 'IngressRequestRateLimitExceeded',
+  'errorLabels': ['SystemOverloadedError', 'RetryableError'],
+}
+```
+
+When a new connection attempt exceeds the ingress connection rate limit, the server closes the TCP connection before TLS
+handshake is complete. Drivers will observe this as a network error (e.g. "connection reset by peer" or "connection
+closed").
+
+When a new connection attempt is queued by the server for so long that the driver-side timeout expires, drivers will
+observe this as a network timeout error.
+
+#### Goodput
+
+The throughput of positive, useful output. In the context of drivers, this refers to the number of non-error results
+that the driver processes per unit of time.
+
+See [goodput](https://en.wikipedia.org/wiki/Goodput).
+
+### Requirements for Client Backpressure
+
+#### Overload retry policy
+
+This specification expands the driver's retry ability to all commands, including those not currently considered
+retryable such as updateMany, create collection, getMore, and generic runCommand. The new command execution method obeys
+the following rules:
+
+1. If the command succeeds on the first attempt, drivers MUST deposit `RETRY_TOKEN_RETURN_RATE` tokens.
+    - The value is 0.1 and non-configurable.
+2. If the command succeeds on a retry attempt, drivers MUST deposit `RETRY_TOKEN_RETURN_RATE`+1 tokens.
+3. If a retry attempt fails with an error that does not include `SystemOverloadedError` label, drivers MUST deposit 1
+    token.
+4. A retry attempt will only be permitted if the error includes the `RetryableError` label, we have not reached
+    `MAX_ATTEMPTS`, the CSOT deadline has not expired, and a token can be acquired from the token bucket.
+    - The value of `MAX_ATTEMPTS` is 5 and non-configurable.
+    - This intentionally changes the behavior of CSOT which otherwise would retry an unlimited number of times within the
+        timeout to avoid retry storms.
+5. If the previous error includes the `SystemOverloadedError` label, the client MUST apply exponential backoff according
+    to according to the following formula: `delayMS = j * min(maxBackoff, baseBackoff * 2^i)`
+    - `i` is the retry attempt (starting with 0 for the first retry).
+    - `j` is a random jitter value between 0 and 1.
+    - `baseBackoff` is constant 100ms.
+    - `maxBackoff` is 10000ms.
+    - This results in delays of 100ms, 200ms, 400ms, 800ms, and 1600ms before accounting for jitter.
+6. If the previous error contained the `SystemOverloadedError` error label, the node will be added to the set of
+    deprioritized servers.
+
+#### Pseudocode
+
+The following pseudocode describes the overload retry policy:
+
+```python
+BASE_BACKOFF = 0.1
+MAX_BACKOFF = 10
+RETRY_TOKEN_RETURN_RATE = 0.1
+
+def execute_command_retryable(command, ...):
+    deprioritized_servers = []
+    attempt = 0
+    while True:
+        try:
+            server = select_server(deprioritized_servers)
+            connection = server.getConnection()
+            res = execute_command(connection, command)
+            # Return tokens to the bucket on success.
+            tokens = RETRY_TOKEN_RETURN_RATE
+            if attempt > 0:
+                tokens += 1
+            token_bucket.deposit(tokens)
+            return res
+        except PyMongoError as exc:
+            backoff = 0
+            attempt += 1
+
+            if attempt > MAX_ATTEMPTS:
+                raise
+
+            # Raise if the error is non retryable.
+            is_retryable = exc.has_error_label("RetryableError") or is_retryable_write_error() or is_retryable_read_error()
+            if not is_retryable:
+                raise error
+            if exc.has_error_label("SystemOverloadedError"):
+                jitter = random.random() # Random float between [0.0, 1.0).
+                backoff = jitter * min(BASE_BACKOFF * (2 ** attempt), MAX_BACKOFF)
+		   
+            # If the delay exceeds the deadline, bail early before consuming a token.
+            if _csot.get_timeout():
+                if time.monotonic() + backoff > _csot.get_deadline():
+                    raise
+
+            if not token_bucket.consume(1):
+                raise
+
+            if backoff:
+                time.sleep(backoff)
+            deprioritized_servers.append(server)
+            continue
+```
+
+Some drivers might not have retryability implementations that allow easy separation of the existing retryable
+reads/writes mechanisms from the exponential backoff and jitter retry algorithm. An example pseudocode is defined below
+that demonstrates a combined retryable reads/writes implementation with the corresponding backpressure changes (adapted
+from the Node driver's implementation):
+
+```typescript
+async function tryOperation<T extends AbstractOperation, TResult = ResultTypeFromOperation<T>>(
+  operation: T,
+  { topology, timeoutContext, session, readPreference }: RetryOptions
+): Promise<TResult> {
+  const serverSelector = getServerSelectorForReadPreference(operation, readPreference);
+
+  let server = await topology.selectServer(selector, {
+    session,
+  });
+
+  const hasReadAspect = operation.hasAspect(Aspect.READ_OPERATION);
+  const hasWriteAspect = operation.hasAspect(Aspect.WRITE_OPERATION);
+  const inTransaction = session?.inTransaction() ?? false;
+
+  const willRetryRead = topology.s.options.retryReads && !inTransaction && operation.canRetryRead;
+
+  const willRetryWrite =
+    topology.s.options.retryWrites &&
+    !inTransaction &&
+    supportsRetryableWrites(server) &&
+    operation.canRetryWrite;
+
+  const willRetry =
+    operation.hasAspect(Aspect.RETRYABLE) &&
+    session != null &&
+    ((hasReadAspect && willRetryRead) || (hasWriteAspect && willRetryWrite));
+
+  if (hasWriteAspect && willRetryWrite && session != null) {
+    operation.options.willRetryWrite = true;
+    session.incrementTransactionNumber();
+  }
+
+  // The maximum number of retry attempts using regular retryable reads/writes logic (not including
+  // SystemOverLoad error retries).
+  const maxNonOverloadRetryAttempts = willRetry 
+    ? timeoutMS != null 
+        ? Infinity 
+        : 2 
+    : 1;
+
+  let previousOperationError: MongoError | undefined;
+  let previousServer: ServerDescription | undefined;
+
+  let nonOverloadRetryAttempt = 0;
+  let systemOverloadRetryAttempt = 0;
+
+  const maxSystemOverloadRetryAttempts = 5;
+  const backoffDelayProvider = exponentialBackoffDelayProvider(
+    10_000, // MAX_BACKOFF
+    100, // base backoff
+    2 // backoff rate
+  );
+
+  while (true) {
+    if (previousOperationError) {
+      if (previousOperationError.hasErrorLabel("SystemOverloadError")) {
+        systemOverloadRetryAttempt += 1;
+
+        if (
+          // if the SystemOverloadError is not retryable, throw.
+          !previousOperationError.hasErrorLabel("RetryableError") ||
+          !(
+            // if retryable writes or reads are not configured, throw.
+            (
+              (hasReadAspect && topology.s.options.retryReads) ||
+              (hasWriteAspect && topology.s.options.retryWrites)
+            )
+          )
+        ) {
+          throw previousOperationError;
+        }
+
+        // if we have exhausted overload retry attempts, throw.
+        if (systemOverloadRetryAttempt > maxSystemOverloadRetryAttempts) {
+          throw previousOperationError;
+        }
+
+        const { value: delayMS } = backoffDelayProvider.next();
+
+        // if the delay would exhaust the CSOT timeout, short-circuit.
+        if (timeoutContext.csotEnabled() && delayMS > timeoutContext.remainingTimeMS) {
+          throw previousError;
+        }
+
+        await setTimeout(delayMS);
+
+        // attempt to consume a retry token, throw if we don't have budget.
+        if (!topology.tokenBucket.consume(RETRY_COST)) {
+          throw previousOperationError;
+        }
+
+        server = await topology.selectServer(selector, { session });
+      } else {
+        nonOverloadRetryAttempt++;
+        // we have no more retry attempts, throw.
+        if (nonOverloadRetryAttempt > maxNonOverloadRetryAttempts) {
+          throw previousOperationError;
+        }
+
+        // Handle MMAPv1 not supporting retryable writes.
+        if (hasWriteAspect && previousOperationError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) {
+          throw new MongoServerError({
+            message: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
+            errmsg: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
+            originalError: previousOperationError
+          });
+        }
+
+        // handle non-retryable errors
+        if (
+          (hasWriteAspect && !isRetryableWriteError(previousOperationError)) ||
+          (hasReadAspect && !isRetryableReadError(previousOperationError))
+        ) {
+          throw previousOperationError;
+        }
+
+        server = await topology.selectServer(selector, { session });
+
+        // handle rare downgrade scenarios where some nodes don't support 
+        // retryable writes but others do.
+        if (hasWriteAspect && !supportsRetryableWrites(server)) {
+          throw new MongoUnexpectedServerResponseError(
+            'Selected server does not support retryable writes'
+          );
+        }
+      }
+    }
+
+    try {
+      try {
+        const result = await server.command(operation, timeoutContext);
+        const isRetry = nonOverloadRetryAttempt > 0 || systemOverloadRetryAttempt > 0;
+        topology.tokenBucket.deposit(
+          isRetry
+            ? // on successful retry, deposit the retry cost + the refresh rate.
+              TOKEN_REFRESH_RATE + RETRY_COST
+            : // otherwise, just deposit the refresh rate.
+              TOKEN_REFRESH_RATE
+        );
+        return operation.handleOk(result);
+      } catch (error) {
+        return operation.handleError(error);
+      }
+    } catch (operationError) {
+      if (!operationError.hasErrorLabel("SystemOverloadError")) {
+        // if an operation fails with an error that does not contain the SystemOverloadError, deposit 1 token.
+        topology.tokenBucket.deposit(RETRY_COST);
+      }
+
+      if (
+        previousOperationError != null &&
+        operationError.hasErrorLabel("NoWritesPerformed")
+      ) {
+        throw previousOperationError;
+      }
+      previousServer = server.description;
+      previousOperationError = operationError;
+    }
+  }
+}
+```
+
+### Token Bucket
+
+The overload retry policy introduces a per-client token bucket to limit retry attempts. Although the server rejects
+excess operations as quickly as possible, doing so costs CPU and creates extra contention on the connection pool which
+can eventually negatively affect goodput. To reduce this risk, the token bucket will limit retry attempts during a
+prolonged overload.
+
+The token bucket capacity is set to 1000 for consistency with the server.
+
+#### Pseudocode
+
+The token bucket is implemented via a thread safe counter. For languages without atomics, this can be implemented via a
+lock, for example:
+
+```python
+DEFAULT_RETRY_TOKEN_CAPACITY = 1000
+class TokenBucket:
+    """A token bucket implementation for rate limiting."""
+    def __init__(
+        self,
+        capacity: float = DEFAULT_RETRY_TOKEN_CAPACITY,
+    ):
+        self.lock = Lock()
+        self.capacity = capacity
+        self.tokens = capacity
+
+    def consume(self, n: float) -> bool:
+        """Consume n tokens from the bucket if available."""
+        with self.lock:
+            if self.tokens >= n:
+                self.tokens -= n
+                return True
+            return False
+
+   def deposit(self, n: float) -> None:
+        """Deposit n tokens back into the bucket."""
+        with self.lock:
+            self.tokens = min(self.capacity, self.tokens + n)
+```
+
+#### Handshake changes
+
+Drivers conforming to this spec MUST add `“backpressure”: True` to the connection handshake. This flag allows the server
+to identify clients which do and do not support backpressure. Currently, this flag is unused but in the future the
+server may offer different rate limiting behavior for clients that do not support backpressure.
+
+##### Implementation notes
+
+On some platforms sleep() can have a very low precision, meaning an attempt to sleep for 50ms may actually sleep for a
+much larger time frame. Drivers are not required to work around this limitation.
+
+### Logging Retry Attempts
+
+[As with retryable writes](../retryable-writes/retryable-writes.md#logging-retry-attempts), drivers MAY choose to log
+retry attempts for load shed operations. This specification does not define a format for such log messages.
+
+### Command Monitoring
+
+[As with retryable writes](../retryable-writes/retryable-writes.md#command-monitoring), in accordance with the
+[Command Logging and Monitoring](../command-logging-and-monitoring/command-logging-and-monitoring.md) specification,
+drivers MUST guarantee that each `CommandStartedEvent` has either a correlating `CommandSucceededEvent` or
+`CommandFailedEvent` and that every "command started" log message has either a correlating "command succeeded" log
+message or "command failed" log message. If the first attempt of a retryable operation encounters a retryable error,
+drivers MUST fire a `CommandFailedEvent` and emit a "command failed" log message for the retryable error and fire a
+separate `CommandStartedEvent` and emit a separate "command started" log message when executing the subsequent retry
+attempt. Note that the second `CommandStartedEvent` and "command started" log message may have a different
+`connectionId`, since a server is reselected for a retry attempt.
+
+### Documentation
+
+1. Drivers MUST document that all operations support retries on server overload.
+2. Driver release notes MUST make it clear to users that they may need to adjust custom retry logic to prevent an
+    application from inadvertently retrying for too long (see [Backwards Compatibility](#backwards-compatibility) for
+    details).
+
+### Backwards Compatibility
+
+TODO
+
+## Test Plan
+
+See the [README](./tests/README.md) for tests.
+
+## Motivation for Change
+
+New load shedding mechanisms are being introduced to the server that improve its ability to remain available under
+extreme load, however clients do not know how to handle the errors returned when one of its requests has been rejected.
+As a result, such overload errors would currently either be propagated back to applications, increasing
+externally-visible command failure rates, or be retried immediately, increasing the load on already overburdened
+servers. To minimize these effects, this specification enables clients to retry requests that have been load shed in a
+way that does not overburden already overloaded servers. This retry behavior allows for more aggressive and effective
+load shedding policies to be deployed in the future. This will also help unify the currently-divergent retry behavior
+between drivers and the server (mongos).
+
+## Reference Implementation
+
+The Node and Python drivers will provide the reference implementations. See
+[NODE-7142](https://jira.mongodb.org/browse/NODE-7142) and [PYTHON-5528](https://jira.mongodb.org/browse/PYTHON-5528).
+
+## Future work
+
+1. [DRIVERS-3333](https://jira.mongodb.org/browse/DRIVERS-3333) Add a backoff state into the connection pool.
+2. [DRIVERS-3241](https://jira.mongodb.org/browse/DRIVERS-3241) Add diagnostic metadata to retried commands.
+
+## Q&A
+
+TODO
+
+## Changelog
+
+- 2025-XX-XX: Initial version.
diff --git a/source/client-backpressure/tests/README.md b/source/client-backpressure/tests/README.md
new file mode 100644
index 0000000000..a4e62b9ec1
--- /dev/null
+++ b/source/client-backpressure/tests/README.md
@@ -0,0 +1,61 @@
+# Client Backpressure Tests
+
+______________________________________________________________________
+
+## Introduction
+
+The YAML and JSON files in this directory are platform-independent tests meant to exercise a driver's implementation of
+retryable reads. These tests utilize the [Unified Test Format](../../unified-test-format/unified-test-format.md).
+
+Several prose tests, which are not easily expressed in YAML, are also presented in this file. Those tests will need to
+be manually implemented by each driver.
+
+### Prose Tests
+
+#### Test 1: Operation Retry Uses Exponential Backoff
+
+Drivers should test that retries do not occur immediately when a SystemOverloadedError is encountered.
+
+1. let `client` be a `MongoClient`
+2. let `collection` be a collection
+3. Now, run transactions without backoff:
+    1. Configure the random number generator used for jitter to always return `0` -- this effectively disables backoff.
+
+    2. Configure the following failPoint:
+
+        ```javascript
+            {
+                configureFailPoint: 'failCommand',
+                mode: 'alwaysOn',
+                data: {
+                failCommands: ['insert'],
+                errorCode: 2,
+                errorLabels: ['SystemOverloadedError', 'RetryableError']
+                }
+            }
+        ```
+
+    3. Execute the following command. Expect that the command errors. Measure the duration of the command execution.
+
+        ```javascript
+           const start = performance.now();
+           expect(
+            await coll.insertOne({ a: 1 }).catch(e => e)
+           ).to.be.an.instanceof(MongoServerError);
+           const end = performance.now();
+        ```
+
+    4. Configure the random number generator used for jitter to always return `1`.
+
+    5. Execute step 3 again.
+
+    6. Compare the two time between the two runs.
+    ```python
+    assertTrue(absolute_value(with_backoff_time - (no_backoff_time + 3.1 seconds)) < 1)
+    ```
+    The sum of 5 backoffs is 3.1 seconds. There is a 1-second window to account for potential variance between the two
+    runs.
+
+## Changelog
+
+- 2025-XX-XX: Initial version.
diff --git a/source/client-backpressure/tests/backpressure-retry-loop.json b/source/client-backpressure/tests/backpressure-retry-loop.json
new file mode 100644
index 0000000000..b121d9bd3d
--- /dev/null
+++ b/source/client-backpressure/tests/backpressure-retry-loop.json
@@ -0,0 +1,3376 @@
+{
+  "description": "tests that operations respect overload backoff retry loop",
+  "schemaVersion": "1.3",
+  "runOnRequirements": [
+    {
+      "minServerVersion": "4.4",
+      "topologies": [
+        "replicaset",
+        "sharded",
+        "load-balanced"
+      ]
+    }
+  ],
+  "createEntities": [
+    {
+      "client": {
+        "id": "client",
+        "useMultipleMongoses": false,
+        "observeEvents": [
+          "commandStartedEvent",
+          "commandSucceededEvent",
+          "commandFailedEvent"
+        ]
+      }
+    },
+    {
+      "client": {
+        "id": "failPointClient",
+        "useMultipleMongoses": false
+      }
+    },
+    {
+      "database": {
+        "id": "utilDb",
+        "client": "failPointClient",
+        "databaseName": "retryable-writes-tests"
+      }
+    },
+    {
+      "collection": {
+        "id": "utilCollection",
+        "database": "utilDb",
+        "collectionName": "coll"
+      }
+    },
+    {
+      "database": {
+        "id": "database",
+        "client": "client",
+        "databaseName": "retryable-writes-tests"
+      }
+    },
+    {
+      "collection": {
+        "id": "collection",
+        "database": "database",
+        "collectionName": "coll"
+      }
+    }
+  ],
+  "initialData": [
+    {
+      "collectionName": "coll",
+      "databaseName": "retryable-writes-tests",
+      "documents": [
+        {
+          "_id": 1,
+          "x": 11
+        },
+        {
+          "_id": 2,
+          "x": 22
+        }
+      ]
+    }
+  ],
+  "tests": [
+    {
+      "description": "client.listDatabases retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "listDatabases"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "client",
+          "name": "listDatabases",
+          "arguments": {
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "listDatabases"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "client.listDatabaseNames retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "listDatabases"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "client",
+          "name": "listDatabaseNames"
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "listDatabases"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "client.createChangeStream retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "client",
+          "name": "createChangeStream",
+          "arguments": {
+            "pipeline": []
+          },
+          "saveResultAsEntity": "changeStream"
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "client.clientBulkWrite retries using operation loop",
+      "runOnRequirements": [
+        {
+          "minServerVersion": "8.0"
+        }
+      ],
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "bulkWrite"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "client",
+          "name": "clientBulkWrite",
+          "arguments": {
+            "models": [
+              {
+                "insertOne": {
+                  "namespace": "retryable-writes-tests.coll",
+                  "document": {
+                    "_id": 8,
+                    "x": 88
+                  }
+                }
+              }
+            ]
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "bulkWrite"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.aggregate retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "aggregate",
+          "arguments": {
+            "pipeline": [
+              {
+                "$listLocalSessions": {}
+              },
+              {
+                "$limit": 1
+              }
+            ]
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.listCollections retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "listCollections"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "listCollections",
+          "arguments": {
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "listCollections"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.listCollectionNames retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "listCollections"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "listCollectionNames",
+          "arguments": {
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "listCollections"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.runCommand retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "ping"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "runCommand",
+          "arguments": {
+            "command": {
+              "ping": 1
+            },
+            "commandName": "ping"
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "ping"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.createChangeStream retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "createChangeStream",
+          "arguments": {
+            "pipeline": []
+          },
+          "saveResultAsEntity": "changeStream"
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.aggregate retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "aggregate",
+          "arguments": {
+            "pipeline": []
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.countDocuments retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "countDocuments",
+          "arguments": {
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.estimatedDocumentCount retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "count"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "estimatedDocumentCount"
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "count"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.distinct retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "distinct"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "distinct",
+          "arguments": {
+            "fieldName": "x",
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "distinct"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.find retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "find"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "find",
+          "arguments": {
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "find"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.findOne retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "find"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "findOne",
+          "arguments": {
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "find"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.listIndexes retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "listIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "listIndexes"
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "listIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.listIndexNames retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "listIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "listIndexNames"
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "listIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.createChangeStream retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "createChangeStream",
+          "arguments": {
+            "pipeline": []
+          },
+          "saveResultAsEntity": "changeStream"
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.insertOne retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "insert"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "insertOne",
+          "arguments": {
+            "document": {
+              "_id": 2,
+              "x": 22
+            }
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "insert"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.insertMany retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "insert"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "insertMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 2,
+                "x": 22
+              }
+            ]
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "insert"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.deleteOne retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "delete"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "deleteOne",
+          "arguments": {
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "delete"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.deleteMany retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "delete"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "delete"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.replaceOne retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "update"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "replaceOne",
+          "arguments": {
+            "filter": {},
+            "replacement": {
+              "x": 22
+            }
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "update"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.updateOne retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "update"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "updateOne",
+          "arguments": {
+            "filter": {},
+            "update": {
+              "$set": {
+                "x": 22
+              }
+            }
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "update"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.updateMany retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "update"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "updateMany",
+          "arguments": {
+            "filter": {},
+            "update": {
+              "$set": {
+                "x": 22
+              }
+            }
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "update"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.findOneAndDelete retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "findAndModify"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "findOneAndDelete",
+          "arguments": {
+            "filter": {}
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "findAndModify"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.findOneAndReplace retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "findAndModify"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "findOneAndReplace",
+          "arguments": {
+            "filter": {},
+            "replacement": {
+              "x": 22
+            }
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "findAndModify"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.findOneAndUpdate retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "findAndModify"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "findOneAndUpdate",
+          "arguments": {
+            "filter": {},
+            "update": {
+              "$set": {
+                "x": 22
+              }
+            }
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "findAndModify"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.bulkWrite retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "insert"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "bulkWrite",
+          "arguments": {
+            "requests": [
+              {
+                "insertOne": {
+                  "document": {
+                    "_id": 2,
+                    "x": 22
+                  }
+                }
+              }
+            ]
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "insert"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.createIndex retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "createIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "createIndex",
+          "arguments": {
+            "keys": {
+              "x": 11
+            },
+            "name": "x_11"
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "createIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.dropIndex retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "createIndex",
+          "arguments": {
+            "keys": {
+              "x": 11
+            },
+            "name": "x_11"
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "dropIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "dropIndex",
+          "arguments": {
+            "name": "x_11"
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "dropIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.dropIndexes retries using operation loop",
+      "operations": [
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          }
+        },
+        {
+          "object": "utilCollection",
+          "name": "deleteMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 1,
+                "x": 11
+              }
+            ]
+          }
+        },
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": {
+                "times": 3
+              },
+              "data": {
+                "failCommands": [
+                  "dropIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "dropIndexes"
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandSucceededEvent": {
+                "commandName": "dropIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
diff --git a/source/client-backpressure/tests/backpressure-retry-loop.yml b/source/client-backpressure/tests/backpressure-retry-loop.yml
new file mode 100644
index 0000000000..08d6072edd
--- /dev/null
+++ b/source/client-backpressure/tests/backpressure-retry-loop.yml
@@ -0,0 +1,1830 @@
+# Tests in this file are generated from backpressure-retry-loop.yml.template.
+
+description: tests that operations respect overload backoff retry loop
+
+schemaVersion: '1.3'
+
+runOnRequirements:
+  -
+    minServerVersion: '4.4' # failCommand
+    topologies: [replicaset, sharded, load-balanced]
+
+createEntities:
+  -
+    client:
+      id: &client client
+      useMultipleMongoses: false
+      observeEvents: [ 'commandStartedEvent', 'commandSucceededEvent', 'commandFailedEvent' ]
+
+  -
+    client:
+      id: &failPointClient failPointClient
+      useMultipleMongoses: false
+
+  -
+    database:
+      id: &utilDb utilDb
+      client: *failPointClient
+      databaseName: &database_name retryable-writes-tests
+
+  -
+    collection:
+      id: &utilCollection utilCollection
+      database: *utilDb
+      collectionName: &collection_name coll
+
+  -
+    database:
+      id: &database database
+      client: *client
+      databaseName: &database_name retryable-writes-tests
+  -
+    collection:
+      id: &collection collection
+      database: *database
+      collectionName: &collection_name coll
+
+initialData:
+  -
+    collectionName: *collection_name
+    databaseName: *database_name
+    documents:
+      - { _id: 1, x: 11 }
+      - { _id: 2, x: 22 }
+
+tests:
+
+  -
+    description: 'client.listDatabases retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [listDatabases]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *client
+        name: listDatabases
+        arguments:
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandSucceededEvent:
+              commandName: listDatabases
+
+  -
+    description: 'client.listDatabaseNames retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [listDatabases]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *client
+        name: listDatabaseNames
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandSucceededEvent:
+              commandName: listDatabases
+
+  -
+    description: 'client.createChangeStream retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *client
+        name: createChangeStream
+        arguments:
+          pipeline: []
+        saveResultAsEntity: changeStream
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandSucceededEvent:
+              commandName: aggregate
+
+  -
+    description: 'client.clientBulkWrite retries using operation loop'
+    runOnRequirements:
+      - minServerVersion: '8.0' # client bulk write added to server in 8.0
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [bulkWrite]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *client
+        name: clientBulkWrite
+        arguments:
+          models:
+          - insertOne:
+              namespace: retryable-writes-tests.coll
+              document: { _id: 8, x: 88 }
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandFailedEvent:
+              commandName: bulkWrite
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandFailedEvent:
+              commandName: bulkWrite
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandFailedEvent:
+              commandName: bulkWrite
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandSucceededEvent:
+              commandName: bulkWrite
+
+  -
+    description: 'database.aggregate retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: aggregate
+        arguments:
+          pipeline: [ { $listLocalSessions: {} }, { $limit: 1 } ]
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandSucceededEvent:
+              commandName: aggregate
+
+  -
+    description: 'database.listCollections retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [listCollections]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: listCollections
+        arguments:
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandSucceededEvent:
+              commandName: listCollections
+
+  -
+    description: 'database.listCollectionNames retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [listCollections]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: listCollectionNames
+        arguments:
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandSucceededEvent:
+              commandName: listCollections
+
+  -
+    description: 'database.runCommand retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [ping]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: runCommand
+        arguments:
+          command: { ping: 1 }
+          commandName: ping
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: ping
+          - commandFailedEvent:
+              commandName: ping
+          - commandStartedEvent:
+              commandName: ping
+          - commandFailedEvent:
+              commandName: ping
+          - commandStartedEvent:
+              commandName: ping
+          - commandFailedEvent:
+              commandName: ping
+          - commandStartedEvent:
+              commandName: ping
+          - commandSucceededEvent:
+              commandName: ping
+
+  -
+    description: 'database.createChangeStream retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: createChangeStream
+        arguments:
+          pipeline: []
+        saveResultAsEntity: changeStream
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandSucceededEvent:
+              commandName: aggregate
+
+  -
+    description: 'collection.aggregate retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: aggregate
+        arguments:
+          pipeline: []
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandSucceededEvent:
+              commandName: aggregate
+
+  -
+    description: 'collection.countDocuments retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: countDocuments
+        arguments:
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandSucceededEvent:
+              commandName: aggregate
+
+  -
+    description: 'collection.estimatedDocumentCount retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [count]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: estimatedDocumentCount
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: count
+          - commandFailedEvent:
+              commandName: count
+          - commandStartedEvent:
+              commandName: count
+          - commandFailedEvent:
+              commandName: count
+          - commandStartedEvent:
+              commandName: count
+          - commandFailedEvent:
+              commandName: count
+          - commandStartedEvent:
+              commandName: count
+          - commandSucceededEvent:
+              commandName: count
+
+  -
+    description: 'collection.distinct retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [distinct]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: distinct
+        arguments:
+          fieldName: x
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: distinct
+          - commandFailedEvent:
+              commandName: distinct
+          - commandStartedEvent:
+              commandName: distinct
+          - commandFailedEvent:
+              commandName: distinct
+          - commandStartedEvent:
+              commandName: distinct
+          - commandFailedEvent:
+              commandName: distinct
+          - commandStartedEvent:
+              commandName: distinct
+          - commandSucceededEvent:
+              commandName: distinct
+
+  -
+    description: 'collection.find retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [find]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: find
+        arguments:
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandSucceededEvent:
+              commandName: find
+
+  -
+    description: 'collection.findOne retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [find]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: findOne
+        arguments:
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandSucceededEvent:
+              commandName: find
+
+  -
+    description: 'collection.listIndexes retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [listIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: listIndexes
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandSucceededEvent:
+              commandName: listIndexes
+
+  -
+    description: 'collection.listIndexNames retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [listIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: listIndexNames
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandSucceededEvent:
+              commandName: listIndexes
+
+  -
+    description: 'collection.createChangeStream retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: createChangeStream
+        arguments:
+          pipeline: []
+        saveResultAsEntity: changeStream
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandSucceededEvent:
+              commandName: aggregate
+
+  -
+    description: 'collection.insertOne retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [insert]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: insertOne
+        arguments:
+          document: { _id: 2, x: 22 }
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandSucceededEvent:
+              commandName: insert
+
+  -
+    description: 'collection.insertMany retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [insert]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: insertMany
+        arguments:
+          documents:
+            - { _id: 2, x: 22 }
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandSucceededEvent:
+              commandName: insert
+
+  -
+    description: 'collection.deleteOne retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [delete]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: deleteOne
+        arguments:
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandSucceededEvent:
+              commandName: delete
+
+  -
+    description: 'collection.deleteMany retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [delete]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandSucceededEvent:
+              commandName: delete
+
+  -
+    description: 'collection.replaceOne retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [update]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: replaceOne
+        arguments:
+          filter: {}
+          replacement: { x: 22 }
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandSucceededEvent:
+              commandName: update
+
+  -
+    description: 'collection.updateOne retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [update]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: updateOne
+        arguments:
+          filter: {}
+          update: { $set: { x: 22 } }
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandSucceededEvent:
+              commandName: update
+
+  -
+    description: 'collection.updateMany retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [update]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: updateMany
+        arguments:
+          filter: {}
+          update: { $set: { x: 22 } }
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandSucceededEvent:
+              commandName: update
+
+  -
+    description: 'collection.findOneAndDelete retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [findAndModify]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: findOneAndDelete
+        arguments:
+          filter: {}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandSucceededEvent:
+              commandName: findAndModify
+
+  -
+    description: 'collection.findOneAndReplace retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [findAndModify]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: findOneAndReplace
+        arguments:
+          filter: {}
+          replacement: { x: 22 }
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandSucceededEvent:
+              commandName: findAndModify
+
+  -
+    description: 'collection.findOneAndUpdate retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [findAndModify]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: findOneAndUpdate
+        arguments:
+          filter: {}
+          update: { $set: { x: 22 } }
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandSucceededEvent:
+              commandName: findAndModify
+
+  -
+    description: 'collection.bulkWrite retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [insert]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: bulkWrite
+        arguments:
+          requests:
+            - insertOne:
+                document: { _id: 2, x: 22 }
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandSucceededEvent:
+              commandName: insert
+
+  -
+    description: 'collection.createIndex retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [createIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: createIndex
+        arguments:
+          keys: { x: 11 }
+          name: "x_11"
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandFailedEvent:
+              commandName: createIndexes
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandFailedEvent:
+              commandName: createIndexes
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandFailedEvent:
+              commandName: createIndexes
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandSucceededEvent:
+              commandName: createIndexes
+
+  -
+    description: 'collection.dropIndex retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }
+      -
+        object: *utilCollection
+        name: createIndex
+        arguments:
+          keys: { x: 11 }
+          name: "x_11"      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [dropIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: dropIndex
+        arguments:
+          name: "x_11"
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandSucceededEvent:
+              commandName: dropIndexes
+
+  -
+    description: 'collection.dropIndexes retries using operation loop'
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [dropIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: dropIndexes
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandSucceededEvent:
+              commandName: dropIndexes
diff --git a/source/client-backpressure/tests/backpressure-retry-loop.yml.template b/source/client-backpressure/tests/backpressure-retry-loop.yml.template
new file mode 100644
index 0000000000..db3ce498e9
--- /dev/null
+++ b/source/client-backpressure/tests/backpressure-retry-loop.yml.template
@@ -0,0 +1,131 @@
+# Tests in this file are generated from backpressure-retry-loop.yml.template.
+
+description: tests that operations respect overload backoff retry loop
+
+schemaVersion: '1.3'
+
+runOnRequirements:
+  -
+    minServerVersion: '4.4' # failCommand
+    topologies: [replicaset, sharded, load-balanced]
+
+createEntities:
+  -
+    client:
+      id: &client client
+      useMultipleMongoses: false
+      observeEvents: [ 'commandStartedEvent', 'commandSucceededEvent', 'commandFailedEvent' ]
+
+  -
+    client:
+      id: &failPointClient failPointClient
+      useMultipleMongoses: false
+
+  -
+    database:
+      id: &utilDb utilDb
+      client: *failPointClient
+      databaseName: &database_name retryable-writes-tests
+
+  -
+    collection:
+      id: &utilCollection utilCollection
+      database: *utilDb
+      collectionName: &collection_name coll
+
+  -
+    database:
+      id: &database database
+      client: *client
+      databaseName: &database_name retryable-writes-tests
+  -
+    collection:
+      id: &collection collection
+      database: *database
+      collectionName: &collection_name coll
+
+initialData:
+  -
+    collectionName: *collection_name
+    databaseName: *database_name
+    documents:
+      - { _id: 1, x: 11 }
+      - { _id: 2, x: 22 }
+
+tests:
+{% for operation in operations %}
+  -
+    description: '{{operation.object}}.{{operation.operation_name}} retries using operation loop'
+    {%- if ((operation.operation_name == 'clientBulkWrite')) %}
+    runOnRequirements:
+      - minServerVersion: '8.0' # client bulk write added to server in 8.0
+    {%- endif %}
+    operations:
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          filter: {}
+
+      -
+        object: *utilCollection
+        name: deleteMany
+        arguments:
+          documents:
+            - { _id: 1, x: 11 }
+
+        {%- if operation.operation_name == "dropIndex" %}
+      -
+        object: *utilCollection
+        name: createIndex
+        arguments:
+          keys: { x: 11 }
+          name: "x_11"
+        {%- endif %}      
+
+
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: { times: 3 }
+            data:
+              failCommands: [{{operation.command_name}}]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *{{operation.object}}
+        name: {{operation.operation_name}}
+        {%- if operation.arguments|length > 0 %}
+        arguments:
+          {%- for arg in operation.arguments %}
+          {{arg}}
+          {%- endfor -%}
+        {%- endif %}
+        {%- if operation.operation_name == "createChangeStream" %}
+        saveResultAsEntity: changeStream
+        {%- endif %}
+
+    expectEvents:
+      - client: "client"
+        events:
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandFailedEvent:
+              commandName: {{operation.command_name}}
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandFailedEvent:
+              commandName: {{operation.command_name}}
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandFailedEvent:
+              commandName: {{operation.command_name}}
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandSucceededEvent:
+              commandName: {{operation.command_name}}
+{% endfor -%}
diff --git a/source/client-backpressure/tests/backpressure-retry-max-attempts.json b/source/client-backpressure/tests/backpressure-retry-max-attempts.json
new file mode 100644
index 0000000000..a499aa490b
--- /dev/null
+++ b/source/client-backpressure/tests/backpressure-retry-max-attempts.json
@@ -0,0 +1,3413 @@
+{
+  "description": "tests that operations retry at most maxAttempts=5 times",
+  "schemaVersion": "1.3",
+  "runOnRequirements": [
+    {
+      "minServerVersion": "4.4",
+      "topologies": [
+        "replicaset",
+        "sharded",
+        "load-balanced"
+      ]
+    }
+  ],
+  "createEntities": [
+    {
+      "client": {
+        "id": "client",
+        "useMultipleMongoses": false,
+        "observeEvents": [
+          "commandStartedEvent",
+          "commandSucceededEvent",
+          "commandFailedEvent"
+        ]
+      }
+    },
+    {
+      "client": {
+        "id": "failPointClient",
+        "useMultipleMongoses": false
+      }
+    },
+    {
+      "database": {
+        "id": "database",
+        "client": "client",
+        "databaseName": "retryable-writes-tests"
+      }
+    },
+    {
+      "collection": {
+        "id": "collection",
+        "database": "database",
+        "collectionName": "coll"
+      }
+    }
+  ],
+  "initialData": [
+    {
+      "collectionName": "coll",
+      "databaseName": "retryable-writes-tests",
+      "documents": [
+        {
+          "_id": 1,
+          "x": 11
+        },
+        {
+          "_id": 2,
+          "x": 22
+        }
+      ]
+    }
+  ],
+  "tests": [
+    {
+      "description": "client.listDatabases retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "listDatabases"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "client",
+          "name": "listDatabases",
+          "arguments": {
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "client.listDatabaseNames retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "listDatabases"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "client",
+          "name": "listDatabaseNames",
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listDatabases"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listDatabases"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "client.createChangeStream retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "client",
+          "name": "createChangeStream",
+          "arguments": {
+            "pipeline": []
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "client.clientBulkWrite retries at most maxAttempts=5 times",
+      "runOnRequirements": [
+        {
+          "minServerVersion": "8.0"
+        }
+      ],
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "bulkWrite"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "client",
+          "name": "clientBulkWrite",
+          "arguments": {
+            "models": [
+              {
+                "insertOne": {
+                  "namespace": "retryable-writes-tests.coll",
+                  "document": {
+                    "_id": 8,
+                    "x": 88
+                  }
+                }
+              }
+            ]
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "bulkWrite"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "bulkWrite"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.aggregate retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "aggregate",
+          "arguments": {
+            "pipeline": [
+              {
+                "$listLocalSessions": {}
+              },
+              {
+                "$limit": 1
+              }
+            ]
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.listCollections retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "listCollections"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "listCollections",
+          "arguments": {
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.listCollectionNames retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "listCollections"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "listCollectionNames",
+          "arguments": {
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listCollections"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listCollections"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.runCommand retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "ping"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "runCommand",
+          "arguments": {
+            "command": {
+              "ping": 1
+            },
+            "commandName": "ping"
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "ping"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "ping"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "database.createChangeStream retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "database",
+          "name": "createChangeStream",
+          "arguments": {
+            "pipeline": []
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.aggregate retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "aggregate",
+          "arguments": {
+            "pipeline": []
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.countDocuments retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "countDocuments",
+          "arguments": {
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.estimatedDocumentCount retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "count"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "estimatedDocumentCount",
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "count"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "count"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.distinct retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "distinct"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "distinct",
+          "arguments": {
+            "fieldName": "x",
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "distinct"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "distinct"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.find retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "find"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "find",
+          "arguments": {
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.findOne retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "find"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "findOne",
+          "arguments": {
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "find"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "find"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.listIndexes retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "listIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "listIndexes",
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.listIndexNames retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "listIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "listIndexNames",
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "listIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "listIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.createChangeStream retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "aggregate"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "createChangeStream",
+          "arguments": {
+            "pipeline": []
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "aggregate"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "aggregate"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.insertOne retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "insert"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "insertOne",
+          "arguments": {
+            "document": {
+              "_id": 2,
+              "x": 22
+            }
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.insertMany retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "insert"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "insertMany",
+          "arguments": {
+            "documents": [
+              {
+                "_id": 2,
+                "x": 22
+              }
+            ]
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.deleteOne retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "delete"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "deleteOne",
+          "arguments": {
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.deleteMany retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "delete"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "deleteMany",
+          "arguments": {
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "delete"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "delete"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.replaceOne retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "update"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "replaceOne",
+          "arguments": {
+            "filter": {},
+            "replacement": {
+              "x": 22
+            }
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.updateOne retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "update"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "updateOne",
+          "arguments": {
+            "filter": {},
+            "update": {
+              "$set": {
+                "x": 22
+              }
+            }
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.updateMany retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "update"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "updateMany",
+          "arguments": {
+            "filter": {},
+            "update": {
+              "$set": {
+                "x": 22
+              }
+            }
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "update"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "update"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.findOneAndDelete retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "findAndModify"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "findOneAndDelete",
+          "arguments": {
+            "filter": {}
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.findOneAndReplace retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "findAndModify"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "findOneAndReplace",
+          "arguments": {
+            "filter": {},
+            "replacement": {
+              "x": 22
+            }
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.findOneAndUpdate retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "findAndModify"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "findOneAndUpdate",
+          "arguments": {
+            "filter": {},
+            "update": {
+              "$set": {
+                "x": 22
+              }
+            }
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "findAndModify"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "findAndModify"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.bulkWrite retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "insert"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "bulkWrite",
+          "arguments": {
+            "requests": [
+              {
+                "insertOne": {
+                  "document": {
+                    "_id": 2,
+                    "x": 22
+                  }
+                }
+              }
+            ]
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "insert"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "insert"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.createIndex retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "createIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "createIndex",
+          "arguments": {
+            "keys": {
+              "x": 11
+            },
+            "name": "x_11"
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "createIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "createIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.dropIndex retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "dropIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "dropIndex",
+          "arguments": {
+            "name": "x_11"
+          },
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "collection.dropIndexes retries at most maxAttempts=5 times",
+      "operations": [
+        {
+          "name": "failPoint",
+          "object": "testRunner",
+          "arguments": {
+            "client": "failPointClient",
+            "failPoint": {
+              "configureFailPoint": "failCommand",
+              "mode": "alwaysOn",
+              "data": {
+                "failCommands": [
+                  "dropIndexes"
+                ],
+                "errorLabels": [
+                  "RetryableError",
+                  "SystemOverloadedError"
+                ],
+                "errorCode": 2
+              }
+            }
+          }
+        },
+        {
+          "object": "collection",
+          "name": "dropIndexes",
+          "expectError": {
+            "isError": true
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandStartedEvent": {
+                "commandName": "dropIndexes"
+              }
+            },
+            {
+              "commandFailedEvent": {
+                "commandName": "dropIndexes"
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
diff --git a/source/client-backpressure/tests/backpressure-retry-max-attempts.yml b/source/client-backpressure/tests/backpressure-retry-max-attempts.yml
new file mode 100644
index 0000000000..3bd4582757
--- /dev/null
+++ b/source/client-backpressure/tests/backpressure-retry-max-attempts.yml
@@ -0,0 +1,1777 @@
+# Tests in this file are generated from backpressure-retry-max-attempts.yml.template.
+
+description: tests that operations retry at most maxAttempts=5 times
+
+schemaVersion: '1.3'
+
+runOnRequirements:
+  -
+    minServerVersion: '4.4' # failCommand
+    topologies: [replicaset, sharded, load-balanced]
+
+createEntities:
+  -
+    client:
+      id: &client client
+      useMultipleMongoses: false
+      observeEvents: [ 'commandStartedEvent', 'commandSucceededEvent', 'commandFailedEvent' ]
+
+  -
+    client:
+      id: &failPointClient failPointClient
+      useMultipleMongoses: false
+
+  -
+    database:
+      id: &database database
+      client: *client
+      databaseName: &database_name retryable-writes-tests
+  -
+    collection:
+      id: &collection collection
+      database: *database
+      collectionName: &collection_name coll
+
+initialData:
+  -
+    collectionName: *collection_name
+    databaseName: *database_name
+    documents:
+      - { _id: 1, x: 11 }
+      - { _id: 2, x: 22 }
+
+tests:
+
+  -
+    description: 'client.listDatabases retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [listDatabases]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *client
+        name: listDatabases
+        arguments:
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+
+
+  -
+    description: 'client.listDatabaseNames retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [listDatabases]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *client
+        name: listDatabaseNames
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+          - commandStartedEvent:
+              commandName: listDatabases
+          - commandFailedEvent:
+              commandName: listDatabases
+
+
+  -
+    description: 'client.createChangeStream retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *client
+        name: createChangeStream
+        arguments:
+          pipeline: []
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+
+
+  -
+    description: 'client.clientBulkWrite retries at most maxAttempts=5 times'
+    runOnRequirements:
+      - minServerVersion: '8.0' # client bulk write added to server in 8.0
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [bulkWrite]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *client
+        name: clientBulkWrite
+        arguments:
+          models:
+          - insertOne:
+              namespace: retryable-writes-tests.coll
+              document: { _id: 8, x: 88 }
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandFailedEvent:
+              commandName: bulkWrite
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandFailedEvent:
+              commandName: bulkWrite
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandFailedEvent:
+              commandName: bulkWrite
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandFailedEvent:
+              commandName: bulkWrite
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandFailedEvent:
+              commandName: bulkWrite
+          - commandStartedEvent:
+              commandName: bulkWrite
+          - commandFailedEvent:
+              commandName: bulkWrite
+
+
+  -
+    description: 'database.aggregate retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: aggregate
+        arguments:
+          pipeline: [ { $listLocalSessions: {} }, { $limit: 1 } ]
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+
+
+  -
+    description: 'database.listCollections retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [listCollections]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: listCollections
+        arguments:
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+
+
+  -
+    description: 'database.listCollectionNames retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [listCollections]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: listCollectionNames
+        arguments:
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+          - commandStartedEvent:
+              commandName: listCollections
+          - commandFailedEvent:
+              commandName: listCollections
+
+
+  -
+    description: 'database.runCommand retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [ping]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: runCommand
+        arguments:
+          command: { ping: 1 }
+          commandName: ping
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: ping
+          - commandFailedEvent:
+              commandName: ping
+          - commandStartedEvent:
+              commandName: ping
+          - commandFailedEvent:
+              commandName: ping
+          - commandStartedEvent:
+              commandName: ping
+          - commandFailedEvent:
+              commandName: ping
+          - commandStartedEvent:
+              commandName: ping
+          - commandFailedEvent:
+              commandName: ping
+          - commandStartedEvent:
+              commandName: ping
+          - commandFailedEvent:
+              commandName: ping
+          - commandStartedEvent:
+              commandName: ping
+          - commandFailedEvent:
+              commandName: ping
+
+
+  -
+    description: 'database.createChangeStream retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *database
+        name: createChangeStream
+        arguments:
+          pipeline: []
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+
+
+  -
+    description: 'collection.aggregate retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: aggregate
+        arguments:
+          pipeline: []
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+
+
+  -
+    description: 'collection.countDocuments retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: countDocuments
+        arguments:
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+
+
+  -
+    description: 'collection.estimatedDocumentCount retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [count]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: estimatedDocumentCount
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: count
+          - commandFailedEvent:
+              commandName: count
+          - commandStartedEvent:
+              commandName: count
+          - commandFailedEvent:
+              commandName: count
+          - commandStartedEvent:
+              commandName: count
+          - commandFailedEvent:
+              commandName: count
+          - commandStartedEvent:
+              commandName: count
+          - commandFailedEvent:
+              commandName: count
+          - commandStartedEvent:
+              commandName: count
+          - commandFailedEvent:
+              commandName: count
+          - commandStartedEvent:
+              commandName: count
+          - commandFailedEvent:
+              commandName: count
+
+
+  -
+    description: 'collection.distinct retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [distinct]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: distinct
+        arguments:
+          fieldName: x
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: distinct
+          - commandFailedEvent:
+              commandName: distinct
+          - commandStartedEvent:
+              commandName: distinct
+          - commandFailedEvent:
+              commandName: distinct
+          - commandStartedEvent:
+              commandName: distinct
+          - commandFailedEvent:
+              commandName: distinct
+          - commandStartedEvent:
+              commandName: distinct
+          - commandFailedEvent:
+              commandName: distinct
+          - commandStartedEvent:
+              commandName: distinct
+          - commandFailedEvent:
+              commandName: distinct
+          - commandStartedEvent:
+              commandName: distinct
+          - commandFailedEvent:
+              commandName: distinct
+
+
+  -
+    description: 'collection.find retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [find]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: find
+        arguments:
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+
+
+  -
+    description: 'collection.findOne retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [find]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: findOne
+        arguments:
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+          - commandStartedEvent:
+              commandName: find
+          - commandFailedEvent:
+              commandName: find
+
+
+  -
+    description: 'collection.listIndexes retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [listIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: listIndexes
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+
+
+  -
+    description: 'collection.listIndexNames retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [listIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: listIndexNames
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+          - commandStartedEvent:
+              commandName: listIndexes
+          - commandFailedEvent:
+              commandName: listIndexes
+
+
+  -
+    description: 'collection.createChangeStream retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [aggregate]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: createChangeStream
+        arguments:
+          pipeline: []
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+          - commandStartedEvent:
+              commandName: aggregate
+          - commandFailedEvent:
+              commandName: aggregate
+
+
+  -
+    description: 'collection.insertOne retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [insert]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: insertOne
+        arguments:
+          document: { _id: 2, x: 22 }
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+
+
+  -
+    description: 'collection.insertMany retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [insert]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: insertMany
+        arguments:
+          documents:
+            - { _id: 2, x: 22 }
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+
+
+  -
+    description: 'collection.deleteOne retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [delete]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: deleteOne
+        arguments:
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+
+
+  -
+    description: 'collection.deleteMany retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [delete]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: deleteMany
+        arguments:
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+          - commandStartedEvent:
+              commandName: delete
+          - commandFailedEvent:
+              commandName: delete
+
+
+  -
+    description: 'collection.replaceOne retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [update]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: replaceOne
+        arguments:
+          filter: {}
+          replacement: { x: 22 }
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+
+
+  -
+    description: 'collection.updateOne retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [update]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: updateOne
+        arguments:
+          filter: {}
+          update: { $set: { x: 22 } }
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+
+
+  -
+    description: 'collection.updateMany retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [update]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: updateMany
+        arguments:
+          filter: {}
+          update: { $set: { x: 22 } }
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+          - commandStartedEvent:
+              commandName: update
+          - commandFailedEvent:
+              commandName: update
+
+
+  -
+    description: 'collection.findOneAndDelete retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [findAndModify]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: findOneAndDelete
+        arguments:
+          filter: {}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+
+
+  -
+    description: 'collection.findOneAndReplace retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [findAndModify]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: findOneAndReplace
+        arguments:
+          filter: {}
+          replacement: { x: 22 }
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+
+
+  -
+    description: 'collection.findOneAndUpdate retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [findAndModify]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: findOneAndUpdate
+        arguments:
+          filter: {}
+          update: { $set: { x: 22 } }
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+          - commandStartedEvent:
+              commandName: findAndModify
+          - commandFailedEvent:
+              commandName: findAndModify
+
+
+  -
+    description: 'collection.bulkWrite retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [insert]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: bulkWrite
+        arguments:
+          requests:
+            - insertOne:
+                document: { _id: 2, x: 22 }
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+          - commandStartedEvent:
+              commandName: insert
+          - commandFailedEvent:
+              commandName: insert
+
+
+  -
+    description: 'collection.createIndex retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [createIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: createIndex
+        arguments:
+          keys: { x: 11 }
+          name: "x_11"
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandFailedEvent:
+              commandName: createIndexes
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandFailedEvent:
+              commandName: createIndexes
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandFailedEvent:
+              commandName: createIndexes
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandFailedEvent:
+              commandName: createIndexes
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandFailedEvent:
+              commandName: createIndexes
+          - commandStartedEvent:
+              commandName: createIndexes
+          - commandFailedEvent:
+              commandName: createIndexes
+
+
+  -
+    description: 'collection.dropIndex retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [dropIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: dropIndex
+        arguments:
+          name: "x_11"
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+
+
+  -
+    description: 'collection.dropIndexes retries at most maxAttempts=5 times'
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [dropIndexes]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *collection
+        name: dropIndexes
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+          - commandStartedEvent:
+              commandName: dropIndexes
+          - commandFailedEvent:
+              commandName: dropIndexes
+
diff --git a/source/client-backpressure/tests/backpressure-retry-max-attempts.yml.template b/source/client-backpressure/tests/backpressure-retry-max-attempts.yml.template
new file mode 100644
index 0000000000..4f2cfeee47
--- /dev/null
+++ b/source/client-backpressure/tests/backpressure-retry-max-attempts.yml.template
@@ -0,0 +1,106 @@
+# Tests in this file are generated from backpressure-retry-max-attempts.yml.template.
+
+description: tests that operations retry at most maxAttempts=5 times
+
+schemaVersion: '1.3'
+
+runOnRequirements:
+  -
+    minServerVersion: '4.4' # failCommand
+    topologies: [replicaset, sharded, load-balanced]
+
+createEntities:
+  -
+    client:
+      id: &client client
+      useMultipleMongoses: false
+      observeEvents: [ 'commandStartedEvent', 'commandSucceededEvent', 'commandFailedEvent' ]
+
+  -
+    client:
+      id: &failPointClient failPointClient
+      useMultipleMongoses: false
+
+  -
+    database:
+      id: &database database
+      client: *client
+      databaseName: &database_name retryable-writes-tests
+  -
+    collection:
+      id: &collection collection
+      database: *database
+      collectionName: &collection_name coll
+
+initialData:
+  -
+    collectionName: *collection_name
+    databaseName: *database_name
+    documents:
+      - { _id: 1, x: 11 }
+      - { _id: 2, x: 22 }
+
+tests:
+{% for operation in operations %}
+  -
+    description: '{{operation.object}}.{{operation.operation_name}} retries at most maxAttempts=5 times'
+    {%- if ((operation.operation_name == 'clientBulkWrite')) %}
+    runOnRequirements:
+      - minServerVersion: '8.0' # client bulk write added to server in 8.0
+    {%- endif %}
+    operations:
+      - name: failPoint
+        object: testRunner
+        arguments:
+          client: *failPointClient
+          failPoint:
+            configureFailPoint: failCommand
+            mode: alwaysOn
+            data:
+              failCommands: [{{operation.command_name}}]
+              errorLabels: ["RetryableError", "SystemOverloadedError"]
+              errorCode: 2
+      
+      -
+        object: *{{operation.object}}
+        name: {{operation.operation_name}}
+        {%- if operation.arguments|length > 0 %}
+        arguments:
+          {%- for arg in operation.arguments %}
+          {{arg}}
+          {%- endfor -%}
+        {%- endif %}
+        expectError: 
+          isError: true
+
+    expectEvents:
+      - client: "client"
+        events:
+          # we expect 6 pairs of command started and succeeded events: 1 initial 
+          # attempt and 5 retries.
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandFailedEvent:
+              commandName: {{operation.command_name}}
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandFailedEvent:
+              commandName: {{operation.command_name}}
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandFailedEvent:
+              commandName: {{operation.command_name}}
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandFailedEvent:
+              commandName: {{operation.command_name}}
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandFailedEvent:
+              commandName: {{operation.command_name}}
+          - commandStartedEvent:
+              commandName: {{operation.command_name}}
+          - commandFailedEvent:
+              commandName: {{operation.command_name}}
+
+{% endfor -%}
diff --git a/source/etc/generate-backpressure-retryability-tests.py b/source/etc/generate-backpressure-retryability-tests.py
new file mode 100644
index 0000000000..305cfa585d
--- /dev/null
+++ b/source/etc/generate-backpressure-retryability-tests.py
@@ -0,0 +1,125 @@
+from collections import namedtuple
+from jinja2 import Template
+import os
+import sys
+
+Operation = namedtuple(
+    'Operation', ['operation_name', 'command_name', 'object', 'arguments'])
+
+CLIENT_BULK_WRITE_ARGUMENTS = '''models:
+          - insertOne:
+              namespace: retryable-writes-tests.coll
+              document: { _id: 8, x: 88 }'''
+
+CLIENT_OPERATIONS = [
+    Operation('listDatabases', 'listDatabases', 'client', ['filter: {}']),
+    Operation('listDatabaseNames', 'listDatabases', 'client', []),
+    Operation('createChangeStream', 'aggregate', 'client', ['pipeline: []']),
+    Operation('clientBulkWrite', 'bulkWrite', 'client', [CLIENT_BULK_WRITE_ARGUMENTS])
+]
+
+RUN_COMMAND_ARGUMENTS = '''command: { ping: 1 }
+          commandName: ping'''
+
+DB_OPERATIONS = [
+    Operation('aggregate', 'aggregate', 'database', [
+              'pipeline: [ { $listLocalSessions: {} }, { $limit: 1 } ]']),
+    Operation('listCollections', 'listCollections',
+              'database', ['filter: {}']),
+    Operation('listCollectionNames', 'listCollections',
+              'database', ['filter: {}']), # Optional.
+    Operation('runCommand', 'ping', 'database', [RUN_COMMAND_ARGUMENTS]),
+    Operation('createChangeStream', 'aggregate', 'database', ['pipeline: []'])
+]
+
+INSERT_MANY_ARGUMENTS = '''documents:
+            - { _id: 2, x: 22 }'''
+
+BULK_WRITE_ARGUMENTS = '''requests:
+            - insertOne:
+                document: { _id: 2, x: 22 }'''
+
+COLLECTION_READ_OPERATIONS = [
+    Operation('aggregate', 'aggregate', 'collection', ['pipeline: []']),
+    # Operation('count', 'count', 'collection', ['filter: {}']),  # Deprecated.
+    Operation('countDocuments', 'aggregate', 'collection', ['filter: {}']),
+    Operation('estimatedDocumentCount', 'count', 'collection', []),
+    Operation('distinct', 'distinct', 'collection',
+              ['fieldName: x', 'filter: {}']),
+    Operation('find', 'find', 'collection', ['filter: {}']),
+    Operation('findOne', 'find', 'collection', ['filter: {}']),  # Optional.
+    Operation('listIndexes', 'listIndexes', 'collection', []),
+    Operation('listIndexNames', 'listIndexes', 'collection', []),  # Optional.
+    Operation('createChangeStream', 'aggregate',
+              'collection', ['pipeline: []']),
+]
+
+COLLECTION_WRITE_OPERATIONS = [
+    Operation('insertOne', 'insert', 'collection',
+              ['document: { _id: 2, x: 22 }']),
+    Operation('insertMany', 'insert', 'collection', [INSERT_MANY_ARGUMENTS]),
+    Operation('deleteOne', 'delete', 'collection', ['filter: {}']),
+    Operation('deleteMany', 'delete', 'collection', ['filter: {}']),
+    Operation('replaceOne', 'update', 'collection', [
+              'filter: {}', 'replacement: { x: 22 }']),
+    Operation('updateOne', 'update', 'collection', [
+              'filter: {}', 'update: { $set: { x: 22 } }']),
+    Operation('updateMany', 'update', 'collection', [
+              'filter: {}', 'update: { $set: { x: 22 } }']),
+    Operation('findOneAndDelete', 'findAndModify',
+              'collection', ['filter: {}']),
+    Operation('findOneAndReplace', 'findAndModify', 'collection',
+              ['filter: {}', 'replacement: { x: 22 }']),
+    Operation('findOneAndUpdate', 'findAndModify', 'collection',
+              ['filter: {}', 'update: { $set: { x: 22 } }']),
+    Operation('bulkWrite', 'insert', 'collection', [BULK_WRITE_ARGUMENTS]),
+    Operation('createIndex', 'createIndexes', 'collection',
+              ['keys: { x: 11 }', 'name: "x_11"']),
+    Operation('dropIndex', 'dropIndexes', 'collection', ['name: "x_11"']),
+    Operation('dropIndexes', 'dropIndexes', 'collection', []),
+]
+
+COLLECTION_OPERATIONS = COLLECTION_READ_OPERATIONS + COLLECTION_WRITE_OPERATIONS
+
+# Session and GridFS operations are generally tested in other files, so they're not included in the list of all
+# operations. Individual generation functions can choose to include them if needed.
+OPERATIONS = CLIENT_OPERATIONS + DB_OPERATIONS + COLLECTION_OPERATIONS
+
+# ./source/etc
+DIR = os.path.dirname(os.path.realpath(__file__))
+
+
+def get_template(file, templates_dir):
+    path = f'{templates_dir}/{file}.yml.template'
+    return Template(open(path, 'r').read())
+
+
+def write_yaml(file, template, tests_dir, injections):
+    rendered = template.render(**injections)
+    path = f'{tests_dir}/{file}.yml'
+    open(path, 'w').write(rendered)
+
+
+def generate(name, templates_dir, tests_dir, operations):
+    template = get_template(name, templates_dir)
+    injections = {
+        'operations': operations,
+    }
+    write_yaml(name, template, tests_dir, injections)
+
+
+def generate_retry_loop_tests():
+    templates_dir = f'{os.path.dirname(DIR)}/client-backpressure/tests'
+    tests_dir = f'{os.path.dirname(DIR)}/client-backpressure/tests'
+    generate('backpressure-retry-loop', templates_dir,
+             tests_dir, OPERATIONS)
+
+
+def generate_max_attempts_tests():
+    templates_dir = f'{os.path.dirname(DIR)}/client-backpressure/tests'
+    tests_dir = f'{os.path.dirname(DIR)}/client-backpressure/tests'
+    generate('backpressure-retry-max-attempts', templates_dir,
+             tests_dir, OPERATIONS)
+
+generate_retry_loop_tests()
+generate_max_attempts_tests()
\ No newline at end of file
diff --git a/source/index.md b/source/index.md
index 29b2a51e86..bcff8b0ffd 100644
--- a/source/index.md
+++ b/source/index.md
@@ -12,6 +12,7 @@
 - [CRUD API](crud/crud.md)
 - [Causal Consistency Specification](causal-consistency/causal-consistency.md)
 - [Change Streams](change-streams/change-streams.md)
+- [Client Backpressure](client-backpressure/client-backpressure.md)
 - [Client Side Encryption](client-side-encryption/client-side-encryption.md)
 - [Client Side Operations Timeout](client-side-operations-timeout/client-side-operations-timeout.md)
 - [Collation](collation/collation.md)
diff --git a/source/logging/logging.md b/source/logging/logging.md
index 6f7c36c200..8971dbcde7 100644
--- a/source/logging/logging.md
+++ b/source/logging/logging.md
@@ -95,7 +95,7 @@ Drivers MUST support configuring where log messages should be output, including
     > - If the value is "stdout" (case-insensitive), log to stdout.
     > - If the value is "stderr" (case-insensitive), log to stderr.
     > - Else, if direct logging to files is supported, log to a file at the specified path. If the file already exists, it
-    >     MUST be appended to.
+    >   MUST be appended to.
     >
     > If the variable is not provided or is set to an invalid value (which could be invalid for any reason, e.g. the path
     > does not exist or is not writeable), the driver MUST log to stderr and the driver MAY attempt to warn the user about
diff --git a/source/mongodb-handshake/handshake.md b/source/mongodb-handshake/handshake.md
index 24c6eea50d..5a62627326 100644
--- a/source/mongodb-handshake/handshake.md
+++ b/source/mongodb-handshake/handshake.md
@@ -84,6 +84,7 @@ if stable_api_configured or client_options.load_balanced:
 else:
     cmd = {"legacy hello": 1, "helloOk": 1}
     conn.supports_op_msg = False  # Send the initial command via OP_QUERY.
+cmd["backpressure"] = True
 cmd["client"] = client_metadata
 if client_options.compressors:
     cmd["compression"] = client_options.compressors
diff --git a/source/mongodb-handshake/tests/README.md b/source/mongodb-handshake/tests/README.md
index d88a49fa92..0ba58b713a 100644
--- a/source/mongodb-handshake/tests/README.md
+++ b/source/mongodb-handshake/tests/README.md
@@ -486,3 +486,17 @@ Before each test case, perform the setup.
 7. Store the response as `updatedClientMetadata`.
 
 8. Assert that `initialClientMetadata` is identical to `updatedClientMetadata`.
+
+### Test 9: Handshake documents include `backpressure: true`
+
+These tests require a mechanism for observing handshake documents sent to the server.
+
+1. Create a `MongoClient` that is configured to record all handshake documents sent to the server as a part of
+    connection establishment.
+
+2. Send a `ping` command to the server and verify that the command succeeds. This ensure that a connection is
+    established on all topologies.
+
+3. Assert that for every handshake document intercepted:
+
+    1. the document has a field `backpressure` whose value is `true`.
diff --git a/source/retryable-reads/retryable-reads.md b/source/retryable-reads/retryable-reads.md
index d715f774ef..42046e8b9a 100644
--- a/source/retryable-reads/retryable-reads.md
+++ b/source/retryable-reads/retryable-reads.md
@@ -15,6 +15,11 @@ This specification will
 - outline how an API for retryable read operations will be implemented in drivers
 - define an option to enable retryable reads for an application.
 
+The changes in this specification are related to but distinct from the retryability behaviors defined in the
+[Client Backpressure Specification](../client-backpressure/client-backpressure.md), which defines a retryability
+mechanism for all commands under certain server conditions. Unless otherwise noted, the changes in this specification
+refer only to the retryability behaviors summarized above.
+
 ## META
 
 The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and
@@ -267,6 +272,13 @@ The following pseudocode for executing retryable read commands has been adapted
 [the pseudocode for executing retryable write commands](../retryable-writes/retryable-writes.md#executing-retryable-write-commands)
 and reflects the flow described above.
 
+> [!NOTE]
+> The rules above and the pseudocode below only demonstrate the rules for retryable reads as outlined in this
+> specification. For simplicity, and to make the retryable reads rules easier to follow, the pseudocode was
+> intentionally unmodified. For a pseudocode block that contains both retryable reads logic as defined in this
+> specification and backoff retryabilitity as defined in the client backpressure specification, see the pseudocode in
+> the [Backpressure Specification](../client-backpressure/client-backpressure.md).
+
 ```typescript
 /**
  * Checks if a connection supports retryable reads.
@@ -547,6 +559,8 @@ any customers experiencing degraded performance can simply disable `retryableRea
 
 ## Changelog
 
+- xxxx-xx-xx: Clarify handling of deprioritized servers in pseudocode.
+
 - 2024-04-30: Migrated from reStructuredText to Markdown.
 
 - 2023-12-05: Add that any server information associated with retryable exceptions MUST reflect the originating server,
diff --git a/source/retryable-writes/retryable-writes.md b/source/retryable-writes/retryable-writes.md
index 609de18b92..d8cf74c009 100644
--- a/source/retryable-writes/retryable-writes.md
+++ b/source/retryable-writes/retryable-writes.md
@@ -19,6 +19,11 @@ specification will outline how an API for retryable write operations will be imp
 will define an option to enable retryable writes for an application and describe how a transaction ID will be provided
 to write commands executed therein.
 
+The changes in this specification are related to but distinct from the retryability behaviors defined in the
+[Client Backpressure Specification](../client-backpressure/client-backpressure.md), which defines a retryability
+mechanism for all commands under certain server conditions. Unless otherwise noted, the changes in this specification
+refer only to the retryability behaviors summarized above.
+
 ## META
 
 The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and
@@ -43,10 +48,10 @@ specification. This object is always associated with a server session; however,
 that creating a ClientSession will not always entail creation of a new server session. The name of this object MAY vary
 across drivers.
 
-**Retryable Error**
+**Retryable Write Error**
 
 An error is considered retryable if it has a RetryableWriteError label in its top-level "errorLabels" field. See
-[Determining Retryable Errors](#determining-retryable-errors) for more information.
+[Determining Retryable Write Errors](#determining-retryable-write-errors) for more information.
 
 Additional terms may be defined in the [Driver Session](../sessions/driver-sessions.md) specification.
 
@@ -102,7 +107,7 @@ In a sharded cluster, it is possible that mongos may appear to support retryable
 cluster do not (e.g. replica set shard is configured with feature compatibility version 3.4, a standalone is added as a
 new shard). In these rare cases, a write command that fans out to a shard that does not support retryable writes may
 partially fail and an error may be reported in the write result from mongos (e.g. `writeErrors` array in the bulk write
-result). This does not constitute a retryable error. Drivers MUST relay such errors to the user.
+result). This does not constitute a retryable write error. Drivers MUST relay such errors to the user.
 
 #### Supported Write Operations
 
@@ -162,7 +167,7 @@ occurs during a write command within a transaction (excepting `commitTransation`
 
 ### Implementing Retryable Writes
 
-#### Determining Retryable Errors
+#### Determining Retryable Write Errors
 
 When connected to a MongoDB instance that supports retryable writes (versions 3.6+), the driver MUST treat all errors
 with the RetryableWriteError label as retryable. This error label can be found in the top-level "errorLabels" field of
@@ -333,6 +338,13 @@ errors are labeled "NoWritesPerformed", then the first error should be raised.
 If a driver associates server information (e.g. the server address or description) with an error, the driver MUST ensure
 that the reported server information corresponds to the server that originated the error.
 
+> [!NOTE]
+> The rules above and the pseudocode below only demonstrate the rules for retryable writes as outlined in this
+> specification. For simplicity, and to make the retryable writes rules easier to follow, the pseudocode was
+> intentionally unmodified. For a pseudocode block that contains both retryable writes logic as defined in this
+> specification and backoff retryabilitity as defined in the client backpressure specification, see the pseudocode in
+> the [Backpressure Specification](../client-backpressure/client-backpressure.md).
+
 The above rules are implemented in the following pseudo-code:
 
 ```typescript