couchbase 3.8.2 → 3.9.1

data/ext/couchbase/core/transactions/internal/atr_entry.hxx

@@ -69,11 +69,31 @@ public:
   {
   }
 
+  /**
+   * @brief Determines whether this ATR entry's transaction has exceeded its configured timeout.
+   *
+   * Uses the ATR document's CAS as a server-side clock (CAS encodes a server timestamp in
+   * nanoseconds).  The elapsed time is computed as:
+   *   @code elapsed_ms = (cas / 1_000_000) - timestamp_start_ms @endcode
+   *
+   * Returns @c false conservatively if either @c timestamp_start_ms or @c expires_after_ms are
+   * absent — this avoids spurious expiry decisions when the ATR entry has not yet been fully
+   * initialised or when the CAS has not advanced past the recorded start time.
+   *
+   * @param safety_margin Additional milliseconds added to the configured TTL before declaring
+   *                       the entry expired.  Useful to declare expiry slightly early in order
+   *                       to avoid races with the owning client.
+   * @return @c true if the transaction has exceeded @c (expires_after_ms + safety_margin) of
+   *         elapsed CAS-time since @c timestamp_start_ms.
+   */
   [[nodiscard]] bool has_expired(std::uint32_t safety_margin = 0) const
   {
     std::uint64_t cas_ms = cas_ / 1000000;
-    if (timestamp_start_ms_ && cas_ms > *timestamp_start_ms_) {
-      std::uint32_t expires_after_ms = *expires_after_ms_;
+    if (timestamp_start_ms_ && expires_after_ms_ && cas_ms > *timestamp_start_ms_) {
+      // Compute the effective TTL in std::uint64_t: expires_after_ms + safety_margin would
+      // otherwise be evaluated in std::uint32_t and could overflow for large TTLs/margins,
+      // flipping the comparison.
+      const std::uint64_t expires_after_ms = *expires_after_ms_;
       return (cas_ms - *timestamp_start_ms_) > (expires_after_ms + safety_margin);
     }
     return false;

data/ext/couchbase/core/transactions/internal/transaction_context.hxx

@@ -40,7 +40,7 @@ using txn_complete_callback =
   std::function<void(std::optional<transaction_exception>,
                      std::optional<::couchbase::transactions::transaction_result>)>;
 
-struct exp_delay;
+struct async_timed_exp_delay;
 
 class transaction_context : public std::enable_shared_from_this<transaction_context>
 {
@@ -174,6 +174,6 @@ private:
   std::shared_ptr<attempt_context_impl> current_attempt_context_;
   mutable std::mutex mutex_;
 
-  std::unique_ptr<exp_delay> delay_;
+  std::unique_ptr<async_timed_exp_delay> delay_;
 };
 } // namespace couchbase::core::transactions

data/ext/couchbase/core/transactions/internal/transactions_cleanup.hxx

@@ -22,8 +22,12 @@
 
 #include <couchbase/transactions/transactions_config.hxx>
 
+#include <asio/thread_pool.hpp>
+
 #include <atomic>
 #include <condition_variable>
+#include <cstdint>
+#include <optional>
 #include <thread>
 
 namespace couchbase::core
@@ -118,7 +122,7 @@ public:
   void add_collection(const couchbase::transactions::transaction_keyspace& keyspace);
   auto collections() -> std::list<couchbase::transactions::transaction_keyspace>
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::scoped_lock<std::mutex> lock(mutex_);
     return collections_;
   }
 
@@ -127,6 +131,11 @@ public:
   // only used for testing
   void force_cleanup_entry(atr_cleanup_entry& entry, transactions_cleanup_attempt& attempt);
   // only used for testing
