CSHARP-6089: Use attempt number as backoff exponent per updated spec

Update the exponential-backoff formula from 2^(attempt-1) to 2^attempt
per the client-backpressure and transactions-convenient-api spec change
(mongodb/specifications#1953), and update the dependent backoff tests.
Also adds the baseBackoffMS overload integration test.

Author: papafe

src/MongoDB.Driver/Core/Operations/RetryabilityHelper.cs

@@ -126,7 +126,7 @@ public static int GetRetryDelayMs(IRandom random, int attempt, double backoffBas
             Ensure.IsGreaterThanOrEqualTo(backoffMax, backoffInitial, nameof(backoffMax));
 
             var j = random.NextDouble();
-            return (int)(j * Math.Min(backoffMax, backoffInitial * Math.Pow(backoffBase, attempt - 1)));
+            return (int)(j * Math.Min(backoffMax, backoffInitial * Math.Pow(backoffBase, attempt)));
         }
 
         /// <summary>

tests/MongoDB.Driver.Tests/ClientSessionHandleTests.cs

@@ -653,7 +653,7 @@ public async Task WithTransaction_retry_backoff_is_enforced([Values(true, false)
             var noBackoffTimeMs = await ExecuteWithTransactionAsync(0);
             var backoffTimeMs = await ExecuteWithTransactionAsync(1);
 
-            backoffTimeMs.Should().BeApproximately(noBackoffTimeMs + 1800, 150);
+            backoffTimeMs.Should().BeApproximately(noBackoffTimeMs + 2280, 150);
 
             async Task<double> ExecuteWithTransactionAsync(double randomValue)
             {

tests/MongoDB.Driver.Tests/Core/Operations/RetryabilityHelperTests.cs

@@ -103,13 +103,13 @@ public void AddRetryableWriteErrorLabelIfRequired_should_add_RetryableWriteError
         }
 
         [Theory]
-        [InlineData(1, 2, 100, 10000, 0, 100)]
-        [InlineData(2, 2, 100, 10000, 0, 200)]
-        [InlineData(3, 2, 100, 10000, 0, 400)]
+        [InlineData(1, 2, 100, 10000, 0, 200)]
+        [InlineData(2, 2, 100, 10000, 0, 400)]
+        [InlineData(3, 2, 100, 10000, 0, 800)]
         [InlineData(9999, 2, 100, 10000, 0, 10000)]
-        [InlineData(1, 1.5, 100, 10000, 0, 100)]
-        [InlineData(2, 1.5, 100, 10000, 0, 150)]
-        [InlineData(3, 1.5, 100, 10000, 0, 225)]
+        [InlineData(1, 1.5, 100, 10000, 0, 150)]
+        [InlineData(2, 1.5, 100, 10000, 0, 225)]
+        [InlineData(3, 1.5, 100, 10000, 0, 337)]
         [InlineData(9999, 1.5, 100, 10000, 0, 10000)]
         public void GetRetryDelayMs_should_return_expected_result(int attempt, double backoffBase, int backoffInitial, int backoffMax, int expectedRangeMin, int expectedRangeMax)
         {

tests/MongoDB.Driver.Tests/Core/Operations/RetryableReadOperationExecutorTests.cs

@@ -139,8 +139,8 @@ public void ShouldRetry_with_system_overloaded_exception_should_not_retry_when_r
         }
 
         [Theory]
-        [InlineData(1, 50, 0, 50)]
-        [InlineData(2, 50, 0, 100)]
+        [InlineData(1, 50, 0, 100)]
+        [InlineData(2, 50, 0, 200)]
         [InlineData(1, 10000, 0, 10000)]
         [InlineData(2, 20000, 0, 10000)]
         public void ShouldRetry_with_baseBackoffMs_should_use_it_as_backoff_base(

tests/MongoDB.Driver.Tests/Core/Operations/RetryableWriteOperationExecutorTests.cs

@@ -89,8 +89,8 @@ public void IsOperationAcknowledged_should_return_expected_result(bool? isAcknow
         }
 
         [Theory]
-        [InlineData(1, 50, 0, 50)]
-        [InlineData(2, 50, 0, 100)]
+        [InlineData(1, 50, 0, 100)]
+        [InlineData(2, 50, 0, 200)]
         [InlineData(1, 10000, 0, 10000)]
         [InlineData(2, 20000, 0, 10000)]
         public void ShouldRetry_with_baseBackoffMs_should_use_it_as_backoff_base(

tests/MongoDB.Driver.Tests/Specifications/client-backpressure/prose-tests/ClientBackpressureProseTests.cs

@@ -169,11 +169,11 @@ private async Task AssertBackoffBehavior<TContext>(
 
         withBackoffException.Should().NotBeNull().And.BeOfType<MongoCommandException>();
 
-        // With MAX_RETRIES=2 and jitter=1, total backoff = 100ms + 200ms = 300ms.
-        // Per the spec: assertTrue(abs(with_backoff_time - (no_backoff_time + 0.3s)) < 0.3s)
+        // With MAX_RETRIES=2 and jitter=1, total backoff = 200ms + 400ms = 600ms.
+        // Per the spec: assertTrue(abs(with_backoff_time - (no_backoff_time + 0.6s)) < 0.6s)
         var difference = withBackoffTime - noBackoffTime;
-        Math.Abs(difference - 300).Should().BeLessThan(300,
-            $"backoff difference should be approximately 300ms, got {difference}ms (noBackoff: {noBackoffTime}ms, withBackoff: {withBackoffTime}ms)");
+        Math.Abs(difference - 600).Should().BeLessThan(600,
+            $"backoff difference should be approximately 600ms, got {difference}ms (noBackoff: {noBackoffTime}ms, withBackoff: {withBackoffTime}ms)");
     }
 
     private async Task AssertBaseBackoffMsOverridesBackoff<TOperation, TContext>(
@@ -188,17 +188,17 @@ private async Task AssertBaseBackoffMsOverridesBackoff<TOperation, TContext>(
         var fullJitterRandom = new Mock<IRandom>();
         fullJitterRandom.Setup(r => r.NextDouble()).Returns(1.0);
 
-        // Exponential backoff run: overload error without baseBackoffMS -> 100ms + 200ms = 300ms with jitter = 1.
+        // Exponential backoff run: overload error without baseBackoffMS -> 200ms + 400ms = 600ms with jitter = 1.
         var exponentialException = CoreExceptionHelper.CreateMongoCommandExceptionWithLabels(462, "SystemOverloadedError", "RetryableError");
         var exponentialMs = await MeasureBackoff(async, executeSync, executeAsync, operationContext, createOperation(exponentialException), createContext(fullJitterRandom.Object));
 
-        // baseBackoffMS override run: overload error with baseBackoffMS = 50 -> 50ms + 100ms = 150ms with jitter = 1.
+        // baseBackoffMS override run: overload error with baseBackoffMS = 50 -> 100ms + 200ms = 300ms with jitter = 1.
         var overrideResult = BsonDocument.Parse("{ ok : 0, code : 462, baseBackoffMS : 50 }");
         var overrideException = CoreExceptionHelper.CreateMongoCommandExceptionWithLabels(overrideResult, "SystemOverloadedError", "RetryableError");
         var withBaseBackoffMs = await MeasureBackoff(async, executeSync, executeAsync, operationContext, createOperation(overrideException), createContext(fullJitterRandom.Object));
 
-        // Per the spec: assertTrue(abs(exponential_backoff_time - (with_retry_after_ms_time + 0.2s)) < 0.2s)
-        Math.Abs(exponentialMs - (withBaseBackoffMs + 200)).Should().BeLessThan(200,
+        // Per the spec: assertTrue(abs(exponential_backoff_time - (with_base_backoff_ms_time + 0.3s)) < 0.3s)
+        Math.Abs(exponentialMs - (withBaseBackoffMs + 300)).Should().BeLessThan(300,
             $"baseBackoffMS should shorten the backoff base (exponential: {exponentialMs}ms, withBaseBackoffMS: {withBaseBackoffMs}ms)");
     }
 
@@ -374,4 +374,69 @@ public void Overload_errors_are_retried_a_maximum_of_maxAdaptiveRetries_times_wh
         // maxAdaptiveRetries = 1, so total started commands = maxAdaptiveRetries + 1 = 2
         eventCapturer.Events.OfType<CommandStartedEvent>().Count().Should().Be(2);
     }
+
+    [Fact]
+    // https://github.com/mongodb/specifications/pull/1953 (Test 5: overload errors with baseBackoffMS override base backoff)
+    public void Overload_errors_with_baseBackoffMS_shorten_the_backoff_base()
+    {
+        RequireServer.Check()
+            .ClusterTypes(ClusterType.ReplicaSet)
+            .VersionGreaterThanOrEqualTo("9.0.0");
+
+        var failPointCommand = BsonDocument.Parse(
+            @"{
+                configureFailPoint: ""failCommand"",
+                mode: ""alwaysOn"",
+                data:
+                {
+                    failCommands: [""insert""],
+                    errorCode: 462,
+                    errorLabels: [""SystemOverloadedError"", ""RetryableError""]
+                }
+            }");
+
+        using var client = DriverTestConfiguration.CreateMongoClient(s => s.RetryWrites = true);
+        var database = client.GetDatabase(DriverTestConfiguration.DatabaseNamespace.DatabaseName);
+        var collection = database.GetCollection<BsonDocument>(DriverTestConfiguration.CollectionNamespace.CollectionName);
+        var adminDatabase = client.GetDatabase(DatabaseNamespace.Admin.DatabaseName);
+
+        long MeasureFailedInsertMs()
+        {
+            using var failPoint = FailPoint.Configure(failPointCommand);
+            var stopwatch = Stopwatch.StartNew();
+            var exception = Record.Exception(() => collection.InsertOne(new BsonDocument("a", 1)));
+            stopwatch.Stop();
+
+            var mongoException = exception.Should().BeAssignableTo<MongoException>().Subject;
+            mongoException.HasErrorLabel("SystemOverloadedError").Should().BeTrue();
+            return stopwatch.ElapsedMilliseconds;
+        }
+
+        // Baseline: no override. With MaxAdaptiveRetries = 2, the worst case (jitter = 1 on both retries)
+        // is 200ms + 400ms = 600ms of backoff.
+        var baselineMs = MeasureFailedInsertMs();
+
+        // A value at/above MaxBackoff (10000ms) clamps to 10000ms on every attempt, so both retries draw
+        // their backoff from [0, 10000) instead of [0, 100)/[0, 200) -- an order of magnitude bigger
+        // regardless of jitter.
+        const int overrideBaseBackoffMs = 20000;
+        adminDatabase.RunCommand<BsonDocument>(
+            $@"{{ setParameter : 1, externalClientBaseBackoffMS : {overrideBaseBackoffMs} }}");
+        try
+        {
+            var overrideMs = MeasureFailedInsertMs();
+
+            // Baseline maxes out at 600ms; the override's two draws from [0, 10000) average 10000ms
+            // combined. A 1s gap requires both override jitters to independently land below ~0.13, which
+            // happens well under 1% of the time -- comfortably low flake risk while still being a real,
+            // unmocked timing check.
+            (overrideMs - baselineMs).Should().BeGreaterThan(1000,
+                $"a large baseBackoffMS override should produce a much longer backoff (baseline: {baselineMs}ms, override: {overrideMs}ms)");
+        }
+        finally
+        {
+            adminDatabase.RunCommand<BsonDocument>(
+                @"{ setParameter : 1, externalClientBaseBackoffMS : 0 }");
+        }
+    }
 }