couchbase 4.2.1 → 4.2.3

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

@@ -57,9 +57,10 @@ attempt_context_impl::attempt_context_impl(transaction_context& transaction_ctx)
 {
     // put a new transaction_attempt in the context...
     overall_.add_attempt();
-    trace("added new attempt, state {}, expiration in {}ms",
-          attempt_state_name(state()),
-          std::chrono::duration_cast<std::chrono::milliseconds>(overall_.remaining()).count());
+    CB_ATTEMPT_CTX_LOG_TRACE(this,
+                             "added new attempt, state {}, expiration in {}ms",
+                             attempt_state_name(state()),
+                             std::chrono::duration_cast<std::chrono::milliseconds>(overall_.remaining()).count());
 }
 
 attempt_context_impl::~attempt_context_impl() = default;
@@ -73,11 +74,11 @@ attempt_context_impl::check_and_handle_blocking_transactions(const transaction_g
         // Check not just writing the same doc twice in the same transaction
         // NOTE: we check the transaction rather than attempt id. This is to handle [RETRY-ERR-AMBIG-REPLACE].
         if (doc.links().staged_transaction_id().value() == transaction_id()) {
-            debug("doc {} has been written by this transaction, ok to continue", doc.id());
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "doc {} has been written by this transaction, ok to continue", doc.id());
             return cb(std::nullopt);
         }
         if (doc.links().atr_id() && doc.links().atr_bucket_name() && doc.links().staged_attempt_id()) {
-            debug("doc {} in another txn, checking atr...", doc.id());
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "doc {} in another txn, checking atr...", doc.id());
             auto err = forward_compat::check(stage, doc.links().forward_compat());
             if (err) {
                 return cb(err);
@@ -85,10 +86,11 @@ attempt_context_impl::check_and_handle_blocking_transactions(const transaction_g
             exp_delay delay(std::chrono::milliseconds(50), std::chrono::milliseconds(500), std::chrono::seconds(1));
             return check_atr_entry_for_blocking_document(doc, delay, std::move(cb));
         }
-        debug("doc {} is in another transaction {}, but doesn't have enough info to check the atr. "
-              "probably a bug, proceeding to overwrite",
-              doc.id(),
-              *doc.links().staged_attempt_id());
+        CB_ATTEMPT_CTX_LOG_DEBUG(this,
+                                 "doc {} is in another transaction {}, but doesn't have enough info to check the atr. "
+                                 "probably a bug, proceeding to overwrite",
+                                 doc.id(),
+                                 *doc.links().staged_attempt_id());
     }
     return cb(std::nullopt);
 }