+  [[nodiscard]] auto client_uuid() const -> const std::string&
+  {
+    return client_uuid_;
+  }
+  // only used for testing
   auto force_cleanup_atr(const core::document_id& atr_id,
                          std::vector<transactions_cleanup_attempt>& results) -> atr_cleanup_stats;
   auto get_active_clients(const couchbase::transactions::transaction_keyspace& keyspace,
@@ -147,7 +156,20 @@ private:
   mutable std::mutex mutex_;
   std::list<std::thread> lost_attempt_cleanup_workers_;
 
+  // Bounded, shared pool of threads for the blocking per-ATR cleanup checks. These checks block on
+  // KV, so they must not run on the single Asio IO thread. The pool is shared across every
+  // collection cleanup worker, so this count bounds the TOTAL number of concurrent get_atr checks
+  // across the whole cleanup subsystem -- deliberately, to cap load on the cluster regardless of
+  // how many keyspaces are registered for cleanup. The same value doubles as each worker's
+  // in-flight cap: with one collection a worker saturates the pool; with many collections the
+  // shared pool multiplexes them (fair FIFO) and per-collection throughput drops accordingly, which
+  // is the intended trade-off (bounded cluster load over guaranteed per-collection pacing).
+  static constexpr std::size_t max_in_flight_atr_checks_{ 16 };
+  std::optional<asio::thread_pool> atr_cleanup_pool_;
+
   const std::string client_uuid_;
+  // The process that registered client_uuid_. A forked child inherits the uuid but not the record.
+  const std::int64_t client_record_owner_pid_;
   std::list<couchbase::transactions::transaction_keyspace> collections_;
 
   void attempts_loop();

data/ext/couchbase/core/transactions/internal/utils.hxx

@@ -47,6 +47,25 @@ namespace transactions
 std::uint64_t
 now_ns_from_vbucket(const tao::json::value& vbucket);
 
+/**
+ * ${Mutation.CAS} is written by kvengine with 'macroToString(htonll(info.cas))'. Discussed this
+ * with the KV team and, though there is consensus that this is off (htonll is definitely wrong,
+ * and a string is an odd choice), there are clients (SyncGateway) that consume the current
+ * string, so it can't be changed.
+ *
+ * The byte order inside that string is therefore fixed by the server, whatever host reads it,
+ * so recovering the value needs an unconditional reversal rather than a network-to-host
+ * conversion. See core::utils::reverse_bytes.
+ *
+ * Looks like: "0x000058a71dd25c15"
+ * Want:        0x155CD21DA7580000  (1539336197457313792 in base10, an epoch time in
+ *                                   nanoseconds)
+ *
+ * @return epoch time in milliseconds, or 0 for an empty string
+ */
+std::uint64_t
+parse_mutation_cas(const std::string& cas);
+
 std::string
 jsonify(const tao::json::value& obj);
 
@@ -175,7 +194,7 @@ jitter()
   static std::mt19937 gen(rd());
   static std::uniform_real_distribution<> dist(1 - RETRY_OP_JITTER, 1 + RETRY_OP_JITTER);
 
-  std::lock_guard<std::mutex> lock(mtx);
+  std::scoped_lock<std::mutex> lock(mtx);
   return dist(gen);
 }
 
@@ -260,7 +279,13 @@ retry_op(std::function<R()> func)
     DEFAULT_RETRY_OP_DELAY, std::numeric_limits<std::size_t>::max(), func);
 }
 
