fix mongo: deadline propagation stale snapshot on connection creation

When a new MongoDB connection needs to be created (no idle connections in pool),
Create() runs a ping to MongoDB without any deadline enforcement — it is bounded
only by SOCKETTIMEOUTMS from the URI config (typically several seconds).

Meanwhile, MakeRequestContext() captures the remaining deadline as a snapshot
*before* calling GetClient(), so if Create() takes several seconds the snapshot
becomes stale. The stale value is then used as maxTimeMS for the actual query,
causing requests to run far beyond the original deadline.

Example: deadline=999ms, Create() takes ~6.9s ping, then query runs another
999ms → total 7.883s with "operation exceeded time limit" from MongoDB.

Fix in collection_impl.cpp: After GetClient() returns, re-evaluate the
remaining deadline with a fresh GetDeadlineTimeLeft() call. If the deadline has
already expired, throw CancelledException immediately. Pass the fresh value as
inherited_deadline so maxTimeMS is computed correctly.
commit_hash:6a4eeb4aa39628bf4bae31a00048927e735e0a3c

Author: askvorcov

mongo/src/storages/mongo/cdriver/collection_impl.cpp

@@ -134,6 +134,20 @@ void SetMaxServerTime(
     }
 }
 
+std::optional<std::chrono::milliseconds> GetTimeoutOrThrow(
+    const dynamic_config::Snapshot& dynamic_config,
+    stats::OperationStatisticsItem& stats,
+    tracing::Span& span
+) {
+    const auto time_left = GetDeadlineTimeLeft(dynamic_config);
+    if (time_left && time_left <= std::chrono::seconds{0}) {
+        stats.Account(stats::ErrorType::kCancelled);
+        span.AddTag(kCancelledByDeadlineTag, true);
+        throw CancelledException(CancelledException::ByDeadlinePropagation{});
+    }
+    return time_left;
+}
+
 }  // namespace
 
 CDriverCollectionImpl::CDriverCollectionImpl(
@@ -616,28 +630,29 @@ RequestContext CDriverCollectionImpl::MakeRequestContext(std::string&& span_name
     auto stats = statistics_->items[stats_key];
     auto dynamic_config = pool_impl_->GetConfig();
 
-    const auto inherited_deadline = GetDeadlineTimeLeft(dynamic_config);
-    if (inherited_deadline && inherited_deadline <= std::chrono::seconds{0}) {
-        stats->Account(stats::ErrorType::kCancelled);
-        span.AddTag(kCancelledByDeadlineTag, true);
-        throw CancelledException(CancelledException::ByDeadlinePropagation{});
-    }
-
-    if (inherited_deadline) {
-        span.AddTag(tracing::kTimeoutMs, inherited_deadline->count());
+    // first deadline check, to make sure we dont get/wait for client if deadline is already reached.
+    auto timeout_ms = GetTimeoutOrThrow(dynamic_config, *stats, span);
+    if (timeout_ms) {
+        span.AddTag(tracing::kTimeoutMs, timeout_ms->count());
     }
 
     auto client = GetClient(*stats);
     cdriver::CollectionPtr
         collection(mongoc_client_get_collection(client.get(), GetDatabaseName().c_str(), GetCollectionName().c_str()));
 
+    // The second deadline check, to make sure we did not hit deadline after waiting or creating a new client.
+    timeout_ms = timeout_ms ? GetTimeoutOrThrow(dynamic_config, *stats, span) : timeout_ms;
+    if (timeout_ms) {
+        span.AddTag(tracing::kTimeoutMs, timeout_ms->count());
+    }
+
     return RequestContext{
         std::move(stats),
         std::move(dynamic_config),
         std::move(client),
         std::move(collection),
         std::move(span),
-        inherited_deadline,
+        timeout_ms,
     };
 }
 

mongo/src/storages/mongo/cdriver/pool_impl.cpp

@@ -495,6 +495,7 @@ CDriverPoolImpl::ConnPtr CDriverPoolImpl::Pop() {
                   << "' has too many establishing connections. " << MakeQueueDeadlineMessage(inherited_timeout);
             }
             conn = Create();
+            TESTPOINT("mongo-connection-created", {});
         }
     }
 

mongo/src/storages/mongo/deadline_mongotest.cpp

@@ -1,13 +1,17 @@
 #include <userver/utest/utest.hpp>
 
+#include <userver/engine/sleep.hpp>
 #include <userver/engine/task/cancel.hpp>
 #include <userver/server/request/task_inherited_data.hpp>
+#include <userver/testsuite/testpoint.hpp>
+#include <userver/testsuite/testpoint_control.hpp>
 
 #include <storages/mongo/util_mongotest.hpp>
 #include <userver/formats/bson.hpp>
 #include <userver/storages/mongo/collection.hpp>
 #include <userver/storages/mongo/exception.hpp>
 #include <userver/storages/mongo/pool.hpp>
+#include <userver/tracing/span.hpp>
 
 using namespace std::chrono_literals;
 
@@ -84,4 +88,42 @@ UTEST_F(DeadlinePropagation, AlreadyCancelled) {
     UEXPECT_THROW(coll.InsertOne(bson::MakeDoc("_id", 2)), mongo::CancelledException);
 }
 
+UTEST_F(DeadlinePropagation, CancelledByDeadlineAfterGetClient) {
+    auto pool_config = MakeTestPoolConfig();
+    pool_config.pool_settings.initial_size = 0;
+    pool_config.pool_settings.idle_limit = 1;
+    pool_config.pool_settings.max_size = 1;
+    pool_config.queue_timeout = utest::kMaxTestWaitTime;
+
+    {
+        // check positive case, connection creation is fast
+        auto pool = MakePool({}, pool_config);
+        auto coll = pool.GetCollection("dp");
+        server::request::kTaskInheritedData.Set(MakeRequestData(engine::Deadline::FromDuration(100ms)));
+        UASSERT_NO_THROW(coll.InsertOne(bson::MakeDoc("_id", 1)));
+    }
+    {
+        // check negative case, connection creation is too slow
+        auto pool = MakePool({}, pool_config);
+        auto coll = pool.GetCollection("dp");
+        // delay in connection create
+        testsuite::TestpointControl testpoint_control;
+        class SlowConnectionClient final : public testsuite::TestpointClientBase {
+        public:
+            mutable size_t times_called = 0;
+            ~SlowConnectionClient() override { Unregister(); }
+            void Execute(std::string_view, const formats::json::Value&, Callback) const override {
+                engine::SleepFor(std::chrono::milliseconds{200});
+                times_called++;
+            }
+        } slow_client;
+        testpoint_control.SetClient(slow_client);
+        testpoint_control.SetEnabledNames({"mongo-connection-created"});
+
+        server::request::kTaskInheritedData.Set(MakeRequestData(engine::Deadline::FromDuration(100ms)));
+        UEXPECT_THROW(coll.InsertOne(bson::MakeDoc("_id", 2)), mongo::CancelledException);
+        EXPECT_EQ(slow_client.times_called, 1);
+    }
+}
+
 USERVER_NAMESPACE_END