@@ -241,6 +243,7 @@ core::operations::mutate_in_request
 attempt_context_impl::create_staging_request(const core::document_id& id,
                                              const transaction_get_result* document,
                                              const std::string type,
+                                             const std::string op_id,
                                              std::optional<std::vector<std::byte>> content)
 {
     core::operations::mutate_in_request req{ id };
@@ -248,6 +251,7 @@ attempt_context_impl::create_staging_request(const core::document_id& id,
     txn["id"] = tao::json::empty_object;
     txn["id"]["txn"] = transaction_id();
     txn["id"]["atmpt"] = this->id();
+    txn["id"]["op"] = op_id;
     txn["atr"] = tao::json::empty_object;
     txn["atr"]["id"] = atr_id();
     txn["atr"]["bkt"] = atr_id_->bucket();
@@ -294,17 +298,18 @@ attempt_context_impl::replace_raw(const transaction_get_result& document, const
                 return op_completed_with_error(std::move(cb), transaction_operation_failed(FAIL_OTHER, ec.message()));
             }
             try {
+                auto op_id = uid_generator::next();
                 // a get can return a 'empty' doc, so check for that and short-circuit the eventual error that will occur...
                 if (document.key().empty() || document.bucket().empty()) {
                     return op_completed_with_error(std::move(cb),
                                                    transaction_operation_failed(FAIL_DOC_NOT_FOUND, "can't replace empty doc")
                                                      .cause(external_exception::DOCUMENT_NOT_FOUND_EXCEPTION));
                 }
-                trace("replacing {} with {}", document, to_string(content));
+                CB_ATTEMPT_CTX_LOG_TRACE(this, "replacing {} with {}", document, to_string(content));
                 check_if_done(cb);
                 staged_mutation* existing_sm = staged_mutations_->find_any(document.id());
                 if (existing_sm != nullptr && existing_sm->type() == staged_mutation_type::REMOVE) {
-                    debug("found existing REMOVE of {} while replacing", document);
+                    CB_ATTEMPT_CTX_LOG_DEBUG(this, "found existing REMOVE of {} while replacing", document);
                     return op_completed_with_error(
                       std::move(cb),
                       transaction_operation_failed(FAIL_DOC_NOT_FOUND,
@@ -319,7 +324,7 @@ attempt_context_impl::replace_raw(const transaction_get_result& document, const
                 check_and_handle_blocking_transactions(
                   document,
                   forward_compat_stage::WWC_REPLACING,
-                  [this, existing_sm = std::move(existing_sm), document = std::move(document), cb = std::move(cb), content](
+                  [this, existing_sm = std::move(existing_sm), document = std::move(document), cb = std::move(cb), op_id, content](
                     std::optional<transaction_operation_failed> e1) mutable {
                       if (e1) {
                           return op_completed_with_error(std::move(cb), *e1);
@@ -328,19 +333,19 @@ attempt_context_impl::replace_raw(const transaction_get_result& document, const
                         document_id{ document.id().bucket(), document.id().scope(), document.id().collection(), document.id().key() };
                       select_atr_if_needed_unlocked(
                         tmp_doc,
-                        [this, existing_sm = std::move(existing_sm), document = std::move(document), cb = std::move(cb), content](
+                        [this, existing_sm = std::move(existing_sm), document = std::move(document), cb = std::move(cb), op_id, content](
                           std::optional<transaction_operation_failed> e2) mutable {
                             if (e2) {
                                 return op_completed_with_error(std::move(cb), *e2);
                             }
                             if (existing_sm != nullptr && existing_sm->type() == staged_mutation_type::INSERT) {
-                                debug("found existing INSERT of {} while replacing", document);
+                                CB_ATTEMPT_CTX_LOG_DEBUG(this, "found existing INSERT of {} while replacing", document);
                                 exp_delay delay(
                                   std::chrono::milliseconds(5), std::chrono::milliseconds(300), overall_.config().expiration_time);
-                                create_staged_insert(document.id(), content, existing_sm->doc().cas().value(), delay, std::move(cb));
+                                create_staged_insert(document.id(), content, existing_sm->doc().cas().value(), delay, op_id, std::move(cb));
                                 return;
                             }
-                            create_staged_replace(document, content, std::move(cb));
+                            create_staged_replace(document, content, op_id, std::move(cb));
                         });
                   });
             } catch (const client_error& e) {
@@ -359,9 +364,12 @@ attempt_context_impl::replace_raw(const transaction_get_result& document, const
 
 template<typename Handler>
 void
-attempt_context_impl::create_staged_replace(const transaction_get_result& document, const std::vector<std::byte>& content, Handler&& cb)
+attempt_context_impl::create_staged_replace(const transaction_get_result& document,
+                                            const std::vector<std::byte>& content,
+                                            const std::string& op_id,
+                                            Handler&& cb)
 {
-    auto req = create_staging_request(document.id(), &document, "replace", content);
+    auto req = create_staging_request(document.id(), &document, "replace", op_id, content);
     req.cas = document.cas();
     req.access_deleted = true;
     auto error_handler = [this](error_class ec, const std::string& msg, Handler&& cb) {
@@ -383,7 +391,8 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
     if (ec) {
         return error_handler(*ec, "before_staged_replace hook raised error", std::move(cb));
     }
-    trace("about to replace doc {} with cas {} in txn {}", document.id(), document.cas().value(), overall_.transaction_id());
+    CB_ATTEMPT_CTX_LOG_TRACE(
+      this, "about to replace doc {} with cas {} in txn {}", document.id(), document.cas().value(), overall_.transaction_id());
     overall_.cluster_ref()->execute(
       req,
       [this, document = std::move(document), content, cb = std::move(cb), error_handler = std::move(error_handler)](
@@ -398,7 +407,7 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
           transaction_get_result out = document;
           out.cas(resp.cas.value());
           out.content(content);
-          trace("replace staged content, result {}", out);
+          CB_ATTEMPT_CTX_LOG_TRACE(this, "replace staged content, result {}", out);
           staged_mutations_->add(staged_mutation(out, content, staged_mutation_type::REPLACE));
           return op_completed_with_callback(std::move(cb), std::optional<transaction_get_result>(out));
       });
@@ -446,10 +455,11 @@ attempt_context_impl::insert_raw(const core::document_id& id, const std::vector<
             }
             try {
                 check_if_done(cb);
+                auto op_id = uid_generator::next();
                 staged_mutation* existing_sm = staged_mutations_->find_any(id);
                 if ((existing_sm != nullptr) &&
                     (existing_sm->type() == staged_mutation_type::INSERT || existing_sm->type() == staged_mutation_type::REPLACE)) {
-                    debug("found existing insert or replace of {} while inserting", id);
+                    CB_ATTEMPT_CTX_LOG_DEBUG(this, "found existing insert or replace of {} while inserting", id);
                     return op_completed_with_error(
                       std::move(cb),
                       transaction_operation_failed(FAIL_DOC_ALREADY_EXISTS, "found existing insert or replace of same document"));
@@ -459,17 +469,17 @@ attempt_context_impl::insert_raw(const core::document_id& id, const std::vector<
                                                    transaction_operation_failed(FAIL_EXPIRY, "transaction expired").expired());
                 }
                 select_atr_if_needed_unlocked(
-                  id, [this, existing_sm, cb = std::move(cb), id, content](std::optional<transaction_operation_failed> err) mutable {
+                  id, [this, existing_sm, cb = std::move(cb), id, op_id, content](std::optional<transaction_operation_failed> err) mutable {
                       if (err) {
                           return op_completed_with_error(std::move(cb), *err);
                       }
                       if (existing_sm != nullptr && existing_sm->type() == staged_mutation_type::REMOVE) {
-                          debug("found existing remove of {} while inserting", id);
-                          return create_staged_replace(existing_sm->doc(), content, std::move(cb));
+                          CB_ATTEMPT_CTX_LOG_DEBUG(this, "found existing remove of {} while inserting", id);
+                          return create_staged_replace(existing_sm->doc(), content, op_id, std::move(cb));
                       }
                       uint64_t cas = 0;
                       exp_delay delay(std::chrono::milliseconds(5), std::chrono::milliseconds(300), overall_.config().expiration_time);
-                      create_staged_insert(id, content, cas, delay, std::move(cb));
+                      create_staged_insert(id, content, cas, delay, op_id, std::move(cb));
                   });
             } catch (const std::exception& e) {
                 return op_completed_with_error(std::move(cb), transaction_operation_failed(FAIL_OTHER, e.what()));
@@ -485,7 +495,7 @@ attempt_context_impl::select_atr_if_needed_unlocked(const core::document_id id,
     try {
         std::unique_lock<std::mutex> lock(mutex_);
         if (atr_id_) {
-            trace("atr exists, moving on");
+            CB_ATTEMPT_CTX_LOG_TRACE(this, "atr exists, moving on");
             return cb(std::nullopt);
         }
         std::size_t vbucket_id = 0;
@@ -500,11 +510,12 @@ attempt_context_impl::select_atr_if_needed_unlocked(const core::document_id id,
         overall_.atr_collection(collection_spec_from_id(id));
         overall_.atr_id(atr_id_->key());
         state(attempt_state::NOT_STARTED);
-        trace(R"(first mutated doc in transaction is "{}" on vbucket {}, so using atr "{}")", id, vbucket_id, atr_id_.value());
+        CB_ATTEMPT_CTX_LOG_TRACE(
+          this, R"(first mutated doc in transaction is "{}" on vbucket {}, so using atr "{}")", id, vbucket_id, atr_id_.value());
         overall_.cleanup().add_collection({ atr_id_->bucket(), atr_id_->scope(), atr_id_->collection() });
         set_atr_pending_locked(id, std::move(lock), std::move(cb));
     } catch (const std::exception& e) {
-        error("unexpected error \"{}\" during select atr if needed", e.what());
+        CB_ATTEMPT_CTX_LOG_ERROR(this, "unexpected error \"{}\" during select atr if needed", e.what());
     }
 }
 template<typename Handler, typename Delay>
@@ -539,15 +550,17 @@ attempt_context_impl::check_atr_entry_for_blocking_document(const transaction_ge
                           switch (it->state()) {
                               case attempt_state::COMPLETED:
                               case attempt_state::ROLLED_BACK:
-                                  debug("existing atr entry can be ignored due to state {}", attempt_state_name(it->state()));
+                                  CB_ATTEMPT_CTX_LOG_DEBUG(
+                                    this, "existing atr entry can be ignored due to state {}", attempt_state_name(it->state()));
                                   return cb(std::nullopt);
                               default:
-                                  debug("existing atr entry found in state {}, retrying", attempt_state_name(it->state()));
+                                  CB_ATTEMPT_CTX_LOG_DEBUG(
+                                    this, "existing atr entry found in state {}, retrying", attempt_state_name(it->state()));
                           }
                           return check_atr_entry_for_blocking_document(doc, delay, std::move(cb));
                       }
                   }
-                  debug("no blocking atr entry");
+                  CB_ATTEMPT_CTX_LOG_DEBUG(this, "no blocking atr entry");
                   return cb(std::nullopt);
               }
               // if we are here, there is still a write-write conflict
@@ -592,10 +605,11 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
             if (check_expiry_pre_commit(STAGE_REMOVE, document.id().key())) {
                 return error_handler(FAIL_EXPIRY, "transaction expired", std::move(cb));
             }
-            debug("removing {}", document);
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "removing {}", document);
+            auto op_id = uid_generator::next();
             if (existing_sm != nullptr) {
                 if (existing_sm->type() == staged_mutation_type::REMOVE) {
-                    debug("found existing REMOVE of {} while removing", document);
+                    CB_ATTEMPT_CTX_LOG_DEBUG(this, "found existing REMOVE of {} while removing", document);
                     return op_completed_with_error(
                       std::move(cb),
                       transaction_operation_failed(FAIL_DOC_NOT_FOUND,
@@ -610,7 +624,7 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
             check_and_handle_blocking_transactions(
               document,
               forward_compat_stage::WWC_REMOVING,
-              [this, document = std::move(document), cb = std::move(cb), error_handler = std::move(error_handler)](
+              [this, document = std::move(document), cb = std::move(cb), op_id, error_handler = std::move(error_handler)](
                 std::optional<transaction_operation_failed> err1) mutable {
                   if (err1) {
                       return op_completed_with_error(std::move(cb), *err1);
@@ -619,7 +633,7 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
                     document_id{ document.id().bucket(), document.id().scope(), document.id().collection(), document.id().key() };
                   select_atr_if_needed_unlocked(
                     tmp_doc,
-                    [document = std::move(document), cb = std::move(cb), this, error_handler = std::move(error_handler)](
+                    [document = std::move(document), cb = std::move(cb), this, op_id, error_handler = std::move(error_handler)](
                       std::optional<transaction_operation_failed> err2) mutable {
                         if (err2) {
                             return op_completed_with_error(std::move(cb), *err2);
@@ -627,8 +641,8 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
                         if (auto ec = hooks_.before_staged_remove(this, document.id().key())) {
                             return error_handler(*ec, "before_staged_remove hook raised error", std::move(cb));
                         }
-                        trace("about to remove doc {} with cas {}", document.id(), document.cas().value());
-                        auto req = create_staging_request(document.id(), &document, "remove");
+                        CB_ATTEMPT_CTX_LOG_TRACE(this, "about to remove doc {} with cas {}", document.id(), document.cas().value());
+                        auto req = create_staging_request(document.id(), &document, "remove", op_id);
                         req.cas = document.cas();
                         req.access_deleted = document.links().is_deleted();
                         overall_.cluster_ref()->execute(
@@ -640,7 +654,8 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
                                   ec = hooks_.after_staged_remove_complete(this, document.id().key());
                               }
                               if (!ec) {
-                                  trace("removed doc {} CAS={}, rc={}", document.id(), resp.cas.value(), resp.ctx.ec().message());
+                                  CB_ATTEMPT_CTX_LOG_TRACE(
+                                    this, "removed doc {} CAS={}, rc={}", document.id(), resp.cas.value(), resp.ctx.ec().message());
                                   // TODO: this copy...  can we do better?
                                   transaction_get_result new_res = document;
                                   new_res.cas(resp.cas.value());
@@ -672,7 +687,7 @@ attempt_context_impl::remove_staged_insert(const core::document_id& id, VoidCall
                 return op_completed_with_error(std::move(cb), err.retry());
         }
     };
-    debug("removing staged insert {}", id);
+    CB_ATTEMPT_CTX_LOG_DEBUG(this, "removing staged insert {}", id);
 
     if (auto err = hooks_.before_remove_staged_insert(this, id.key()); err) {
         return error_handler(*err, "before_remove_staged_insert hook returned error", std::move(cb));
@@ -701,7 +716,7 @@ attempt_context_impl::remove_staged_insert(const core::document_id& id, VoidCall
                                             op_completed_with_callback(std::move(cb));
                                             return;
                                         }
-                                        debug("remove_staged_insert got error {}", *ec);
+                                        CB_ATTEMPT_CTX_LOG_DEBUG(this, "remove_staged_insert got error {}", *ec);
                                         return error_handler(*ec, resp.ctx.ec().message(), std::move(cb));
                                     });
 }
@@ -738,7 +753,7 @@ wrap_query_request(const couchbase::transactions::transaction_query_options& opt
 }
 
 void
-attempt_context_impl::query_begin_work(std::function<void(std::exception_ptr)>&& cb)
+attempt_context_impl::query_begin_work(std::optional<std::string> query_context, std::function<void(std::exception_ptr)>&& cb)
 {
     // construct the txn_data and query options for the existing transaction
     couchbase::transactions::transaction_query_options opts;
@@ -784,19 +799,20 @@ attempt_context_impl::query_begin_work(std::function<void(std::exception_ptr)>&&
     }
     txdata["mutations"] = mutations;
     std::vector<core::json_string> params;
-    trace("begin_work using txdata: {}", core::utils::json::generate(txdata));
+    CB_ATTEMPT_CTX_LOG_TRACE(this, "begin_work using txdata: {}", core::utils::json::generate(txdata));
     wrap_query(BEGIN_WORK,
                opts,
                params,
                txdata,
                STAGE_QUERY_BEGIN_WORK,
                false,
+               query_context,
                [this, cb = std::move(cb)](std::exception_ptr err, core::operations::query_response resp) mutable {
                    if (resp.served_by_node.empty()) {
-                       trace("begin_work didn't reach a query node, resetting mode to kv");
+                       CB_ATTEMPT_CTX_LOG_TRACE(this, "begin_work didn't reach a query node, resetting mode to kv");
                        op_list_.reset_query_mode();
                    } else {
-                       trace("begin_work setting query node to {}", resp.served_by_node);
+                       CB_ATTEMPT_CTX_LOG_TRACE(this, "begin_work setting query node to {}", resp.served_by_node);
                        op_list_.set_query_node(resp.served_by_node);
                    }
                    // we check for expiry _after_ this call, so we always set the query node if we can.
@@ -839,14 +855,15 @@ attempt_context_impl::handle_query_error(const core::operations::query_response&
     if (!resp.ctx.ec && !resp.meta.errors) {
         return {};
     }
-    auto tx_resp = couchbase::core::impl::build_transaction_query_result(resp);
+    auto [tx_err, query_result] = couchbase::core::impl::build_transaction_query_result(resp);
     // TODO: look at ambiguous and unambiguous timeout errors vs the codes, etc...
-    trace("handling query error {}, {} errors in meta_data", resp.ctx.ec.message(), resp.meta.errors ? "has" : "no");
+    CB_ATTEMPT_CTX_LOG_TRACE(
+      this, "handling query error {}, {} errors in meta_data", resp.ctx.ec.message(), resp.meta.errors ? "has" : "no");
     if (resp.ctx.ec == couchbase::errc::common::ambiguous_timeout || resp.ctx.ec == couchbase::errc::common::unambiguous_timeout) {
-        return std::make_exception_ptr(query_attempt_expired(tx_resp.ctx()));
+        return std::make_exception_ptr(query_attempt_expired(tx_err));
     }
     if (resp.ctx.ec == couchbase::errc::common::parsing_failure) {
-        return std::make_exception_ptr(query_parsing_failure(tx_resp.ctx()));
+        return std::make_exception_ptr(query_parsing_failure(tx_err));
     }
     if (!resp.meta.errors) {
         // can't choose an error, map using the ec...
@@ -860,7 +877,7 @@ attempt_context_impl::handle_query_error(const core::operations::query_response&
 
     // just chose first one, to start with...
     auto chosen_error = choose_error(errors);
-    trace("chosen query error: {}", jsonify(chosen_error));
+    CB_ATTEMPT_CTX_LOG_TRACE(this, "chosen query error: {}", jsonify(chosen_error));
     auto code = chosen_error.at("code").as<uint64_t>();
 
     // we have a fixed strategy for these errors...
@@ -874,16 +891,16 @@ attempt_context_impl::handle_query_error(const core::operations::query_response&
               transaction_operation_failed(FAIL_OTHER, "This couchbase server requires all queries use a scope.")
                 .cause(FEATURE_NOT_AVAILABLE_EXCEPTION));
         case 17004:
-            return std::make_exception_ptr(query_attempt_not_found(tx_resp.ctx()));
+            return std::make_exception_ptr(query_attempt_not_found(tx_err));
         case 1080:
         case 17010:
             return std::make_exception_ptr(transaction_operation_failed(FAIL_EXPIRY, "transaction expired").expired());
         case 17012:
-            return std::make_exception_ptr(document_exists(tx_resp.ctx()));
+            return std::make_exception_ptr(document_exists(tx_err));
         case 17014:
-            return std::make_exception_ptr(document_not_found(tx_resp.ctx()));
+            return std::make_exception_ptr(document_not_found(tx_err));
         case 17015:
-            return std::make_exception_ptr(query_cas_mismatch(tx_resp.ctx()));
+            return std::make_exception_ptr(query_cas_mismatch(tx_err));
     }
 
     // For these errors, we will create a transaction_operation_failed from the info in it.
@@ -907,29 +924,31 @@ attempt_context_impl::handle_query_error(const core::operations::query_response&
             } else if (raise == std::string("failed_post_commit")) {
                 err.failed_post_commit();
             } else if (raise != std::string("failed")) {
-                trace("unknown value in raise field: {}, raising failed", raise);
+                CB_ATTEMPT_CTX_LOG_TRACE(this, "unknown value in raise field: {}, raising failed", raise);
             }
             return std::make_exception_ptr(err);
         }
     }
 
-    return { std::make_exception_ptr(op_exception(tx_resp.ctx())) };
+    return { std::make_exception_ptr(op_exception(tx_err)) };
 }
 
 void
 attempt_context_impl::do_query(const std::string& statement,
                                const couchbase::transactions::transaction_query_options& opts,
+                               std::optional<std::string> query_context,
                                QueryCallback&& cb)
 {
     std::vector<core::json_string> params;
     tao::json::value txdata;
-    trace("do_query called with statement {}", statement);
+    CB_ATTEMPT_CTX_LOG_TRACE(this, "do_query called with statement {}", statement);
     wrap_query(statement,
                opts,
                params,
                txdata,
                STAGE_QUERY,
                true,
+               query_context,
                [this, cb = std::move(cb)](std::exception_ptr err, core::operations::query_response resp) mutable {
                    if (err) {
                        return op_completed_with_error(std::move(cb), err);
@@ -961,6 +980,7 @@ attempt_context_impl::wrap_query(const std::string& statement,
                                  const tao::json::value& txdata,
                                  const std::string& hook_point,
                                  bool check_expiry,
+                                 std::optional<std::string> query_context,
                                  std::function<void(std::exception_ptr, core::operations::query_response)>&& cb)
 {
     auto req = wrap_query_request(opts, overall_);
@@ -972,8 +992,10 @@ attempt_context_impl::wrap_query(const std::string& statement,
         }
     }
     // set the query_context, if one has been set, unless this query already has one
-    if (!req.scope_qualifier && !query_context_.empty()) {
-        req.scope_qualifier = query_context_;
+    if (!query_context && !query_context_.empty()) {
+        req.query_context = query_context_;
+    } else if (query_context) {
+        req.query_context = query_context;
     }
 
     if (check_expiry) {
@@ -1003,9 +1025,9 @@ attempt_context_impl::wrap_query(const std::string& statement,
         }
         return cb(std::make_exception_ptr(transaction_operation_failed(*ec, "before_query hook raised error")), {});
     }
-    trace("http request: {}", dump_request(req));
+    CB_ATTEMPT_CTX_LOG_TRACE(this, "http request: {}", dump_request(req));
     overall_.cluster_ref()->execute(req, [this, cb = std::move(cb)](core::operations::query_response resp) mutable {
-        trace("response: {} status: {}", resp.ctx.http_body, resp.meta.status);
+        CB_ATTEMPT_CTX_LOG_TRACE(this, "response: {} status: {}", resp.ctx.http_body, resp.meta.status);
         if (auto ec = hooks_.after_query(this, resp.ctx.statement)) {
             auto err = std::make_exception_ptr(transaction_operation_failed(*ec, "after_query hook raised error"));
             return cb(err, {});
@@ -1017,34 +1039,38 @@ attempt_context_impl::wrap_query(const std::string& statement,
 void
 attempt_context_impl::query(const std::string& statement,
                             const couchbase::transactions::transaction_query_options& options,
+                            std::optional<std::string> query_context,
                             QueryCallback&& cb)
 {
     return cache_error_async(cb, [&]() {
         check_if_done(cb);
         // decrement in_flight, as we just incremented it in cache_error_async.
         op_list_.set_query_mode(
-          [this, statement, options, cb]() mutable {
-              // set query context if set in query options.
-              if (auto query_context = options.get_query_options().build().scope_qualifier; query_context) {
+          [this, statement, options, query_context, cb]() mutable {
+              // set query context if set
+              if (query_context) {
                   query_context_ = query_context.value();
               }
-              query_begin_work([this, statement, options, cb = std::move(cb)](std::exception_ptr err) mutable {
-                  if (err) {
-                      return op_completed_with_error(std::move(cb), err);
-                  }
-                  return do_query(statement, options, std::move(cb));
-              });
+              query_begin_work(query_context,
+                               [this, statement, query_context, options, cb = std::move(cb)](std::exception_ptr err) mutable {
+                                   if (err) {
+                                       return op_completed_with_error(std::move(cb), err);
+                                   }
+                                   return do_query(statement, options, query_context, std::move(cb));
+                               });
           },
-          [this, statement, options, cb]() mutable { return do_query(statement, options, std::move(cb)); });
+          [this, statement, options, query_context, cb]() mutable { return do_query(statement, options, query_context, std::move(cb)); });
     });
 }
 
 core::operations::query_response
-attempt_context_impl::do_core_query(const std::string& statement, const couchbase::transactions::transaction_query_options& options)
+attempt_context_impl::do_core_query(const std::string& statement,
+                                    const couchbase::transactions::transaction_query_options& options,
+                                    std::optional<std::string> query_context)
 {
     auto barrier = std::make_shared<std::promise<core::operations::query_response>>();
     auto f = barrier->get_future();
-    query(statement, options, [barrier](std::exception_ptr err, std::optional<core::operations::query_response> resp) {
+    query(statement, options, query_context, [barrier](std::exception_ptr err, std::optional<core::operations::query_response> resp) {
         if (err) {
             return barrier->set_exception(err);
         }
@@ -1053,20 +1079,22 @@ attempt_context_impl::do_core_query(const std::string& statement, const couchbas
     return f.get();
 }
 
-couchbase::transactions::transaction_query_result_ptr
-attempt_context_impl::do_public_query(const std::string& statement, const couchbase::transactions::transaction_query_options& opts)
+std::pair<couchbase::transaction_op_error_context, couchbase::transactions::transaction_query_result>
+attempt_context_impl::do_public_query(const std::string& statement,
+                                      const couchbase::transactions::transaction_query_options& opts,
+                                      std::optional<std::string> query_context)
 {
     try {
-        auto result = do_core_query(statement, opts);
-        return std::make_shared<couchbase::transactions::transaction_query_result>(core::impl::build_transaction_query_result(result));
+        auto result = do_core_query(statement, opts, query_context);
+        return core::impl::build_transaction_query_result(result);
     } catch (const transaction_operation_failed& e) {
-        return std::make_shared<couchbase::transactions::transaction_query_result>(e.get_error_ctx());
+        return { e.get_error_ctx(), {} };
     } catch (const op_exception& qe) {
-        return std::make_shared<couchbase::transactions::transaction_query_result>(qe.ctx());
+        return { qe.ctx(), {} };
     } catch (...) {
         // should not be necessary, but just in case...
         transaction_op_error_context ctx(couchbase::errc::transaction_op::unknown);
-        return std::make_shared<couchbase::transactions::transaction_query_result>(ctx);
+        return { ctx, {} };
     }
 }
 
@@ -1110,6 +1138,7 @@ attempt_context_impl::get_with_query(const core::document_id& id, bool optional,
                           make_kv_txdata(),
                           STAGE_QUERY_KV_GET,
                           true,
+                          {},
                           [this, id, optional, cb = std::move(cb)](std::exception_ptr err, core::operations::query_response resp) mutable {
                               if (resp.ctx.ec == couchbase::errc::key_value::document_not_found) {
                                   return op_completed_with_callback(std::move(cb), std::optional<transaction_get_result>());
@@ -1118,10 +1147,13 @@ attempt_context_impl::get_with_query(const core::document_id& id, bool optional,
                                   // make a transaction_get_result from the row...
                                   try {
                                       if (resp.rows.empty()) {
+                                          if (optional) {
+                                              return op_completed_with_callback(std::move(cb), std::optional<transaction_get_result>());
+                                          }
                                           return op_completed_with_error(
                                             std::move(cb), transaction_operation_failed(FAIL_DOC_NOT_FOUND, "document not found"));
                                       }
-                                      trace("get_with_query got: {}", resp.rows.front());
+                                      CB_ATTEMPT_CTX_LOG_TRACE(this, "get_with_query got: {}", resp.rows.front());
                                       transaction_get_result doc(id, core::utils::json::parse(resp.rows.front()));
                                       return op_completed_with_callback(std::move(cb), std::optional<transaction_get_result>(doc));
                                   } catch (const std::exception& e) {
@@ -1157,6 +1189,7 @@ attempt_context_impl::insert_raw_with_query(const core::document_id& id, const s
                           make_kv_txdata(),
                           STAGE_QUERY_KV_INSERT,
                           true,
+                          {},
                           [this, id, cb = std::move(cb)](std::exception_ptr err, core::operations::query_response resp) mutable {
                               if (err) {
                                   try {
@@ -1175,7 +1208,7 @@ attempt_context_impl::insert_raw_with_query(const core::document_id& id, const s
                               }
                               // make a transaction_get_result from the row...
                               try {
-                                  trace("insert_raw_with_query got: {}", resp.rows.front());
+                                  CB_ATTEMPT_CTX_LOG_TRACE(this, "insert_raw_with_query got: {}", resp.rows.front());
                                   transaction_get_result doc(id, core::utils::json::parse(resp.rows.front()));
                                   return op_completed_with_callback(std::move(cb), std::optional<transaction_get_result>(doc));
                               } catch (const std::exception& e) {
@@ -1200,6 +1233,7 @@ attempt_context_impl::replace_raw_with_query(const transaction_get_result& docum
           make_kv_txdata(document),
           STAGE_QUERY_KV_REPLACE,
           true,
+          {},
           [this, id = document.id(), cb = std::move(cb)](std::exception_ptr err, core::operations::query_response resp) mutable {
               if (err) {
                   try {
@@ -1218,7 +1252,7 @@ attempt_context_impl::replace_raw_with_query(const transaction_get_result& docum
               }
               // make a transaction_get_result from the row...
               try {
-                  trace("replace_raw_with_query got: {}", resp.rows.front());
+                  CB_ATTEMPT_CTX_LOG_TRACE(this, "replace_raw_with_query got: {}", resp.rows.front());
                   transaction_get_result doc(id, core::utils::json::parse(resp.rows.front()));
                   return op_completed_with_callback(std::move(cb), std::optional<transaction_get_result>(doc));
               } catch (const std::exception& e) {
@@ -1242,6 +1276,7 @@ attempt_context_impl::remove_with_query(const transaction_get_result& document,
           make_kv_txdata(document),
           STAGE_QUERY_KV_REMOVE,
           true,
+          {},
           [this, id = document.id(), cb = std::move(cb)](std::exception_ptr err, core::operations::query_response /* resp */) mutable {
               if (err) {
                   try {
@@ -1268,7 +1303,7 @@ void
 attempt_context_impl::commit_with_query(VoidCallback&& cb)
 {
     core::operations::query_request req;
-    trace("commit_with_query called");
+    CB_ATTEMPT_CTX_LOG_TRACE(this, "commit_with_query called");
     couchbase::transactions::transaction_query_options opts;
     std::vector<core::json_string> params;
     wrap_query(
@@ -1278,6 +1313,7 @@ attempt_context_impl::commit_with_query(VoidCallback&& cb)
       make_kv_txdata(std::nullopt),
       STAGE_QUERY_COMMIT,
       true,
+      {},
       [this, cb = std::move(cb)](std::exception_ptr err, core::operations::query_response /* resp */) mutable {
           is_done_ = true;
           if (err) {
@@ -1305,7 +1341,7 @@ void
 attempt_context_impl::rollback_with_query(VoidCallback&& cb)
 {
     core::operations::query_request req;
-    trace("rollback_with_query called");
+    CB_ATTEMPT_CTX_LOG_TRACE(this, "rollback_with_query called");
     couchbase::transactions::transaction_query_options opts;
     std::vector<core::json_string> params;
     wrap_query(ROLLBACK,
@@ -1314,6 +1350,7 @@ attempt_context_impl::rollback_with_query(VoidCallback&& cb)
                make_kv_txdata(std::nullopt),
                STAGE_QUERY_ROLLBACK,
                true,
+               {},
                [this, cb = std::move(cb)](std::exception_ptr err, core::operations::query_response /* resp */) mutable {
                    is_done_ = true;
                    if (err) {
@@ -1322,13 +1359,14 @@ attempt_context_impl::rollback_with_query(VoidCallback&& cb)
                        } catch (const transaction_operation_failed&) {
                            return cb(std::current_exception());
                        } catch (const query_attempt_not_found& e) {
-                           debug("got query_attempt_not_found, assuming query was already rolled back successfullly: {}", e.what());
+                           CB_ATTEMPT_CTX_LOG_DEBUG(
+                             this, "got query_attempt_not_found, assuming query was already rolled back successfullly: {}", e.what());
                        } catch (const std::exception& e) {
                            return cb(std::make_exception_ptr(transaction_operation_failed(FAIL_OTHER, e.what()).no_rollback()));
                        }
                    }
                    state(attempt_state::ROLLED_BACK);
-                   trace("rollback successful");
+                   CB_ATTEMPT_CTX_LOG_TRACE(this, "rollback successful");
                    return cb({});
                });
 }
@@ -1358,7 +1396,7 @@ attempt_context_impl::atr_commit(bool ambiguity_resolution_mode)
             staged_mutations_->extract_to(prefix, req);
             auto barrier = std::make_shared<std::promise<result>>();
             auto f = barrier->get_future();
-            trace("updating atr {}, setting to {}", req.id, attempt_state_name(attempt_state::COMMITTED));
+            CB_ATTEMPT_CTX_LOG_TRACE(this, "updating atr {}, setting to {}", req.id, attempt_state_name(attempt_state::COMMITTED));
             overall_.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, false);
@@ -1381,7 +1419,7 @@ attempt_context_impl::atr_commit(bool ambiguity_resolution_mode)
                     throw out;
                 }
                 case FAIL_AMBIGUOUS:
-                    debug("atr_commit got FAIL_AMBIGUOUS, resolving ambiguity...");
+                    CB_ATTEMPT_CTX_LOG_DEBUG(this, "atr_commit got FAIL_AMBIGUOUS, resolving ambiguity...");
                     ambiguity_resolution_mode = true;
                     throw retry_operation(e.what());
                 case FAIL_TRANSIENT:
@@ -1427,11 +1465,12 @@ attempt_context_impl::atr_commit(bool ambiguity_resolution_mode)
                     throw out;
                 }
                 default: {
-                    error("failed to commit transaction {}, attempt {}, ambiguity_resolution_mode {}, with error {}",
-                          transaction_id(),
-                          id(),
-                          ambiguity_resolution_mode,
-                          e.what());
+                    CB_ATTEMPT_CTX_LOG_ERROR(this,
+                                             "failed to commit transaction {}, attempt {}, ambiguity_resolution_mode {}, with error {}",
+                                             transaction_id(),
+                                             id(),
+                                             ambiguity_resolution_mode,
+                                             e.what());
                     auto out = transaction_operation_failed(ec, e.what());
                     if (ambiguity_resolution_mode) {
                         out.no_rollback().ambiguous();
@@ -1464,7 +1503,7 @@ attempt_context_impl::atr_commit_ambiguity_resolution()
           req, [barrier](core::operations::lookup_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         auto res = wrap_operation_future(f);
         auto atr_status_raw = res.values[0].content_as<std::string>();
-        debug("atr_commit_ambiguity_resolution read atr state {}", atr_status_raw);
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "atr_commit_ambiguity_resolution read atr state {}", atr_status_raw);
         auto atr_status = attempt_state_value(atr_status_raw);
         switch (atr_status) {
             case attempt_state::COMMITTED:
@@ -1510,7 +1549,7 @@ attempt_context_impl::atr_complete()
         if (!!(ec = error_if_expired_and_not_in_overtime(STAGE_ATR_COMPLETE, {}))) {
             throw client_error(*ec, "atr_complete threw error");
         }
-        debug("removing attempt {} from atr", atr_id_.value());
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "removing attempt {} from atr", atr_id_.value());
         std::string prefix(ATR_FIELD_ATTEMPTS + "." + id());
         core::operations::mutate_in_request req{ atr_id_.value() };
         req.specs =
@@ -1535,7 +1574,7 @@ attempt_context_impl::atr_complete()
             case FAIL_HARD:
                 throw transaction_operation_failed(ec, er.what()).no_rollback().failed_post_commit();
             default:
-                info("ignoring error in atr_complete {}", er.what());
+                CB_ATTEMPT_CTX_LOG_INFO(this, "ignoring error in atr_complete {}", er.what());
         }
     }
 }
@@ -1558,10 +1597,10 @@ attempt_context_impl::commit(VoidCallback&& cb)
 void
 attempt_context_impl::commit()
 {
-    debug("waiting on ops to finish...");
+    CB_ATTEMPT_CTX_LOG_DEBUG(this, "waiting on ops to finish...");
     op_list_.wait_and_block_ops();
     existing_error(false);
-    debug("commit {}", id());
+    CB_ATTEMPT_CTX_LOG_DEBUG(this, "commit {}", id());
     if (op_list_.get_mode().is_query()) {
         auto barrier = std::make_shared<std::promise<void>>();
         auto f = barrier->get_future();
@@ -1579,13 +1618,13 @@ attempt_context_impl::commit()
         }
         if (atr_id_ && !atr_id_->key().empty() && !is_done_) {
             retry_op_exp<void>([&]() { atr_commit(false); });
-            staged_mutations_->commit(*this);
+            staged_mutations_->commit(this);
             atr_complete();
             is_done_ = true;
         } else {
             // no mutation, no need to commit
             if (!is_done_) {
-                debug("calling commit on attempt that has got no mutations, skipping");
+                CB_ATTEMPT_CTX_LOG_DEBUG(this, "calling commit on attempt that has got no mutations, skipping");
                 is_done_ = true;
                 return;
             } // do not rollback or retry
@@ -1629,17 +1668,17 @@ attempt_context_impl::atr_abort()
         if (ec) {
             throw client_error(*ec, "after_atr_aborted hook threw error");
         }
-        debug("rollback completed atr abort phase");
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "rollback completed atr abort phase");
     } catch (const client_error& e) {
         auto ec = e.ec();
-        trace("atr_abort got {} {}", ec, e.what());
+        CB_ATTEMPT_CTX_LOG_TRACE(this, "atr_abort got {} {}", ec, e.what());
         if (expiry_overtime_mode_.load()) {
-            debug("atr_abort got error \"{}\" while in overtime mode", e.what());
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "atr_abort got error \"{}\" while in overtime mode", e.what());
             throw transaction_operation_failed(FAIL_EXPIRY, std::string("expired in atr_abort with {} ") + e.what())
               .no_rollback()
               .expired();
         }
-        debug("atr_abort got error {}", ec);
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "atr_abort got error {}", ec);
         switch (ec) {
             case FAIL_EXPIRY:
                 expiry_overtime_mode_ = true;
@@ -1692,28 +1731,28 @@ attempt_context_impl::atr_rollback_complete()
     } catch (const client_error& e) {
         auto ec = e.ec();
         if (expiry_overtime_mode_.load()) {
-            debug("atr_rollback_complete error while in overtime mode {}", e.what());
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "atr_rollback_complete error while in overtime mode {}", e.what());
             throw transaction_operation_failed(FAIL_EXPIRY, std::string("expired in atr_rollback_complete with {} ") + e.what())
               .no_rollback()
               .expired();
         }
-        debug("atr_rollback_complete got error {}", ec);
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "atr_rollback_complete got error {}", ec);
         switch (ec) {
             case FAIL_DOC_NOT_FOUND:
             case FAIL_PATH_NOT_FOUND:
-                debug("atr {} not found, ignoring", atr_id_->key());
+                CB_ATTEMPT_CTX_LOG_DEBUG(this, "atr {} not found, ignoring", atr_id_->key());
                 is_done_ = true;
                 break;
             case FAIL_ATR_FULL:
-                debug("atr {} full!", atr_id_->key());
+                CB_ATTEMPT_CTX_LOG_DEBUG(this, "atr {} full!", atr_id_->key());
                 throw retry_operation(e.what());
             case FAIL_HARD:
                 throw transaction_operation_failed(ec, e.what()).no_rollback();
             case FAIL_EXPIRY:
-                debug("timed out writing atr {}", atr_id_->key());
+                CB_ATTEMPT_CTX_LOG_DEBUG(this, "timed out writing atr {}", atr_id_->key());
                 throw transaction_operation_failed(ec, e.what()).no_rollback().expired();
             default:
-                debug("retrying atr_rollback_complete");
+                CB_ATTEMPT_CTX_LOG_DEBUG(this, "retrying atr_rollback_complete");
                 throw retry_operation(e.what());
         }
     }
@@ -1743,7 +1782,7 @@ void
 attempt_context_impl::rollback()
 {
     op_list_.wait_and_block_ops();
-    debug("rolling back {}", id());
+    CB_ATTEMPT_CTX_LOG_DEBUG(this, "rolling back {}", id());
     if (op_list_.get_mode().is_query()) {
         auto barrier = std::make_shared<std::promise<void>>();
         auto f = barrier->get_future();
@@ -1760,13 +1799,13 @@ attempt_context_impl::rollback()
     check_expiry_during_commit_or_rollback(STAGE_ROLLBACK, std::nullopt);
     if (!atr_id_ || atr_id_->key().empty() || state() == attempt_state::NOT_STARTED) {
         // TODO: check this, but if we try to rollback an empty txn, we should prevent a subsequent commit
-        debug("rollback called on txn with no mutations");
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "rollback called on txn with no mutations");
         is_done_ = true;
         return;
     }
     if (is_done()) {
         std::string msg("Transaction already done, cannot rollback");
-        error(msg);
+        CB_ATTEMPT_CTX_LOG_ERROR(this, msg);
         // need to raise a FAIL_OTHER which is not retryable or rollback-able
         throw transaction_operation_failed(FAIL_OTHER, msg).no_rollback();
     }
@@ -1774,14 +1813,14 @@ attempt_context_impl::rollback()
         // (1) atr_abort
         retry_op_exp<void>([&]() { atr_abort(); });
         // (2) rollback staged mutations
-        staged_mutations_->rollback(*this);
-        debug("rollback completed unstaging docs");
+        staged_mutations_->rollback(this);
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "rollback completed unstaging docs");
 
         // (3) atr_rollback
         retry_op_exp<void>([&]() { atr_rollback_complete(); });
     } catch (const client_error& e) {
         error_class ec = e.ec();
-        error("rollback transaction {}, attempt {} fail with error {}", transaction_id(), id(), e.what());
+        CB_ATTEMPT_CTX_LOG_ERROR(this, "rollback transaction {}, attempt {} fail with error {}", transaction_id(), id(), e.what());
         if (ec == FAIL_HARD) {
             throw transaction_operation_failed(ec, e.what()).no_rollback();
         }
@@ -1794,10 +1833,10 @@ attempt_context_impl::has_expired_client_side(std::string place, std::optional<c
     bool over = overall_.has_expired_client_side();
     bool hook = hooks_.has_expired_client_side(this, place, doc_id);
     if (over) {
-        debug("{} expired in {}", id(), place);
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "{} expired in {}", id(), place);
     }
     if (hook) {
-        debug("{} fake expiry in {}", id(), place);
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "{} fake expiry in {}", id(), place);
     }
     return over || hook;
 }
@@ -1806,7 +1845,8 @@ bool
 attempt_context_impl::check_expiry_pre_commit(std::string stage, std::optional<const std::string> doc_id)
 {
     if (has_expired_client_side(stage, std::move(doc_id))) {
-        debug("{} has expired in stage {}, entering expiry-overtime mode - will make one attempt to rollback", id(), stage);
+        CB_ATTEMPT_CTX_LOG_DEBUG(
+          this, "{} has expired in stage {}, entering expiry-overtime mode - will make one attempt to rollback", id(), stage);
 
         // [EXP-ROLLBACK] Combo of setting this mode and throwing AttemptExpired will result in an attempt to rollback, which will
         // ignore expiry, and bail out if anything fails
@@ -1820,11 +1860,11 @@ std::optional<error_class>
 attempt_context_impl::error_if_expired_and_not_in_overtime(const std::string& stage, std::optional<const std::string> doc_id)
 {
     if (expiry_overtime_mode_.load()) {
-        debug("not doing expired check in {} as already in expiry-overtime", stage);
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "not doing expired check in {} as already in expiry-overtime", stage);
         return {};
     }
     if (has_expired_client_side(stage, std::move(doc_id))) {
-        debug("expired in {}", stage);
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "expired in {}", stage);
         return FAIL_EXPIRY;
     }
     return {};
@@ -1836,11 +1876,12 @@ attempt_context_impl::check_expiry_during_commit_or_rollback(const std::string&
     // [EXP-COMMIT-OVERTIME]
     if (!expiry_overtime_mode_.load()) {
         if (has_expired_client_side(stage, std::move(doc_id))) {
-            debug("{} has expired in stage {}, entering expiry-overtime mode (one attempt to complete commit)", id(), stage);
+            CB_ATTEMPT_CTX_LOG_DEBUG(
+              this, "{} has expired in stage {}, entering expiry-overtime mode (one attempt to complete commit)", id(), stage);
             expiry_overtime_mode_ = true;
         }
     } else {
-        debug("{} ignoring expiry in stage {}  as in expiry-overtime mode", id(), stage);
+        CB_ATTEMPT_CTX_LOG_DEBUG(this, "{} ignoring expiry in stage {}  as in expiry-overtime mode", id(), stage);
     }
 }
 template<typename Handler>
@@ -1859,7 +1900,7 @@ attempt_context_impl::set_atr_pending_locked(const core::document_id& id, std::u
             auto error_handler =
               [this, &lock](error_class ec, const std::string& message, const core::document_id& doc_id, Handler&& fn) mutable {
                   transaction_operation_failed err(ec, message);
-                  trace("got {} trying to set atr to pending", message);
+                  CB_ATTEMPT_CTX_LOG_TRACE(this, "got {} trying to set atr to pending", message);
                   if (expiry_overtime_mode_.load()) {
                       return fn(err.no_rollback().expired());
                   }
@@ -1875,10 +1916,10 @@ attempt_context_impl::set_atr_pending_locked(const core::document_id& id, std::u
                           return fn(std::nullopt);
                       case FAIL_AMBIGUOUS:
                           // Retry just this
-                          overall_.retry_delay();
-                          // keep it locked!
-                          debug("got {}, retrying set atr pending", ec);
-                          return set_atr_pending_locked(doc_id, std::move(lock), std::move(fn));
+                          CB_ATTEMPT_CTX_LOG_DEBUG(this, "got FAIL_AMBIGUOUS, retrying set atr pending", ec);
+                          return overall_.after_delay(std::chrono::milliseconds(1), [this, doc_id, &lock, fn = std::move(fn)]() {
+                              set_atr_pending_locked(doc_id, std::move(lock), std::move(fn));
+                          });
                       case FAIL_TRANSIENT:
                           // Retry txn
                           return fn(err.retry());
@@ -1891,10 +1932,8 @@ attempt_context_impl::set_atr_pending_locked(const core::document_id& id, std::u
             if (auto ec = hooks_.before_atr_pending(this); ec) {
                 return error_handler(*ec, "before_atr_pending hook raised error", id, std::forward<Handler>(fn));
             }
-            debug("updating atr {}", atr_id_.value());
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "updating atr {}", atr_id_.value());
 
-            // FIXME: do we need to capture "now" here?
-            // std::chrono::time_point<std::chrono::steady_clock> now = std::chrono::steady_clock::now();
             std::chrono::nanoseconds remaining = overall_.remaining();
             // This bounds the value to [0-expirationTime].  It should always be in this range, this is just to protect
             // against the application clock changing.
@@ -1935,7 +1974,7 @@ attempt_context_impl::set_atr_pending_locked(const core::document_id& id, std::u
                   }
                   if (!ec) {
                       state(attempt_state::PENDING);
-                      debug("set ATR {} to Pending, got CAS (start time) {}", atr_id_.value(), resp.cas.value());
+                      CB_ATTEMPT_CTX_LOG_DEBUG(this, "set ATR {} to Pending, got CAS (start time) {}", atr_id_.value(), resp.cas.value());
                       return fn(std::nullopt);
                   }
                   return error_handler(*ec,
@@ -1945,7 +1984,7 @@ attempt_context_impl::set_atr_pending_locked(const core::document_id& id, std::u
               });
         }
     } catch (const std::exception& e) {
-        error("unexpected error setting atr pending {}", e.what());
+        CB_ATTEMPT_CTX_LOG_ERROR(this, "unexpected error setting atr pending {}", e.what());
         return fn(transaction_operation_failed(FAIL_OTHER, "unexpected error setting atr pending"));
     }
 }
@@ -1986,13 +2025,13 @@ attempt_context_impl::do_get(const core::document_id& id, const std::optional<st
 
         staged_mutation* own_write = check_for_own_write(id);
         if (own_write) {
-            debug("found own-write of mutated doc {}", id);
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "found own-write of mutated doc {}", id);
             return cb(std::nullopt, std::nullopt, transaction_get_result::create_from(own_write->doc(), own_write->content()));
         }
         staged_mutation* own_remove = staged_mutations_->find_remove(id);
         if (own_remove) {
             auto msg = fmt::format("found own-write of removed doc {}", id);
-            debug(msg);
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, msg);
             return cb(FAIL_DOC_NOT_FOUND, msg, std::nullopt);
         }
 
@@ -2010,11 +2049,12 @@ attempt_context_impl::do_get(const core::document_id& id, const std::optional<st
               }
               if (!ec) {
                   if (doc->links().is_document_in_transaction()) {
-                      debug("doc {} in transaction, resolving_missing_atr_entry={}", *doc, resolving_missing_atr_entry.value_or("-"));
+                      CB_ATTEMPT_CTX_LOG_DEBUG(
+                        this, "doc {} in transaction, resolving_missing_atr_entry={}", *doc, resolving_missing_atr_entry.value_or("-"));
 
                       if (resolving_missing_atr_entry.has_value() &&
                           resolving_missing_atr_entry.value() == doc->links().staged_attempt_id()) {
-                          debug("doc is in lost pending transaction");
+                          CB_ATTEMPT_CTX_LOG_DEBUG(this, "doc is in lost pending transaction");
 
                           if (doc->links().is_document_being_inserted()) {
                               // this document is being inserted, so should not be visible yet
@@ -2072,8 +2112,9 @@ attempt_context_impl::do_get(const core::document_id& id, const std::optional<st
                                     }
                                 } else {
                                     // failed to get the ATR entry
-                                    debug("could not get ATR entry, checking again with {}",
-                                          doc->links().staged_attempt_id().value_or("-"));
+                                    CB_ATTEMPT_CTX_LOG_DEBUG(this,
+                                                             "could not get ATR entry, checking again with {}",
+                                                             doc->links().staged_attempt_id().value_or("-"));
                                     return do_get(id, doc->links().staged_attempt_id(), cb);
                                 }
                                 if (ignore_doc) {
@@ -2083,13 +2124,14 @@ attempt_context_impl::do_get(const core::document_id& id, const std::optional<st
 
                             } else {
                                 // failed to get the ATR
-                                debug("could not get ATR, checking again with {}", doc->links().staged_attempt_id().value_or("-"));
+                                CB_ATTEMPT_CTX_LOG_DEBUG(
+                                  this, "could not get ATR, checking again with {}", doc->links().staged_attempt_id().value_or("-"));
                                 return do_get(id, doc->links().staged_attempt_id(), cb);
                             }
                         });
                   } else {
                       if (doc->links().is_deleted()) {
-                          debug("doc not in txn, and is_deleted, so not returning it.");
+                          CB_ATTEMPT_CTX_LOG_DEBUG(this, "doc not in txn, and is_deleted, so not returning it.");
                           // doc has been deleted, not in txn, so don't return it
                           return cb(std::nullopt, std::nullopt, std::nullopt);
                       }
@@ -2120,6 +2162,7 @@ attempt_context_impl::get_doc(
           lookup_in_specs::get(ATR_ID).xattr(),
           lookup_in_specs::get(TRANSACTION_ID).xattr(),
           lookup_in_specs::get(ATTEMPT_ID).xattr(),
+          lookup_in_specs::get(OPERATION_ID).xattr(),
           lookup_in_specs::get(STAGED_DATA).xattr(),
           lookup_in_specs::get(ATR_BUCKET_NAME).xattr(),
           lookup_in_specs::get(ATR_SCOPE_NAME).xattr(),
@@ -2138,7 +2181,7 @@ attempt_context_impl::get_doc(
         overall_.cluster_ref()->execute(req, [this, id, cb = std::move(cb)](core::operations::lookup_in_response resp) {
             auto ec = error_class_from_response(resp);
             if (ec) {
-                trace("get_doc got error {} : {}", resp.ctx.ec().message(), *ec);
+                CB_ATTEMPT_CTX_LOG_TRACE(this, "get_doc got error {} : {}", resp.ctx.ec().message(), *ec);
                 switch (*ec) {
                     case FAIL_PATH_NOT_FOUND:
                         return cb(*ec, resp.ctx.ec().message(), transaction_get_result::create_from(resp));
@@ -2160,11 +2203,12 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
                                                          const std::vector<std::byte>& content,
                                                          uint64_t cas,
                                                          Delay&& delay,
+                                                         const std::string& op_id,
                                                          Handler&& cb,
                                                          error_class ec,
                                                          const std::string& message)
 {
-    trace("create_staged_insert got error class {}: {}", ec, message);
+    CB_ATTEMPT_CTX_LOG_TRACE(this, "create_staged_insert got error class {}: {}", ec, message);
     if (expiry_overtime_mode_.load()) {
         return op_completed_with_error(std::forward<Handler>(cb), transaction_operation_failed(FAIL_EXPIRY, "attempt timed out").expired());
     }
@@ -2176,9 +2220,9 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
             return op_completed_with_error(std::forward<Handler>(cb),
                                            transaction_operation_failed(ec, "transient error in insert").retry());
         case FAIL_AMBIGUOUS:
-            debug("FAIL_AMBIGUOUS in create_staged_insert, retrying");
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "FAIL_AMBIGUOUS in create_staged_insert, retrying");
             delay();
-            return create_staged_insert(id, content, cas, delay, std::forward<Handler>(cb));
+            return create_staged_insert(id, content, cas, delay, op_id, std::forward<Handler>(cb));
         case FAIL_OTHER:
             return op_completed_with_error(std::forward<Handler>(cb), transaction_operation_failed(ec, "error in create_staged_insert"));
         case FAIL_HARD:
@@ -2187,9 +2231,10 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
         case FAIL_DOC_ALREADY_EXISTS:
         case FAIL_CAS_MISMATCH: {
             // special handling for doc already existing
-            debug("found existing doc {}, may still be able to insert", id);
-            auto error_handler = [this, id, content](error_class ec2, const std::string& err_message, Handler&& cb) mutable {
-                trace("after a CAS_MISMATCH or DOC_ALREADY_EXISTS, then got error {} in create_staged_insert", ec2);
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "found existing doc {}, may still be able to insert", id);
+            auto error_handler = [this, id, op_id, content](error_class ec2, const std::string& err_message, Handler&& cb) mutable {
+                CB_ATTEMPT_CTX_LOG_TRACE(
+                  this, "after a CAS_MISMATCH or DOC_ALREADY_EXISTS, then got error {} in create_staged_insert", ec2);
                 if (expiry_overtime_mode_.load()) {
                     return op_completed_with_error(std::move(cb), transaction_operation_failed(FAIL_EXPIRY, "attempt timed out").expired());
                 }
@@ -2213,14 +2258,15 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
             }
             return get_doc(
               id,
-              [this, id, content, cb = std::forward<Handler>(cb), error_handler, delay](
+              [this, id, content, op_id, cb = std::forward<Handler>(cb), error_handler, delay](
                 std::optional<error_class> ec3, std::optional<std::string> err_message, std::optional<transaction_get_result> doc) mutable {
                   if (!ec3) {
                       if (doc) {
-                          debug("document {} exists, is_in_transaction {}, is_deleted {} ",
-                                doc->id(),
-                                doc->links().is_document_in_transaction(),
-                                doc->links().is_deleted());
+                          CB_ATTEMPT_CTX_LOG_DEBUG(this,
+                                                   "document {} exists, is_in_transaction {}, is_deleted {} ",
+                                                   doc->id(),
+                                                   doc->links().is_document_in_transaction(),
+                                                   doc->links().is_deleted());
 
                           if (auto err = forward_compat::check(forward_compat_stage::WWC_INSERTING_GET, doc->links().forward_compat());
                               err) {
@@ -2228,17 +2274,30 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
                           }
                           if (!doc->links().is_document_in_transaction() && doc->links().is_deleted()) {
                               // it is just a deleted doc, so we are ok.  Let's try again, but with the cas
-                              debug("create staged insert found existing deleted doc, retrying with cas {}", doc->cas().value());
+                              CB_ATTEMPT_CTX_LOG_DEBUG(
+                                this, "create staged insert found existing deleted doc, retrying with cas {}", doc->cas().value());
                               delay();
-                              return create_staged_insert(id, content, doc->cas().value(), delay, std::forward<Handler>(cb));
+                              return create_staged_insert(id, content, doc->cas().value(), delay, op_id, std::forward<Handler>(cb));
                           }
                           if (!doc->links().is_document_in_transaction()) {
                               // doc was inserted outside txn elsewhere
-                              trace("doc {} not in txn - was inserted outside txn", id);
+                              CB_ATTEMPT_CTX_LOG_TRACE(this, "doc {} not in txn - was inserted outside txn", id);
                               return op_completed_with_error(
                                 std::forward<Handler>(cb),
                                 document_exists({ couchbase::errc::transaction_op::document_exists_exception, key_value_error_context() }));
                           }
+                          if (doc->links().staged_attempt_id() == this->id()) {
+                              if (doc->links().staged_operation_id() == op_id) {
+                                  // this is us dealing with resolving an ambiguity.  So, lets just update the staged_mutation with the
+                                  // correct cas and continue...
+                                  staged_mutations_->add(staged_mutation(*doc, content, staged_mutation_type::INSERT));
+                                  return op_completed_with_callback(std::forward<Handler>(cb), doc);
+                              }
+                              return op_completed_with_error(
+                                std::forward<Handler>(cb),
+                                transaction_operation_failed(FAIL_OTHER, "concurrent operations on a document are not allowed")
+                                  .cause(CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT));
+                          }
                           // CBD-3787 - Only a staged insert is ok to overwrite
                           if (doc->links().op() && *doc->links().op() != "insert") {
                               return op_completed_with_error(
@@ -2249,18 +2308,19 @@ attempt_context_impl::create_staged_insert_error_handler(const core::document_id
                           check_and_handle_blocking_transactions(
                             *doc,
                             forward_compat_stage::WWC_INSERTING,
-                            [this, id, content, doc, cb = std::forward<Handler>(cb), delay](
+                            [this, id, op_id, content, doc, cb = std::forward<Handler>(cb), delay](
                               std::optional<transaction_operation_failed> err) mutable {
                                 if (err) {
                                     return op_completed_with_error(std::move(cb), *err);
                                 }
-                                debug("doc ok to overwrite, retrying create_staged_insert with cas {}", doc->cas().value());
+                                CB_ATTEMPT_CTX_LOG_DEBUG(
+                                  this, "doc ok to overwrite, retrying create_staged_insert with cas {}", doc->cas().value());
                                 delay();
-                                return create_staged_insert(id, content, doc->cas().value(), delay, std::forward<Handler>(cb));
+                                return create_staged_insert(id, content, doc->cas().value(), delay, op_id, std::forward<Handler>(cb));
                             });
                       } else {
                           // no doc now, just retry entire txn
-                          trace("got {} from get_doc in exists during staged insert", *ec3);
+                          CB_ATTEMPT_CTX_LOG_TRACE(this, "got {} from get_doc in exists during staged insert", *ec3);
                           return op_completed_with_error(
                             std::move(cb),
                             transaction_operation_failed(FAIL_DOC_NOT_FOUND, "insert failed as the doc existed, but now seems to not exist")
@@ -2283,20 +2343,27 @@ attempt_context_impl::create_staged_insert(const core::document_id& id,
                                            const std::vector<std::byte>& content,
                                            uint64_t cas,
                                            Delay&& delay,
+                                           const std::string& op_id,
                                            Handler&& cb)
 {
 
     if (auto ec = error_if_expired_and_not_in_overtime(STAGE_CREATE_STAGED_INSERT, id.key()); ec) {
-        return create_staged_insert_error_handler(
-          id, content, cas, std::forward<Delay>(delay), std::forward<Handler>(cb), *ec, "create_staged_insert expired and not in overtime");
+        return create_staged_insert_error_handler(id,
+                                                  content,
+                                                  cas,
+                                                  std::forward<Delay>(delay),
+                                                  op_id,
+                                                  std::forward<Handler>(cb),
+                                                  *ec,
+                                                  "create_staged_insert expired and not in overtime");
     }
 
     if (auto ec = hooks_.before_staged_insert(this, id.key()); ec) {
         return create_staged_insert_error_handler(
-          id, content, cas, std::forward<Delay>(delay), std::forward<Handler>(cb), *ec, "before_staged_insert hook threw error");
+          id, content, cas, std::forward<Delay>(delay), op_id, std::forward<Handler>(cb), *ec, "before_staged_insert hook threw error");
     }
-    debug("about to insert staged doc {} with cas {}", id, cas);
-    auto req = create_staging_request(id, nullptr, "insert", content);
+    CB_ATTEMPT_CTX_LOG_DEBUG(this, "about to insert staged doc {} with cas {}", id, cas);
+    auto req = create_staging_request(id, nullptr, "insert", op_id, content);
     req.access_deleted = true;
     req.create_as_deleted = true;
     req.cas = couchbase::cas(cas);
@@ -2304,14 +2371,16 @@ attempt_context_impl::create_staged_insert(const core::document_id& id,
     wrap_durable_request(req, overall_.config());
     overall_.cluster_ref()->execute(
       req,
-      [this, id, content, cas, cb = std::forward<Handler>(cb), delay = std::forward<Delay>(delay)](
+      [this, id, content, cas, op_id, cb = std::forward<Handler>(cb), delay = std::forward<Delay>(delay)](
         core::operations::mutate_in_response resp) mutable {
-          if (auto ec = hooks_.after_staged_insert_complete(this, id.key()); ec) {
+          auto ec = resp.ctx.ec() ? error_class_from_response(resp) : hooks_.after_staged_insert_complete(this, id.key());
+          if (ec) {
+              auto msg = (resp.ctx.ec() ? resp.ctx.ec().message() : "after_staged_insert hook threw error");
               return create_staged_insert_error_handler(
-                id, content, cas, std::forward<Delay>(delay), std::forward<Handler>(cb), *ec, "after_staged_insert hook threw error");
+                id, content, cas, std::forward<Delay>(delay), op_id, std::forward<Handler>(cb), *ec, msg);
           }
           if (!resp.ctx.ec()) {
-              debug("inserted doc {} CAS={}, {}", id, resp.cas.value(), resp.ctx.ec().message());
+              CB_ATTEMPT_CTX_LOG_DEBUG(this, "inserted doc {} CAS={}, {}", id, resp.cas.value(), resp.ctx.ec().message());
 
               // TODO: clean this up (do most of this in transactions_document(...))
               transaction_links links(atr_id_->key(),
@@ -2320,6 +2389,7 @@ attempt_context_impl::create_staged_insert(const core::document_id& id,
                                       id.collection(),
                                       overall_.transaction_id(),
                                       this->id(),
+                                      op_id,
                                       content,
                                       std::nullopt,
                                       std::nullopt,
@@ -2336,6 +2406,7 @@ attempt_context_impl::create_staged_insert(const core::document_id& id,
                                                     content,
                                                     cas,
                                                     std::forward<Delay>(delay),
+                                                    op_id,
                                                     std::forward<Handler>(cb),
                                                     error_class_from_response(resp).value(),
                                                     resp.ctx.ec().message());