couchbase 4.2.1 → 4.2.3

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() };
+                core::operations::insert_request req{ item.doc().id(), item.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

@@ -17,9 +17,9 @@
 #pragma once
 
 #include "attempt_context_impl.hxx"
-
 #include "internal/utils.hxx"
 #include "transaction_get_result.hxx"
+#include "uid_generator.hxx"
 
 #include <mutex>
 #include <string>
@@ -35,13 +35,18 @@ class staged_mutation
     transaction_get_result doc_;
     staged_mutation_type type_;
     std::vector<std::byte> content_;
+    std::string operation_id_;
 
   public:
     template<typename Content>
-    staged_mutation(transaction_get_result& doc, Content content, staged_mutation_type type)
+    staged_mutation(transaction_get_result& doc,
+                    Content content,
+                    staged_mutation_type type,
+                    std::string operation_id = uid_generator::next())
       : doc_(doc)
       , type_(type)
       , content_(std::move(content))
+      , operation_id_(std::move(operation_id))
     {
     }
 
@@ -97,6 +102,11 @@ class staged_mutation
         }
         throw std::runtime_error("unknown type of staged mutation");
     }
+
+    [[nodiscard]] const std::string& operation_id() const
+    {
+        return operation_id_;
+    }
 };
 
 class staged_mutation_queue
@@ -104,17 +114,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

@@ -17,7 +17,7 @@
 #include "attempt_context_impl.hxx"
 #include "uid_generator.hxx"
 #include <asio/post.hpp>
-#include <core/cluster.hxx>
+#include <asio/steady_timer.hpp>
 
 #include "internal/logging.hxx"
 #include "internal/transaction_context.hxx"
@@ -45,6 +45,7 @@ void
 transaction_context::add_attempt()
 {
     transaction_attempt attempt{};
+    std::lock_guard<std::mutex> lock(mutex_);
     attempts_.push_back(attempt);
 }
 
@@ -65,28 +66,27 @@ 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;
 }
 
 void
-transaction_context::retry_delay()
+transaction_context::after_delay(std::chrono::milliseconds delay, std::function<void()> fn)
 {
-    // when we retry an operation, we typically call that function recursively.  So, we need to
-    // limit total number of times we do it.  CXXCBC-263 will address this, and no longer make the
-    // recursive calls that lead to hacks like this. No way to know how many calls will blow up the
-    // 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());
-    std::this_thread::sleep_for(delay);
+    auto timer = std::make_shared<asio::steady_timer>(this->transactions_.cluster_ref()->io_context());
+    timer->expires_after(delay);
+    timer->async_wait([timer, fn](std::error_code) {
+        // have to always call the function, even if timer was canceled.
+        fn();
+    });
 }
 
 void
@@ -98,7 +98,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 +161,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 +215,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 +234,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 +242,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 +256,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 +268,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.cxx

