couchbase 4.2.0 → 4.2.1

package/deps/couchbase-cxx-client/core/transactions/transactions_cleanup.cxx

@@ -42,19 +42,22 @@ transactions_cleanup_attempt::transactions_cleanup_attempt(const atr_cleanup_ent
 }
 
 transactions_cleanup::transactions_cleanup(std::shared_ptr<core::cluster> cluster,
-                                           const couchbase::transactions::transaction_config& config)
+                                           const couchbase::transactions::transactions_config::built& config)
   : cluster_(cluster)
   , config_(config)
   , client_uuid_(uid_generator::next())
   , running_(false)
 {
-    if (config.cleanup_client_attempts()) {
-        running_ = true;
+    running_ = config.cleanup_config.cleanup_client_attempts || config.cleanup_config.cleanup_lost_attempts;
+    if (config.cleanup_config.cleanup_client_attempts) {
         cleanup_thr_ = std::thread(std::bind(&transactions_cleanup::attempts_loop, this));
     }
-    if (config.cleanup_lost_attempts()) {
-        running_ = true;
-        lost_attempts_thr_ = std::thread(std::bind(&transactions_cleanup::lost_attempts_loop, this));
+    if (config_.metadata_collection) {
+        add_collection(
+          { config_.metadata_collection->bucket, config_.metadata_collection->scope, config_.metadata_collection->collection });
+    }
+    for (auto& k : config_.cleanup_config.collections) {
+        add_collection(k);
     }
 }
 
@@ -120,74 +123,82 @@ transactions_cleanup::interruptable_wait(std::chrono::duration<R, P> delay)
 }
 
 void
-transactions_cleanup::clean_lost_attempts_in_bucket(const std::string& bucket_name)
+transactions_cleanup::clean_collection(const couchbase::transactions::transaction_keyspace& keyspace)
 {
-    lost_attempts_cleanup_log->info("{} cleanup for {} starting", static_cast<void*>(this), bucket_name);
-    if (!running_.load()) {
-        lost_attempts_cleanup_log->info("{} cleanup of {} complete", static_cast<void*>(this), bucket_name);
-        return;
-    }
-    auto details = get_active_clients(bucket_name, client_uuid_);
-    auto all_atrs = atr_ids::all();
-
-    // TXNCXX-232 - dynamically adjust the budget for fetching each ATR, based on how long is left of the cleanup window and how many are
-    // left to fetch
-    // FIXME: was not used in original transactions code
-    // auto atrs_handled_by_this_client = all_atrs.size() / details.num_active_clients;
-    std::chrono::microseconds cleanup_window = std::chrono::duration_cast<std::chrono::microseconds>(config_.cleanup_window());
-    auto start = std::chrono::steady_clock::now();
-    lost_attempts_cleanup_log->info("{} {} active clients (including this one), {} ATRs to check in {}ms",
-                                    static_cast<void*>(this),
-                                    details.num_active_clients,
-                                    all_atrs.size(),
-                                    config_.cleanup_window().count());
-
-    for (auto it = all_atrs.begin() + details.index_of_this_client; it < all_atrs.end(); it += details.num_active_clients) {
-        auto atrs_left_for_this_client =
-          std::distance(it, all_atrs.end()) / std::max<decltype(it)::difference_type>(1, details.num_active_clients);
-        auto now = std::chrono::steady_clock::now();
-        std::chrono::microseconds elapsed_in_cleanup_window = std::chrono::duration_cast<std::chrono::microseconds>(now - start);
-        std::chrono::microseconds remaining_in_cleanup_window = cleanup_window - elapsed_in_cleanup_window;
-        std::chrono::microseconds budget_for_this_atr = std::chrono::microseconds(
-          remaining_in_cleanup_window.count() / std::max<decltype(it)::difference_type>(1, atrs_left_for_this_client));
-
-        // clean the ATR entry
-        std::string atr_id = *it;
-        if (!running_.load()) {
-            lost_attempts_cleanup_log->debug("{} cleanup of {} complete", static_cast<void*>(this), bucket_name);
-            return;
+    // first make sure the collection is in the list
+    while (running_.load()) {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (collections_.end() == std::find(collections_.begin(), collections_.end(), keyspace)) {
+                lost_attempts_cleanup_log->info(
+                  "{} cleanup for {} ending, no longer in collection cleanup list", static_cast<void*>(this), keyspace);
+                return;
+            }
         }
+        lost_attempts_cleanup_log->info("{} cleanup for {} starting", static_cast<void*>(this), keyspace);
+        // we are running, and collection is in the list, so lets clean it.
         try {
-            auto id = config_.atr_id_from_bucket_and_key(bucket_name, atr_id);
-            handle_atr_cleanup(id);
+            auto details = get_active_clients(keyspace, client_uuid_);
+
+            auto all_atrs = atr_ids::all();
+
+            std::chrono::microseconds cleanup_window =
+              std::chrono::duration_cast<std::chrono::microseconds>(config_.cleanup_config.cleanup_window);
+            auto start = std::chrono::steady_clock::now();
+            lost_attempts_cleanup_log->info("{} {} active clients (including this one), {} ATRs to check in {}ms",
+                                            static_cast<void*>(this),
+                                            details.num_active_clients,
+                                            all_atrs.size(),
+                                            config_.cleanup_config.cleanup_window.count());
+
+            for (auto it = all_atrs.begin() + details.index_of_this_client; it < all_atrs.end(); it += details.num_active_clients) {
+                auto atrs_left_for_this_client =
+                  std::distance(it, all_atrs.end()) / std::max<decltype(it)::difference_type>(1, details.num_active_clients);
+                auto now = std::chrono::steady_clock::now();
+                std::chrono::microseconds elapsed_in_cleanup_window = std::chrono::duration_cast<std::chrono::microseconds>(now - start);
+                std::chrono::microseconds remaining_in_cleanup_window = cleanup_window - elapsed_in_cleanup_window;
+                std::chrono::microseconds budget_for_this_atr = std::chrono::microseconds(
+                  remaining_in_cleanup_window.count() / std::max<decltype(it)::difference_type>(1, atrs_left_for_this_client));
+                // clean the ATR entry
+                std::string atr_id = *it;
+                if (!running_.load()) {
+                    lost_attempts_cleanup_log->debug("{} cleanup of {} complete", static_cast<void*>(this), keyspace);
+                    return;
+                }
 
-        } catch (const std::runtime_error& err) {
-            lost_attempts_cleanup_log->error(
-              "{} cleanup of atr {} failed with {}, moving on", static_cast<void*>(this), atr_id, err.what());
-        }
+                try {
+                    handle_atr_cleanup({ keyspace.bucket, keyspace.scope, keyspace.collection, atr_id });
+                } catch (const std::exception& e) {
+                    lost_attempts_cleanup_log->error(
+                      "{} cleanup of atr {} failed with {}, moving on", static_cast<void*>(this), atr_id, e.what());
+                }
 
-        auto atr_end = std::chrono::steady_clock::now();
-        std::chrono::microseconds atr_used = std::chrono::duration_cast<std::chrono::microseconds>(atr_end - now);
-        std::chrono::microseconds atr_left = budget_for_this_atr - atr_used;
-
-        // Too verbose to log, but leaving here commented as it may be useful later for internal debugging
-        /*lost_attempts_cleanup_log->info("{} {} atrs_left_for_this_client={} elapsed_in_cleanup_window={}us "
-                                        "remaining_in_cleanup_window={}us budget_for_this_atr={}us atr_used={}us atr_left={}us",
-                                        bucket_name,
-                                        atr_id,
-                                        atrs_left_for_this_client,
-                                        elapsed_in_cleanup_window.count(),
-                                        remaining_in_cleanup_window.count(),
-                                        budget_for_this_atr.count(),
-                                        atr_used.count(),
-                                        atr_left.count());*/
-
-        if (atr_left.count() > 0 && atr_left.count() < 1000000000) { // safety check protects against bugs
-            std::this_thread::sleep_for(atr_left);
+                auto atr_end = std::chrono::steady_clock::now();
+                std::chrono::microseconds atr_used = std::chrono::duration_cast<std::chrono::microseconds>(atr_end - now);
+                std::chrono::microseconds atr_left = budget_for_this_atr - atr_used;
+
+                // Too verbose to log, but leaving here commented as it may be useful later for internal debugging
+                /*lost_attempts_cleanup_log->info("{} {} atrs_left_for_this_client={} elapsed_in_cleanup_window={}us "
+                                            "remaining_in_cleanup_window={}us budget_for_this_atr={}us atr_used={}us atr_left={}us",
+                                            bucket_name,
+                                            atr_id,
+                                            atrs_left_for_this_client,
+                                            elapsed_in_cleanup_window.count(),
+                                            remaining_in_cleanup_window.count(),
+                                            budget_for_this_atr.count(),
+                                            atr_used.count(),
+                                            atr_left.count());*/
+
+                if (atr_left.count() > 0 && atr_left.count() < 1000000000) { // safety check protects against bugs
+                    std::this_thread::sleep_for(atr_left);
+                }
+            }
+        } catch (const std::exception& ex) {
+            lost_attempts_cleanup_log->error("{} cleanup failed with {}, trying again in 3 sec...", static_cast<void*>(this), ex.what());
+            // we must have gotten an exception trying to get the client records.   Let's wait 3 sec and try again
+            std::this_thread::sleep_for(std::chrono::seconds(3));
         }
     }
-    auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - start);
-    lost_attempts_cleanup_log->info("{} cleanup of {} complete in {}s", static_cast<void*>(this), bucket_name, elapsed.count());
 }
 
 const atr_cleanup_stats
@@ -225,10 +236,11 @@ transactions_cleanup::handle_atr_cleanup(const core::document_id& atr_id, std::v
 }
 
 void
-transactions_cleanup::create_client_record(const std::string& bucket_name)
+transactions_cleanup::create_client_record(const couchbase::transactions::transaction_keyspace& keyspace)
+
 {
     try {
-        auto id = config_.atr_id_from_bucket_and_key(bucket_name, CLIENT_RECORD_DOC_ID);
+        auto id = document_id(keyspace.bucket, keyspace.scope, keyspace.collection, CLIENT_RECORD_DOC_ID);
         core::operations::mutate_in_request req{ id };
         req.store_semantics = couchbase::store_semantics::insert;
         req.specs =
@@ -236,13 +248,13 @@ transactions_cleanup::create_client_record(const std::string& bucket_name)
               couchbase::mutate_in_specs::insert(FIELD_CLIENTS, tao::json::empty_object).xattr().create_path(),
               // subdoc::opcode::set_doc used in replace w/ empty path
               // ExtBinaryMetadata
-              couchbase::mutate_in_specs::replace({}, std::string({ 0x00 })),
+              couchbase::mutate_in_specs::replace_raw({}, std::vector<std::byte>{ std::byte{ 0x00 } }),
           }
             .specs();
         wrap_durable_request(req, config_);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        auto ec = config_.cleanup_hooks().client_record_before_create(bucket_name);
+        auto ec = config_.cleanup_hooks->client_record_before_create(keyspace.bucket);
         if (ec) {
             throw client_error(*ec, "client_record_before_create hook raised error");
         }
@@ -264,18 +276,18 @@ transactions_cleanup::create_client_record(const std::string& bucket_name)
 }
 
 const client_record_details
-transactions_cleanup::get_active_clients(const std::string& bucket_name, const std::string& uuid)
+transactions_cleanup::get_active_clients(const couchbase::transactions::transaction_keyspace& keyspace, const std::string& uuid)
 {
     std::chrono::milliseconds min_retry(1000);
-    if (config_.cleanup_window() < min_retry) {
-        min_retry = config_.cleanup_window();
+    if (config_.cleanup_config.cleanup_window < min_retry) {
+        min_retry = config_.cleanup_config.cleanup_window;
     }
     return retry_op_exponential_backoff_timeout<client_record_details>(
-      min_retry, std::chrono::seconds(1), config_.cleanup_window(), [&]() -> client_record_details {
+      min_retry, std::chrono::seconds(1), config_.cleanup_config.cleanup_window, [this, keyspace, uuid]() -> client_record_details {
           client_record_details details;
           // Write our client record, return details.
           try {
-              auto id = config_.atr_id_from_bucket_and_key(bucket_name, CLIENT_RECORD_DOC_ID);
+              auto id = document_id{ keyspace.bucket, keyspace.scope, keyspace.collection, CLIENT_RECORD_DOC_ID };
               core::operations::lookup_in_request req{ id };
               req.specs =
                 lookup_in_specs{
@@ -286,7 +298,7 @@ transactions_cleanup::get_active_clients(const std::string& bucket_name, const s
               wrap_request(req, config_);
               auto barrier = std::make_shared<std::promise<result>>();
               auto f = barrier->get_future();
-              auto ec = config_.cleanup_hooks().client_record_before_get(bucket_name);
+              auto ec = config_.cleanup_hooks->client_record_before_get(keyspace.bucket);
               if (ec) {
                   throw client_error(*ec, "client_record_before_get hook raised error");
               }
@@ -353,7 +365,7 @@ transactions_cleanup::get_active_clients(const std::string& bucket_name, const s
                     .xattr()
                     .create_path(),
                   couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_EXPIRES,
-                                                     config_.cleanup_window().count() / 2 + SAFETY_MARGIN_EXPIRY_MS)
+                                                     config_.cleanup_config.cleanup_window.count() / 2 + SAFETY_MARGIN_EXPIRY_MS)
                     .xattr()
                     .create_path(),
                   couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_NUM_ATRS, atr_ids::all().size())
@@ -366,7 +378,7 @@ transactions_cleanup::get_active_clients(const std::string& bucket_name, const s
                   mut_specs.push_back(couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + details.expired_client_ids[idx]).xattr());
               }
               mutate_req.specs = mut_specs.specs();
-              ec = config_.cleanup_hooks().client_record_before_update(bucket_name);
+              ec = config_.cleanup_hooks->client_record_before_update(keyspace.bucket);
               if (ec) {
                   throw client_error(*ec, "client_record_before_update hook raised error");
               }
@@ -388,7 +400,7 @@ transactions_cleanup::get_active_clients(const std::string& bucket_name, const s
               switch (ec) {
                   case FAIL_DOC_NOT_FOUND:
                       lost_attempts_cleanup_log->debug("{} client record not found, creating new one", static_cast<void*>(this));
-                      create_client_record(bucket_name);
+                      create_client_record(keyspace);
                       throw retry_operation("Client record didn't exist. Creating and retrying");
                   default:
                       throw; // retry_operation(fmt::format("got error '' while processing client record, retrying...", e.what()));
@@ -400,19 +412,19 @@ transactions_cleanup::get_active_clients(const std::string& bucket_name, const s
 void
 transactions_cleanup::remove_client_record_from_all_buckets(const std::string& uuid)
 {
-    for (const auto& bucket_name : get_and_open_buckets(cluster_)) {
+    for (const auto& keyspace : collections_) {
         try {
             retry_op_exponential_backoff_timeout<void>(
-              std::chrono::milliseconds(10), std::chrono::milliseconds(250), std::chrono::milliseconds(500), [&]() {
+              std::chrono::milliseconds(10), std::chrono::milliseconds(250), std::chrono::milliseconds(500), [this, keyspace, uuid]() {
                   try {
                       // insure a client record document exists...
-                      create_client_record(bucket_name);
+                      create_client_record(keyspace);
                       // now, proceed to remove the client uuid if it exists
-                      auto ec = config_.cleanup_hooks().client_record_before_remove_client(bucket_name);
+                      auto ec = config_.cleanup_hooks->client_record_before_remove_client(keyspace.bucket);
                       if (ec) {
                           throw client_error(*ec, "client_record_before_remove_client hook raised error");
                       }
-                      auto id = config_.atr_id_from_bucket_and_key(bucket_name, CLIENT_RECORD_DOC_ID);
+                      document_id id{ keyspace.bucket, keyspace.scope, keyspace.collection, CLIENT_RECORD_DOC_ID };
                       core::operations::mutate_in_request req{ id };
                       req.specs =
                         couchbase::mutate_in_specs{
@@ -426,18 +438,17 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
                           barrier->set_value(result::create_from_subdoc_response(resp));
                       });
                       wrap_operation_future(f);
-                      lost_attempts_cleanup_log->debug("{} removed {} from {}", static_cast<void*>(this), uuid, bucket_name);
+                      lost_attempts_cleanup_log->debug("{} removed {} from {}", static_cast<void*>(this), uuid, keyspace);
                   } catch (const client_error& e) {
                       lost_attempts_cleanup_log->debug("{} error removing client records {}", static_cast<void*>(this), e.what());
                       auto ec = e.ec();
                       switch (ec) {
                           case FAIL_DOC_NOT_FOUND:
-                              lost_attempts_cleanup_log->debug(
-                                "{} no client record in {}, ignoring", static_cast<void*>(this), bucket_name);
+                              lost_attempts_cleanup_log->debug("{} no client record in {}, ignoring", static_cast<void*>(this), keyspace);
                               return;
                           case FAIL_PATH_NOT_FOUND:
                               lost_attempts_cleanup_log->debug(
-                                "{} client {} not in client record for {}, ignoring", static_cast<void*>(this), uuid, bucket_name);
+                                "{} client {} not in client record for {}, ignoring", static_cast<void*>(this), uuid, keyspace);
                               return;
                           default:
                               throw retry_operation("retry remove until timeout");
@@ -446,45 +457,11 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
               });
         } catch (const std::exception& e) {
             lost_attempts_cleanup_log->error(
-              "{} Error removing client record {} from bucket {}: {}", static_cast<void*>(this), uuid, bucket_name, e.what());
+              "{} Error removing client record {} from {}: {}", static_cast<void*>(this), uuid, keyspace, e.what());
         }
     }
 }
 
-void
-transactions_cleanup::lost_attempts_loop()
-{
-    lost_attempts_cleanup_log->info("{} starting lost attempts loop", static_cast<void*>(this));
-    while (running_.load()) {
-        std::list<std::thread> workers;
-        try {
-            auto names = get_and_open_buckets(cluster_);
-            lost_attempts_cleanup_log->info("{} creating {} tasks to clean buckets", static_cast<void*>(this), names.size());
-            // TODO consider std::async here.
-            for (const auto& name : names) {
-                workers.emplace_back([&]() {
-                    try {
-                        clean_lost_attempts_in_bucket(name);
-                    } catch (const std::runtime_error& e) {
-                        lost_attempts_cleanup_log->error(
-                          "{} got error {} attempting to clean {}", static_cast<void*>(this), e.what(), name);
-                    }
-                });
-            }
-            for (auto& thr : workers) {
-                if (thr.joinable()) {
-                    thr.join();
-                }
-            }
-        } catch (const std::exception& e) {
-            lost_attempts_cleanup_log->error(
-              "{} got error {}, rescheduling in {}ms", static_cast<void*>(this), e.what(), config_.cleanup_window().count());
-            interruptable_wait(config_.cleanup_window());
-        }
-    }
-    remove_client_record_from_all_buckets(client_uuid_);
-}
-
 const atr_cleanup_stats
 transactions_cleanup::force_cleanup_atr(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results)
 {
@@ -564,7 +541,7 @@ transactions_cleanup::add_attempt(attempt_context& ctx)
             attempt_cleanup_log->trace("attempt in state {}, not adding to cleanup", attempt_state_name(ctx_impl.state()));
             return;
         default:
-            if (config_.cleanup_client_attempts()) {
+            if (config_.cleanup_config.cleanup_client_attempts) {
                 attempt_cleanup_log->debug("adding attempt {} to cleanup queue", ctx_impl.id());
                 atr_queue_.push(ctx);
             } else {
@@ -573,6 +550,24 @@ transactions_cleanup::add_attempt(attempt_context& ctx)
     }
 }
 
+void
+transactions_cleanup::add_collection(couchbase::transactions::transaction_keyspace keyspace)
+{
+
+    if (keyspace.valid() && config_.cleanup_config.cleanup_lost_attempts) {
+        std::unique_lock<std::mutex> lock(mutex_);
+
+        auto it = std::find(collections_.begin(), collections_.end(), keyspace);
+        if (it == collections_.end()) {
+            collections_.emplace_back(std::move(keyspace));
+            // start cleaning right away
+            lost_attempt_cleanup_workers_.emplace_back([this, keyspace = collections_.back()]() { this->clean_collection(keyspace); });
+        }
+        lock.unlock();
+        lost_attempts_cleanup_log->info("added {} to lost transaction cleanup", keyspace);
+    }
+}
+
 void
 transactions_cleanup::close()
 {
@@ -585,9 +580,15 @@ transactions_cleanup::close()
         cleanup_thr_.join();
         attempt_cleanup_log->info("cleanup attempt thread closed");
     }
-    if (lost_attempts_thr_.joinable()) {
-        lost_attempts_thr_.join();
-        lost_attempts_cleanup_log->info("{} lost attempts thread closed", static_cast<void*>(this));
+    for (auto& t : lost_attempt_cleanup_workers_) {
+        lost_attempts_cleanup_log->info("shutting down all lost attempt threads...");
+        if (t.joinable()) {
+            t.join();
+        }
+    }
+    lost_attempts_cleanup_log->info("all lost attempt cleanup threads closed");
+    if (true) {
+        remove_client_record_from_all_buckets(client_uuid_);
     }
 }
 

package/deps/couchbase-cxx-client/core/transactions/transactions_config.cxx

@@ -0,0 +1,81 @@
+/*
+ *     Copyright 2021-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "attempt_context_testing_hooks.hxx"
+#include "cleanup_testing_hooks.hxx"
+
+#include "couchbase/transactions/transactions_config.hxx"
+
+#include <memory>
+
+namespace couchbase::transactions
+{
+
+transactions_config::transactions_config()
+  : level_(couchbase::durability_level::majority)
+  , expiration_time_(std::chrono::seconds(15))
+  , attempt_context_hooks_(new core::transactions::attempt_context_testing_hooks())
+  , cleanup_hooks_(new core::transactions::cleanup_testing_hooks())
+{
+}
+
+transactions_config::~transactions_config() = default;
+
+transactions_config::transactions_config(transactions_config&& c) noexcept
+  : level_(c.level_)
+  , expiration_time_(c.expiration_time_)
+  , attempt_context_hooks_(c.attempt_context_hooks_)
+  , cleanup_hooks_(c.cleanup_hooks_)
+  , metadata_collection_(std::move(c.metadata_collection_))
+  , query_config_(c.query_config_)
+  , cleanup_config_(std::move(c.cleanup_config_))
+{
+}
+
+transactions_config::transactions_config(const transactions_config& config)
+  : level_(config.durability_level())
+  , expiration_time_(config.expiration_time())
+  , attempt_context_hooks_(std::make_shared<core::transactions::attempt_context_testing_hooks>(config.attempt_context_hooks()))
+  , cleanup_hooks_(std::make_shared<core::transactions::cleanup_testing_hooks>(config.cleanup_hooks()))
+  , metadata_collection_(config.metadata_collection())
+  , query_config_(config.query_config())
+  , cleanup_config_(config.cleanup_config())
+{
+}
+
+transactions_config&
+transactions_config::operator=(const transactions_config& c)
+{
+    if (this != &c) {
+        level_ = c.level_;
+        expiration_time_ = c.expiration_time_;
+        attempt_context_hooks_ = c.attempt_context_hooks_;
+        cleanup_hooks_ = c.cleanup_hooks_;
+        query_config_ = c.query_config_;
+        metadata_collection_ = c.metadata_collection_;
+        cleanup_config_ = c.cleanup_config_;
+    }
+    return *this;
+}
+
+transactions_config::built
+transactions_config::build() const
+{
+    return { level_,         expiration_time_,     kv_timeout_,           attempt_context_hooks_,
+             cleanup_hooks_, metadata_collection_, query_config_.build(), cleanup_config_.build() };
+}
+
+} // namespace couchbase::transactions

package/deps/couchbase-cxx-client/core/transactions/utils.cxx

@@ -109,4 +109,15 @@ error_class_from_response_extras(const core::operations::mutate_in_response& res
     }
     return FAIL_OTHER;
 }
+
+core::document_id
+atr_id_from_bucket_and_key(const couchbase::transactions::transactions_config::built& cfg,
+                           const std::string& bucket,
+                           const std::string& key)
+{
+    if (cfg.metadata_collection) {
+        return { cfg.metadata_collection->bucket, cfg.metadata_collection->scope, cfg.metadata_collection->collection, key };
+    }
+    return { bucket, couchbase::scope::default_name, couchbase::collection::default_name, key };
+}
 } // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/waitable_op_list.hxx

@@ -98,9 +98,11 @@ class waitable_op_list
         in_flight_--;
         if (mode_.mode == attempt_mode::modes::KV) {
             // wait until all in_flight ops are done
+            txn_log->trace("set_query_mode: waiting for in_flight ops to go to 0...");
             cv_in_flight_.wait(lock, [this]() { return (0 == in_flight_); });
             // ok, now no outstanding ops(apart from the query that called this), and I have the lock, so...
             if (mode_.mode == attempt_mode::modes::KV) {
+                txn_log->trace("set_query_mode: in_flight ops = 0, we were kv, setting mode to query");
                 // still kv, so now (while blocking) set the mode
                 mode_.mode = attempt_mode::modes::QUERY;
                 // ok to unlock now, as any racing set_query_mode will wait for
@@ -115,8 +117,10 @@ class waitable_op_list
         }
         // you make it here, and someone else is currently setting the node (a byproduct of
         // calling the callback).  So wait for that.
+        txn_log->trace("set_query_mode: mode already query, waiting for node to be set...");
         cv_query_.wait(lock, [this]() { return !mode_.query_node.empty(); });
         in_flight_++;
+        txn_log->trace("set_query_mode: node set, continuing...");
         lock.unlock();
         cb();
     }

package/deps/couchbase-cxx-client/core/transactions.hxx

@@ -18,9 +18,9 @@
 
 #include <couchbase/transactions.hxx>
 
-#include "couchbase/transactions/per_transaction_config.hxx"
-#include "couchbase/transactions/transaction_config.hxx"
+#include "couchbase/transactions/transaction_options.hxx"
 #include "couchbase/transactions/transaction_result.hxx"
+#include "couchbase/transactions/transactions_config.hxx"
 #include "transactions/async_attempt_context.hxx"
 #include "transactions/attempt_context.hxx"
 #include "transactions/exceptions.hxx"
@@ -52,14 +52,14 @@ namespace transactions
 class transactions_cleanup;
 
 /** @brief Transaction logic should be contained in a lambda of this form */
-using logic = utils::movable_function<void(attempt_context&)>;
+using logic = std::function<void(attempt_context&)>;
 
 /** @brief AsyncTransaction logic should be contained in a lambda of this form */
-using async_logic = utils::movable_function<void(async_attempt_context&)>;
+using async_logic = std::function<void(async_attempt_context&)>;
 
 /** @brief AsyncTransaction callback when transaction has completed */
 using txn_complete_callback =
-  utils::movable_function<void(std::optional<transaction_exception>, std::optional<::couchbase::transactions::transaction_result>)>;
+  std::function<void(std::optional<transaction_exception>, std::optional<::couchbase::transactions::transaction_result>)>;
 
 /**
  * @brief set log level for transactions
@@ -84,7 +84,7 @@ create_loggers(core::logger::level level = core::logger::level::off, spdlog::sin
  *
  * @code{.cpp}
  * cluster c("couchbase://127.0.0.1", "Administrator", "password");
- * transaction_config config;
+ * transactions_config config;
  * config.durability_level(transactions::durability_level::MAJORITY);
  * auto b = cluster.bucket("default");
  * auto coll = b->default_collection();
@@ -146,7 +146,8 @@ class transactions : public couchbase::transactions::transactions
      * @param cluster The cluster to use for the transactions.
      * @param config The configuration parameters to use for the transactions.
      */
-    transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transaction_config& config);
+    transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config::built& config);
+    transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config& config);
 
     /**
      * @brief Destructor
@@ -166,11 +167,11 @@ class transactions : public couchbase::transactions::transactions
      */
     couchbase::transactions::transaction_result run(logic&& code);
 
-    couchbase::transactions::transaction_result run(const couchbase::transactions::per_transaction_config& config, logic&& code);
+    couchbase::transactions::transaction_result run(const couchbase::transactions::transaction_options& config, logic&& code);
 
     couchbase::transactions::transaction_result run(
       ::couchbase::transactions::txn_logic&& code,
-      const couchbase::transactions::per_transaction_config& cfg = couchbase::transactions::per_transaction_config()) override;
+      const couchbase::transactions::transaction_options& cfg = couchbase::transactions::transaction_options()) override;
 
     /**
      * @brief Run a transaction
@@ -186,11 +187,11 @@ class transactions : public couchbase::transactions::transactions
      */
     void run(async_logic&& code, txn_complete_callback&& cb);
 
-    void run(const couchbase::transactions::per_transaction_config& config, async_logic&& code, txn_complete_callback&& cb);
+    void run(const couchbase::transactions::transaction_options& config, async_logic&& code, txn_complete_callback&& cb);
 
     void run(couchbase::transactions::async_txn_logic&& code,
              couchbase::transactions::async_txn_complete_logic&& complete_cb,
-             const couchbase::transactions::per_transaction_config& cfg = {}) override;
+             const couchbase::transactions::transaction_options& cfg = {}) override;
     /**
      * @internal
      * called internally - will likely move
@@ -218,11 +219,11 @@ class transactions : public couchbase::transactions::transactions
     void close();
 
     /**
-     * @brief Return reference to @ref transaction_config.
+     * @brief Return reference to @ref transactions_config.
      *
      * @return config for this transactions instance.
      */
-    [[nodiscard]] couchbase::transactions::transaction_config& config()
+    [[nodiscard]] couchbase::transactions::transactions_config::built& config()
     {
         return config_;
     }
@@ -257,7 +258,7 @@ class transactions : public couchbase::transactions::transactions
 
   private:
     std::shared_ptr<core::cluster> cluster_;
-    couchbase::transactions::transaction_config config_;
+    couchbase::transactions::transactions_config::built config_;
     std::unique_ptr<transactions_cleanup> cleanup_;
     const std::size_t max_attempts_{ 1000 };
     const std::chrono::milliseconds min_retry_delay_{ 1 };