pr

Oleksandr Poliakov · Oleksandr Poliakov · commit da1d2126fa15 · 2025-06-09T13:48:38.000-07:00
diff --git a/src/MongoDB.Driver/Core/Clusters/Cluster.cs b/src/MongoDB.Driver/Core/Clusters/Cluster.cs
@@ -222,21 +222,21 @@ public IServer SelectServer(IServerSelector selector, OperationContext operation
             Ensure.IsNotNull(selector, nameof(selector));
             Ensure.IsNotNull(operationContext, nameof(operationContext));
 
-            var serverSelectionCancellationContext = operationContext.WithTimeout(Settings.ServerSelectionTimeout);
+            var serverSelectionOperationContext = operationContext.WithTimeout(Settings.ServerSelectionTimeout);
 
             using (var helper = new SelectServerHelper(this, selector))
             {
                 try
                 {
                     while (true)
                     {
-                        var server = helper.SelectServer(serverSelectionCancellationContext);
+                        var server = helper.SelectServer(serverSelectionOperationContext);
                         if (server != null)
                         {
                             return server;
                         }
 
-                        helper.WaitForDescriptionChanged(serverSelectionCancellationContext);
+                        helper.WaitForDescriptionChanged(serverSelectionOperationContext);
                     }
                 }
                 catch (TimeoutException)
@@ -261,21 +261,21 @@ public async Task<IServer> SelectServerAsync(IServerSelector selector, Operation
             Ensure.IsNotNull(selector, nameof(selector));
             Ensure.IsNotNull(operationContext, nameof(operationContext));
 
-            var serverSelectionCancellationContext = operationContext.WithTimeout(Settings.ServerSelectionTimeout);
+            var serverSelectionOperationContext = operationContext.WithTimeout(Settings.ServerSelectionTimeout);
 
             using (var helper = new SelectServerHelper(this, selector))
             {
                 try
                 {
                     while (true)
                     {
-                        var server = helper.SelectServer(serverSelectionCancellationContext);
+                        var server = helper.SelectServer(serverSelectionOperationContext);
                         if (server != null)
                         {
                             return server;
                         }
 
-                        await helper.WaitForDescriptionChangedAsync(serverSelectionCancellationContext).ConfigureAwait(false);
+                        await helper.WaitForDescriptionChangedAsync(serverSelectionOperationContext).ConfigureAwait(false);
                     }
                 }
                 catch (TimeoutException)
diff --git a/src/MongoDB.Driver/Core/Clusters/LoadBalancedCluster.cs b/src/MongoDB.Driver/Core/Clusters/LoadBalancedCluster.cs
@@ -176,7 +176,7 @@ public IServer SelectServer(IServerSelector selector, OperationContext operation
             Ensure.IsNotNull(operationContext, nameof(operationContext));
             ThrowIfDisposed();
 
-            var serverSelectionCancellationContext = operationContext.WithTimeout(_settings.ServerSelectionTimeout);
+            var serverSelectionOperationContext = operationContext.WithTimeout(_settings.ServerSelectionTimeout);
 
             _serverSelectionEventLogger.LogAndPublish(new ClusterSelectingServerEvent(
                 _description,
@@ -186,7 +186,7 @@ public IServer SelectServer(IServerSelector selector, OperationContext operation
 
             try
             {
-                serverSelectionCancellationContext.WaitTask(_serverReadyTaskCompletionSource.Task);
+                serverSelectionOperationContext.WaitTask(_serverReadyTaskCompletionSource.Task);
             }
             catch (TimeoutException)
             {
@@ -199,7 +199,7 @@ public IServer SelectServer(IServerSelector selector, OperationContext operation
                    _description,
                    selector,
                    _server.Description,
-                   serverSelectionCancellationContext.Elapsed,
+                   serverSelectionOperationContext.Elapsed,
                    null,
                    EventContext.OperationName));
             }
@@ -214,7 +214,7 @@ public async Task<IServer> SelectServerAsync(IServerSelector selector, Operation
             Ensure.IsNotNull(operationContext, nameof(operationContext));
             ThrowIfDisposed();
 
-            var serverSelectionCancellationContext = operationContext.WithTimeout(_settings.ServerSelectionTimeout);
+            var serverSelectionOperationContext = operationContext.WithTimeout(_settings.ServerSelectionTimeout);
 
             _serverSelectionEventLogger.LogAndPublish(new ClusterSelectingServerEvent(
                 _description,
@@ -224,7 +224,7 @@ public async Task<IServer> SelectServerAsync(IServerSelector selector, Operation
 
             try
             {
-                await serverSelectionCancellationContext.WaitTaskAsync(_serverReadyTaskCompletionSource.Task).ConfigureAwait(false);
+                await serverSelectionOperationContext.WaitTaskAsync(_serverReadyTaskCompletionSource.Task).ConfigureAwait(false);
             }
             catch (TimeoutException)
             {
@@ -237,7 +237,7 @@ public async Task<IServer> SelectServerAsync(IServerSelector selector, Operation
                    _description,
                    selector,
                    _server.Description,
-                   serverSelectionCancellationContext.Elapsed,
+                   serverSelectionOperationContext.Elapsed,
                    null,
                    EventContext.OperationName));
             }
diff --git a/src/MongoDB.Driver/Core/ConnectionPools/ExclusiveConnectionPool.Helpers.cs b/src/MongoDB.Driver/Core/ConnectionPools/ExclusiveConnectionPool.Helpers.cs
@@ -33,7 +33,7 @@ namespace MongoDB.Driver.Core.ConnectionPools
     internal sealed partial class ExclusiveConnectionPool
     {
         // private methods
-        private Exception CreateTimeoutException(OperationContext operationContext, string message)
+        private Exception CreateTimeoutException(TimeSpan elapsed, string message)
         {
             var checkOutsForCursorCount = _checkOutReasonCounter.GetCheckOutsCount(CheckOutReason.Cursor);
             var checkOutsForTransactionCount = _checkOutReasonCounter.GetCheckOutsCount(CheckOutReason.Transaction);
@@ -47,7 +47,7 @@ private Exception CreateTimeoutException(OperationContext operationContext, stri
                 var checkOutsForOtherCount = checkOutsCount - checkOutsForCursorCount - checkOutsForTransactionCount;
 
                 message =
-                    $"Timed out after {operationContext.Elapsed.TotalMilliseconds}ms waiting for a connection from the connection pool. " +
+                    $"Timed out after {elapsed.TotalMilliseconds}ms waiting for a connection from the connection pool. " +
                     $"maxPoolSize: {maxPoolSize}, " +
                     $"connections in use by cursors: {checkOutsForCursorCount}, " +
                     $"connections in use by transactions: {checkOutsForTransactionCount}, " +
@@ -296,9 +296,9 @@ private IConnectionHandle EndCheckingOut(PooledConnection pooledConnection, Oper
 
             private void EnsureTimeout(OperationContext operationContext)
             {
-                if (operationContext.IsTimedOut())
+                if (operationContext.IsTimedOut(out var elapsed))
                 {
-                    throw _pool.CreateTimeoutException(operationContext, $"Timed out waiting for a connection after {operationContext.Elapsed.TotalMilliseconds}ms.");
+                    throw _pool.CreateTimeoutException(elapsed, $"Timed out waiting for a connection after {elapsed.TotalMilliseconds}ms.");
                 }
             }
 
@@ -308,7 +308,7 @@ private Exception CreateException(OperationContext operationContext) =>
                     SemaphoreSlimSignalable.SemaphoreWaitResult.Signaled =>
                         MongoConnectionPoolPausedException.ForConnectionPool(_pool._endPoint),
                     SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut =>
-                        _pool.CreateTimeoutException(operationContext, $"Timed out waiting for a connection after {operationContext.Elapsed.TotalMilliseconds}ms."),
+                        _pool.CreateTimeoutException(operationContext.Elapsed, $"Timed out waiting for a connection after {operationContext.Elapsed.TotalMilliseconds}ms."),
                     // should not be reached
                     _ => new InvalidOperationException($"Invalid {_poolQueueWaitResult}.")
                 };
@@ -853,7 +853,7 @@ public PooledConnection CreateOpened(OperationContext operationContext)
 
                     if (_connectingWaitStatus == SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut)
                     {
-                        _pool.CreateTimeoutException(operationContext, $"Timed out waiting for in connecting queue after {operationContext.Elapsed.TotalMilliseconds}ms.");
+                        _pool.CreateTimeoutException(operationContext.Elapsed, $"Timed out waiting for in connecting queue after {operationContext.Elapsed.TotalMilliseconds}ms.");
                     }
 
                     return CreateOpenedInternal(operationContext);
@@ -885,13 +885,13 @@ public PooledConnection CreateOpenedOrReuse(OperationContext operationContext)
                         {
                             SemaphoreSlimSignalable.SemaphoreWaitResult.Signaled => _pool._connectionHolder.Acquire(),
                             SemaphoreSlimSignalable.SemaphoreWaitResult.Entered => CreateOpenedInternal(operationContext),
-                            SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut => throw CreateTimeoutException(operationContext),
+                            SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut => throw CreateTimeoutException(operationContext.Elapsed),
                             _ => throw new InvalidOperationException($"Invalid wait result {_connectingWaitStatus}")
                         };
 
-                        if (connection == null && operationContext.IsTimedOut())
+                        if (connection == null && operationContext.IsTimedOut(out var elapsed))
                         {
-                            throw CreateTimeoutException(operationContext);
+                            throw CreateTimeoutException(elapsed);
                         }
                     }
 
@@ -924,13 +924,13 @@ public async Task<PooledConnection> CreateOpenedOrReuseAsync(OperationContext op
                         {
                             SemaphoreSlimSignalable.SemaphoreWaitResult.Signaled => _pool._connectionHolder.Acquire(),
                             SemaphoreSlimSignalable.SemaphoreWaitResult.Entered => await CreateOpenedInternalAsync(operationContext).ConfigureAwait(false),
-                            SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut => throw CreateTimeoutException(operationContext),
+                            SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut => throw CreateTimeoutException(operationContext.Elapsed),
                             _ => throw new InvalidOperationException($"Invalid wait result {_connectingWaitStatus}")
                         };
 
-                        if (connection == null && operationContext.IsTimedOut())
+                        if (connection == null && operationContext.IsTimedOut(out var elapsed))
                         {
-                            throw CreateTimeoutException(operationContext);
+                            throw CreateTimeoutException(elapsed);
                         }
                     }
 
@@ -987,7 +987,7 @@ private void StartCreating(OperationContext operationContext)
                 _pool._eventLogger.LogAndPublish(new ConnectionPoolAddingConnectionEvent(_pool._serverId, EventContext.OperationId));
 
                 operationContext.CancellationToken.ThrowIfCancellationRequested();
-                if (operationContext.IsTimedOut())
+                if (operationContext.IsTimedOut(out _))
                 {
                     throw new TimeoutException();
                 }
@@ -1004,10 +1004,10 @@ private void FinishCreating(ConnectionDescription description, OperationContext
                 _pool._serviceStates.IncrementConnectionCount(description?.ServiceId);
             }
 
-            private Exception CreateTimeoutException(OperationContext operationContext)
+            private Exception CreateTimeoutException(TimeSpan elapsed)
             {
-                var message = $"Timed out waiting in connecting queue after {operationContext.Elapsed.TotalMilliseconds}ms.";
-                return _pool.CreateTimeoutException(operationContext, message);
+                var message = $"Timed out waiting in connecting queue after {elapsed.TotalMilliseconds}ms.";
+                return _pool.CreateTimeoutException(elapsed, message);
             }
         }
     }
diff --git a/src/MongoDB.Driver/OperationContext.cs b/src/MongoDB.Driver/OperationContext.cs
@@ -63,8 +63,9 @@ public TimeSpan RemainingTimeout
 
         private Stopwatch Stopwatch { get; }
 
-        public bool IsTimedOut()
+        public bool IsTimedOut(out TimeSpan elapsed)
         {
+            elapsed = Elapsed;
             var remainingTimeout = RemainingTimeout;
             if (remainingTimeout == System.Threading.Timeout.InfiniteTimeSpan)
             {
diff --git a/tests/MongoDB.Driver.Tests/OperationContextTests.cs b/tests/MongoDB.Driver.Tests/OperationContextTests.cs
@@ -99,9 +99,10 @@ public void IsTimedOut_should_return_expected_result(bool expected, TimeSpan tim
             stopwatch.Stop();
 
             var operationContext = new OperationContext(stopwatch, timeout, CancellationToken.None);
-            var result = operationContext.IsTimedOut();
+            var result = operationContext.IsTimedOut(out var elapsed);
 
             result.Should().Be(expected);
+            elapsed.Should().Be(stopwatch.Elapsed);
         }
 
         public static IEnumerable<object[]> IsTimedOut_test_cases =

Original file line number	Diff line number	Diff line change
`@@ -222,21 +222,21 @@ public IServer SelectServer(IServerSelector selector, OperationContext operation`
`222`	`222`	`Ensure.IsNotNull(selector, nameof(selector));`
`223`	`223`	`Ensure.IsNotNull(operationContext, nameof(operationContext));`
`224`	`224`
`225`		`- var serverSelectionCancellationContext = operationContext.WithTimeout(Settings.ServerSelectionTimeout);`
	`225`	`+ var serverSelectionOperationContext = operationContext.WithTimeout(Settings.ServerSelectionTimeout);`
`226`	`226`
`227`	`227`	`using (var helper = new SelectServerHelper(this, selector))`
`228`	`228`	`{`
`229`	`229`	`try`
`230`	`230`	`{`
`231`	`231`	`while (true)`
`232`	`232`	`{`
`233`		`- var server = helper.SelectServer(serverSelectionCancellationContext);`
	`233`	`+ var server = helper.SelectServer(serverSelectionOperationContext);`
`234`	`234`	`if (server != null)`
`235`	`235`	`{`
`236`	`236`	`return server;`
`237`	`237`	`}`
`238`	`238`
`239`		`- helper.WaitForDescriptionChanged(serverSelectionCancellationContext);`
	`239`	`+ helper.WaitForDescriptionChanged(serverSelectionOperationContext);`
`240`	`240`	`}`
`241`	`241`	`}`
`242`	`242`	`catch (TimeoutException)`
`@@ -261,21 +261,21 @@ public async Task<IServer> SelectServerAsync(IServerSelector selector, Operation`
`261`	`261`	`Ensure.IsNotNull(selector, nameof(selector));`
`262`	`262`	`Ensure.IsNotNull(operationContext, nameof(operationContext));`
`263`	`263`
`264`		`- var serverSelectionCancellationContext = operationContext.WithTimeout(Settings.ServerSelectionTimeout);`
	`264`	`+ var serverSelectionOperationContext = operationContext.WithTimeout(Settings.ServerSelectionTimeout);`
`265`	`265`
`266`	`266`	`using (var helper = new SelectServerHelper(this, selector))`
`267`	`267`	`{`
`268`	`268`	`try`
`269`	`269`	`{`
`270`	`270`	`while (true)`
`271`	`271`	`{`
`272`		`- var server = helper.SelectServer(serverSelectionCancellationContext);`
	`272`	`+ var server = helper.SelectServer(serverSelectionOperationContext);`
`273`	`273`	`if (server != null)`
`274`	`274`	`{`
`275`	`275`	`return server;`
`276`	`276`	`}`
`277`	`277`
`278`		`- await helper.WaitForDescriptionChangedAsync(serverSelectionCancellationContext).ConfigureAwait(false);`
	`278`	`+ await helper.WaitForDescriptionChangedAsync(serverSelectionOperationContext).ConfigureAwait(false);`
`279`	`279`	`}`
`280`	`280`	`}`
`281`	`281`	`catch (TimeoutException)`
Original file line number	Diff line number	Diff line change
`@@ -176,7 +176,7 @@ public IServer SelectServer(IServerSelector selector, OperationContext operation`
`176`	`176`	`Ensure.IsNotNull(operationContext, nameof(operationContext));`
`177`	`177`	`ThrowIfDisposed();`
`178`	`178`
`179`		`- var serverSelectionCancellationContext = operationContext.WithTimeout(_settings.ServerSelectionTimeout);`
	`179`	`+ var serverSelectionOperationContext = operationContext.WithTimeout(_settings.ServerSelectionTimeout);`
`180`	`180`
`181`	`181`	`_serverSelectionEventLogger.LogAndPublish(new ClusterSelectingServerEvent(`
`182`	`182`	`_description,`
`@@ -186,7 +186,7 @@ public IServer SelectServer(IServerSelector selector, OperationContext operation`
`186`	`186`
`187`	`187`	`try`
`188`	`188`	`{`
`189`		`- serverSelectionCancellationContext.WaitTask(_serverReadyTaskCompletionSource.Task);`
	`189`	`+ serverSelectionOperationContext.WaitTask(_serverReadyTaskCompletionSource.Task);`
`190`	`190`	`}`
`191`	`191`	`catch (TimeoutException)`
`192`	`192`	`{`
`@@ -199,7 +199,7 @@ public IServer SelectServer(IServerSelector selector, OperationContext operation`
`199`	`199`	`_description,`
`200`	`200`	`selector,`
`201`	`201`	`_server.Description,`
`202`		`- serverSelectionCancellationContext.Elapsed,`
	`202`	`+ serverSelectionOperationContext.Elapsed,`
`203`	`203`	`null,`
`204`	`204`	`EventContext.OperationName));`
`205`	`205`	`}`
`@@ -214,7 +214,7 @@ public async Task<IServer> SelectServerAsync(IServerSelector selector, Operation`
`214`	`214`	`Ensure.IsNotNull(operationContext, nameof(operationContext));`
`215`	`215`	`ThrowIfDisposed();`
`216`	`216`
`217`		`- var serverSelectionCancellationContext = operationContext.WithTimeout(_settings.ServerSelectionTimeout);`
	`217`	`+ var serverSelectionOperationContext = operationContext.WithTimeout(_settings.ServerSelectionTimeout);`
`218`	`218`
`219`	`219`	`_serverSelectionEventLogger.LogAndPublish(new ClusterSelectingServerEvent(`
`220`	`220`	`_description,`
`@@ -224,7 +224,7 @@ public async Task<IServer> SelectServerAsync(IServerSelector selector, Operation`
`224`	`224`
`225`	`225`	`try`
`226`	`226`	`{`
`227`		`- await serverSelectionCancellationContext.WaitTaskAsync(_serverReadyTaskCompletionSource.Task).ConfigureAwait(false);`
	`227`	`+ await serverSelectionOperationContext.WaitTaskAsync(_serverReadyTaskCompletionSource.Task).ConfigureAwait(false);`
`228`	`228`	`}`
`229`	`229`	`catch (TimeoutException)`
`230`	`230`	`{`
`@@ -237,7 +237,7 @@ public async Task<IServer> SelectServerAsync(IServerSelector selector, Operation`
`237`	`237`	`_description,`
`238`	`238`	`selector,`
`239`	`239`	`_server.Description,`
`240`		`- serverSelectionCancellationContext.Elapsed,`
	`240`	`+ serverSelectionOperationContext.Elapsed,`
`241`	`241`	`null,`
`242`	`242`	`EventContext.OperationName));`
`243`	`243`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ namespace MongoDB.Driver.Core.ConnectionPools`
`33`	`33`	`internal sealed partial class ExclusiveConnectionPool`
`34`	`34`	`{`
`35`	`35`	`// private methods`
`36`		`- private Exception CreateTimeoutException(OperationContext operationContext, string message)`
	`36`	`+ private Exception CreateTimeoutException(TimeSpan elapsed, string message)`
`37`	`37`	`{`
`38`	`38`	`var checkOutsForCursorCount = _checkOutReasonCounter.GetCheckOutsCount(CheckOutReason.Cursor);`
`39`	`39`	`var checkOutsForTransactionCount = _checkOutReasonCounter.GetCheckOutsCount(CheckOutReason.Transaction);`
`@@ -47,7 +47,7 @@ private Exception CreateTimeoutException(OperationContext operationContext, stri`
`47`	`47`	`var checkOutsForOtherCount = checkOutsCount - checkOutsForCursorCount - checkOutsForTransactionCount;`
`48`	`48`
`49`	`49`	`message =`
`50`		`- $"Timed out after {operationContext.Elapsed.TotalMilliseconds}ms waiting for a connection from the connection pool. " +`
	`50`	`+ $"Timed out after {elapsed.TotalMilliseconds}ms waiting for a connection from the connection pool. " +`
`51`	`51`	`$"maxPoolSize: {maxPoolSize}, " +`
`52`	`52`	`$"connections in use by cursors: {checkOutsForCursorCount}, " +`
`53`	`53`	`$"connections in use by transactions: {checkOutsForTransactionCount}, " +`
`@@ -296,9 +296,9 @@ private IConnectionHandle EndCheckingOut(PooledConnection pooledConnection, Oper`
`296`	`296`
`297`	`297`	`private void EnsureTimeout(OperationContext operationContext)`
`298`	`298`	`{`
`299`		`- if (operationContext.IsTimedOut())`
	`299`	`+ if (operationContext.IsTimedOut(out var elapsed))`
`300`	`300`	`{`
`301`		`- throw _pool.CreateTimeoutException(operationContext, $"Timed out waiting for a connection after {operationContext.Elapsed.TotalMilliseconds}ms.");`
	`301`	`+ throw _pool.CreateTimeoutException(elapsed, $"Timed out waiting for a connection after {elapsed.TotalMilliseconds}ms.");`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`
`@@ -308,7 +308,7 @@ private Exception CreateException(OperationContext operationContext) =>`
`308`	`308`	`SemaphoreSlimSignalable.SemaphoreWaitResult.Signaled =>`
`309`	`309`	`MongoConnectionPoolPausedException.ForConnectionPool(_pool._endPoint),`
`310`	`310`	`SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut =>`
`311`		`- _pool.CreateTimeoutException(operationContext, $"Timed out waiting for a connection after {operationContext.Elapsed.TotalMilliseconds}ms."),`
	`311`	`+ _pool.CreateTimeoutException(operationContext.Elapsed, $"Timed out waiting for a connection after {operationContext.Elapsed.TotalMilliseconds}ms."),`
`312`	`312`	`// should not be reached`
`313`	`313`	`_ => new InvalidOperationException($"Invalid {_poolQueueWaitResult}.")`
`314`	`314`	`};`
`@@ -853,7 +853,7 @@ public PooledConnection CreateOpened(OperationContext operationContext)`
`853`	`853`
`854`	`854`	`if (_connectingWaitStatus == SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut)`
`855`	`855`	`{`
`856`		`- _pool.CreateTimeoutException(operationContext, $"Timed out waiting for in connecting queue after {operationContext.Elapsed.TotalMilliseconds}ms.");`
	`856`	`+ _pool.CreateTimeoutException(operationContext.Elapsed, $"Timed out waiting for in connecting queue after {operationContext.Elapsed.TotalMilliseconds}ms.");`
`857`	`857`	`}`
`858`	`858`
`859`	`859`	`return CreateOpenedInternal(operationContext);`
`@@ -885,13 +885,13 @@ public PooledConnection CreateOpenedOrReuse(OperationContext operationContext)`
`885`	`885`	`{`
`886`	`886`	`SemaphoreSlimSignalable.SemaphoreWaitResult.Signaled => _pool._connectionHolder.Acquire(),`
`887`	`887`	`SemaphoreSlimSignalable.SemaphoreWaitResult.Entered => CreateOpenedInternal(operationContext),`
`888`		`- SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut => throw CreateTimeoutException(operationContext),`
	`888`	`+ SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut => throw CreateTimeoutException(operationContext.Elapsed),`
`889`	`889`	`_ => throw new InvalidOperationException($"Invalid wait result {_connectingWaitStatus}")`
`890`	`890`	`};`
`891`	`891`
`892`		`- if (connection == null && operationContext.IsTimedOut())`
	`892`	`+ if (connection == null && operationContext.IsTimedOut(out var elapsed))`
`893`	`893`	`{`
`894`		`- throw CreateTimeoutException(operationContext);`
	`894`	`+ throw CreateTimeoutException(elapsed);`
`895`	`895`	`}`
`896`	`896`	`}`
`897`	`897`
`@@ -924,13 +924,13 @@ public async Task<PooledConnection> CreateOpenedOrReuseAsync(OperationContext op`
`924`	`924`	`{`
`925`	`925`	`SemaphoreSlimSignalable.SemaphoreWaitResult.Signaled => _pool._connectionHolder.Acquire(),`
`926`	`926`	`SemaphoreSlimSignalable.SemaphoreWaitResult.Entered => await CreateOpenedInternalAsync(operationContext).ConfigureAwait(false),`
`927`		`- SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut => throw CreateTimeoutException(operationContext),`
	`927`	`+ SemaphoreSlimSignalable.SemaphoreWaitResult.TimedOut => throw CreateTimeoutException(operationContext.Elapsed),`
`928`	`928`	`_ => throw new InvalidOperationException($"Invalid wait result {_connectingWaitStatus}")`
`929`	`929`	`};`
`930`	`930`
`931`		`- if (connection == null && operationContext.IsTimedOut())`
	`931`	`+ if (connection == null && operationContext.IsTimedOut(out var elapsed))`
`932`	`932`	`{`
`933`		`- throw CreateTimeoutException(operationContext);`
	`933`	`+ throw CreateTimeoutException(elapsed);`
`934`	`934`	`}`
`935`	`935`	`}`
`936`	`936`
`@@ -987,7 +987,7 @@ private void StartCreating(OperationContext operationContext)`
`987`	`987`	`_pool._eventLogger.LogAndPublish(new ConnectionPoolAddingConnectionEvent(_pool._serverId, EventContext.OperationId));`
`988`	`988`
`989`	`989`	`operationContext.CancellationToken.ThrowIfCancellationRequested();`
`990`		`- if (operationContext.IsTimedOut())`
	`990`	`+ if (operationContext.IsTimedOut(out _))`
`991`	`991`	`{`
`992`	`992`	`throw new TimeoutException();`
`993`	`993`	`}`
`@@ -1004,10 +1004,10 @@ private void FinishCreating(ConnectionDescription description, OperationContext`
`1004`	`1004`	`_pool._serviceStates.IncrementConnectionCount(description?.ServiceId);`
`1005`	`1005`	`}`
`1006`	`1006`
`1007`		`- private Exception CreateTimeoutException(OperationContext operationContext)`
	`1007`	`+ private Exception CreateTimeoutException(TimeSpan elapsed)`
`1008`	`1008`	`{`
`1009`		`- var message = $"Timed out waiting in connecting queue after {operationContext.Elapsed.TotalMilliseconds}ms.";`
`1010`		`- return _pool.CreateTimeoutException(operationContext, message);`
	`1009`	`+ var message = $"Timed out waiting in connecting queue after {elapsed.TotalMilliseconds}ms.";`
	`1010`	`+ return _pool.CreateTimeoutException(elapsed, message);`
`1011`	`1011`	`}`
`1012`	`1012`	`}`
`1013`	`1013`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,8 +63,9 @@ public TimeSpan RemainingTimeout`
`63`	`63`
`64`	`64`	`private Stopwatch Stopwatch { get; }`
`65`	`65`
`66`		`- public bool IsTimedOut()`
	`66`	`+ public bool IsTimedOut(out TimeSpan elapsed)`
`67`	`67`	`{`
	`68`	`+ elapsed = Elapsed;`
`68`	`69`	`var remainingTimeout = RemainingTimeout;`
`69`	`70`	`if (remainingTimeout == System.Threading.Timeout.InfiniteTimeSpan)`
`70`	`71`	`{`
Original file line number	Diff line number	Diff line change
`@@ -99,9 +99,10 @@ public void IsTimedOut_should_return_expected_result(bool expected, TimeSpan tim`
`99`	`99`	`stopwatch.Stop();`
`100`	`100`
`101`	`101`	`var operationContext = new OperationContext(stopwatch, timeout, CancellationToken.None);`
`102`		`- var result = operationContext.IsTimedOut();`
	`102`	`+ var result = operationContext.IsTimedOut(out var elapsed);`
`103`	`103`
`104`	`104`	`result.Should().Be(expected);`
	`105`	`+ elapsed.Should().Be(stopwatch.Elapsed);`
`105`	`106`	`}`
`106`	`107`
`107`	`108`	`public static IEnumerable<object[]> IsTimedOut_test_cases =`