-struct exp_delay {
+// Exponential backoff bounded by a timeout, waiting on a timer so that it is safe to call from a
+// completion handler. The first call starts the timeout and completes inline. Later calls complete
+// after the backoff, or with retry_operation_timeout past the timeout or on cancellation, or with
+// retry_operation_retries_exhausted after max_retries. Calls must not overlap: state is
+// unsynchronised and expires_after cancels a pending wait.
+struct async_timed_exp_delay {
+  std::shared_ptr<asio::steady_timer> timer;
   std::chrono::nanoseconds initial_delay;
   std::chrono::nanoseconds max_delay;
   std::chrono::nanoseconds timeout;
@@ -269,36 +294,44 @@ struct exp_delay {
   std::size_t max_retries{ 100 };
 
   template<typename R1, typename P1, typename R2, typename P2, typename R3, typename P3>
-  exp_delay(std::chrono::duration<R1, P1> initial,
-            std::chrono::duration<R2, P2> max,
-            std::chrono::duration<R3, P3> limit)
-    : initial_delay(std::chrono::duration_cast<std::chrono::nanoseconds>(initial))
+  async_timed_exp_delay(std::shared_ptr<asio::steady_timer> timer,
+                        std::chrono::duration<R1, P1> initial,
+                        std::chrono::duration<R2, P2> max,
+                        std::chrono::duration<R3, P3> limit)
+    : timer(std::move(timer))
+    , initial_delay(std::chrono::duration_cast<std::chrono::nanoseconds>(initial))
     , max_delay(std::chrono::duration_cast<std::chrono::nanoseconds>(max))
     , timeout(std::chrono::duration_cast<std::chrono::nanoseconds>(limit))
   {
   }
-  void operator()() const
+  void operator()(utils::movable_function<void(std::exception_ptr)> callback) const
   {
     auto now = std::chrono::steady_clock::now();
     if (retries >= max_retries) {
-      throw retry_operation_retries_exhausted("retries exhausted");
+      return callback(
+        std::make_exception_ptr(retry_operation_retries_exhausted("retries exhausted")));
     }
     if (!end_time) {
       end_time = std::chrono::steady_clock::now() + timeout;
-      return;
+      return callback({});
     }
     if (now > *end_time) {
-      throw retry_operation_timeout("timed out");
+      return callback(std::make_exception_ptr(retry_operation_timeout("timed out")));
     }
     auto delay = initial_delay * (jitter() * pow(2, retries++));
     if (delay > max_delay) {
       delay = max_delay;
     }
     if (now + delay > *end_time) {
-      std::this_thread::sleep_for(*end_time - now);
-    } else {
-      std::this_thread::sleep_for(delay);
+      delay = *end_time - now;
     }
+    timer->expires_after(std::chrono::duration_cast<std::chrono::nanoseconds>(delay));
+    timer->async_wait([callback = std::move(callback)](std::error_code ec) mutable {
+      if (ec == asio::error::operation_aborted) {
+        return callback(std::make_exception_ptr(retry_operation_timeout("retry aborted")));
+      }
+      callback({});
+    });
   }
 };
 
@@ -353,7 +386,10 @@ struct async_exp_delay {
 
   void operator()(utils::movable_function<void(std::exception_ptr)> callback) const
   {
-    if (retries++ >= max_retries) {
+    // retries must be incremented exactly once per call: the guard reads it without mutating, and
+    // pow() does the single post-increment. Incrementing in both places double-counts -- halving
+    // the effective max_retries and doubling the exponent growth per attempt.
+    if (retries >= max_retries) {
       callback(std::make_exception_ptr(retry_operation_retries_exhausted("retries exhausted")));
       return;
     }

data/ext/couchbase/core/transactions/staged_mutation.cxx

@@ -110,7 +110,7 @@ staged_mutation::operation_id() const -> const std::string&
 }
 
 auto
-staged_mutation::type_as_string() const -> std::string
+staged_mutation::type_as_string() const -> std::string_view
 {
   switch (type_) {
     case staged_mutation_type::INSERT:
@@ -149,7 +149,7 @@ unstaging_state::wait_until_unstage_possible() -> bool
 void
 unstaging_state::notify_unstage_complete()
 {
-  const std::lock_guard lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   in_flight_count_--;
   cv_.notify_one();
 }
@@ -157,7 +157,7 @@ unstaging_state::notify_unstage_complete()
 void
 unstaging_state::notify_unstage_error()
 {
-  const std::lock_guard lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   abort_ = true;
   in_flight_count_--;
   cv_.notify_all();
@@ -166,14 +166,14 @@ unstaging_state::notify_unstage_error()
 auto
 staged_mutation_queue::empty() -> bool
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   return queue_.empty();
 }
 
 void
 staged_mutation_queue::add(staged_mutation&& mutation)
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   // Can only have one staged mutation per document.
   queue_.erase(std::remove_if(queue_.begin(),
                               queue_.end(),
@@ -188,16 +188,21 @@ void
 staged_mutation_queue::extract_to(const std::string& prefix,
                                   core::operations::mutate_in_request& req)
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   tao::json::value inserts = tao::json::empty_array;
   tao::json::value replaces = tao::json::empty_array;
   tao::json::value removes = tao::json::empty_array;
 
   for (const auto& mutation : queue_) {
-    const tao::json::value doc{ { ATR_FIELD_PER_DOC_ID, mutation.id().key() },
-                                { ATR_FIELD_PER_DOC_BUCKET, mutation.id().bucket() },
-                                { ATR_FIELD_PER_DOC_SCOPE, mutation.id().scope() },
-                                { ATR_FIELD_PER_DOC_COLLECTION, mutation.id().collection() } };
+    const tao::json::value doc{
+      { ATR_FIELD_PER_DOC_ID, mutation.id().key() },
+      { ATR_FIELD_PER_DOC_BUCKET, mutation.id().bucket() },
+      { ATR_FIELD_PER_DOC_SCOPE, mutation.id().scope() },
+      {
+        ATR_FIELD_PER_DOC_COLLECTION,
+        mutation.id().collection(),
+      },
+    };
     switch (mutation.type()) {
       case staged_mutation_type::INSERT:
         inserts.push_back(doc);
@@ -232,7 +237,7 @@ staged_mutation_queue::extract_to(const std::string& prefix,
 void
 staged_mutation_queue::remove_any(const core::document_id& id)
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   auto new_end = std::remove_if(queue_.begin(), queue_.end(), [&id](const staged_mutation& item) {
     return document_ids_equal(item.id(), id);
   });
@@ -242,7 +247,7 @@ staged_mutation_queue::remove_any(const core::document_id& id)
 auto
 staged_mutation_queue::find_any(const core::document_id& id) -> staged_mutation*
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   for (auto& item : queue_) {
     if (document_ids_equal(item.id(), id)) {
       return &item;
@@ -254,7 +259,7 @@ staged_mutation_queue::find_any(const core::document_id& id) -> staged_mutation*
 auto
 staged_mutation_queue::find_replace(const core::document_id& id) -> staged_mutation*
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   for (auto& item : queue_) {
     if (item.type() == staged_mutation_type::REPLACE && document_ids_equal(item.id(), id)) {
       return &item;
@@ -266,7 +271,7 @@ staged_mutation_queue::find_replace(const core::document_id& id) -> staged_mutat
 auto
 staged_mutation_queue::find_insert(const core::document_id& id) -> staged_mutation*
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   for (auto& item : queue_) {
     if (item.type() == staged_mutation_type::INSERT && document_ids_equal(item.id(), id)) {
       return &item;
@@ -278,7 +283,7 @@ staged_mutation_queue::find_insert(const core::document_id& id) -> staged_mutati
 auto
 staged_mutation_queue::find_remove(const core::document_id& id) -> staged_mutation*
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   for (auto& item : queue_) {
     if (item.type() == staged_mutation_type::REMOVE && document_ids_equal(item.id(), id)) {
       return &item;
@@ -289,7 +294,7 @@ staged_mutation_queue::find_remove(const core::document_id& id) -> staged_mutati
 void
 staged_mutation_queue::iterate(const std::function<void(staged_mutation&)>& op)
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   for (auto& item : queue_) {
     op(item);
   }
@@ -299,7 +304,7 @@ void
 staged_mutation_queue::commit(const std::shared_ptr<attempt_context_impl>& ctx)
 {
   CB_ATTEMPT_CTX_LOG_TRACE(ctx, "committing staged mutations...");
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
 
   unstaging_state state{ ctx };
   std::vector<std::future<void>> futures{};
@@ -390,7 +395,7 @@ void
 staged_mutation_queue::rollback(const std::shared_ptr<attempt_context_impl>& ctx)
 {
   CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rolling back staged mutations...");
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
 
   unstaging_state state{ ctx };
   std::vector<std::future<void>> futures{};

data/ext/couchbase/core/transactions/staged_mutation.hxx

@@ -23,8 +23,12 @@
 
 #include <couchbase/codec/encoded_value.hxx>
 
+#include <atomic>
+#include <condition_variable>
 #include <mutex>
+#include <optional>
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace couchbase::core::transactions
@@ -32,7 +36,7 @@ namespace couchbase::core::transactions
 enum class staged_mutation_type {
   INSERT,
   REMOVE,
-  REPLACE
+  REPLACE,
 };
 
 class staged_mutation
@@ -62,7 +66,14 @@ public:
   [[nodiscard]] auto current_user_flags() const -> std::uint32_t;
   [[nodiscard]] auto doc_metadata() const -> const std::optional<document_metadata>&;
   [[nodiscard]] auto operation_id() const -> const std::string&;
-  [[nodiscard]] auto type_as_string() const -> std::string;
+  /**
+   * @brief Returns the human-readable name of the mutation type as a string literal view.
+   *
+   * Returns one of @c "INSERT", @c "REPLACE", or @c "REMOVE" without any heap allocation.
+   * The returned view is backed by a string literal and remains valid for the lifetime of the
+   * program.
+   */
+  [[nodiscard]] auto type_as_string() const -> std::string_view;
 
   void cas(couchbase::cas cas);
 
@@ -166,8 +177,8 @@ public:
   void extract_to(const std::string& prefix, core::operations::mutate_in_request& req);
   void commit(const std::shared_ptr<attempt_context_impl>& ctx);
   void rollback(const std::shared_ptr<attempt_context_impl>& ctx);
-  void iterate(const std::function<void(staged_mutation&)>&);
-  void remove_any(const core::document_id&);
+  void iterate(const std::function<void(staged_mutation& /*mutation*/)>&);
+  void remove_any(const core::document_id& /*id*/);
 
   auto find_any(const core::document_id& id) -> staged_mutation*;
   auto find_replace(const core::document_id& id) -> staged_mutation*;

data/ext/couchbase/core/transactions/transaction_context.cxx

@@ -27,6 +27,7 @@
 
 #include <asio/post.hpp>
 #include <asio/steady_timer.hpp>
+#include <optional>
 #include <utility>
 
 namespace couchbase::core::transactions
@@ -59,9 +60,11 @@ transaction_context::transaction_context(transactions& txns,
   , config_(config.apply(txns.config()))
   , deferred_elapsed_(0)
   , cleanup_(txns.cleanup())
-  , delay_(new exp_delay(std::chrono::milliseconds(1),
-                         std::chrono::milliseconds(100),
-                         2 * config_.timeout))
+  , delay_(std::make_unique<async_timed_exp_delay>(
+      std::make_shared<asio::steady_timer>(txns.cluster_ref().io_context()),
+      std::chrono::milliseconds(1),
+      std::chrono::milliseconds(100),
+      2 * config_.timeout))
 {
   // add metadata_collection to cleanup, if present
   if (config_.metadata_collection) {
@@ -77,7 +80,7 @@ void
 transaction_context::add_attempt()
 {
   const transaction_attempt attempt{};
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   attempts_.push_back(attempt);
 }
 
@@ -138,21 +141,25 @@ void
 transaction_context::new_attempt_context(async_attempt_context::VoidCallback&& cb)
 {
   asio::post(transactions_.cluster_ref().io_context(),
-             [self = shared_from_this(), cb = std::move(cb)]() {
+             [self = shared_from_this(), cb = std::move(cb)]() mutable {
                // the first time we call the delay, it just records an end time.  After
                // that, it actually delays.
-               try {
-                 (*self->delay_)();
-                 self->current_attempt_context_ = attempt_context_impl::create(self);
-                 CB_ATTEMPT_CTX_LOG_INFO(self->current_attempt_context_,
-                                         "starting attempt {}/{}/{}/",
-                                         self->num_attempts(),
-                                         self->transaction_id(),
-                                         self->current_attempt_context_->id());
-                 cb(nullptr);
-               } catch (...) {
-                 cb(std::current_exception());
-               }
+               (*self->delay_)([self, cb = std::move(cb)](const std::exception_ptr& err) mutable {
+                 if (err) {
+                   return cb(err);
+                 }
+                 try {
+                   self->current_attempt_context_ = attempt_context_impl::create(self);
+                   CB_ATTEMPT_CTX_LOG_INFO(self->current_attempt_context_,
+                                           "starting attempt {}/{}/{}/",
+                                           self->num_attempts(),
+                                           self->transaction_id(),
+                                           self->current_attempt_context_->id());
+                   cb(nullptr);
+                 } catch (...) {
+                   cb(std::current_exception());
+                 }
+               });
              });
 }
 
@@ -299,6 +306,18 @@ transaction_context::existing_error(bool previous_op_failed)
 void
 transaction_context::handle_error(const std::exception_ptr& err, txn_complete_callback&& callback)
 {
+  auto auto_rollback = [this]() -> std::optional<final_error> {
+    try {
+      current_attempt_context_->rollback();
+      return {};
+    } catch (const std::exception& e) {
+      CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "auto rollback failed: {}", e.what());
+    } catch (...) {
+      CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "auto rollback failed");
+    }
+    return current_attempt_context_->query_check_expired_ ? EXPIRED : FAILED;
+  };
+
   try {
     try {
       std::rethrow_exception(err);
@@ -316,16 +335,15 @@ transaction_context::handle_error(const std::exception_ptr& err, txn_complete_ca
     if (er.should_rollback()) {
       CB_ATTEMPT_CTX_LOG_TRACE(current_attempt_context_,
                                "got rollback-able exception, rolling back");
-      try {
-        current_attempt_context_->rollback();
-      } catch (const std::exception& er_rollback) {
+      if (auto rollback_failed = auto_rollback(); rollback_failed) {
         cleanup().add_attempt(current_attempt_context_);
-        CB_ATTEMPT_CTX_LOG_TRACE(
-          current_attempt_context_,
-          "got error \"{}\" while auto rolling back, throwing original error",
-          er_rollback.what(),
-          er.what());
-        auto final = er.get_final_exception(*this);
+        // A failed auto-rollback raises the original error without retry, or EXPIRED in place of
+        // FAILED.
+        auto raised = er;
+        if (rollback_failed == EXPIRED && raised.to_raise() == FAILED) {
+          raised.expired();
+        }
+        auto final = raised.get_final_exception(*this);
         // if you get here, we didn't throw, yet we had an error.  Fall through
         // in this case.  Note the current logic is such that rollback will not
         // have a commit ambiguous error, so we should always throw.
@@ -359,28 +377,25 @@ transaction_context::handle_error(const std::exception_ptr& err, txn_complete_ca
     return callback(final, res);
   } catch (const std::exception& ex) {
     CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "got runtime error \"{}\"", ex.what());
-    try {
-      current_attempt_context_->rollback();
-    } catch (...) {
-      CB_ATTEMPT_CTX_LOG_ERROR(
-        current_attempt_context_, "got error rolling back \"{}\"", ex.what());
-    }
+    const auto rollback_failed = auto_rollback();
     cleanup().add_attempt(current_attempt_context_);
     // the assumption here is this must come from the logic, not
     // our operations (which only throw transaction_operation_failed),
     auto op_failed = transaction_operation_failed(FAIL_OTHER, ex.what());
+    if (rollback_failed == EXPIRED) {
+      op_failed.expired();
+    }
     return callback(op_failed.get_final_exception(*this), std::nullopt);
   } catch (...) {
     CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "got unexpected error, rolling back");
-    try {
-      current_attempt_context_->rollback();
-    } catch (...) {
-      CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "got error rolling back unexpected error");
-    }
+    const auto rollback_failed = auto_rollback();
     cleanup().add_attempt(current_attempt_context_);
     // the assumption here is this must come from the logic, not
     // our operations (which only throw transaction_operation_failed),
     auto op_failed = transaction_operation_failed(FAIL_OTHER, "Unexpected error");
+    if (rollback_failed == EXPIRED) {
+      op_failed.expired();
+    }
     return callback(op_failed.get_final_exception(*this), std::nullopt);
   }
 }
@@ -408,7 +423,7 @@ transaction_context::finalize(txn_complete_callback&& cb)
 void
 transaction_context::current_attempt_state(attempt_state s)
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   if (attempts_.empty()) {
     throw std::runtime_error("transaction_context has no attempts yet");
   }
@@ -488,7 +503,7 @@ transaction_context::new_attempt_context()
 auto
 transaction_context::current_attempt() const -> const transaction_attempt&
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   if (attempts_.empty()) {
     throw std::runtime_error("transaction context has no attempts yet");
   }
@@ -498,7 +513,7 @@ transaction_context::current_attempt() const -> const transaction_attempt&
 auto
 transaction_context::num_attempts() const -> std::size_t
 {
-  const std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
   return attempts_.size();
 }
 

data/ext/couchbase/core/transactions/transaction_get_result.hxx

@@ -23,9 +23,11 @@
 #include "transaction_links.hxx"
 
 #include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/fmt/cas.hxx>
 #include <couchbase/transactions/transaction_get_result.hxx>
 
+#include <system_error>
 #include <utility>
 
 namespace couchbase::core::transactions
@@ -108,6 +110,20 @@ public:
         cas != nullptr && cas->is_string() && cas_.value() == 0U) {
       cas_ = couchbase::cas(stoull(cas->as<std::string>()));
     }
+    // This ctor parses the JSON row returned by a query-mode KV get/insert/replace,
+    // where the document CAS is carried as the string field "scas" (a numeric
+    // "cas" is also accepted above). Per the transactions query spec, KV
+    // get/insert/replace result handling requires scas to be present and raises a
+    // DecodingFailure when it is absent: without a usable CAS, cas_ stays at its
+    // default 0, which is not a valid document CAS and would corrupt a later COMMIT
+    // that stages against it. The query KV op handlers translate this
+    // DecodingFailure into a FAIL_OTHER (rollback). "doc" is intentionally not
+    // required here, since insert/replace rows and content-less reads legitimately
+    // carry a CAS but no content.
+    if (cas_.value() == 0U) {
+      throw std::system_error(couchbase::errc::common::decoding_failure,
+                              "transaction get result row is missing a usable CAS (scas or cas)");
+    }
     if (const auto* doc = json.find("doc"); doc != nullptr) {
       content_ = { core::utils::json::generate_binary(doc->get_object()),
                    codec::codec_flags::json_common_flags };