couchbase 4.2.1 → 4.2.2

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

@@ -151,9 +151,9 @@ staged_mutation_queue::iterate(std::function<void(staged_mutation&)> op)
 }
 
 void
-staged_mutation_queue::commit(attempt_context_impl& ctx)
+staged_mutation_queue::commit(attempt_context_impl* ctx)
 {
-    ctx.trace("staged mutations committing...");
+    CB_ATTEMPT_CTX_LOG_TRACE(ctx, "staged mutations committing...");
     std::lock_guard<std::mutex> lock(mutex_);
     for (auto& item : queue_) {
         switch (item.type()) {
@@ -169,7 +169,7 @@ staged_mutation_queue::commit(attempt_context_impl& ctx)
 }
 
 void
-staged_mutation_queue::rollback(attempt_context_impl& ctx)
+staged_mutation_queue::rollback(attempt_context_impl* ctx)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     for (auto& item : queue_) {
@@ -186,15 +186,15 @@ staged_mutation_queue::rollback(attempt_context_impl& ctx)
 }
 
 void
-staged_mutation_queue::rollback_insert(attempt_context_impl& ctx, const staged_mutation& item)
+staged_mutation_queue::rollback_insert(attempt_context_impl* ctx, const staged_mutation& item)
 {
     try {
-        ctx.trace("rolling back staged insert for {} with cas {}", item.doc().id(), item.doc().cas().value());
-        auto ec = ctx.error_if_expired_and_not_in_overtime(STAGE_DELETE_INSERTED, item.doc().id().key());
+        CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rolling back staged insert for {} with cas {}", item.doc().id(), item.doc().cas().value());
+        auto ec = ctx->error_if_expired_and_not_in_overtime(STAGE_DELETE_INSERTED, item.doc().id().key());
         if (ec) {
             throw client_error(*ec, "expired in rollback and not in overtime mode");
         }
-        ec = ctx.hooks_.before_rollback_delete_inserted(&ctx, item.doc().id().key());
+        ec = ctx->hooks_.before_rollback_delete_inserted(ctx, item.doc().id().key());
         if (ec) {
             throw client_error(*ec, "before_rollback_delete_insert hook threw error");
         }
@@ -206,21 +206,21 @@ staged_mutation_queue::rollback_insert(attempt_context_impl& ctx, const staged_m
             .specs();
         req.access_deleted = true;
         req.cas = item.doc().cas();
-        wrap_durable_request(req, ctx.overall_.config());
+        wrap_durable_request(req, ctx->overall_.config());
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        ctx.cluster_ref()->execute(
+        ctx->cluster_ref()->execute(
           req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         auto res = wrap_operation_future(f);
-        ctx.trace("rollback result {}", res);
-        ec = ctx.hooks_.after_rollback_delete_inserted(&ctx, item.doc().id().key());
+        CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rollback result {}", res);
+        ec = ctx->hooks_.after_rollback_delete_inserted(ctx, item.doc().id().key());
         if (ec) {
             throw client_error(*ec, "after_rollback_delete_insert hook threw error");
         }
     } catch (const client_error& e) {
         auto ec = e.ec();
-        if (ctx.expiry_overtime_mode_.load()) {
-            ctx.trace("rollback_insert for {} error while in overtime mode {}", item.doc().id(), e.what());
+        if (ctx->expiry_overtime_mode_.load()) {
+            CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rollback_insert for {} error while in overtime mode {}", item.doc().id(), e.what());
             throw transaction_operation_failed(FAIL_EXPIRY, std::string("expired while rolling back insert with {} ") + e.what())
               .no_rollback()
               .expired();
@@ -230,8 +230,8 @@ staged_mutation_queue::rollback_insert(attempt_context_impl& ctx, const staged_m
             case FAIL_CAS_MISMATCH:
                 throw transaction_operation_failed(ec, e.what()).no_rollback();
             case FAIL_EXPIRY:
-                ctx.expiry_overtime_mode_ = true;
-                ctx.trace("rollback_insert in expiry overtime mode, retrying...");
+                ctx->expiry_overtime_mode_ = true;
+                CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rollback_insert in expiry overtime mode, retrying...");
                 throw retry_operation("retry rollback_insert");
             case FAIL_DOC_NOT_FOUND:
             case FAIL_PATH_NOT_FOUND:
@@ -244,15 +244,15 @@ staged_mutation_queue::rollback_insert(attempt_context_impl& ctx, const staged_m
 }
 
 void
-staged_mutation_queue::rollback_remove_or_replace(attempt_context_impl& ctx, const staged_mutation& item)
+staged_mutation_queue::rollback_remove_or_replace(attempt_context_impl* ctx, const staged_mutation& item)
 {
     try {
-        ctx.trace("rolling back staged remove/replace for {} with cas {}", item.doc().id(), item.doc().cas().value());
-        auto ec = ctx.error_if_expired_and_not_in_overtime(STAGE_ROLLBACK_DOC, item.doc().id().key());
+        CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rolling back staged remove/replace for {} with cas {}", item.doc().id(), item.doc().cas().value());
+        auto ec = ctx->error_if_expired_and_not_in_overtime(STAGE_ROLLBACK_DOC, item.doc().id().key());
         if (ec) {
             throw client_error(*ec, "expired in rollback_remove_or_replace and not in expiry overtime");
         }
-        ec = ctx.hooks_.before_doc_rolled_back(&ctx, item.doc().id().key());
+        ec = ctx->hooks_.before_doc_rolled_back(ctx, item.doc().id().key());
         if (ec) {
             throw client_error(*ec, "before_doc_rolled_back hook threw error");
         }
@@ -263,20 +263,20 @@ staged_mutation_queue::rollback_remove_or_replace(attempt_context_impl& ctx, con
           }
             .specs();
         req.cas = item.doc().cas();
-        wrap_durable_request(req, ctx.overall_.config());
+        wrap_durable_request(req, ctx->overall_.config());
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        ctx.cluster_ref()->execute(
+        ctx->cluster_ref()->execute(
           req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         auto res = wrap_operation_future(f);
-        ctx.trace("rollback result {}", res);
-        ec = ctx.hooks_.after_rollback_replace_or_remove(&ctx, item.doc().id().key());
+        CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rollback result {}", res);
+        ec = ctx->hooks_.after_rollback_replace_or_remove(ctx, item.doc().id().key());
         if (ec) {
             throw client_error(*ec, "after_rollback_replace_or_remove hook threw error");
         }
     } catch (const client_error& e) {
         auto ec = e.ec();
-        if (ctx.expiry_overtime_mode_.load()) {
+        if (ctx->expiry_overtime_mode_.load()) {
             throw transaction_operation_failed(FAIL_EXPIRY, std::string("expired while handling ") + e.what()).no_rollback();
         }
         switch (ec) {
@@ -285,8 +285,8 @@ staged_mutation_queue::rollback_remove_or_replace(attempt_context_impl& ctx, con
             case FAIL_CAS_MISMATCH:
                 throw transaction_operation_failed(ec, e.what()).no_rollback();
             case FAIL_EXPIRY:
-                ctx.expiry_overtime_mode_ = true;
-                ctx.trace("setting expiry overtime mode in {}", STAGE_ROLLBACK_DOC);
+                ctx->expiry_overtime_mode_ = true;
+                CB_ATTEMPT_CTX_LOG_TRACE(ctx, "setting expiry overtime mode in {}", STAGE_ROLLBACK_DOC);
                 throw retry_operation("retry rollback_remove_or_replace");
             case FAIL_PATH_NOT_FOUND:
                 // already cleaned up?
@@ -297,29 +297,30 @@ staged_mutation_queue::rollback_remove_or_replace(attempt_context_impl& ctx, con
     }
 }
 void
-staged_mutation_queue::commit_doc(attempt_context_impl& ctx, staged_mutation& item, bool ambiguity_resolution_mode, bool cas_zero_mode)
+staged_mutation_queue::commit_doc(attempt_context_impl* ctx, staged_mutation& item, bool ambiguity_resolution_mode, bool cas_zero_mode)
 {
     retry_op<void>([&]() {
-        ctx.trace(
-          "commit doc {}, cas_zero_mode {}, ambiguity_resolution_mode {}", item.doc().id(), cas_zero_mode, ambiguity_resolution_mode);
+        CB_ATTEMPT_CTX_LOG_TRACE(
+          ctx, "commit doc {}, cas_zero_mode {}, ambiguity_resolution_mode {}", item.doc().id(), cas_zero_mode, ambiguity_resolution_mode);
         try {
-            ctx.check_expiry_during_commit_or_rollback(STAGE_COMMIT_DOC, std::optional<const std::string>(item.doc().id().key()));
-            auto ec = ctx.hooks_.before_doc_committed(&ctx, item.doc().id().key());
+            ctx->check_expiry_during_commit_or_rollback(STAGE_COMMIT_DOC, std::optional<const std::string>(item.doc().id().key()));
+            auto ec = ctx->hooks_.before_doc_committed(ctx, item.doc().id().key());
             if (ec) {
                 throw client_error(*ec, "before_doc_committed hook threw error");
             }
 
             // move staged content into doc
-            ctx.trace("commit doc id {}, content {}, cas {}", item.doc().id(), to_string(item.content()), item.doc().cas().value());
+            CB_ATTEMPT_CTX_LOG_TRACE(
+              ctx, "commit doc id {}, content {}, cas {}", item.doc().id(), to_string(item.content()), item.doc().cas().value());
 
             result res;
             if (item.type() == staged_mutation_type::INSERT && !cas_zero_mode) {
                 core::operations::insert_request req{ item.doc().id(), item.doc().content() };
                 req.flags = couchbase::codec::codec_flags::json_common_flags;
-                wrap_durable_request(req, ctx.overall_.config());
+                wrap_durable_request(req, ctx->overall_.config());
                 auto barrier = std::make_shared<std::promise<result>>();
                 auto f = barrier->get_future();
-                ctx.cluster_ref()->execute(req, [barrier](core::operations::insert_response resp) {
+                ctx->cluster_ref()->execute(req, [barrier](core::operations::insert_response resp) {
                     barrier->set_value(result::create_from_mutation_response(resp));
                 });
                 res = wrap_operation_future(f);
@@ -334,28 +335,28 @@ staged_mutation_queue::commit_doc(attempt_context_impl& ctx, staged_mutation& it
                     .specs();
                 req.store_semantics = couchbase::store_semantics::replace;
                 req.cas = couchbase::cas(cas_zero_mode ? 0 : item.doc().cas().value());
-                wrap_durable_request(req, ctx.overall_.config());
+                wrap_durable_request(req, ctx->overall_.config());
                 auto barrier = std::make_shared<std::promise<result>>();
                 auto f = barrier->get_future();
-                ctx.cluster_ref()->execute(req, [barrier](core::operations::mutate_in_response resp) {
+                ctx->cluster_ref()->execute(req, [barrier](core::operations::mutate_in_response resp) {
                     barrier->set_value(result::create_from_subdoc_response(resp));
                 });
                 res = wrap_operation_future(f);
             }
-            ctx.trace("commit doc result {}", res);
+            CB_ATTEMPT_CTX_LOG_TRACE(ctx, "commit doc result {}", res);
             // TODO: mutation tokens
-            ec = ctx.hooks_.after_doc_committed_before_saving_cas(&ctx, item.doc().id().key());
+            ec = ctx->hooks_.after_doc_committed_before_saving_cas(ctx, item.doc().id().key());
             if (ec) {
                 throw client_error(*ec, "after_doc_committed_before_saving_cas threw error");
             }
             item.doc().cas(res.cas);
-            ec = ctx.hooks_.after_doc_committed(&ctx, item.doc().id().key());
+            ec = ctx->hooks_.after_doc_committed(ctx, item.doc().id().key());
             if (ec) {
                 throw client_error(*ec, "after_doc_committed threw error");
             }
         } catch (const client_error& e) {
             error_class ec = e.ec();
-            if (ctx.expiry_overtime_mode_.load()) {
+            if (ctx->expiry_overtime_mode_.load()) {
                 throw transaction_operation_failed(FAIL_EXPIRY, "expired during commit").no_rollback().failed_post_commit();
             }
             switch (ec) {
@@ -378,29 +379,29 @@ staged_mutation_queue::commit_doc(attempt_context_impl& ctx, staged_mutation& it
 }
 
 void
-staged_mutation_queue::remove_doc(attempt_context_impl& ctx, const staged_mutation& item)
+staged_mutation_queue::remove_doc(attempt_context_impl* ctx, const staged_mutation& item)
 {
     retry_op<void>([&] {
         try {
-            ctx.check_expiry_during_commit_or_rollback(STAGE_REMOVE_DOC, std::optional<const std::string>(item.doc().id().key()));
-            auto ec = ctx.hooks_.before_doc_removed(&ctx, item.doc().id().key());
+            ctx->check_expiry_during_commit_or_rollback(STAGE_REMOVE_DOC, std::optional<const std::string>(item.doc().id().key()));
+            auto ec = ctx->hooks_.before_doc_removed(ctx, item.doc().id().key());
             if (ec) {
                 throw client_error(*ec, "before_doc_removed hook threw error");
             }
             core::operations::remove_request req{ item.doc().id() };
-            wrap_durable_request(req, ctx.overall_.config());
+            wrap_durable_request(req, ctx->overall_.config());
             auto barrier = std::make_shared<std::promise<result>>();
             auto f = barrier->get_future();
-            ctx.cluster_ref()->execute(
+            ctx->cluster_ref()->execute(
               req, [barrier](core::operations::remove_response resp) { barrier->set_value(result::create_from_mutation_response(resp)); });
             wrap_operation_future(f);
-            ec = ctx.hooks_.after_doc_removed_pre_retry(&ctx, item.doc().id().key());
+            ec = ctx->hooks_.after_doc_removed_pre_retry(ctx, item.doc().id().key());
             if (ec) {
                 throw client_error(*ec, "after_doc_removed_pre_retry threw error");
             }
         } catch (const client_error& e) {
             error_class ec = e.ec();
-            if (ctx.expiry_overtime_mode_.load()) {
+            if (ctx->expiry_overtime_mode_.load()) {
                 throw transaction_operation_failed(ec, e.what()).no_rollback().failed_post_commit();
             }
             switch (ec) {

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

@@ -104,17 +104,17 @@ class staged_mutation_queue
   private:
     std::mutex mutex_;
     std::vector<staged_mutation> queue_;
-    void commit_doc(attempt_context_impl& ctx, staged_mutation& item, bool ambiguity_resolution_mode = false, bool cas_zero_mode = false);
-    void remove_doc(attempt_context_impl& ctx, const staged_mutation& item);
-    void rollback_insert(attempt_context_impl& ctx, const staged_mutation& item);
-    void rollback_remove_or_replace(attempt_context_impl& ctx, const staged_mutation& item);
+    void commit_doc(attempt_context_impl* ctx, staged_mutation& item, bool ambiguity_resolution_mode = false, bool cas_zero_mode = false);
+    void remove_doc(attempt_context_impl* ctx, const staged_mutation& item);
+    void rollback_insert(attempt_context_impl* ctx, const staged_mutation& item);
+    void rollback_remove_or_replace(attempt_context_impl* ctx, const staged_mutation& item);
 
   public:
     bool empty();
     void add(const staged_mutation& mutation);
     void extract_to(const std::string& prefix, core::operations::mutate_in_request& req);
-    void commit(attempt_context_impl& ctx);
-    void rollback(attempt_context_impl& ctx);
+    void commit(attempt_context_impl* ctx);
+    void rollback(attempt_context_impl* ctx);
     void iterate(std::function<void(staged_mutation&)>);
     void remove_any(const core::document_id&);
 

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

@@ -65,13 +65,14 @@ transaction_context::has_expired_client_side()
     auto expired_millis = std::chrono::duration_cast<std::chrono::milliseconds>(expired_nanos);
     bool is_expired = expired_nanos > config_.expiration_time;
     if (is_expired) {
-        txn_log->info("has expired client side (now={}ns, start={}ns, deferred_elapsed={}ns, expired={}ns ({}ms), config={}ms)",
-                      now.time_since_epoch().count(),
-                      start_time_client_.time_since_epoch().count(),
-                      deferred_elapsed_.count(),
-                      expired_nanos.count(),
-                      expired_millis.count(),
-                      std::chrono::duration_cast<std::chrono::milliseconds>(config_.expiration_time).count());
+        CB_ATTEMPT_CTX_LOG_INFO(current_attempt_context_,
+                                "has expired client side (now={}ns, start={}ns, deferred_elapsed={}ns, expired={}ns ({}ms), config={}ms)",
+                                now.time_since_epoch().count(),
+                                start_time_client_.time_since_epoch().count(),
+                                deferred_elapsed_.count(),
+                                expired_nanos.count(),
+                                expired_millis.count(),
+                                std::chrono::duration_cast<std::chrono::milliseconds>(config_.expiration_time).count());
     }
     return is_expired;
 }
@@ -85,7 +86,8 @@ transaction_context::retry_delay()
     // stack, so using 50 in hopes that makes jenkins happy till we do this better.
     constexpr auto arbitrary_factor = 50;
     auto delay = config_.expiration_time / arbitrary_factor;
-    txn_log->trace("about to sleep for {} ms", std::chrono::duration_cast<std::chrono::milliseconds>(delay).count());
+    CB_ATTEMPT_CTX_LOG_TRACE(
+      current_attempt_context_, "about to sleep for {} ms", std::chrono::duration_cast<std::chrono::milliseconds>(delay).count());
     std::this_thread::sleep_for(delay);
 }
 
@@ -98,7 +100,8 @@ transaction_context::new_attempt_context(async_attempt_context::VoidCallback&& c
         try {
             (*delay_)();
             current_attempt_context_ = std::make_shared<attempt_context_impl>(*this);
-            txn_log->info("starting attempt {}/{}/{}/", num_attempts(), transaction_id(), current_attempt_context_->id());
+            CB_ATTEMPT_CTX_LOG_INFO(
+              current_attempt_context_, "starting attempt {}/{}/{}/", num_attempts(), transaction_id(), current_attempt_context_->id());
             cb(nullptr);
         } catch (...) {
             cb(std::current_exception());
@@ -160,14 +163,22 @@ transaction_context::remove(const transaction_get_result& doc, async_attempt_con
 void
 transaction_context::query(const std::string& statement,
                            const couchbase::transactions::transaction_query_options& opts,
+                           std::optional<std::string> query_context,
                            async_attempt_context::QueryCallback&& cb)
 {
     if (current_attempt_context_) {
-        return current_attempt_context_->query(statement, opts, std::move(cb));
+        return current_attempt_context_->query(statement, opts, query_context, std::move(cb));
     }
     throw(transaction_operation_failed(FAIL_OTHER, "no current attempt context"));
 }
 
+void
+transaction_context::query(const std::string& statement,
+                           const couchbase::transactions::transaction_query_options& opts,
+                           async_attempt_context::QueryCallback&& cb)
+{
+    query(statement, opts, {}, std::move(cb));
+}
 void
 transaction_context::commit(async_attempt_context::VoidCallback&& cb)
 {
@@ -206,14 +217,17 @@ transaction_context::handle_error(std::exception_ptr err, txn_complete_callback&
             throw transaction_operation_failed(FAIL_OTHER, e.what()).cause(e.cause());
         }
     } catch (const transaction_operation_failed& er) {
-        txn_log->error("got transaction_operation_failed {}", er.what());
+        CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "got transaction_operation_failed {}", er.what());
         if (er.should_rollback()) {
-            txn_log->trace("got rollback-able exception, rolling back");
+            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) {
                 cleanup().add_attempt(*current_attempt_context_);
-                txn_log->trace("got error \"{}\" while auto rolling back, throwing original error", er_rollback.what(), er.what());
+                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);
                 // 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
@@ -222,7 +236,7 @@ transaction_context::handle_error(std::exception_ptr err, txn_complete_callback&
                 return callback(final, std::nullopt);
             }
             if (er.should_retry() && has_expired_client_side()) {
-                txn_log->trace("auto rollback succeeded, however we are expired so no retry");
+                CB_ATTEMPT_CTX_LOG_TRACE(current_attempt_context_, "auto rollback succeeded, however we are expired so no retry");
 
                 return callback(
                   transaction_operation_failed(FAIL_EXPIRY, "expired in auto rollback").no_rollback().expired().get_final_exception(*this),
@@ -230,7 +244,7 @@ transaction_context::handle_error(std::exception_ptr err, txn_complete_callback&
             }
         }
         if (er.should_retry()) {
-            txn_log->trace("got retryable exception, retrying");
+            CB_ATTEMPT_CTX_LOG_TRACE(current_attempt_context_, "got retryable exception, retrying");
             cleanup().add_attempt(*current_attempt_context_);
             return callback(std::nullopt, std::nullopt);
         }
@@ -244,11 +258,11 @@ transaction_context::handle_error(std::exception_ptr err, txn_complete_callback&
         }
         return callback(final, res);
     } catch (const std::exception& ex) {
-        txn_log->error("got runtime error \"{}\"", ex.what());
+        CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "got runtime error \"{}\"", ex.what());
         try {
             current_attempt_context_->rollback();
         } catch (...) {
-            txn_log->error("got error rolling back \"{}\"", ex.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "got error rolling back \"{}\"", ex.what());
         }
         cleanup().add_attempt(*current_attempt_context_);
         // the assumption here is this must come from the logic, not
@@ -256,11 +270,11 @@ transaction_context::handle_error(std::exception_ptr err, txn_complete_callback&
         auto op_failed = transaction_operation_failed(FAIL_OTHER, ex.what());
         return callback(op_failed.get_final_exception(*this), std::nullopt);
     } catch (...) {
-        txn_log->error("got unexpected error, rolling back");
+        CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "got unexpected error, rolling back");
         try {
             current_attempt_context_->rollback();
         } catch (...) {
-            txn_log->error("got error rolling back unexpected error");
+            CB_ATTEMPT_CTX_LOG_ERROR(current_attempt_context_, "got error rolling back unexpected error");
         }
         cleanup().add_attempt(*current_attempt_context_);
         // the assumption here is this must come from the logic, not

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

@@ -15,13 +15,13 @@
  */
 
 #pragma once
-#include <couchbase/transactions/transaction_get_result.hxx>
-
 #include "core/document_id.hxx"
 #include "core/operations.hxx"
 #include "core/utils/json.hxx"
 #include "document_metadata.hxx"
 #include "transaction_links.hxx"
+#include <couchbase/fmt/cas.hxx>
+#include <couchbase/transactions/transaction_get_result.hxx>
 
 #include <ostream>
 #include <utility>
@@ -227,3 +227,19 @@ class transaction_get_result : public couchbase::transactions::transaction_get_r
     }
 };
 } // namespace couchbase::core::transactions
+
+template<>
+struct fmt::formatter<couchbase::core::transactions::transaction_get_result> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    constexpr auto format(const couchbase::core::transactions::transaction_get_result& r, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(), "transaction_get_result:{{ id: {}, cas: {}, links: }}", r.id(), r.cas(), r.links());
+    }
+};

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

@@ -16,11 +16,11 @@
 
 #pragma once
 
-#include <tao/json/value.hpp>
-
+#include <fmt/format.h>
 #include <optional>
 #include <ostream>
 #include <string>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::transactions
 {
@@ -227,3 +227,26 @@ class transaction_links
 std::ostream&
 operator<<(std::ostream& os, const transaction_links& links);
 } // namespace couchbase::core::transactions
+
+template<>
+struct fmt::formatter<couchbase::core::transactions::transaction_links> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    constexpr auto format(const couchbase::core::transactions::transaction_links& r, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(),
+                         "transaction_links:{{ atr: {}.{}.{}.{}, txn_id: {}, attempt_id: {}, crc32_of_staging: {} }}",
+                         r.atr_bucket_name().value_or("none"),
+                         r.atr_scope_name().value_or("none"),
+                         r.atr_collection_name().value_or("none"),
+                         r.atr_id().value_or("none"),
+                         r.staged_attempt_id().value_or("none"),
+                         r.crc32_of_staging().value_or("none"));
+    }
+};

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

@@ -37,7 +37,7 @@ transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchba
   , config_(config)
   , cleanup_(new transactions_cleanup(cluster_, config_))
 {
-    txn_log->info(
+    CB_TXN_LOG_DEBUG(
       "couchbase transactions {} ({}) creating new transaction object", couchbase::core::meta::sdk_id(), couchbase::core::meta::os());
     // if the config specifies custom metadata collection, lets be sure to open that bucket
     // on the cluster before we start.  NOTE: we actually do call get_and_open_buckets which opens all the buckets
@@ -59,7 +59,7 @@ transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchba
         if (err) {
             auto err_msg =
               fmt::format("error opening metadata_collection bucket '{}' specified in the config!", config_.metadata_collection->bucket);
-            txn_log->error(err_msg);
+            CB_TXN_LOG_DEBUG(err_msg);
             throw std::runtime_error(err_msg);
         }
     }
@@ -176,8 +176,8 @@ transactions::run(async_logic&& code, txn_complete_callback&& cb)
 void
 transactions::close()
 {
-    txn_log->info("closing transactions");
+    CB_TXN_LOG_DEBUG("closing transactions");
     cleanup_->close();
-    txn_log->info("transactions closed");
+    CB_TXN_LOG_DEBUG("transactions closed");
 }
 } // namespace couchbase::core::transactions