couchbase 4.2.1 → 4.2.3

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

@@ -0,0 +1,52 @@
+/*
+ *     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 "cleanup_testing_hooks.hxx"
+
+namespace couchbase::core::transactions
+{
+namespace
+{
+inline std::optional<couchbase::core::transactions::error_class>
+noop1(const std::string&)
+{
+    return {};
+}
+
+inline std::optional<couchbase::core::transactions::error_class>
+noop2()
+{
+    return {};
+}
+} // namespace
+
+cleanup_testing_hooks::cleanup_testing_hooks()
+  : before_commit_doc{ noop1 }
+  , before_doc_get{ noop1 }
+  , before_remove_doc_staged_for_removal{ noop1 }
+  , before_remove_doc{ noop1 }
+  , before_atr_get{ noop1 }
+  , before_remove_links{ noop1 }
+  , before_atr_remove{ noop2 }
+  , on_cleanup_docs_completed{ noop2 }
+  , on_cleanup_completed{ noop2 }
+  , client_record_before_create{ noop1 }
+  , client_record_before_get{ noop1 }
+  , client_record_before_update{ noop1 }
+  , client_record_before_remove_client{ noop1 }
+{
+}
+} // namespace couchbase::core::transactions

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

@@ -18,52 +18,38 @@
 #include "core/transactions/error_class.hxx"
 
 #include <functional>
+#include <optional>
 #include <string>
 
 namespace couchbase::core::transactions
 {
 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<couchbase::core::transactions::error_class>
-noop1(const std::string&)
-{
-    return {};
-}
-std::optional<couchbase::core::transactions::error_class>
-noop2()
-{
-    return {};
-}
-
-} // namespace
 
 /**
  * Hooks purely for testing purposes.  If you're an end-user looking at these for any reason, then please contact us first
  * about your use-case: we are always open to adding good ideas into the transactions library.
  */
 struct cleanup_testing_hooks {
-    error_func3 before_commit_doc = noop1;
-    error_func3 before_doc_get = noop1;
-    error_func3 before_remove_doc_staged_for_removal = noop1;
-    error_func3 before_remove_doc = noop1;
-    error_func3 before_atr_get = noop1;
-    error_func3 before_remove_links = noop1;
+    error_func3 before_commit_doc;
+    error_func3 before_doc_get;
+    error_func3 before_remove_doc_staged_for_removal;
+    error_func3 before_remove_doc;
+    error_func3 before_atr_get;
+    error_func3 before_remove_links;
 
-    error_func4 before_atr_remove = noop2;
+    error_func4 before_atr_remove;
 
-    error_func4 on_cleanup_docs_completed = noop2;
-    error_func4 on_cleanup_completed = noop2;
+    error_func4 on_cleanup_docs_completed;
+    error_func4 on_cleanup_completed;
 
-    error_func3 client_record_before_create = noop1;
-    error_func3 client_record_before_get = noop1;
-    error_func3 client_record_before_update = noop1;
-    error_func3 client_record_before_remove_client = noop1;
+    error_func3 client_record_before_create;
+    error_func3 client_record_before_get;
+    error_func3 client_record_before_update;
+    error_func3 client_record_before_remove_client;
 
+    cleanup_testing_hooks();
     // needed for unique_ptr<cleanup_testing_hooks> in transaction_config, with a forward declaration.
-    ~cleanup_testing_hooks()
-    {
-    }
+    ~cleanup_testing_hooks() = default;
 };
-} // namespace couchbase::core::transactions
+} // namespace couchbase::core::transactions

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

@@ -103,7 +103,6 @@ transaction_exception::transaction_exception(const std::runtime_error& cause, co
     if (nullptr != txn_op) {
         cause_ = txn_op->cause();
     }
-    result_.ctx = error_context();
 }
 
 errc::transaction_op

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

@@ -16,11 +16,14 @@
 
 #pragma once
 
-#include <core/error_context/query.hxx>
+#include "core/error_context/query.hxx"
+#include "error_class.hxx"
+
 #include <couchbase/error_codes.hxx>
 #include <couchbase/transactions/transaction_result.hxx>