@@ -25,6 +25,7 @@ transaction_get_result::create_from(const core::operations::lookup_in_response&
     std::optional<std::string> atr_id;
     std::optional<std::string> transaction_id;
     std::optional<std::string> attempt_id;
+    std::optional<std::string> operation_id;
     std::optional<std::vector<std::byte>> staged_content;
     std::optional<std::string> atr_bucket_name;
     std::optional<std::string> atr_scope_name;
@@ -56,46 +57,49 @@ transaction_get_result::create_from(const core::operations::lookup_in_response&
         attempt_id = codec::tao_json_serializer::deserialize<std::string>(resp.fields[2].value);
     }
     if (resp.fields[3].status == key_value_status_code::success) {
-        staged_content = resp.fields[3].value;
+        operation_id = codec::tao_json_serializer::deserialize<std::string>(resp.fields[3].value);
     }
     if (resp.fields[4].status == key_value_status_code::success) {
-        atr_bucket_name = codec::tao_json_serializer::deserialize<std::string>(resp.fields[4].value);
+        staged_content = resp.fields[4].value;
     }
     if (resp.fields[5].status == key_value_status_code::success) {
-        atr_scope_name = codec::tao_json_serializer::deserialize<std::string>(resp.fields[5].value);
+        atr_bucket_name = codec::tao_json_serializer::deserialize<std::string>(resp.fields[5].value);
     }
     if (resp.fields[6].status == key_value_status_code::success) {
-        atr_collection_name = codec::tao_json_serializer::deserialize<std::string>(resp.fields[6].value);
+        atr_scope_name = codec::tao_json_serializer::deserialize<std::string>(resp.fields[6].value);
     }
-
     if (resp.fields[7].status == key_value_status_code::success) {
-        auto restore = core::utils::json::parse_binary(resp.fields[7].value);
+        atr_collection_name = codec::tao_json_serializer::deserialize<std::string>(resp.fields[7].value);
+    }
+
+    if (resp.fields[8].status == key_value_status_code::success) {
+        auto restore = core::utils::json::parse_binary(resp.fields[8].value);
         cas_pre_txn = restore["CAS"].as<std::string>();
         // only present in 6.5+
         revid_pre_txn = restore["revid"].as<std::string>();
         exptime_pre_txn = restore["exptime"].as<std::uint32_t>();
     }
-    if (resp.fields[8].status == key_value_status_code::success) {
-        op = codec::tao_json_serializer::deserialize<std::string>(resp.fields[8].value);
-    }
     if (resp.fields[9].status == key_value_status_code::success) {
-        auto doc = core::utils::json::parse_binary(resp.fields[9].value);
+        op = codec::tao_json_serializer::deserialize<std::string>(resp.fields[9].value);
+    }
+    if (resp.fields[10].status == key_value_status_code::success) {
+        auto doc = core::utils::json::parse_binary(resp.fields[10].value);
         cas_from_doc = doc["CAS"].as<std::string>();
         // only present in 6.5+
         revid_from_doc = doc["revid"].as<std::string>();
         exptime_from_doc = doc["exptime"].as<std::uint32_t>();
         crc32_from_doc = doc["value_crc32c"].as<std::string>();
     }
-    if (resp.fields[10].status == key_value_status_code::success) {
-        crc32_of_staging = codec::tao_json_serializer::deserialize<std::string>(resp.fields[10].value);
-    }
     if (resp.fields[11].status == key_value_status_code::success) {
-        forward_compat = core::utils::json::parse_binary(resp.fields[11].value);
+        crc32_of_staging = codec::tao_json_serializer::deserialize<std::string>(resp.fields[11].value);
+    }
+    if (resp.fields[12].status == key_value_status_code::success) {
+        forward_compat = core::utils::json::parse_binary(resp.fields[12].value);
     } else {
         forward_compat = tao::json::empty_object;
     }
-    if (resp.fields[12].status == key_value_status_code::success) {
-        content = resp.fields[12].value;
+    if (resp.fields[13].status == key_value_status_code::success) {
+        content = resp.fields[13].value;
     }
 
     transaction_links links(atr_id,
@@ -104,6 +108,7 @@ transaction_get_result::create_from(const core::operations::lookup_in_response&
                             atr_collection_name,
                             transaction_id,
                             attempt_id,
+                            operation_id,
                             staged_content,
                             cas_pre_txn,
                             revid_pre_txn,
@@ -126,6 +131,7 @@ transaction_get_result::create_from(const core::document_id& id, const result& r
     std::optional<std::string> atr_id;
     std::optional<std::string> transaction_id;
     std::optional<std::string> attempt_id;
+    std::optional<std::string> operation_id;
     std::optional<std::vector<std::byte>> staged_content;
     std::optional<std::string> atr_bucket_name;
     std::optional<std::string> atr_scope_name;
@@ -157,45 +163,48 @@ transaction_get_result::create_from(const core::document_id& id, const result& r
         attempt_id = res.values[2].content_as<std::string>();
     }
     if (res.values[3].has_value()) {
-        staged_content = res.values[3].raw_value;
+        operation_id = res.values[3].content_as<std::string>();
     }
     if (res.values[4].has_value()) {
-        atr_bucket_name = res.values[4].content_as<std::string>();
+        staged_content = res.values[4].raw_value;
     }
     if (res.values[5].has_value()) {
-        atr_scope_name = res.values[5].content_as<std::string>();
+        atr_bucket_name = res.values[5].content_as<std::string>();
     }
     if (res.values[6].has_value()) {
-        atr_collection_name = res.values[6].content_as<std::string>();
+        atr_scope_name = res.values[6].content_as<std::string>();
     }
     if (res.values[7].has_value()) {
-        auto restore = res.values[7].content_as();
+        atr_collection_name = res.values[7].content_as<std::string>();
+    }
+    if (res.values[8].has_value()) {
+        auto restore = res.values[8].content_as();
         cas_pre_txn = restore["CAS"].as<std::string>();
         // only present in 6.5+
         revid_pre_txn = restore["revid"].as<std::string>();
         exptime_pre_txn = restore["exptime"].as<std::uint32_t>();
     }
-    if (res.values[8].has_value()) {
-        op = res.values[8].content_as<std::string>();
-    }
     if (res.values[9].has_value()) {
-        auto doc = res.values[9].content_as();
+        op = res.values[9].content_as<std::string>();
+    }
+    if (res.values[10].has_value()) {
+        auto doc = res.values[10].content_as();
         cas_from_doc = doc["CAS"].as<std::string>();
         // only present in 6.5+
         revid_from_doc = doc["revid"].as<std::string>();
         exptime_from_doc = doc["exptime"].as<std::uint32_t>();
         crc32_from_doc = doc["value_crc32c"].as<std::string>();
     }
-    if (res.values[10].has_value()) {
-        crc32_of_staging = res.values[10].content_as<std::string>();
-    }
     if (res.values[11].has_value()) {
-        forward_compat = res.values[11].content_as();
+        crc32_of_staging = res.values[11].content_as<std::string>();
+    }
+    if (res.values[12].has_value()) {
+        forward_compat = res.values[12].content_as();
     } else {
         forward_compat = tao::json::empty_object;
     }
-    if (res.values[12].has_value()) {
-        content = res.values[12].raw_value;
+    if (res.values[13].has_value()) {
+        content = res.values[13].raw_value;
     }
 
     transaction_links links(atr_id,
@@ -204,6 +213,7 @@ transaction_get_result::create_from(const core::document_id& id, const result& r
                             atr_collection_name,
                             transaction_id,
                             attempt_id,
+                            operation_id,
                             staged_content,
                             cas_pre_txn,
                             revid_pre_txn,