couchbase 4.2.0 → 4.2.1

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

@@ -16,8 +16,10 @@
 
 #pragma once
 
+#include <core/cluster.hxx>
 #include <couchbase/transactions/async_attempt_context.hxx>
 #include <couchbase/transactions/attempt_context.hxx>
+#include <couchbase/transactions/transaction_query_options.hxx>
 
 #include "attempt_context_testing_hooks.hxx"
 #include "error_list.hxx"
@@ -38,6 +40,18 @@
 #include <thread>
 #include <utility>
 
+// implemented in core::impl::query, to take advantage of the statics over there
+namespace couchbase::core::impl
+{
+
+couchbase::transactions::transaction_query_result
+build_transaction_query_result(operations::query_response resp, std::error_code ec = {});
+
+core::operations::query_request
+build_transaction_query_request(couchbase::query_options::built opts);
+
+} // namespace couchbase::core::impl
+
 namespace couchbase::core::transactions
 {
 /**
@@ -64,6 +78,7 @@ class attempt_context_impl
     error_list errors_;
     std::mutex mutex_;
     waitable_op_list op_list_;
+    std::string query_context_;
 
     // commit needs to access the hooks
     friend class staged_mutation_queue;
@@ -72,21 +87,21 @@ class attempt_context_impl
     // transaction_context needs access to the two functions below
     friend class transaction_context;
 
-    couchbase::transactions::transaction_get_result_ptr insert_raw(std::shared_ptr<couchbase::collection> coll,
+    couchbase::transactions::transaction_get_result_ptr insert_raw(const couchbase::collection& coll,
                                                                    const std::string& id,
                                                                    std::vector<std::byte> content) override
     {
         return wrap_call_for_public_api([this, coll, &id, &content]() -> transaction_get_result {
-            return insert_raw({ coll->bucket_name(), coll->scope_name(), coll->name(), id }, content);
+            return insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), id }, content);
         });
     }
     transaction_get_result insert_raw(const core::document_id& id, const std::vector<std::byte>& content) override;
-    void insert_raw(std::shared_ptr<collection> coll,
+    void insert_raw(const collection& coll,
                     std::string id,
                     std::vector<std::byte> content,
                     couchbase::transactions::async_result_handler&& handler) override
     {
-        insert_raw({ coll->bucket_name(), coll->scope_name(), coll->name(), std::move(id) },
+        insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
                    content,
                    [this, handler = std::move(handler)](std::exception_ptr err, std::optional<transaction_get_result> res) mutable {
                        wrap_callback_for_async_public_api(err, res, std::move(handler));
@@ -123,17 +138,17 @@ class attempt_context_impl
     void commit_with_query(VoidCallback&& cb);
     void rollback_with_query(VoidCallback&& cb);
 
-    void query_begin_work(utils::movable_function<void(std::exception_ptr)>&& cb);
+    void query_begin_work(std::function<void(std::exception_ptr)>&& cb);
 
-    void do_query(const std::string& statement, const transaction_query_options& opts, QueryCallback&& cb);
+    void do_query(const std::string& statement, const couchbase::transactions::transaction_query_options& opts, QueryCallback&& cb);
     std::exception_ptr handle_query_error(const core::operations::query_response& resp);
     void wrap_query(const std::string& statement,
-                    const transaction_query_options& opts,
+                    const couchbase::transactions::transaction_query_options& opts,
                     const std::vector<core::json_string>& params,
                     const tao::json::value& txdata,
                     const std::string& hook_point,
                     bool check_expiry,
-                    utils::movable_function<void(std::exception_ptr, core::operations::query_response)>&& cb);
+                    std::function<void(std::exception_ptr, core::operations::query_response)>&& cb);
 
     void handle_err_from_callback(std::exception_ptr e)
     {
@@ -147,9 +162,10 @@ class attempt_context_impl
         } catch (const async_operation_conflict& op_ex) {
             // the count isn't changed when this is thrown, so just swallow it and log
             txn_log->error("op callback called a txn operation that threw exception {}", op_ex.what());
-        } catch (const query_exception& query_ex) {
-            txn_log->warn("op callback called a txn operation that threw (and didn't handle) a query_exception {}", query_ex.what());
-            errors_.push_back(transaction_operation_failed(FAIL_OTHER, query_ex.what()).cause(query_ex.cause()));
+        } catch (const op_exception& op_ex) {
+            txn_log->warn("op callback called a txn operation that threw (and didn't handle) a op_exception {}", op_ex.what());
+            errors_.push_back(
+              transaction_operation_failed(error_class_from_external_exception(op_ex.cause()), op_ex.what()).cause(op_ex.cause()));
             op_list_.decrement_ops();
         } catch (const std::exception& std_ex) {
             // if the callback throws something which wasn't handled
@@ -270,7 +286,7 @@ class attempt_context_impl
     }
 
     template<typename Handler>
-    void cache_error_async(Handler&& cb, std::function<void()> func)
+    void cache_error_async(Handler cb, std::function<void()> func)
     {
         try {
             op_list_.increment_ops();
@@ -288,6 +304,8 @@ class attempt_context_impl
             if (e.cause() == PREVIOUS_OPERATION_FAILED) {
                 op_completed_with_error(std::move(cb), e);
             }
+        } catch (const op_exception& e) {
+            op_completed_with_error(std::move(cb), e);
         } catch (const std::exception& e) {
             op_completed_with_error(std::move(cb), transaction_operation_failed(FAIL_OTHER, e.what()));
         }
@@ -324,19 +342,19 @@ class attempt_context_impl
     ~attempt_context_impl() override;
 
     transaction_get_result get(const core::document_id& id) override;
-    couchbase::transactions::transaction_get_result_ptr get(std::shared_ptr<couchbase::collection> coll, const std::string& id) override
+    couchbase::transactions::transaction_get_result_ptr get(const couchbase::collection& coll, const std::string& id) override
     {
         return wrap_call_for_public_api([this, coll, id]() mutable -> transaction_get_result {
-            auto ret = get_optional({ coll->bucket_name(), coll->scope_name(), coll->name(), id });
+            auto ret = get_optional({ coll.bucket_name(), coll.scope_name(), coll.name(), id });
             if (ret) {
                 return *ret;
             }
             return { transaction_op_error_context{ errc::transaction_op::document_not_found_exception } };
         });
     }
-    void get(std::shared_ptr<couchbase::collection> coll, std::string id, couchbase::transactions::async_result_handler&& handler) override
+    void get(const couchbase::collection& coll, std::string id, couchbase::transactions::async_result_handler&& handler) override
     {
-        get_optional({ coll->bucket_name(), coll->scope_name(), coll->name(), std::move(id) },
+        get_optional({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
                      [this, handler = std::move(handler)](std::exception_ptr err, std::optional<transaction_get_result> res) mutable {
                          if (!res) {
                              return handler(std::make_shared<transaction_get_result>(
@@ -363,8 +381,40 @@ class attempt_context_impl
         });
     };
 
-    core::operations::query_response query(const std::string& statement, const transaction_query_options& options) override;
-    void query(const std::string& statement, const transaction_query_options& options, QueryCallback&& cb) override;
+    core::operations::query_response do_core_query(const std::string& statement,
+                                                   const couchbase::transactions::transaction_query_options& options) override;
+
+    couchbase::transactions::transaction_query_result_ptr do_public_query(
+      const std::string& statement,
+      const couchbase::transactions::transaction_query_options& opts) override;
+
+    void query(const std::string& statement,
+               const couchbase::transactions::transaction_query_options& options,
+               QueryCallback&& cb) override;
+
+    void query(std::string statement,
+               couchbase::transactions::transaction_query_options opts,
+               couchbase::transactions::async_query_handler&& handler) override
+    {
+        query(
+          statement, opts, [handler = std::move(handler)](std::exception_ptr err, std::optional<core::operations::query_response> resp) {
+              if (err) {
+                  try {
+                      std::rethrow_exception(err);
+                  } catch (const transaction_operation_failed& e) {
+                      return handler(std::make_shared<couchbase::transactions::transaction_query_result>(e.get_error_ctx()));
+                  } catch (const op_exception& ex) {
+                      return handler(std::make_shared<couchbase::transactions::transaction_query_result>(ex.ctx()));
+                  } catch (...) {
+                      // just in case...
+                      return handler(std::make_shared<couchbase::transactions::transaction_query_result>(
+                        transaction_op_error_context(couchbase::errc::transaction_op::unknown)));
+                  }
+              }
+              handler(
+                std::make_shared<couchbase::transactions::transaction_query_result>(core::impl::build_transaction_query_result(*resp)));
+          });
+    }
 
     void commit() override;
     void commit(VoidCallback&& cb) override;
@@ -458,15 +508,13 @@ class attempt_context_impl
 
     void atr_rollback_complete();
 
-    void select_atr_if_needed_unlocked(const core::document_id id,
-                                       utils::movable_function<void(std::optional<transaction_operation_failed>)>&& cb);
+    void select_atr_if_needed_unlocked(const core::document_id id, std::function<void(std::optional<transaction_operation_failed>)>&& cb);
 
     template<typename Handler>
     void do_get(const core::document_id& id, const std::optional<std::string> resolving_missing_atr_entry, Handler&& cb);
 
-    void get_doc(
-      const core::document_id& id,
-      utils::movable_function<void(std::optional<error_class>, std::optional<std::string>, std::optional<transaction_get_result>)>&& cb);
+    void get_doc(const core::document_id& id,
+                 std::function<void(std::optional<error_class>, std::optional<std::string>, std::optional<transaction_get_result>)>&& cb);
 
     core::operations::mutate_in_request create_staging_request(const core::document_id& in,
                                                                const transaction_get_result* document,
@@ -498,6 +546,8 @@ class attempt_context_impl
             return std::make_shared<transaction_get_result>(handler());
         } catch (const transaction_operation_failed& e) {
             return std::make_shared<transaction_get_result>(e.get_error_ctx());
+        } catch (const op_exception& ex) {
+            return std::make_shared<transaction_get_result>(ex.ctx());
         } catch (...) {
             // the handler should catch everything else, but just in case...
             return std::make_shared<transaction_get_result>(transaction_op_error_context(errc::transaction_op::unknown));
@@ -527,6 +577,8 @@ class attempt_context_impl
         if (err) {
             try {
                 std::rethrow_exception(err);
+            } catch (const op_exception& e) {
+                return cb(std::make_shared<transaction_get_result>(e.ctx()));
             } catch (const transaction_operation_failed& e) {
                 return cb(std::make_shared<transaction_get_result>(e.get_error_ctx()));
             } catch (...) {
@@ -549,5 +601,11 @@ class attempt_context_impl
         }
         return cb({});
     }
+
+    void ensure_open_bucket(std::string bucket_name, std::function<void(std::error_code)>&& handler)
+    {
+        cluster_ref()->open_bucket(bucket_name, [handler = std::move(handler)](std::error_code ec) { handler(ec); });
+    }
 };
+
 } // namespace couchbase::core::transactions

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

@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include "internal/exceptions_internal.hxx"
+#include "core/transactions/error_class.hxx"
 
 #include <functional>
 #include <optional>
@@ -136,5 +136,10 @@ struct attempt_context_testing_hooks {
     std::function<std::optional<const std::string>(attempt_context*)> random_atr_id_for_vbucket = noop_3;
 
     std::function<bool(attempt_context*, const std::string&, std::optional<const std::string>)> has_expired_client_side = noop_4;
+
+    // needed for unique_ptr<attempt_context_testing_hooks> in transaction_config, with a forward declaration.
+    ~attempt_context_testing_hooks()
+    {
+    }
 };
 } // namespace couchbase::core::transactions

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

@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include "core/transactions/error_class.hxx"
+
 #include <functional>
 #include <string>
 
@@ -24,12 +26,12 @@ using error_func3 = std::function<std::optional<error_class>(const std::string&)
 using error_func4 = std::function<std::optional<error_class>(void)>;
 namespace
 {
-std::optional<error_class>
+std::optional<couchbase::core::transactions::error_class>
 noop1(const std::string&)
 {
     return {};
 }
-std::optional<error_class>
+std::optional<couchbase::core::transactions::error_class>
 noop2()
 {
     return {};
@@ -58,5 +60,10 @@ struct cleanup_testing_hooks {
     error_func3 client_record_before_get = noop1;
     error_func3 client_record_before_update = noop1;
     error_func3 client_record_before_remove_client = noop1;
+
+    // needed for unique_ptr<cleanup_testing_hooks> in transaction_config, with a forward declaration.
+    ~cleanup_testing_hooks()
+    {
+    }
 };
 } // namespace couchbase::core::transactions

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

@@ -46,7 +46,7 @@ durability_level_to_string_for_query(durability_level level)
         case durability_level::majority:
             return "majority";
         case durability_level::majority_and_persist_to_active:
-            return "majorityAndPersistToActive";
+            return "majorityAndPersistActive";
         case durability_level::persist_to_majority:
             return "persistToMajority";
     }

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

@@ -0,0 +1,35 @@
+/*
+ *     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.
+ */
+
+#pragma once
+
+namespace couchbase::core::transactions
+{
+enum error_class {
+    FAIL_HARD = 0,
+    FAIL_OTHER,
+    FAIL_TRANSIENT,
+    FAIL_AMBIGUOUS,
+    FAIL_DOC_ALREADY_EXISTS,
+    FAIL_DOC_NOT_FOUND,
+    FAIL_PATH_NOT_FOUND,
+    FAIL_CAS_MISMATCH,
+    FAIL_WRITE_WRITE_CONFLICT,
+    FAIL_ATR_FULL,
+    FAIL_PATH_ALREADY_EXISTS,
+    FAIL_EXPIRY
+};
+} // namespace couchbase::core::transactions

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

@@ -33,6 +33,19 @@ external_exception_from_error_class(error_class ec)
     }
 }
 