-#include <optional>
+
 #include <stdexcept>
+#include <utility>
 
 namespace couchbase::core::transactions
 {
@@ -88,9 +91,9 @@ class transaction_exception : public std::runtime_error
      *
      * @returns Internal state of transaction.
      */
-    ::couchbase::transactions::transaction_result get_transaction_result() const
+    std::pair<couchbase::transaction_error_context, couchbase::transactions::transaction_result> get_transaction_result() const
     {
-        return { result_.transaction_id, result_.unstaging_complete, error_context() };
+        return { error_context(), { result_.transaction_id, result_.unstaging_complete } };
     }
 
     /**
@@ -135,7 +138,7 @@ class op_exception : public std::runtime_error
     transaction_op_error_context ctx_;
 
   public:
-    op_exception(transaction_op_error_context ctx, external_exception cause = COUCHBASE_EXCEPTION)
+    explicit op_exception(transaction_op_error_context ctx, external_exception cause = COUCHBASE_EXCEPTION)
       : std::runtime_error(ctx.ec().message())
       , cause_(cause)
       , ctx_(std::move(ctx))
@@ -157,7 +160,7 @@ class document_not_found : public op_exception
 {
   public:
     explicit document_not_found(transaction_op_error_context ctx)
-      : op_exception(ctx, DOCUMENT_NOT_FOUND_EXCEPTION)
+      : op_exception(std::move(ctx), DOCUMENT_NOT_FOUND_EXCEPTION)
     {
     }
 };
@@ -166,7 +169,7 @@ class document_exists : public op_exception
 {
   public:
     explicit document_exists(transaction_op_error_context ctx)
-      : op_exception(ctx, DOCUMENT_EXISTS_EXCEPTION)
+      : op_exception(std::move(ctx), DOCUMENT_EXISTS_EXCEPTION)
     {
     }
 };
@@ -175,7 +178,7 @@ class query_attempt_not_found : public op_exception
 {
   public:
     query_attempt_not_found(transaction_op_error_context ctx)
-      : op_exception(ctx)
+      : op_exception(std::move(ctx))
     {
     }
 };
@@ -184,7 +187,7 @@ class query_cas_mismatch : public op_exception
 {
   public:
     query_cas_mismatch(transaction_op_error_context ctx)
-      : op_exception(ctx)
+      : op_exception(std::move(ctx))
     {
     }
 };
@@ -193,7 +196,7 @@ class query_attempt_expired : public op_exception
 {
   public:
     query_attempt_expired(transaction_op_error_context ctx)
-      : op_exception(ctx)
+      : op_exception(std::move(ctx))
     {
     }
 };
@@ -202,7 +205,7 @@ class query_parsing_failure : public op_exception
 {
   public:
     query_parsing_failure(transaction_op_error_context ctx)
-      : op_exception(ctx, PARSING_FAILURE)
+      : op_exception(std::move(ctx), PARSING_FAILURE)
     {
     }
 };

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

@@ -122,8 +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", "SI",     "QC",     "IX" };
+    std::list<std::string> extensions{ "TI", "MO", "BM",     "QU", "SD", "BF3787", "BF3705", "BF3838", "RC",
+                                       "UA", "CO", "BF3791", "CM", "SI", "QC",     "IX",     "TS" };
 };
 
 struct forward_compat_requirement {
@@ -192,12 +192,12 @@ class forward_compat
                 auto behavior = b->check(supported);
                 switch (behavior.behavior) {
                     case forward_compat_behavior::FAIL_FAST_TXN:
-                        txn_log->trace("forward compatiblity FAIL_FAST_TXN");
+                        CB_TXN_LOG_TRACE("forward compatiblity FAIL_FAST_TXN");
                         return ex;
                     case forward_compat_behavior::RETRY_TXN:
-                        txn_log->trace("forward compatibility RETRY_TXN");
+                        CB_TXN_LOG_TRACE("forward compatibility RETRY_TXN");
                         if (behavior.retry_delay) {
-                            txn_log->trace("delay {}ms before retrying", behavior.retry_delay->count());
+                            CB_TXN_LOG_TRACE("delay {}ms before retrying", behavior.retry_delay->count());
                             std::this_thread::sleep_for(*behavior.retry_delay);
                         }
                         return ex.retry();
@@ -213,7 +213,7 @@ class forward_compat
     forward_compat(tao::json::value& json)
       : json_(json)
     {
-        txn_log->trace("creating forward_compat from {}", core::utils::json::generate(json_));
+        CB_TXN_LOG_TRACE("creating forward_compat from {}", core::utils::json::generate(json_));
         // parse it into the map
         for (const auto& [key, value] : json_.get_object()) {
             auto stage = create_forward_compat_stage(key);

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

@@ -21,6 +21,7 @@
 #include "logging.hxx"
 
 #include <chrono>
+#include <fmt/format.h>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -65,19 +66,16 @@ class atr_cleanup_entry
 
     friend class compare_atr_entries;
 
-    void check_atr_and_cleanup(std::shared_ptr<spdlog::logger> logger, transactions_cleanup_attempt* result);
-    void cleanup_docs(std::shared_ptr<spdlog::logger> logger, durability_level dl);
-    void cleanup_entry(std::shared_ptr<spdlog::logger> logger, durability_level dl);
-    void commit_docs(std::shared_ptr<spdlog::logger> logger, std::optional<std::vector<doc_record>> docs, durability_level dl);
-    void remove_docs(std::shared_ptr<spdlog::logger> logger, std::optional<std::vector<doc_record>> docs, durability_level dl);
-    void remove_docs_staged_for_removal(std::shared_ptr<spdlog::logger> logger,
-                                        std::optional<std::vector<doc_record>> docs,
-                                        durability_level dl);
-    void remove_txn_links(std::shared_ptr<spdlog::logger> logger, std::optional<std::vector<doc_record>> docs, durability_level dl);
-    void do_per_doc(std::shared_ptr<spdlog::logger> logger,
-                    std::vector<doc_record> docs,
+    void check_atr_and_cleanup(transactions_cleanup_attempt* result);
+    void cleanup_docs(durability_level dl);
+    void cleanup_entry(durability_level dl);
+    void commit_docs(std::optional<std::vector<doc_record>> docs, durability_level dl);
+    void remove_docs(std::optional<std::vector<doc_record>> docs, durability_level dl);
+    void remove_docs_staged_for_removal(std::optional<std::vector<doc_record>> docs, durability_level dl);
+    void remove_txn_links(std::optional<std::vector<doc_record>> docs, durability_level dl);
+    void do_per_doc(std::vector<doc_record> docs,
                     bool require_crc_to_match,
-                    const std::function<void(std::shared_ptr<spdlog::logger>, transaction_get_result&, bool)>& call);
+                    const std::function<void(transaction_get_result&, bool)>& call);
 
   public:
     explicit atr_cleanup_entry(attempt_context& ctx);
@@ -88,8 +86,27 @@ class atr_cleanup_entry
 
     explicit atr_cleanup_entry(const core::document_id& atr_id, const std::string& attempt_id, const transactions_cleanup& cleanup);
 
-    void clean(std::shared_ptr<spdlog::logger> logger, transactions_cleanup_attempt* result = nullptr);
+    void clean(transactions_cleanup_attempt* result = nullptr);
     bool ready() const;
+    couchbase::core::document_id atr_id() const
+    {
+        return atr_id_;
+    }
+
+    std::string attempt_id() const
+    {
+        return attempt_id_;
+    }
+
+    bool check_if_expired() const
+    {
+        return check_if_expired_;
+    }
+
+    std::chrono::time_point<std::chrono::steady_clock> min_start_time() const
+    {
+        return min_start_time_;
+    };
 
     template<typename OStream>
     friend OStream& operator<<(OStream& os, const atr_cleanup_entry& e)
@@ -124,3 +141,24 @@ class atr_cleanup_queue
 };
 
 } // namespace couchbase::core::transactions
+
+template<>
+struct fmt::formatter<couchbase::core::transactions::atr_cleanup_entry> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const couchbase::core::transactions::atr_cleanup_entry& e, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(),
+                         "atr_cleanup_entry{{ atr_id: {}, attempt_id: {}, check_if_expired: {}, min_start_time: {} }}",
+                         e.atr_id(),
+                         e.attempt_id(),
+                         e.check_if_expired(),
+                         std::chrono::duration_cast<std::chrono::milliseconds>(e.min_start_time().time_since_epoch()).count());
+    }
+};

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

@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <fmt/format.h>
 #include <string>
 #include <vector>
 
@@ -56,5 +57,29 @@ struct client_record_details {
         return os;
     }
 };
-
 } // namespace couchbase::core::transactions
+template<>
+struct fmt::formatter<couchbase::core::transactions::client_record_details> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const couchbase::core::transactions::client_record_details& r, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(),
+                         "client_record:{{ client_uuid:: {}, active_clients: {}, index_of_this_client: {}, existing_clients: {}, "
+                         "expired_clients: {}, override_enabled: {}, override_expires: {}, cas_now_nanos: {} }}",
+                         r.client_uuid,
+                         r.num_active_clients,
+                         r.index_of_this_client,
+                         r.num_existing_clients,
+                         r.num_expired_clients,
+                         r.override_enabled,
+                         r.override_expires,
+                         r.cas_now_nanos);
+    }
+};

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

@@ -76,3 +76,24 @@ struct doc_record {
     core::document_id id_;
 };
 } // namespace couchbase::core::transactions
+
+template<>
+struct fmt::formatter<couchbase::core::transactions::doc_record> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    constexpr auto format(const couchbase::core::transactions::doc_record& r, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(),
+                         "doc_record:{{ bucket: {}, scope: {}, collection: {}, key: {} }}",
+                         r.document_id().bucket(),
+                         r.document_id().scope(),
+                         r.document_id().collection(),
+                         r.document_id().key());
+    }
+};

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

@@ -15,26 +15,48 @@
  */
 #pragma once
 
-#include <spdlog/fmt/ostr.h>
-#include <spdlog/logger.h>
-
-#define TXN_LOG "transactions"
-#define ATTEMPT_CLEANUP_LOG "attempt_cleanup"
-#define LOST_ATTEMPT_CLEANUP_LOG "lost_attempt_cleanup"
+#include <core/logger/logger.hxx>
 
 namespace couchbase::core::transactions
 {
-static const std::string attempt_format_string("[{}/{}]:");
-
-std::shared_ptr<spdlog::logger>
-init_txn_log();
-std::shared_ptr<spdlog::logger>
-init_attempt_cleanup_log();
-std::shared_ptr<spdlog::logger>
-init_lost_attempts_log();
-
-static std::shared_ptr<spdlog::logger> txn_log = init_txn_log();
-static std::shared_ptr<spdlog::logger> attempt_cleanup_log = init_attempt_cleanup_log();
-static std::shared_ptr<spdlog::logger> lost_attempts_cleanup_log = init_lost_attempts_log();
+static const std::string txn_format_string("[transactions] - ");
+static const std::string attempt_format_string("[transactions]({}/{}) - ");
+static const std::string lost_attempt_format_string("[lost_attempt_cleanup]({}) - ");
+static const std::string attempt_cleanup_format_string("[attempt_cleanup] - ");
+
+#define CB_TXN_LOG(level, ...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, level, __VA_ARGS__)
+
+#define ADD_CTX(ctx, ...) fmt::format(attempt_format_string, ctx->transaction_id(), ctx->id()) + __VA_ARGS__
+#define ADD_LOST_ATTEMPT(ctx, ...) fmt::format(couchbase::core::transactions::lost_attempt_format_string, fmt::ptr(ctx)) + __VA_ARGS__
+#define ADD_ATTEMPT_CLEANUP(...) couchbase::core::transactions::attempt_cleanup_format_string + __VA_ARGS__
+#define ADD_TXN(...) couchbase::core::transactions::txn_format_string + __VA_ARGS__
+
+#define CB_ATTEMPT_CTX_LOG_TRACE(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_CTX(ctx, __VA_ARGS__))
+#define CB_ATTEMPT_CTX_LOG_DEBUG(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_CTX(ctx, __VA_ARGS__))
+#define CB_ATTEMPT_CTX_LOG_INFO(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::info, ADD_CTX(ctx, __VA_ARGS__))
+#define CB_ATTEMPT_CTX_LOG_WARNING(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::warn, ADD_CTX(ctx, __VA_ARGS__))
+#define CB_ATTEMPT_CTX_LOG_ERROR(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::err, ADD_CTX(ctx, __VA_ARGS__))
+#define CB_ATTEMPT_CTX_LOG_CRITICAL(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::critical, ADD_CTX(ctx, __VA_ARGS__))
+
+#define CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE(...) CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
+#define CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG(...) CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
+#define CB_LOST_ATTEMPT_CLEANUP_LOG_INFO(...) CB_TXN_LOG(couchbase::core::logger::level::info, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
+#define CB_LOST_ATTEMPT_CLEANUP_LOG_WARNING(...) CB_TXN_LOG(couchbase::core::logger::level::warn, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
+#define CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR(...) CB_TXN_LOG(couchbase::core::logger::level::err, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
+#define CB_LOST_ATTEMPT_CLEANUP_LOG_CRITICAL(...) CB_TXN_LOG(couchbase::core::logger::level::critical, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
+
+#define CB_ATTEMPT_CLEANUP_LOG_TRACE(...) CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_DEBUG(...) CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_INFO(...) CB_TXN_LOG(couchbase::core::logger::level::info, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_WARNING(...) CB_TXN_LOG(couchbase::core::logger::level::warn, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_ERROR(...) CB_TXN_LOG(couchbase::core::logger::level::err, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_CRITICAL(...) CB_TXN_LOG(couchbase::core::logger::level::critical, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+
+#define CB_TXN_LOG_TRACE(...) CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_DEBUG(...) CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_INFO(...) CB_TXN_LOG(couchbase::core::logger::level::info, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_WARNING(...) CB_TXN_LOG(couchbase::core::logger::level::warn, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_ERROR(...) CB_TXN_LOG(couchbase::core::logger::level::err, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_CRITICAL(...) CB_TXN_LOG(couchbase::core::logger::level::critical, ADD_TXN(__VA_ARGS__))
 
 } // namespace couchbase::core::transactions

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

@@ -49,30 +49,29 @@ class transaction_context
 
     [[nodiscard]] std::size_t num_attempts() const
     {
+        std::lock_guard<std::mutex> lock(mutex_);
         return attempts_.size();
     }
-    [[nodiscard]] const std::vector<transaction_attempt>& attempts() const
-    {
-        return attempts_;
-    }
-    [[nodiscard]] std::vector<transaction_attempt>& attempts()
-    {
-        return const_cast<std::vector<transaction_attempt>&>(const_cast<const transaction_context*>(this)->attempts());
-    }
     [[nodiscard]] const transaction_attempt& current_attempt() const
     {
+        std::lock_guard<std::mutex> lock(mutex_);
         if (attempts_.empty()) {
             throw std::runtime_error("transaction context has no attempts yet");
         }
         return attempts_.back();
     }
-    [[nodiscard]] transaction_attempt& current_attempt()
-    {
-        return const_cast<transaction_attempt&>(const_cast<const transaction_context*>(this)->current_attempt());
-    }
 
     void add_attempt();
 
+    void current_attempt_state(attempt_state s)
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (attempts_.empty()) {
+            throw std::runtime_error("transaction_context has no attempts yet");
+        }
+        attempts_.back().state = s;
+    }
+
     [[nodiscard]] std::shared_ptr<core::cluster> cluster_ref()
     {
         return transactions_.cluster_ref();
@@ -90,7 +89,7 @@ class transaction_context
 
     [[nodiscard]] bool has_expired_client_side();
 
-    void retry_delay();
+    void after_delay(std::chrono::milliseconds delay, std::function<void()> fn);
 
     [[nodiscard]] std::chrono::time_point<std::chrono::steady_clock> start_time_client() const
     {
@@ -119,7 +118,7 @@ class transaction_context
 
     [[nodiscard]] ::couchbase::transactions::transaction_result get_transaction_result() const
     {
-        return couchbase::transactions::transaction_result{ transaction_id(), current_attempt().state == attempt_state::COMPLETED, {} };
+        return couchbase::transactions::transaction_result{ transaction_id(), current_attempt().state == attempt_state::COMPLETED };
     }
     void new_attempt_context()
     {
@@ -149,6 +148,11 @@ class transaction_context
 
     void remove(const transaction_get_result& doc, async_attempt_context::VoidCallback&& cb);
 
+    void query(const std::string& statement,
+               const couchbase::transactions::transaction_query_options& opts,
+               std::optional<std::string> query_context,
+               async_attempt_context::QueryCallback&& cb);
+
     void query(const std::string& statement,
                const couchbase::transactions::transaction_query_options& opts,
                async_attempt_context::QueryCallback&& cb);
@@ -186,6 +190,7 @@ class transaction_context
     std::string atr_collection_;
     transactions_cleanup& cleanup_;
     std::shared_ptr<attempt_context_impl> current_attempt_context_;
+    mutable std::mutex mutex_;
 
     std::unique_ptr<exp_delay> delay_;
 };

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

@@ -50,6 +50,7 @@ static const std::string TRANSACTION_RESTORE_PREFIX_ONLY = TRANSACTION_INTERFACE
 static const std::string TRANSACTION_RESTORE_PREFIX = TRANSACTION_RESTORE_PREFIX_ONLY + ".";
 static const std::string TRANSACTION_ID = TRANSACTION_INTERFACE_PREFIX + "id.txn";
 static const std::string ATTEMPT_ID = TRANSACTION_INTERFACE_PREFIX + "id.atmpt";
+static const std::string OPERATION_ID = TRANSACTION_INTERFACE_PREFIX + "id.op";
 static const std::string ATR_ID = TRANSACTION_INTERFACE_PREFIX + "atr.id";
 static const std::string ATR_BUCKET_NAME = TRANSACTION_INTERFACE_PREFIX + "atr.bkt";
 

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

@@ -145,6 +145,12 @@ class transactions_cleanup
 
     void attempts_loop();
 
+    bool is_running()
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        return running_;
+    }
+
     template<class R, class P>
     bool interruptable_wait(std::chrono::duration<R, P> time);
 
@@ -153,7 +159,7 @@ class transactions_cleanup
     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 };
+    bool running_{ false };
 };
 } // namespace transactions
 } // namespace couchbase::core

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

@@ -22,6 +22,7 @@
 
 #include "couchbase/codec/tao_json_serializer.hxx"
 
+#include <fmt/format.h>
 #include <optional>
 #include <string>
 #include <vector>
@@ -268,3 +269,28 @@ struct result : result_base {
 };
 } // namespace transactions
 } // namespace couchbase::core
+
+template<>
+struct fmt::formatter<couchbase::core::transactions::result> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    constexpr auto format(const couchbase::core::transactions::result& r, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(),
+                         "result:{{ rc: {}, strerror: {}, cas: {}, is_deleted: {}, datatype: {}, flags: {}, raw_value: {:.{}} }}",
+                         r.rc,
+                         r.strerror(),
+                         r.cas,
+                         r.is_deleted,
+                         r.datatype,
+                         r.flags,
+                         couchbase::core::transactions::to_string(r.raw_value),
+                         r.raw_value.size() > 1024 ? 1024 : r.raw_value.size());
+    }
+};