+couchbase::core::transactions::error_class
+error_class_from_external_exception(external_exception e)
+{
+    switch (e) {
+        case DOCUMENT_NOT_FOUND_EXCEPTION:
+            return FAIL_DOC_NOT_FOUND;
+        case DOCUMENT_EXISTS_EXCEPTION:
+            return FAIL_DOC_ALREADY_EXISTS;
+        default:
+            return FAIL_OTHER;
+    }
+}
+
 error_class
 error_class_from_result(const result& res)
 {

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

@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <core/error_context/query.hxx>
 #include <couchbase/error_codes.hxx>
 #include <couchbase/transactions/transaction_result.hxx>
 #include <optional>
@@ -57,6 +58,9 @@ enum external_exception {
 couchbase::errc::transaction_op
 transaction_op_errc_from_external_exception(external_exception e);
 
+couchbase::core::transactions::error_class
+error_class_from_external_exception(external_exception e);
+
 /**
  * @brief Base class for all exceptions expected to be raised from a transaction.
  *
@@ -124,74 +128,81 @@ class transaction_exception : public std::runtime_error
         return { ec, transaction_op_errc_from_external_exception(cause_) };
     }
 };
-
-class query_exception : public std::runtime_error
+class op_exception : public std::runtime_error
 {
+  private:
+    external_exception cause_;
+    transaction_op_error_context ctx_;
+
   public:
-    query_exception(const std::string& what, external_exception cause = COUCHBASE_EXCEPTION)
-      : std::runtime_error(what)
+    op_exception(transaction_op_error_context ctx, external_exception cause = COUCHBASE_EXCEPTION)
+      : std::runtime_error(ctx.ec().message())
       , cause_(cause)
+      , ctx_(std::move(ctx))
     {
     }
-    external_exception cause() const
+
+    [[nodiscard]] external_exception cause() const
     {
         return cause_;
     }
 
-  private:
-    external_exception cause_;
+    [[nodiscard]] const transaction_op_error_context& ctx() const
+    {
+        return ctx_;
+    }
 };
 
-class query_document_not_found : public query_exception
+class document_not_found : public op_exception
 {
   public:
-    explicit query_document_not_found(const std::string& what)
-      : query_exception(what, DOCUMENT_NOT_FOUND_EXCEPTION)
+    explicit document_not_found(transaction_op_error_context ctx)
+      : op_exception(ctx, DOCUMENT_NOT_FOUND_EXCEPTION)
     {
     }
 };
 
-class query_document_exists : public query_exception
+class document_exists : public op_exception
 {
   public:
-    explicit query_document_exists(const std::string& what)
-      : query_exception(what, DOCUMENT_EXISTS_EXCEPTION)
+    explicit document_exists(transaction_op_error_context ctx)
+      : op_exception(ctx, DOCUMENT_EXISTS_EXCEPTION)
     {
     }
 };
 
-class query_attempt_not_found : public query_exception
+class query_attempt_not_found : public op_exception
 {
   public:
-    query_attempt_not_found(const std::string& what)
-      : query_exception(what)
+    query_attempt_not_found(transaction_op_error_context ctx)
+      : op_exception(ctx)
     {
     }
 };
 
-class query_cas_mismatch : public query_exception
+class query_cas_mismatch : public op_exception
 {
   public:
-    query_cas_mismatch(const std::string& what)
-      : query_exception(what)
+    query_cas_mismatch(transaction_op_error_context ctx)
+      : op_exception(ctx)
     {
     }
 };
 
-class query_attempt_expired : public query_exception
+class query_attempt_expired : public op_exception
 {
   public:
-    query_attempt_expired(const std::string& what)
-      : query_exception(what)
+    query_attempt_expired(transaction_op_error_context ctx)
+      : op_exception(ctx)
     {
     }
 };
 
-class query_parsing_failure : public query_exception
+class query_parsing_failure : public op_exception
 {
   public:
-    query_parsing_failure(const std::string& what)
-      : query_exception(what, PARSING_FAILURE)
+    query_parsing_failure(transaction_op_error_context ctx)
+      : op_exception(ctx, PARSING_FAILURE)
     {
     }
 };

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

@@ -122,7 +122,8 @@ struct forward_compat_behavior_full {
 struct forward_compat_supported {
     uint32_t protocol_major = 2;
     uint32_t protocol_minor = 0;
-    std::list<std::string> extensions{ "TI", "MO", "BM", "QU", "SD", "BF3787", "BF3705", "BF3838", "RC", "UA", "CO", "BF3791", "CM" };
+    std::list<std::string> extensions{ "TI", "MO", "BM", "QU",     "SD", "BF3787", "BF3705", "BF3838",
+                                       "RC", "UA", "CO", "BF3791", "CM", "SI",     "QC",     "IX" };
 };
 
 struct forward_compat_requirement {

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

@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "core/transactions/error_class.hxx"
 #include "core/transactions/exceptions.hxx"
 #include "core/transactions/result.hxx"
 #include "transaction_context.hxx"
@@ -64,21 +65,6 @@ class retry_operation_retries_exhausted : public std::runtime_error
     }
 };
 
-enum error_class {
-    FAIL_HARD = 0,
-    FAIL_OTHER,
-    FAIL_TRANSIENT,
-    FAIL_AMBIGUOUS,
-    FAIL_DOC_ALREADY_EXISTS,
-    FAIL_DOC_NOT_FOUND,
-    FAIL_PATH_NOT_FOUND,
-    FAIL_CAS_MISMATCH,
-    FAIL_WRITE_WRITE_CONFLICT,
-    FAIL_ATR_FULL,
-    FAIL_PATH_ALREADY_EXISTS,
-    FAIL_EXPIRY
-};
-
 external_exception
 external_exception_from_error_class(error_class ec);
 

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

@@ -18,9 +18,9 @@
 
 #include "core/transactions.hxx"
 #include "core/transactions/async_attempt_context.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 "transaction_attempt.hxx"
 #include "transactions_cleanup.hxx"
 
@@ -39,7 +39,7 @@ class transaction_context
 {
   public:
     transaction_context(transactions& txns,
-                        const couchbase::transactions::per_transaction_config& conf = couchbase::transactions::per_transaction_config());
+                        const couchbase::transactions::transaction_options& conf = couchbase::transactions::transaction_options());
     transaction_context(const transaction_context&);
 
     [[nodiscard]] const std::string& transaction_id() const
@@ -78,12 +78,7 @@ class transaction_context
         return transactions_.cluster_ref();
     }
 
-    couchbase::transactions::transaction_config& config()
-    {
-        return config_;
-    }
-
-    const couchbase::transactions::transaction_config& config() const
+    const couchbase::transactions::transactions_config::built& config() const
     {
         return config_;
     }
@@ -154,7 +149,9 @@ class transaction_context
 
     void remove(const transaction_get_result& doc, async_attempt_context::VoidCallback&& cb);
 
-    void query(const std::string& statement, const transaction_query_options& opts, async_attempt_context::QueryCallback&& cb);
+    void query(const std::string& statement,
+               const couchbase::transactions::transaction_query_options& opts,
+               async_attempt_context::QueryCallback&& cb);
 
     void commit(async_attempt_context::VoidCallback&& cb);
 
@@ -176,7 +173,7 @@ class transaction_context
 
     transactions& transactions_;
 
-    couchbase::transactions::transaction_config config_;
+    couchbase::transactions::transactions_config::built config_;
 
     /**
      * Will be non-zero only when resuming a deferred transaction. It records how much time has elapsed in total in the deferred

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

@@ -18,7 +18,7 @@
 
 #include "atr_cleanup_entry.hxx"
 #include "client_record.hxx"
-#include "couchbase/transactions/transaction_config.hxx"
+#include "couchbase/transactions/transactions_config.hxx"
 
 #include <atomic>
 #include <condition_variable>
@@ -87,7 +87,7 @@ struct atr_cleanup_stats {
 class transactions_cleanup
 {
   public:
-    transactions_cleanup(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transaction_config& config);
+    transactions_cleanup(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config::built& config);
     ~transactions_cleanup();
 
     [[nodiscard]] std::shared_ptr<core::cluster> cluster_ref() const
@@ -95,12 +95,16 @@ class transactions_cleanup
         return cluster_;
     };
 
-    [[nodiscard]] const couchbase::transactions::transaction_config& config() const
+    [[nodiscard]] const couchbase::transactions::transactions_config::built& config() const
     {
         return config_;
     }
+    [[nodiscard]] couchbase::transactions::transactions_config::built& config()
+    {
+        return config_;
+    };
 
-    // Add an attempt to cleanup later.
+    // Add an attempt cleanup later.
     void add_attempt(attempt_context& ctx);
 
     std::size_t cleanup_queue_length() const
@@ -108,28 +112,36 @@ class transactions_cleanup
         return atr_queue_.size();
     }
 
+    void add_collection(couchbase::transactions::transaction_keyspace keyspace);
+    std::list<couchbase::transactions::transaction_keyspace> collections()
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return collections_;
+    }
+
     // only used for testing.
     void force_cleanup_attempts(std::vector<transactions_cleanup_attempt>& results);
     // only used for testing
     void force_cleanup_entry(atr_cleanup_entry& entry, transactions_cleanup_attempt& attempt);
     // only used for testing
     const atr_cleanup_stats force_cleanup_atr(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results);
-    const client_record_details get_active_clients(const std::string& bucket_name, const std::string& uuid);
+    const client_record_details get_active_clients(const couchbase::transactions::transaction_keyspace& keyspace, const std::string& uuid);
     void remove_client_record_from_all_buckets(const std::string& uuid);
     void close();
 
   private:
     std::shared_ptr<core::cluster> cluster_;
-    const couchbase::transactions::transaction_config& config_;
+    couchbase::transactions::transactions_config::built config_;
     const std::chrono::milliseconds cleanup_loop_delay_{ 100 };
 
-    std::thread lost_attempts_thr_;
     std::thread cleanup_thr_;
     atr_cleanup_queue atr_queue_;
     mutable std::condition_variable cv_;
     mutable std::mutex mutex_;
+    std::list<std::thread> lost_attempt_cleanup_workers_;
 
     const std::string client_uuid_;
+    std::list<couchbase::transactions::transaction_keyspace> collections_;
 
     void attempts_loop();
 
@@ -137,8 +149,8 @@ class transactions_cleanup
     bool interruptable_wait(std::chrono::duration<R, P> time);
 
     void lost_attempts_loop();
-    void clean_lost_attempts_in_bucket(const std::string& bucket_name);
-    void create_client_record(const std::string& bucket_name);
+    void clean_collection(const couchbase::transactions::transaction_keyspace& keyspace);
+    void create_client_record(const couchbase::transactions::transaction_keyspace& keyspace);
     const atr_cleanup_stats handle_atr_cleanup(const core::document_id& atr_id,
                                                std::vector<transactions_cleanup_attempt>* result = nullptr);
     std::atomic<bool> running_{ false };