couchbase 4.4.1-dev.2 → 4.4.1

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

@@ -22,7 +22,7 @@
 #include "attempt_state.hxx"
 #include "core/cluster.hxx"
 #include "core/impl/error.hxx"
-#include "core/operations/document_mutate_in.hxx"
+#include "core/operations.hxx"
 #include "core/transactions/error_class.hxx"
 #include "durability_level.hxx"
 #include "exceptions.hxx"
@@ -30,34 +30,39 @@
 #include "internal/exceptions_internal.hxx"
 #include "internal/exceptions_internal_fmt.hxx"
 #include "internal/logging.hxx"
+#include "internal/transaction_attempt.hxx"
+#include "internal/transaction_context.hxx"
+#include "internal/transactions_cleanup.hxx"
 #include "internal/utils.hxx"
 #include "staged_mutation.hxx"
 
 namespace couchbase::core::transactions
 {
 
+namespace
+{
 // statement constants for queries
-static const std::string BEGIN_WORK{ "BEGIN WORK" };
-static const std::string COMMIT{ "COMMIT" };
-static const std::string ROLLBACK{ "ROLLBACK" };
-static const std::string KV_GET{ "EXECUTE __get" };
-static const std::string KV_INSERT{ "EXECUTE __insert" };
-static const std::string KV_REPLACE{ "EXECUTE __update" };
-static const std::string KV_REMOVE{ "EXECUTE __delete" };
-static const tao::json::value KV_TXDATA{ { "kv", true } };
-
+constexpr auto BEGIN_WORK{ "BEGIN WORK" };
+constexpr auto COMMIT{ "COMMIT" };
+constexpr auto ROLLBACK{ "ROLLBACK" };
+constexpr auto KV_GET{ "EXECUTE __get" };
+constexpr auto KV_INSERT{ "EXECUTE __insert" };
+constexpr auto KV_REPLACE{ "EXECUTE __update" };
+constexpr auto KV_REMOVE{ "EXECUTE __delete" };
+
+// TODO(CXXCBC-549): remove inline clang-tidy directive below
+//
 // the config may have nullptr for attempt context hooks, so we use the noop
 // here in that case
-static auto noop_hooks = attempt_context_testing_hooks{};
+attempt_context_testing_hooks noop_hooks = {}; // NOLINT(cert-err58-cpp)
 
-namespace
-{
 void
-wrap_err_callback_for_async_api(std::exception_ptr err, std::function<void(couchbase::error)>&& cb)
+wrap_err_callback_for_async_api(const std::exception_ptr& err,
+                                std::function<void(couchbase::error)>&& cb)
 {
   if (err) {
     try {
-      std::rethrow_exception(std::move(err));
+      std::rethrow_exception(err);
     } catch (const transaction_operation_failed& e) {
       return cb(core::impl::make_error(e));
     } catch (...) {
@@ -99,7 +104,7 @@ wrap_call_for_public_api(std::function<transaction_get_result()>&& handler)
 
 void
 wrap_callback_for_async_public_api(
-  std::exception_ptr err,
+  const std::exception_ptr& err,
   std::optional<transaction_get_result> res,
   std::function<void(couchbase::error, couchbase::transactions::transaction_get_result)>&& cb)
 {
@@ -108,7 +113,7 @@ wrap_callback_for_async_public_api(
   }
   if (err) {
     try {
-      std::rethrow_exception(std::move(err));
+      std::rethrow_exception(err);
     } catch (const op_exception& e) {
       return cb(core::impl::make_error(e.ctx()), {});
     } catch (const transaction_operation_failed& e) {
@@ -125,39 +130,42 @@ wrap_callback_for_async_public_api(
 auto
 attempt_context_impl::cluster_ref() const -> const core::cluster&
 {
-  return overall_->cluster_ref();
+  return overall()->cluster_ref();
 }
 
-attempt_context_impl::attempt_context_impl(std::shared_ptr<transaction_context> transaction_ctx)
-  : overall_(std::move(transaction_ctx))
+attempt_context_impl::attempt_context_impl(
+  const std::shared_ptr<transaction_context>& transaction_ctx)
+  : overall_{ transaction_ctx }
   , staged_mutations_(std::make_unique<staged_mutation_queue>())
-  , hooks_(overall_->config().attempt_context_hooks ? *overall_->config().attempt_context_hooks
-                                                    : noop_hooks)
+  , hooks_(transaction_ctx->config().attempt_context_hooks
+             ? *transaction_ctx->config().attempt_context_hooks
+             : noop_hooks)
 {
   // put a new transaction_attempt in the context...
-  overall_->add_attempt();
+  overall()->add_attempt();
   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());
+    std::chrono::duration_cast<std::chrono::milliseconds>(overall()->remaining()).count());
 }
 
 attempt_context_impl::~attempt_context_impl() = default;
 
 auto
-attempt_context_impl::create(std::shared_ptr<transaction_context> transaction_ctx)
+attempt_context_impl::create(const std::shared_ptr<transaction_context>& transaction_ctx)
   -> std::shared_ptr<attempt_context_impl>
 {
   class attempt_context_impl_wrapper : public attempt_context_impl
   {
   public:
-    attempt_context_impl_wrapper(std::shared_ptr<transaction_context> transaction_ctx)
-      : attempt_context_impl(std::move(transaction_ctx))
+    explicit attempt_context_impl_wrapper(
+      const std::shared_ptr<transaction_context>& transaction_ctx)
+      : attempt_context_impl(transaction_ctx)
     {
     }
   };
-  return std::make_shared<attempt_context_impl_wrapper>(std::move(transaction_ctx));
+  return std::make_shared<attempt_context_impl_wrapper>(transaction_ctx);
 }
 
 void
@@ -172,27 +180,29 @@ attempt_context_impl::check_and_handle_blocking_transactions(
     // 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()) {
+    if (auto tx_id = doc.links().staged_transaction_id();
+        tx_id.has_value() && tx_id.value() == transaction_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()) {
-      CB_ATTEMPT_CTX_LOG_DEBUG(this, "doc {} in another txn, checking atr...", doc.id());
+      CB_ATTEMPT_CTX_LOG_DEBUG(this, "doc {} in another txn, checking ATR...", doc.id());
       auto err = check_forward_compat(stage, doc.links().forward_compat());
       if (err) {
         return cb(err);
       }
-      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));
+      return check_atr_entry_for_blocking_document(doc,
+                                                   exp_delay(std::chrono::milliseconds(50),
+                                                             std::chrono::milliseconds(500),
+                                                             std::chrono::seconds(1)),
+                                                   std::move(cb));
     }
     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 \"{}\" 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());
+                             doc.links().staged_attempt_id().value_or("<missing-attempt-id>"));
   }
   return cb(std::nullopt);
 }
@@ -202,11 +212,11 @@ attempt_context_impl::get(const core::document_id& id) -> transaction_get_result
 {
   auto barrier = std::make_shared<std::promise<transaction_get_result>>();
   auto f = barrier->get_future();
-  get(id, [barrier](std::exception_ptr err, std::optional<transaction_get_result> res) {
+  get(id, [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
     if (err) {
-      barrier->set_exception(std::move(err));
+      barrier->set_exception(err);
     } else {
-      barrier->set_value(*res);
+      barrier->set_value(std::move(*res));
     }
   });
   return f.get();
@@ -218,16 +228,15 @@ attempt_context_impl::get(const core::document_id& id, Callback&& cb)
   if (op_list_.get_mode().is_query()) {
     return get_with_query(id, false, std::move(cb));
   }
-  cache_error_async(cb, [&]() mutable {
-    check_if_done(cb);
-    do_get(
+  cache_error_async(cb, [self = shared_from_this(), id, cb]() mutable {
+    self->check_if_done(cb);
+    self->do_get(
       id,
       false,
       std::nullopt,
-      [self = shared_from_this(), id, cb = std::move(cb)](
-        std::optional<error_class> ec,
-        std::optional<std::string> err_message,
-        std::optional<transaction_get_result> res) mutable {
+      [self, id, cb = std::move(cb)](std::optional<error_class> ec,
+                                     const std::optional<std::string>& err_message,
+                                     std::optional<transaction_get_result> res) mutable {
         auto handler = [self, id, err_message, res = std::move(res), cb = std::move(cb)](
                          std::optional<error_class> ec) mutable {
           if (ec) {
@@ -291,12 +300,13 @@ attempt_context_impl::get_optional(const core::document_id& id)
 {
   auto barrier = std::make_shared<std::promise<std::optional<transaction_get_result>>>();
   auto f = barrier->get_future();
-  get_optional(id, [barrier](std::exception_ptr err, std::optional<transaction_get_result> res) {
-    if (err) {
-      return barrier->set_exception(std::move(err));
-    }
-    return barrier->set_value(std::move(res));
-  });
+  get_optional(id,
+               [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
+                 if (err) {
+                   return barrier->set_exception(err);
+                 }
+                 return barrier->set_value(std::move(res));
+               });
   return f.get();
 }
 
@@ -307,9 +317,9 @@ attempt_context_impl::get_optional(const core::document_id& id, Callback&& cb)
   if (op_list_.get_mode().is_query()) {
     return get_with_query(id, true, std::move(cb));
   }
-  cache_error_async(cb, [&]() {
-    ensure_open_bucket(
-      id.bucket(), [self = shared_from_this(), id, cb = std::move(cb)](std::error_code ec) mutable {
+  cache_error_async(cb, [self = shared_from_this(), id, cb]() mutable {
+    self->ensure_open_bucket(
+      id.bucket(), [self, id, cb = std::move(cb)](std::error_code ec) mutable {
         if (ec) {
           return self->op_completed_with_error(
             std::move(cb), transaction_operation_failed(FAIL_OTHER, ec.message()));
@@ -320,7 +330,7 @@ attempt_context_impl::get_optional(const core::document_id& id, Callback&& cb)
           false,
           std::nullopt,
           [self, id, cb = std::move(cb)](std::optional<error_class> ec,
-                                         std::optional<std::string> err_message,
+                                         const std::optional<std::string>& err_message,
                                          std::optional<transaction_get_result> res) mutable {
             auto handler = [self, id, err_message, res, cb = std::move(cb)](
                              std::optional<error_class> ec) mutable {
@@ -395,7 +405,7 @@ attempt_context_impl::get_replica_from_preferred_server_group(
       true,
       std::nullopt,
       [self, id, cb = std::move(cb)](std::optional<error_class> ec,
-                                     std::optional<std::string> err_message,
+                                     const std::optional<std::string>& err_message,
                                      std::optional<transaction_get_result> res) mutable {
         auto handler = [self, id, err_message, res = std::move(res), cb = std::move(cb)](
                          std::optional<error_class> ec) mutable {
@@ -425,7 +435,7 @@ attempt_context_impl::get_replica_from_preferred_server_group(
                   return self->op_completed_with_callback(std::move(cb),
                                                           std::optional<transaction_get_result>());
                 }
-                // fall through
+                [[fallthrough]];
               default: {
                 auto msg = fmt::format("got error \"{}\" (ec={}) while getting replica for doc {}",
                                        err_message.value_or(""),
@@ -464,9 +474,9 @@ attempt_context_impl::get_replica_from_preferred_server_group(const core::docume
   auto barrier = std::make_shared<std::promise<std::optional<transaction_get_result>>>();
   auto f = barrier->get_future();
   get_replica_from_preferred_server_group(
-    id, [barrier](std::exception_ptr err, std::optional<transaction_get_result> res) {
+    id, [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
       if (err) {
-        barrier->set_exception(std::move(err));
+        barrier->set_exception(err);
       }
       return barrier->set_value(std::move(res));
     });
@@ -501,12 +511,12 @@ attempt_context_impl::get_replica_from_preferred_server_group(
 {
   get_replica_from_preferred_server_group(
     { coll.bucket_name(), coll.scope_name(), coll.name(), id },
-    [handler = std::move(handler)](std::exception_ptr err,
+    [handler = std::move(handler)](const std::exception_ptr& err,
                                    std::optional<transaction_get_result> res) mutable {
       if (!res) {
         return handler({ errc::transaction_op::document_not_found }, {});
       }
-      return wrap_callback_for_async_public_api(std::move(err), std::move(res), std::move(handler));
+      return wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
     });
 }
 
@@ -518,8 +528,8 @@ attempt_context_impl::create_document_metadata(
   std::uint32_t user_flags_to_stage) -> tao::json::value
 {
   tao::json::value txn;
-  bool binary = codec::codec_flags::has_common_flags(user_flags_to_stage,
-                                                     codec::codec_flags::binary_common_flags);
+  const bool binary = codec::codec_flags::has_common_flags(user_flags_to_stage,
+                                                           codec::codec_flags::binary_common_flags);
 
   txn["op"] = {
     { "type", operation_type },
@@ -534,21 +544,24 @@ attempt_context_impl::create_document_metadata(
   };
   txn["atr"] = {
     { "id", atr_id() },
-    { "bkt", atr_id_->bucket() },
-    { "scp", atr_id_->scope() },
-    { "coll", atr_id_->collection() },
   };
+  // FIXME(SA): Why atr_id_ is an optional field?
+  if (const auto& id = atr_id_; id.has_value()) {
+    txn["atr"]["bkt"] = atr_id_->bucket();
+    txn["atr"]["scp"] = atr_id_->scope();
+    txn["atr"]["coll"] = atr_id_->collection();
+  }
 
   if (document_metadata) {
     tao::json::value restore = tao::json::empty_object;
-    if (document_metadata->cas()) {
-      restore["CAS"] = document_metadata->cas().value();
+    if (auto cas = document_metadata->cas(); cas.has_value()) {
+      restore["CAS"] = cas.value();
     }
-    if (document_metadata->revid()) {
-      restore["revid"] = document_metadata->revid().value();
+    if (auto revid = document_metadata->revid(); revid.has_value()) {
+      restore["revid"] = revid.value();
     }
-    if (document_metadata->exptime()) {
-      restore["exptime"] = document_metadata->exptime().value();
+    if (auto exptime = document_metadata->exptime(); exptime.has_value()) {
+      restore["exptime"] = exptime.value();
     }
     if (!restore.get_object().empty()) {
       txn["restore"] = restore;
@@ -582,104 +595,111 @@ attempt_context_impl::replace_raw(const transaction_get_result& document,
   if (op_list_.get_mode().is_query()) {
     return replace_raw_with_query(document, std::move(content), std::move(cb));
   }
-  return cache_error_async(cb, [&]() {
-    ensure_open_bucket(
-      document.bucket(),
-      [self = shared_from_this(), cb, document, content = std::move(content)](
-        std::error_code ec) mutable {
-        if (ec) {
-          return self->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 self->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));
-          }
-          CB_ATTEMPT_CTX_LOG_TRACE(self, "replacing {} with {}", document, to_string(content.data));
-          self->check_if_done(cb);
-          staged_mutation* existing_sm = self->staged_mutations_->find_any(document.id());
-          if (existing_sm != nullptr && existing_sm->type() == staged_mutation_type::REMOVE) {
-            CB_ATTEMPT_CTX_LOG_DEBUG(self, "found existing REMOVE of {} while replacing", document);
-            return self->op_completed_with_error(
-              std::move(cb),
-              transaction_operation_failed(FAIL_DOC_NOT_FOUND,
-                                           "cannot replace a document that has been "
-                                           "removed in the same transaction")
-                .cause(external_exception::DOCUMENT_NOT_FOUND_EXCEPTION));
-          }
-          if (self->check_expiry_pre_commit(STAGE_REPLACE, document.id().key())) {
+  return cache_error_async(
+    cb, [self = shared_from_this(), cb, document, content = std::move(content)]() mutable {
+      self->ensure_open_bucket(
+        document.bucket(),
+        [self, cb = std::move(cb), document, content = std::move(content)](
+          std::error_code ec) mutable {
+          if (ec) {
             return self->op_completed_with_error(
-              std::move(cb),
-              transaction_operation_failed(FAIL_EXPIRY, "transaction expired").expired());
+              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 self->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));
+            }
+            CB_ATTEMPT_CTX_LOG_TRACE(
+              self, "replacing {} with {}", document, to_string(content.data));
+            self->check_if_done(cb);
+            staged_mutation* existing_sm = self->staged_mutations_->find_any(document.id());
+            if (existing_sm != nullptr && existing_sm->type() == staged_mutation_type::REMOVE) {
+              CB_ATTEMPT_CTX_LOG_DEBUG(
+                self, "found existing REMOVE of {} while replacing", document);
+              return self->op_completed_with_error(
+                std::move(cb),
+                transaction_operation_failed(FAIL_DOC_NOT_FOUND,
+                                             "cannot replace a document that has been "
+                                             "removed in the same transaction")
+                  .cause(external_exception::DOCUMENT_NOT_FOUND_EXCEPTION));
+            }
+            if (self->check_expiry_pre_commit(STAGE_REPLACE, document.id().key())) {
+              return self->op_completed_with_error(
+                std::move(cb),
+                transaction_operation_failed(FAIL_EXPIRY, "transaction expired").expired());
+            }
 
-          self->check_and_handle_blocking_transactions(
-            document,
-            forward_compat_stage::WWC_REPLACING,
-            [self, existing_sm, document, cb = std::move(cb), op_id, content = std::move(content)](
-              std::optional<transaction_operation_failed> e1) mutable {
-              if (e1) {
-                return self->op_completed_with_error(std::move(cb), *e1);
-              }
-              auto tmp_doc = document_id{ document.id().bucket(),
-                                          document.id().scope(),
-                                          document.id().collection(),
-                                          document.id().key() };
-              self->select_atr_if_needed_unlocked(
-                tmp_doc,
-                [self,
-                 existing_sm,
-                 document,
-                 cb = std::move(cb),
-                 op_id,
-                 content =
-                   std::move(content)](std::optional<transaction_operation_failed> e2) mutable {
-                  if (e2) {
-                    return self->op_completed_with_error(std::move(cb), *e2);
-                  }
-                  if (existing_sm != nullptr &&
-                      existing_sm->type() == staged_mutation_type::INSERT) {
-                    CB_ATTEMPT_CTX_LOG_DEBUG(
-                      self, "found existing INSERT of {} while replacing", document);
-                    exp_delay delay(std::chrono::milliseconds(5),
-                                    std::chrono::milliseconds(300),
-                                    self->overall_->config().timeout);
-                    self->create_staged_insert(document.id(),
-                                               std::move(content),
-                                               existing_sm->doc().cas().value(),
-                                               delay,
-                                               op_id,
-                                               std::move(cb));
-                    return;
-                  }
-                  self->create_staged_replace(document, std::move(content), op_id, std::move(cb));
-                });
-            });
-        } catch (const client_error& e) {
-          error_class errc = e.ec();
-          switch (errc) {
-            case FAIL_EXPIRY:
-              self->expiry_overtime_mode_ = true;
-              throw transaction_operation_failed(errc, e.what()).expired();
-            default:
-              throw transaction_operation_failed(errc, e.what());
+            self->check_and_handle_blocking_transactions(
+              document,
+              forward_compat_stage::WWC_REPLACING,
+              [self,
+               existing_sm,
+               document,
+               cb = std::move(cb),
+               op_id,
+               content =
+                 std::move(content)](std::optional<transaction_operation_failed> e1) mutable {
+                if (e1) {
+                  return self->op_completed_with_error(std::move(cb), *e1);
+                }
+                auto tmp_doc = document_id{ document.id().bucket(),
+                                            document.id().scope(),
+                                            document.id().collection(),
+                                            document.id().key() };
+                self->select_atr_if_needed_unlocked(
+                  tmp_doc,
+                  [self,
+                   existing_sm,
+                   document,
+                   cb = std::move(cb),
+                   op_id,
+                   content =
+                     std::move(content)](std::optional<transaction_operation_failed> e2) mutable {
+                    if (e2) {
+                      return self->op_completed_with_error(std::move(cb), *e2);
+                    }
+                    if (existing_sm != nullptr &&
+                        existing_sm->type() == staged_mutation_type::INSERT) {
+                      CB_ATTEMPT_CTX_LOG_DEBUG(
+                        self, "found existing INSERT of {} while replacing", document);
+                      self->create_staged_insert(document.id(),
+                                                 std::move(content),
+                                                 existing_sm->doc().cas().value(),
+                                                 exp_delay(std::chrono::milliseconds(5),
+                                                           std::chrono::milliseconds(300),
+                                                           self->overall()->config().timeout),
+                                                 op_id,
+                                                 std::move(cb));
+                      return;
+                    }
+                    self->create_staged_replace(document, std::move(content), op_id, std::move(cb));
+                  });
+              });
+          } catch (const client_error& e) {
+            const error_class errc = e.ec();
+            switch (errc) {
+              case FAIL_EXPIRY:
+                self->expiry_overtime_mode_ = true;
+                throw transaction_operation_failed(errc, e.what()).expired();
+              default:
+                throw transaction_operation_failed(errc, e.what());
+            }
           }
-        }
-      });
-  });
+        });
+    });
 }
 
 namespace
 {
 template<typename Response>
-external_exception
-external_exception_from_response(const Response& resp)
+auto
+external_exception_from_response(const Response& resp) -> external_exception
 {
   if (const auto error_index = resp.ctx.first_error_index(); error_index) {
     const auto status = resp.fields.at(error_index.value()).status;
@@ -700,7 +720,7 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
                                             Handler&& cb)
 {
   core::operations::mutate_in_request req{ document.id() };
-  bool binary =
+  const bool binary =
     codec::codec_flags::has_common_flags(content.flags, codec::codec_flags::binary_common_flags);
   auto txn = create_document_metadata("replace", op_id, document.metadata(), content.flags);
   req.specs =
@@ -716,7 +736,7 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
         .create_path(),
     }
       .specs();
-  req.durability_level = overall_->config().level;
+  req.durability_level = overall()->config().level;
   req.cas = document.cas();
   req.flags = document.content().flags;
   req.access_deleted = true;
@@ -751,8 +771,8 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
                            "about to replace doc {} with cas {} in txn {}",
                            document.id(),
                            document.cas().value(),
-                           overall_->transaction_id());
-  overall_->cluster_ref().execute(
+                           overall()->transaction_id());
+  overall()->cluster_ref().execute(
     req,
     [self = shared_from_this(),
      operation_id = op_id,
@@ -763,7 +783,7 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
       if (auto ec2 = error_class_from_response(resp); ec2) {
         return error_handler(
           *ec2,
-          external_exception_from_response(std::move(resp)),
+          external_exception_from_response(resp),
           fmt::format("unable to create staged replace ec=\"{}\"", resp.ctx.ec().message()),
           std::forward<Handler>(cb));
       }
@@ -802,7 +822,7 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
               document.id().bucket(),
               document.id().scope(),
               document.id().collection(),
-              self->overall_->transaction_id(),
+              self->overall()->transaction_id(),
               self->id(),
               operation_id,
               std::move(staged_content_json),
@@ -839,11 +859,11 @@ attempt_context_impl::replace_raw(const transaction_get_result& document,
   auto f = barrier->get_future();
   replace_raw(document,
               std::move(content),
-              [barrier](std::exception_ptr err, std::optional<transaction_get_result> res) {
+              [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
                 if (err) {
-                  return barrier->set_exception(std::move(err));
+                  return barrier->set_exception(err);
                 }
-                barrier->set_value(*res);
+                barrier->set_value(std::move(*res));
               });
   return f.get();
 }
@@ -853,12 +873,11 @@ attempt_context_impl::replace_raw(couchbase::transactions::transaction_get_resul
                                   codec::encoded_value content,
                                   couchbase::transactions::async_result_handler&& handler)
 {
-  replace_raw(core::transactions::transaction_get_result(std::move(doc)),
+  replace_raw(core::transactions::transaction_get_result(doc),
               std::move(content),
-              [handler = std::move(handler)](std::exception_ptr err,
+              [handler = std::move(handler)](const std::exception_ptr& err,
                                              std::optional<transaction_get_result> res) mutable {
-                wrap_callback_for_async_public_api(
-                  std::move(err), std::move(res), std::move(handler));
+                wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
               });
 }
 
@@ -869,7 +888,7 @@ attempt_context_impl::replace_raw(const couchbase::transactions::transaction_get
 {
   return wrap_call_for_public_api(
     [self = shared_from_this(), doc, content = std::move(content)]() -> transaction_get_result {
-      return self->replace_raw(transaction_get_result(doc), std::move(content));
+      return self->replace_raw(transaction_get_result(doc), content);
     });
 }
 
@@ -894,10 +913,9 @@ attempt_context_impl::insert_raw(const collection& coll,
 {
   insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
              std::move(content),
-             [handler = std::move(handler)](std::exception_ptr err,
+             [handler = std::move(handler)](const std::exception_ptr& err,
                                             std::optional<transaction_get_result> res) mutable {
-               wrap_callback_for_async_public_api(
-                 std::move(err), std::move(res), std::move(handler));
+               wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
              });
 }
 
@@ -909,11 +927,11 @@ attempt_context_impl::insert_raw(const core::document_id& id,
   auto f = barrier->get_future();
   insert_raw(id,
              std::move(content),
-             [barrier](std::exception_ptr err, std::optional<transaction_get_result> res) {
+             [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
                if (err) {
-                 return barrier->set_exception(std::move(err));
+                 return barrier->set_exception(err);
                }
-               barrier->set_value(*res);
+               barrier->set_value(std::move(*res));
              });
   return f.get();
 }
@@ -966,12 +984,15 @@ attempt_context_impl::insert_raw(const core::document_id& id,
                   return self->create_staged_replace(
                     existing_sm->doc(), std::move(content), op_id, std::move(cb));
                 }
-                std::uint64_t cas = 0;
-                exp_delay delay(std::chrono::milliseconds(5),
-                                std::chrono::milliseconds(300),
-                                self->overall_->config().timeout);
-                self->create_staged_insert(
-                  id, std::move(content), cas, delay, op_id, std::move(cb));
+                const std::uint64_t cas = 0;
+                self->create_staged_insert(id,
+                                           std::move(content),
+                                           cas,
+                                           exp_delay(std::chrono::milliseconds(5),
+                                                     std::chrono::milliseconds(300),
+                                                     self->overall()->config().timeout),
+                                           op_id,
+                                           std::move(cb));
               });
           } catch (const std::exception& e) {
             return self->op_completed_with_error(
@@ -996,16 +1017,16 @@ attempt_context_impl::select_atr_if_needed_unlocked(
     std::optional<const std::string> hook_atr =
       hooks_.random_atr_id_for_vbucket(shared_from_this());
     if (hook_atr) {
-      atr_id_ = atr_id_from_bucket_and_key(overall_->config(), id.bucket(), hook_atr.value());
+      atr_id_ = atr_id_from_bucket_and_key(overall()->config(), id.bucket(), hook_atr.value());
     } else {
       vbucket_id = atr_ids::vbucket_for_key(id.key());
       atr_id_ = atr_id_from_bucket_and_key(
-        overall_->config(), id.bucket(), atr_ids::atr_id_for_vbucket(vbucket_id));
+        overall()->config(), id.bucket(), atr_ids::atr_id_for_vbucket(vbucket_id));
     }
-    // TODO: cleanup the transaction_context - this should be set (threadsafe)
+    // TODO(SA): cleanup the transaction_context - this should be set (threadsafe)
     // from the above calls
-    overall_->atr_collection(collection_spec_from_id(id));
-    overall_->atr_id(atr_id_->key());
+    overall()->atr_collection(collection_spec_from_id(id));
+    overall()->atr_id(atr_id_->key());
     state(attempt_state::NOT_STARTED);
     CB_ATTEMPT_CTX_LOG_TRACE(
       this,
@@ -1013,7 +1034,7 @@ attempt_context_impl::select_atr_if_needed_unlocked(
       id,
       vbucket_id,
       atr_id_.value());
-    overall_->cleanup().add_collection(
+    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) {
@@ -1039,10 +1060,10 @@ attempt_context_impl::check_atr_entry_for_blocking_document(const transaction_ge
                       .retry());
         }
 
-        core::document_id atr_id(doc.links().atr_bucket_name().value(),
-                                 doc.links().atr_scope_name().value(),
-                                 doc.links().atr_collection_name().value(),
-                                 doc.links().atr_id().value());
+        const core::document_id atr_id(doc.links().atr_bucket_name().value(),
+                                       doc.links().atr_scope_name().value(),
+                                       doc.links().atr_collection_name().value(),
+                                       doc.links().atr_id().value());
         return active_transaction_record::get_atr(
           self->cluster_ref(),
           atr_id,
@@ -1105,25 +1126,26 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
           return self->op_completed_with_error(
             std::move(cb), transaction_operation_failed(FAIL_OTHER, ec.message()));
         }
-        staged_mutation* existing_sm = self->staged_mutations_->find_any(document.id());
-        auto error_handler = [self](error_class ec, std::string msg, VoidCallback&& cb) mutable {
-          transaction_operation_failed err(ec, std::move(msg));
-          switch (ec) {
-            case FAIL_EXPIRY:
-              self->expiry_overtime_mode_ = true;
-              return self->op_completed_with_error(std::move(cb), err.expired());
-            case FAIL_DOC_NOT_FOUND:
-            case FAIL_DOC_ALREADY_EXISTS:
-            case FAIL_CAS_MISMATCH:
-            case FAIL_TRANSIENT:
-            case FAIL_AMBIGUOUS:
-              return self->op_completed_with_error(std::move(cb), err.retry());
-            case FAIL_HARD:
-              return self->op_completed_with_error(std::move(cb), err.no_rollback());
-            default:
-              return self->op_completed_with_error(std::move(cb), err);
-          }
-        };
+        const staged_mutation* existing_sm = self->staged_mutations_->find_any(document.id());
+        auto error_handler =
+          [self](error_class ec, const std::string& msg, VoidCallback&& cb) mutable {
+            transaction_operation_failed err(ec, msg);
+            switch (ec) {
+              case FAIL_EXPIRY:
+                self->expiry_overtime_mode_ = true;
+                return self->op_completed_with_error(std::move(cb), err.expired());
+              case FAIL_DOC_NOT_FOUND:
+              case FAIL_DOC_ALREADY_EXISTS:
+              case FAIL_CAS_MISMATCH:
+              case FAIL_TRANSIENT:
+              case FAIL_AMBIGUOUS:
+                return self->op_completed_with_error(std::move(cb), err.retry());
+              case FAIL_HARD:
+                return self->op_completed_with_error(std::move(cb), err.no_rollback());
+              default:
+                return self->op_completed_with_error(std::move(cb), err);
+            }
+          };
         if (self->check_expiry_pre_commit(STAGE_REMOVE, document.id().key())) {
           return error_handler(FAIL_EXPIRY, "transaction expired", std::move(cb));
         }
@@ -1147,12 +1169,8 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
         return self->check_and_handle_blocking_transactions(
           document,
           forward_compat_stage::WWC_REMOVING,
-          [self,
-           document = std::move(document),
-           cb = std::move(cb),
-           op_id,
-           error_handler =
-             std::move(error_handler)](std::optional<transaction_operation_failed> err1) mutable {
+          [self, document, cb = std::move(cb), op_id, error_handler = std::move(error_handler)](
+            std::optional<transaction_operation_failed> err1) mutable {
             if (err1) {
               return self->op_completed_with_error(std::move(cb), *err1);
             }
@@ -1163,7 +1181,7 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
             return self->select_atr_if_needed_unlocked(
               tmp_doc,
               [self,
-               document = std::move(document),
+               document = document,
                cb = std::move(cb),
                op_id,
                error_handler = std::move(error_handler)](
@@ -1202,10 +1220,10 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
                           .create_path(),
                       }
                         .specs();
-                    req.durability_level = self->overall_->config().level;
+                    req.durability_level = self->overall()->config().level;
                     req.cas = document.cas();
                     req.access_deleted = document.links().is_deleted();
-                    return self->overall_->cluster_ref().execute(
+                    return self->overall()->cluster_ref().execute(
                       req,
                       [self,
                        document = std::move(document),
@@ -1234,7 +1252,7 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
                                                      document.id(),
                                                      resp.cas.value(),
                                                      resp.ctx.ec().message());
-                            // TODO: this copy...  can we do better?
+                            // TODO(SA): this copy...  can we do better?
                             transaction_get_result new_res = document;
                             new_res.cas(resp.cas.value());
                             self->staged_mutations_->add(
@@ -1286,13 +1304,13 @@ attempt_context_impl::remove_staged_insert(const core::document_id& id, VoidCall
           couchbase::mutate_in_specs::remove("txn").xattr(),
         }
           .specs();
-      wrap_durable_request(req, self->overall_->config());
+      wrap_durable_request(req, self->overall()->config());
       req.access_deleted = true;
 
-      return self->overall_->cluster_ref().execute(
+      return self->overall()->cluster_ref().execute(
         req,
         [self, id, cb = std::move(cb), error_handler = std::move(error_handler)](
-          core::operations::mutate_in_response resp) mutable {
+          const core::operations::mutate_in_response& resp) mutable {
           auto ec = error_class_from_response(resp);
           if (ec) {
             CB_ATTEMPT_CTX_LOG_DEBUG(self, "remove_staged_insert got error {}", *ec);
@@ -1319,18 +1337,20 @@ attempt_context_impl::remove(const transaction_get_result& document)
 {
   auto barrier = std::make_shared<std::promise<void>>();
   auto f = barrier->get_future();
-  remove(document, [barrier](std::exception_ptr err) {
+  remove(document, [barrier](const std::exception_ptr& err) {
     if (err) {
-      return barrier->set_exception(std::move(err));
+      return barrier->set_exception(err);
     }
     barrier->set_value();
   });
   f.get();
 }
 
-static auto
+namespace
+{
+auto
 wrap_query_request(const couchbase::transactions::transaction_query_options& opts,
-                   std::shared_ptr<transaction_context> txn_context)
+                   const std::shared_ptr<transaction_context>& txn_context)
   -> core::operations::query_request
 {
   // build what we can directly from the options:
@@ -1342,17 +1362,21 @@ wrap_query_request(const couchbase::transactions::transaction_query_options& opt
     req.scan_consistency = txn_context->config().query_config.scan_consistency;
   }
   auto remaining = std::chrono::duration_cast<std::chrono::milliseconds>(txn_context->remaining());
+  // FIXME(SA): is this assignment necessary? cppcheck complains about redundant
+  // assignment below
   req.timeout =
     remaining + extra +
     std::chrono::milliseconds(1000); // match java with 1 second over the kv durable timeout.
   req.raw["txtimeout"] = fmt::format("\"{}ms\"", remaining.count());
-  req.timeout =
+  req.timeout = // cppcheck-suppress redundantAssignment
     std::chrono::duration_cast<std::chrono::milliseconds>(txn_context->remaining()) + extra;
   return req;
 }
+} // namespace
 
 void
-attempt_context_impl::query_begin_work(std::optional<std::string> query_context, VoidCallback&& cb)
+attempt_context_impl::query_begin_work(const std::optional<std::string>& query_context,
+                                       VoidCallback&& cb)
 {
   // construct the txn_data and query options for the existing transaction
   couchbase::transactions::transaction_query_options opts;
@@ -1361,23 +1385,23 @@ attempt_context_impl::query_begin_work(std::optional<std::string> query_context,
   txdata["id"]["atmpt"] = id();
   txdata["id"]["txn"] = transaction_id();
   txdata["state"] = tao::json::empty_object;
-  txdata["state"]["timeLeftMs"] = overall_->remaining().count() / 1000000;
+  txdata["state"]["timeLeftMs"] = overall()->remaining().count() / 1000000;
   txdata["config"] = tao::json::empty_object;
-  auto [ec, origin] = overall_->cluster_ref().origin();
+  auto [ec, origin] = overall()->cluster_ref().origin();
   txdata["config"]["kvTimeoutMs"] = (ec) ? core::timeout_defaults::key_value_durable_timeout.count()
                                          : origin.options().key_value_durable_timeout.count();
   txdata["config"]["numAtrs"] = 1024;
   opts.raw("numatrs", jsonify(1024));
-  txdata["config"]["durabilityLevel"] = durability_level_to_string(overall_->config().level);
-  opts.raw("durability_level", durability_level_to_string_for_query(overall_->config().level));
+  txdata["config"]["durabilityLevel"] = durability_level_to_string(overall()->config().level);
+  opts.raw("durability_level", durability_level_to_string_for_query(overall()->config().level));
   if (atr_id_) {
     txdata["atr"] = tao::json::empty_object;
     txdata["atr"]["scp"] = atr_id_->scope();
     txdata["atr"]["coll"] = atr_id_->collection();
     txdata["atr"]["bkt"] = atr_id_->bucket();
     txdata["atr"]["id"] = atr_id_->key();
-  } else if (overall_->config().metadata_collection) {
-    auto id = atr_id_from_bucket_and_key(overall_->config(), "", "");
+  } else if (overall()->config().metadata_collection) {
+    auto id = atr_id_from_bucket_and_key(overall()->config(), "", "");
     txdata["atr"] = tao::json::empty_object;
     txdata["atr"]["scp"] = id.scope();
     txdata["atr"]["coll"] = id.collection();
@@ -1408,8 +1432,8 @@ attempt_context_impl::query_begin_work(std::optional<std::string> query_context,
     txdata,
     STAGE_QUERY_BEGIN_WORK,
     false,
-    std::move(query_context),
-    [self = shared_from_this(), cb = std::move(cb)](std::exception_ptr err,
+    query_context,
+    [self = shared_from_this(), cb = std::move(cb)](const std::exception_ptr& err,
                                                     core::operations::query_response resp) mutable {
       if (resp.served_by_node.empty()) {
         CB_ATTEMPT_CTX_LOG_TRACE(self,
@@ -1427,7 +1451,7 @@ attempt_context_impl::query_begin_work(std::optional<std::string> query_context,
                                     .no_rollback()
                                     .expired()));
       }
-      return cb(std::move(err));
+      return cb(err);
     });
 }
 
@@ -1458,14 +1482,14 @@ choose_error(std::vector<tao::json::value>& errors) -> tao::json::value
 }
 
 auto
-attempt_context_impl::handle_query_error(const core::operations::query_response& resp)
+attempt_context_impl::handle_query_error(const core::operations::query_response& resp) const
   -> std::exception_ptr
 {
   if (!resp.ctx.ec && !resp.meta.errors) {
     return {};
   }
   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...
+  // TODO(SA): look at ambiguous and unambiguous timeout errors vs the codes, etc...
   CB_ATTEMPT_CTX_LOG_TRACE(this,
                            "handling query error {}, {} errors in meta_data",
                            resp.ctx.ec.message(),
@@ -1479,13 +1503,13 @@ attempt_context_impl::handle_query_error(const core::operations::query_response&
   }
   if (!resp.meta.errors) {
     // can't choose an error, map using the ec...
-    external_exception cause = (resp.ctx.ec == couchbase::errc::common::service_not_available
-                                  ? SERVICE_NOT_AVAILABLE_EXCEPTION
-                                  : COUCHBASE_EXCEPTION);
+    const external_exception cause = (resp.ctx.ec == couchbase::errc::common::service_not_available
+                                        ? SERVICE_NOT_AVAILABLE_EXCEPTION
+                                        : COUCHBASE_EXCEPTION);
     return std::make_exception_ptr(
       transaction_operation_failed(FAIL_OTHER, resp.ctx.ec.message()).cause(cause));
   }
-  // TODO: we should have all the fields in these transactional query errors in
+  // TODO(SA): we should have all the fields in these transactional query errors in
   // the errors object. For now, lets
   //   parse the body, get the serialized info to decide which error to choose.
   auto errors = core::utils::json::parse(resp.ctx.http_body)["errors"].get_array();
@@ -1520,13 +1544,15 @@ attempt_context_impl::handle_query_error(const core::operations::query_response&
       return std::make_exception_ptr(document_not_found(tx_err));
     case 17015:
       return std::make_exception_ptr(query_cas_mismatch(tx_err));
+    default:
+      break;
   }
 
   // For these errors, we will create a transaction_operation_failed from the
   // info in it.
   if (code >= 17000 && code <= 18000) {
     // the assumption below is there's always a top-level msg.
-    // TODO: when we parse the errors more thoroughly in the client, we should
+    // TODO(SA): when we parse the errors more thoroughly in the client, we should
     // be able to add a lot of info on the underlying
     //   cause of the error here (in addition to perhaps a more granular
     //   message).
@@ -1564,10 +1590,10 @@ attempt_context_impl::handle_query_error(const core::operations::query_response&
 void
 attempt_context_impl::do_query(const std::string& statement,
                                const couchbase::transactions::transaction_query_options& opts,
-                               std::optional<std::string> query_context,
+                               const std::optional<std::string>& query_context,
                                QueryCallback&& cb)
 {
-  tao::json::value txdata;
+  const tao::json::value txdata;
   CB_ATTEMPT_CTX_LOG_TRACE(this, "do_query called with statement {}", statement);
   wrap_query(statement,
              opts,
@@ -1575,7 +1601,7 @@ attempt_context_impl::do_query(const std::string& statement,
              txdata,
              STAGE_QUERY,
              true,
-             std::move(query_context),
+             query_context,
              [self = shared_from_this(), cb = std::move(cb)](
                std::exception_ptr err, core::operations::query_response resp) mutable {
                if (err) {
@@ -1611,7 +1637,7 @@ attempt_context_impl::wrap_query(
   const tao::json::value& txdata,
   const std::string& hook_point,
   bool check_expiry,
-  std::optional<std::string> query_context,
+  const std::optional<std::string>& query_context,
   std::function<void(std::exception_ptr, core::operations::query_response)>&& cb)
 {
   bool has_staged_binary{ false };
@@ -1629,7 +1655,7 @@ attempt_context_impl::wrap_query(
               {});
   }
 
-  auto req = wrap_query_request(opts, overall_);
+  auto req = wrap_query_request(opts, overall());
   if (statement != BEGIN_WORK) {
     auto mode = op_list_.get_mode();
     assert(mode.is_query());
@@ -1685,14 +1711,13 @@ attempt_context_impl::wrap_query(
       }
 
       CB_ATTEMPT_CTX_LOG_TRACE(self, "http request: {}", dump_request(req));
-      return self->overall_->cluster_ref().execute(
+      return self->overall()->cluster_ref().execute(
         req, [self, req, cb = std::move(cb)](core::operations::query_response resp) mutable {
           CB_ATTEMPT_CTX_LOG_TRACE(
             self, "response: {} status: {}", resp.ctx.http_body, resp.meta.status);
+          const auto stmt = resp.ctx.statement;
           return self->hooks_.after_query(
-            self,
-            resp.ctx.statement,
-            [self, resp = std::move(resp), cb = std::move(cb)](auto ec) mutable {
+            self, stmt, [self, resp = std::move(resp), cb = std::move(cb)](auto ec) mutable {
               if (ec) {
                 auto err = std::make_exception_ptr(
                   transaction_operation_failed(*ec, "after_query hook raised error"));
@@ -1749,15 +1774,16 @@ attempt_context_impl::do_core_query(
 {
   auto barrier = std::make_shared<std::promise<core::operations::query_response>>();
   auto f = barrier->get_future();
-  query(statement,
-        options,
-        query_context,
-        [barrier](std::exception_ptr err, std::optional<core::operations::query_response> resp) {
-          if (err) {
-            return barrier->set_exception(std::move(err));
-          }
-          barrier->set_value(*resp);
-        });
+  query(
+    statement,
+    options,
+    query_context,
+    [barrier](const std::exception_ptr& err, std::optional<core::operations::query_response> resp) {
+      if (err) {
+        return barrier->set_exception(err);
+      }
+      barrier->set_value(*resp);
+    });
   return f.get();
 }
 
@@ -1855,7 +1881,7 @@ attempt_context_impl::get_with_query(const core::document_id& id, bool optional,
             return self->op_completed_with_callback(std::move(cb),
                                                     std::optional<transaction_get_result>(doc));
           } catch (const std::exception& e) {
-            // TODO: unsure what to do here, but this is pretty fatal, so
+            // TODO(SA): unsure what to do here, but this is pretty fatal, so
             return self->op_completed_with_error(
               std::move(cb), transaction_operation_failed(FAIL_OTHER, e.what()));
           }
@@ -1863,7 +1889,7 @@ attempt_context_impl::get_with_query(const core::document_id& id, bool optional,
         // for get_optional.   <sigh>
         if (optional) {
           try {
-            std::rethrow_exception(std::move(err));
+            std::rethrow_exception(err);
           } catch (const document_not_found&) {
             return self->op_completed_with_callback(std::move(cb),
                                                     std::optional<transaction_get_result>());
@@ -1883,7 +1909,7 @@ attempt_context_impl::insert_raw_with_query(const core::document_id& id,
 {
   cache_error_async(
     cb, [self = shared_from_this(), id, content = std::move(content), cb]() mutable {
-      couchbase::transactions::transaction_query_options opts;
+      const couchbase::transactions::transaction_query_options opts;
       return self->wrap_query(
         KV_INSERT,
         opts,
@@ -1892,7 +1918,7 @@ attempt_context_impl::insert_raw_with_query(const core::document_id& id,
         STAGE_QUERY_KV_INSERT,
         true,
         {},
-        [self, id, cb = std::move(cb)](std::exception_ptr err,
+        [self, id, cb = std::move(cb)](const std::exception_ptr& err,
                                        core::operations::query_response resp) mutable {
           if (err) {
             try {
@@ -1916,7 +1942,7 @@ attempt_context_impl::insert_raw_with_query(const core::document_id& id,
             return self->op_completed_with_callback(std::move(cb),
                                                     std::optional<transaction_get_result>(doc));
           } catch (const std::exception& e) {
-            // TODO: unsure what to do here, but this is pretty fatal, so
+            // TODO(SA): unsure what to do here, but this is pretty fatal, so
             return self->op_completed_with_error(
               std::move(cb), transaction_operation_failed(FAIL_OTHER, e.what()));
           }
@@ -1931,7 +1957,7 @@ attempt_context_impl::replace_raw_with_query(const transaction_get_result& docum
 {
   cache_error_async(
     cb, [self = shared_from_this(), document, content = std::move(content), cb]() mutable {
-      couchbase::transactions::transaction_query_options opts;
+      const couchbase::transactions::transaction_query_options opts;
       return self->wrap_query(
         KV_REPLACE,
         opts,
@@ -1941,10 +1967,10 @@ attempt_context_impl::replace_raw_with_query(const transaction_get_result& docum
         true,
         {},
         [self, id = document.id(), cb = std::move(cb)](
-          std::exception_ptr err, core::operations::query_response resp) mutable {
+          const std::exception_ptr& err, core::operations::query_response resp) mutable {
           if (err) {
             try {
-              std::rethrow_exception(std::move(err));
+              std::rethrow_exception(err);
             } catch (const query_cas_mismatch& e) {
               return self->op_completed_with_error(
                 std::move(cb), transaction_operation_failed(FAIL_CAS_MISMATCH, e.what()).retry());
@@ -1968,7 +1994,7 @@ attempt_context_impl::replace_raw_with_query(const transaction_get_result& docum
             return self->op_completed_with_callback(std::move(cb),
                                                     std::optional<transaction_get_result>(doc));
           } catch (const std::exception& e) {
-            // TODO: unsure what to do here, but this is pretty fatal, so
+            // TODO(SA): unsure what to do here, but this is pretty fatal, so
             return self->op_completed_with_error(
               std::move(cb), transaction_operation_failed(FAIL_OTHER, e.what()));
           }
@@ -1980,7 +2006,7 @@ void
 attempt_context_impl::remove_with_query(const transaction_get_result& document, VoidCallback&& cb)
 {
   cache_error_async(cb, [self = shared_from_this(), document, cb]() {
-    couchbase::transactions::transaction_query_options opts;
+    const couchbase::transactions::transaction_query_options opts;
     return self->wrap_query(
       KV_REMOVE,
       opts,
@@ -1989,11 +2015,11 @@ attempt_context_impl::remove_with_query(const transaction_get_result& document,
       STAGE_QUERY_KV_REMOVE,
       true,
       {},
-      [self, id = document.id(), cb](std::exception_ptr err,
-                                     core::operations::query_response /* resp */) mutable {
+      [self, id = document.id(), cb](const std::exception_ptr& err,
+                                     const core::operations::query_response& /* resp */) mutable {
         if (err) {
           try {
-            std::rethrow_exception(std::move(err));
+            std::rethrow_exception(err);
           } catch (const transaction_operation_failed& e) {
             return self->op_completed_with_error(std::move(cb), e);
           } catch (const document_not_found& e) {
@@ -2019,9 +2045,9 @@ attempt_context_impl::remove_with_query(const transaction_get_result& document,
 void
 attempt_context_impl::commit_with_query(VoidCallback&& cb)
 {
-  core::operations::query_request req;
+  const core::operations::query_request req;
   CB_ATTEMPT_CTX_LOG_TRACE(this, "commit_with_query called");
-  couchbase::transactions::transaction_query_options opts;
+  const couchbase::transactions::transaction_query_options opts;
   wrap_query(
     COMMIT,
     opts,
@@ -2030,12 +2056,12 @@ attempt_context_impl::commit_with_query(VoidCallback&& cb)
     STAGE_QUERY_COMMIT,
     true,
     {},
-    [self = shared_from_this(), cb](std::exception_ptr err,
-                                    core::operations::query_response /* resp */) mutable {
+    [self = shared_from_this(), cb](const std::exception_ptr& err,
+                                    const core::operations::query_response& /* resp */) mutable {
       self->is_done_ = true;
       if (err) {
         try {
-          std::rethrow_exception(std::move(err));
+          std::rethrow_exception(err);
         } catch (const transaction_operation_failed&) {
           return cb(std::current_exception());
         } catch (const query_attempt_expired& e) {
@@ -2062,45 +2088,46 @@ attempt_context_impl::commit_with_query(VoidCallback&& cb)
 void
 attempt_context_impl::rollback_with_query(VoidCallback&& cb)
 {
-  core::operations::query_request req;
+  const core::operations::query_request req;
   CB_ATTEMPT_CTX_LOG_TRACE(this, "rollback_with_query called");
-  couchbase::transactions::transaction_query_options opts;
-  wrap_query(ROLLBACK,
-             opts,
-             {},
-             make_kv_txdata(std::nullopt),
-             STAGE_QUERY_ROLLBACK,
-             true,
-             {},
-             [self = shared_from_this(), cb](std::exception_ptr err,
-                                             core::operations::query_response /* resp */) mutable {
-               self->is_done_ = true;
-               if (err) {
-                 try {
-                   std::rethrow_exception(std::move(err));
-                 } catch (const transaction_operation_failed&) {
-                   return cb(std::current_exception());
-                 } catch (const query_attempt_not_found& e) {
-                   CB_ATTEMPT_CTX_LOG_DEBUG(self,
-                                            "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()));
-                 }
-               }
-               self->state(attempt_state::ROLLED_BACK);
-               CB_ATTEMPT_CTX_LOG_TRACE(self, "rollback successful");
-               return cb({});
-             });
+  const couchbase::transactions::transaction_query_options opts;
+  wrap_query(
+    ROLLBACK,
+    opts,
+    {},
+    make_kv_txdata(std::nullopt),
+    STAGE_QUERY_ROLLBACK,
+    true,
+    {},
+    [self = shared_from_this(), cb](const std::exception_ptr& err,
+                                    const core::operations::query_response& /* resp */) mutable {
+      self->is_done_ = true;
+      if (err) {
+        try {
+          std::rethrow_exception(err);
+        } catch (const transaction_operation_failed&) {
+          return cb(std::current_exception());
+        } catch (const query_attempt_not_found& e) {
+          CB_ATTEMPT_CTX_LOG_DEBUG(self,
+                                   "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()));
+        }
+      }
+      self->state(attempt_state::ROLLED_BACK);
+      CB_ATTEMPT_CTX_LOG_TRACE(self, "rollback successful");
+      return cb({});
+    });
 }
 void
 attempt_context_impl::atr_commit(bool ambiguity_resolution_mode)
 {
   retry_op<void>([self = shared_from_this(), &ambiguity_resolution_mode]() {
     try {
-      std::string prefix(ATR_FIELD_ATTEMPTS + "." + self->id() + ".");
+      const std::string prefix(ATR_FIELD_ATTEMPTS + "." + self->id() + ".");
       core::operations::mutate_in_request req{ self->atr_id_.value() };
       req.specs =
         couchbase::mutate_in_specs{
@@ -2113,7 +2140,7 @@ attempt_context_impl::atr_commit(bool ambiguity_resolution_mode)
           couchbase::mutate_in_specs::insert(prefix + ATR_FIELD_PREVENT_COLLLISION, 0).xattr(),
         }
           .specs();
-      wrap_durable_request(req, self->overall_->config());
+      wrap_durable_request(req, self->overall()->config());
       auto ec = self->error_if_expired_and_not_in_overtime(STAGE_ATR_COMMIT, {});
       if (ec) {
         throw client_error(
@@ -2135,9 +2162,9 @@ attempt_context_impl::atr_commit(bool ambiguity_resolution_mode)
                                "updating atr {}, setting to {}",
                                req.id,
                                attempt_state_name(attempt_state::COMMITTED));
-      self->overall_->cluster_ref().execute(
-        req, [barrier](core::operations::mutate_in_response resp) {
-          barrier->set_value(result::create_from_subdoc_response(std::move(resp)));
+      self->overall()->cluster_ref().execute(
+        req, [barrier](const core::operations::mutate_in_response& resp) {
+          barrier->set_value(result::create_from_subdoc_response(resp));
         });
       auto res = wrap_operation_future(f, false);
       ec = wait_for_hook([self](auto handler) mutable {
@@ -2148,7 +2175,7 @@ attempt_context_impl::atr_commit(bool ambiguity_resolution_mode)
       }
       self->state(attempt_state::COMMITTED);
     } catch (const client_error& e) {
-      error_class ec = e.ec();
+      const error_class ec = e.ec();
       switch (ec) {
         case FAIL_EXPIRY: {
           self->expiry_overtime_mode_ = true;
@@ -2243,14 +2270,17 @@ attempt_context_impl::atr_commit_ambiguity_resolution()
     if (ec) {
       throw client_error(*ec, "before_atr_commit_ambiguity_resolution hook threw error");
     }
-    std::string prefix(ATR_FIELD_ATTEMPTS + "." + id() + ".");
+    const std::string prefix(ATR_FIELD_ATTEMPTS + "." + id() + ".");
+    // FIXME(CXXCBC-549): if atr_id_ is optional, we should report an error somehow
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
     core::operations::lookup_in_request req{ atr_id_.value() };
     req.specs = lookup_in_specs{ lookup_in_specs::get(prefix + ATR_FIELD_STATUS).xattr() }.specs();
     auto barrier = std::make_shared<std::promise<result>>();
     auto f = barrier->get_future();
-    overall_->cluster_ref().execute(req, [barrier](core::operations::lookup_in_response resp) {
-      barrier->set_value(result::create_from_subdoc_response(std::move(resp)));
-    });
+    overall()->cluster_ref().execute(
+      req, [barrier](const 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>();
     CB_ATTEMPT_CTX_LOG_DEBUG(
@@ -2269,10 +2299,9 @@ attempt_context_impl::atr_commit_ambiguity_resolution()
           .no_rollback();
     }
   } catch (const client_error& e) {
-    error_class ec = e.ec();
+    const error_class ec = e.ec();
     switch (ec) {
       case FAIL_EXPIRY:
-        throw transaction_operation_failed(ec, e.what()).no_rollback().ambiguous();
       case FAIL_HARD:
         throw transaction_operation_failed(ec, e.what()).no_rollback().ambiguous();
       case FAIL_TRANSIENT:
@@ -2298,7 +2327,7 @@ void
 attempt_context_impl::atr_complete()
 {
   try {
-    result atr_res;
+    const result atr_res;
     auto ec = wait_for_hook([self = shared_from_this()](auto handler) mutable {
       return self->hooks_.before_atr_complete(self, std::move(handler));
     });
@@ -2311,20 +2340,24 @@ attempt_context_impl::atr_complete()
     if (ec) {
       throw client_error(*ec, "atr_complete threw error");
     }
+    // FIXME(CXXCBC-549): if atr_id_ is optional, we should report an error somehow
+    // NOLINTBEGIN(bugprone-unchecked-optional-access)
     CB_ATTEMPT_CTX_LOG_DEBUG(this, "removing attempt {} from atr", atr_id_.value());
-    std::string prefix(ATR_FIELD_ATTEMPTS + "." + id());
+    const std::string prefix(ATR_FIELD_ATTEMPTS + "." + id());
     core::operations::mutate_in_request req{ atr_id_.value() };
+    // NOLINTEND(bugprone-unchecked-optional-access)
     req.specs =
       couchbase::mutate_in_specs{
         couchbase::mutate_in_specs::remove(prefix).xattr(),
       }
         .specs();
-    wrap_durable_request(req, overall_->config());
+    wrap_durable_request(req, overall()->config());
     auto barrier = std::make_shared<std::promise<result>>();
     auto f = barrier->get_future();
-    overall_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
-      barrier->set_value(result::create_from_subdoc_response(resp));
-    });
+    overall()->cluster_ref().execute(
+      req, [barrier](const core::operations::mutate_in_response& resp) {
+        barrier->set_value(result::create_from_subdoc_response(resp));
+      });
     wrap_operation_future(f);
     ec = wait_for_hook([self = shared_from_this()](auto handler) mutable {
       return self->hooks_.after_atr_complete(self, std::move(handler));
@@ -2334,7 +2367,7 @@ attempt_context_impl::atr_complete()
     }
     state(attempt_state::COMPLETED);
   } catch (const client_error& er) {
-    switch (error_class ec = er.ec(); ec) {
+    switch (const error_class ec = er.ec(); ec) {
       case FAIL_HARD:
         throw transaction_operation_failed(ec, er.what()).no_rollback().failed_post_commit();
       default:
@@ -2342,6 +2375,7 @@ attempt_context_impl::atr_complete()
     }
   }
 }
+
 void
 attempt_context_impl::commit(VoidCallback&& cb)
 {
@@ -2368,7 +2402,7 @@ attempt_context_impl::commit()
   if (op_list_.get_mode().is_query()) {
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    commit_with_query([barrier](std::exception_ptr err) {
+    commit_with_query([barrier](const std::exception_ptr& err) {
       if (err) {
         barrier->set_exception(err);
       } else {
@@ -2416,7 +2450,9 @@ attempt_context_impl::atr_abort()
     if (ec) {
       throw client_error(*ec, "before_atr_aborted hook threw error");
     }
-    std::string prefix(ATR_FIELD_ATTEMPTS + "." + id() + ".");
+    const std::string prefix(ATR_FIELD_ATTEMPTS + "." + id() + ".");
+    // FIXME(CXXCBC-549): if atr_id_ is optional, we should report an error somehow
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
     core::operations::mutate_in_request req{ atr_id_.value() };
     req.specs =
       couchbase::mutate_in_specs{
@@ -2431,12 +2467,13 @@ attempt_context_impl::atr_abort()
       }
         .specs();
     staged_mutations_->extract_to(prefix, req);
-    wrap_durable_request(req, overall_->config());
+    wrap_durable_request(req, overall()->config());
     auto barrier = std::make_shared<std::promise<result>>();
     auto f = barrier->get_future();
-    overall_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
-      barrier->set_value(result::create_from_subdoc_response(resp));
-    });
+    overall()->cluster_ref().execute(
+      req, [barrier](const core::operations::mutate_in_response& resp) {
+        barrier->set_value(result::create_from_subdoc_response(resp));
+      });
     wrap_operation_future(f);
     state(attempt_state::ABORTED);
 
@@ -2497,19 +2534,22 @@ attempt_context_impl::atr_rollback_complete()
     if (ec) {
       throw client_error(*ec, "before_atr_rolled_back hook threw error");
     }
-    std::string prefix(ATR_FIELD_ATTEMPTS + "." + id());
+    const std::string prefix(ATR_FIELD_ATTEMPTS + "." + id());
+    // FIXME(CXXCBC-549): if atr_id_ is optional, we should report an error somehow
+    // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
     core::operations::mutate_in_request req{ atr_id_.value() };
     req.specs =
       couchbase::mutate_in_specs{
         couchbase::mutate_in_specs::remove(prefix).xattr(),
       }
         .specs();
-    wrap_durable_request(req, overall_->config());
+    wrap_durable_request(req, overall()->config());
     auto barrier = std::make_shared<std::promise<result>>();
     auto f = barrier->get_future();
-    overall_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
-      barrier->set_value(result::create_from_subdoc_response(resp));
-    });
+    overall()->cluster_ref().execute(
+      req, [barrier](const core::operations::mutate_in_response& resp) {
+        barrier->set_value(result::create_from_subdoc_response(resp));
+      });
     wrap_operation_future(f);
     state(attempt_state::ROLLED_BACK);
     ec = wait_for_hook([self = shared_from_this()](auto handler) mutable {
@@ -2531,6 +2571,9 @@ attempt_context_impl::atr_rollback_complete()
         .expired();
     }
     CB_ATTEMPT_CTX_LOG_DEBUG(this, "atr_rollback_complete got error {}", ec);
+    // FIXME(SA): if atr_id_ is optional, we should report an error somehow
+    // TODO(CXXCBC-549)
+    // NOLINTBEGIN(bugprone-unchecked-optional-access)
     switch (ec) {
       case FAIL_DOC_NOT_FOUND:
       case FAIL_PATH_NOT_FOUND:
@@ -2549,6 +2592,7 @@ attempt_context_impl::atr_rollback_complete()
         CB_ATTEMPT_CTX_LOG_DEBUG(this, "retrying atr_rollback_complete");
         throw retry_operation(e.what());
     }
+    // NOLINTEND(bugprone-unchecked-optional-access)
   }
 }
 void
@@ -2582,7 +2626,7 @@ attempt_context_impl::rollback()
   if (op_list_.get_mode().is_query()) {
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    rollback_with_query([barrier](std::exception_ptr err) {
+    rollback_with_query([barrier](const std::exception_ptr& err) {
       if (err) {
         barrier->set_exception(err);
       } else {
@@ -2594,7 +2638,7 @@ attempt_context_impl::rollback()
   // check for expiry
   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
+    // TODO(SA): check this, but if we try to rollback an empty txn, we should
     // prevent a subsequent commit
     CB_ATTEMPT_CTX_LOG_DEBUG(this, "rollback called on txn with no mutations");
     is_done_ = true;
@@ -2620,7 +2664,7 @@ attempt_context_impl::rollback()
       self->atr_rollback_complete();
     });
   } catch (const client_error& e) {
-    error_class ec = e.ec();
+    const error_class ec = e.ec();
     CB_ATTEMPT_CTX_LOG_ERROR(this,
                              "rollback transaction {}, attempt {} fail with error {}",
                              transaction_id(),
@@ -2636,8 +2680,8 @@ auto
 attempt_context_impl::has_expired_client_side(std::string place,
                                               std::optional<const std::string> doc_id) -> bool
 {
-  bool over = overall_->has_expired_client_side();
-  bool hook = hooks_.has_expired_client_side(shared_from_this(), place, std::move(doc_id));
+  const bool over = overall()->has_expired_client_side();
+  const bool hook = hooks_.has_expired_client_side(shared_from_this(), place, std::move(doc_id));
   if (over) {
     CB_ATTEMPT_CTX_LOG_DEBUG(this, "{} expired in {}", id(), place);
   }
@@ -2713,7 +2757,7 @@ attempt_context_impl::set_atr_pending_locked(
 {
   try {
     if (staged_mutations_->empty()) {
-      std::string prefix(ATR_FIELD_ATTEMPTS + "." + this->id() + ".");
+      const std::string prefix(ATR_FIELD_ATTEMPTS + "." + this->id() + ".");
       if (!atr_id_) {
         return fn(
           transaction_operation_failed(FAIL_OTHER, std::string("ATR ID is not initialized")));
@@ -2746,7 +2790,7 @@ attempt_context_impl::set_atr_pending_locked(
             case FAIL_AMBIGUOUS:
               // Retry just this
               CB_ATTEMPT_CTX_LOG_DEBUG(self, "got FAIL_AMBIGUOUS, retrying set atr pending", ec);
-              return self->overall_->after_delay(
+              return self->overall()->after_delay(
                 std::chrono::milliseconds(1), [self, doc_id, &lock, fn = std::move(fn)]() mutable {
                   self->set_atr_pending_locked(doc_id, std::move(lock), std::move(fn));
                 });
@@ -2772,21 +2816,21 @@ attempt_context_impl::set_atr_pending_locked(
 
           CB_ATTEMPT_CTX_LOG_DEBUG(self, "updating atr {}", self->atr_id_.value());
 
-          std::chrono::nanoseconds remaining = self->overall_->remaining();
+          const std::chrono::nanoseconds remaining = self->overall()->remaining();
           // This bounds the value to [0-timeout].  It should always be in this
           // range, this is just to protect against the application clock
           // changing.
-          long remaining_bounded_nanos =
-            std::max(std::min(remaining.count(), self->overall_->config().timeout.count()),
+          const long remaining_bounded_nanos =
+            std::max(std::min(remaining.count(), self->overall()->config().timeout.count()),
                      static_cast<std::chrono::nanoseconds::rep>(0));
-          long remaining_bounded_msecs = remaining_bounded_nanos / 1'000'000;
+          const long remaining_bounded_msecs = remaining_bounded_nanos / 1'000'000;
 
           core::operations::mutate_in_request req{ self->atr_id_.value() };
 
           req.specs =
             couchbase::mutate_in_specs{
               couchbase::mutate_in_specs::insert(prefix + ATR_FIELD_TRANSACTION_ID,
-                                                 self->overall_->transaction_id())
+                                                 self->overall()->transaction_id())
                 .xattr()
                 .create_path(),
               couchbase::mutate_in_specs::insert(prefix + ATR_FIELD_STATUS,
@@ -2804,7 +2848,7 @@ attempt_context_impl::set_atr_pending_locked(
               // ExtStoreDurability
               couchbase::mutate_in_specs::insert(
                 prefix + ATR_FIELD_DURABILITY_LEVEL,
-                store_durability_level_to_string(self->overall_->config().level))
+                store_durability_level_to_string(self->overall()->config().level))
                 .xattr()
                 .create_path(),
               // subdoc::opcode::set_doc used in replace w/ empty path
@@ -2815,8 +2859,8 @@ attempt_context_impl::set_atr_pending_locked(
               .specs();
           req.store_semantics = couchbase::store_semantics::upsert;
 
-          wrap_durable_request(req, self->overall_->config());
-          return self->overall_->cluster_ref().execute(
+          wrap_durable_request(req, self->overall()->config());
+          return self->overall()->cluster_ref().execute(
             req,
             [self, fn = std::move(fn), error_handler = std::move(error_handler)](
               core::operations::mutate_in_response resp) mutable {
@@ -2898,15 +2942,14 @@ attempt_context_impl::do_get(const core::document_id& id,
       return cb(FAIL_EXPIRY, "expired in do_get", std::nullopt);
     }
 
-    staged_mutation* own_write = check_for_own_write(id);
-    if (own_write) {
+    if (const staged_mutation* own_write = check_for_own_write(id); own_write != nullptr) {
       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) {
+    if (const staged_mutation* own_remove = staged_mutations_->find_remove(id);
+        own_remove != nullptr) {
       auto msg = fmt::format("found own-write of removed doc {}", id);
       CB_ATTEMPT_CTX_LOG_DEBUG(this, "{}", msg);
       return cb(FAIL_DOC_NOT_FOUND, msg, std::nullopt);
@@ -2958,17 +3001,17 @@ attempt_context_impl::do_get(const core::document_id& id,
                   return cb(std::nullopt, std::nullopt, doc);
                 }
 
-                core::document_id doc_atr_id{ doc->links().atr_bucket_name().value(),
-                                              doc->links().atr_scope_name().value(),
-                                              doc->links().atr_collection_name().value(),
-                                              doc->links().atr_id().value() };
+                const core::document_id doc_atr_id{ doc->links().atr_bucket_name().value(),
+                                                    doc->links().atr_scope_name().value(),
+                                                    doc->links().atr_collection_name().value(),
+                                                    doc->links().atr_id().value() };
                 active_transaction_record::get_atr(
                   self->cluster_ref(),
                   doc_atr_id,
                   [self, id, allow_replica, doc, cb = std::move(cb)](
                     std::error_code ec2, std::optional<active_transaction_record> atr) mutable {
                     if (!ec2 && atr) {
-                      active_transaction_record& atr_doc = atr.value();
+                      const active_transaction_record& atr_doc = atr.value();
                       std::optional<atr_entry> entry;
                       for (const auto& e : atr_doc.entries()) {
                         if (doc->links().staged_attempt_id().value() == e.attempt_id()) {
@@ -3064,9 +3107,9 @@ execute_lookup(attempt_context_impl* ctx, LookupInRequest& req, Callback&& cb)
       CB_ATTEMPT_CTX_LOG_TRACE(ctx, "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));
+          return cb(ec, resp.ctx.ec().message(), transaction_get_result::create_from(resp));
         default:
-          return cb(*ec, resp.ctx.ec().message(), std::nullopt);
+          return cb(ec, resp.ctx.ec().message(), std::nullopt);
       }
     } else {
       return cb({}, {}, transaction_get_result::create_from(resp));
@@ -3103,12 +3146,12 @@ attempt_context_impl::get_doc(const core::document_id& id,
       core::operations::lookup_in_any_replica_request req{ id };
       req.read_preference = couchbase::read_preference::selected_server_group;
       req.specs = specs;
-      execute_lookup(this, req, std::move(cb));
+      execute_lookup(this, req, cb);
     } else {
       core::operations::lookup_in_request req{ id };
       req.access_deleted = true;
       req.specs = specs;
-      execute_lookup(this, req, std::move(cb));
+      execute_lookup(this, req, cb);
     }
   } catch (const std::exception& e) {
     return cb(FAIL_OTHER, e.what(), std::nullopt);
@@ -3344,7 +3387,7 @@ attempt_context_impl::create_staged_insert(const core::document_id& id,
   }
   CB_ATTEMPT_CTX_LOG_DEBUG(this, "about to insert staged doc {} with cas {}", id, cas);
   core::operations::mutate_in_request req{ id };
-  bool binary =
+  const bool binary =
     codec::codec_flags::has_common_flags(content.flags, codec::codec_flags::binary_common_flags);
   auto txn = create_document_metadata("insert", op_id, {}, content.flags);
   req.specs =
@@ -3360,15 +3403,15 @@ attempt_context_impl::create_staged_insert(const core::document_id& id,
         .create_path(),
     }
       .specs();
-  req.durability_level = overall_->config().level;
+  req.durability_level = overall()->config().level;
   req.access_deleted = true;
   req.create_as_deleted = true;
   req.flags = content.flags;
   req.cas = couchbase::cas(cas);
   req.store_semantics =
     cas == 0 ? couchbase::store_semantics::insert : couchbase::store_semantics::replace;
-  wrap_durable_request(req, overall_->config());
-  overall_->cluster_ref().execute(
+  wrap_durable_request(req, overall()->config());
+  overall()->cluster_ref().execute(
     req,
     [self = shared_from_this(),
      id,
@@ -3433,7 +3476,7 @@ attempt_context_impl::create_staged_insert(const core::document_id& id,
               id.bucket(),
               id.scope(),
               id.collection(),
-              self->overall_->transaction_id(),
+              self->overall()->transaction_id(),
               self->id(),
               op_id,
               std::move(staged_content_json),
@@ -3478,9 +3521,10 @@ void
 attempt_context_impl::remove(couchbase::transactions::transaction_get_result doc,
                              couchbase::transactions::async_err_handler&& handler)
 {
-  remove(transaction_get_result(doc), [handler = std::move(handler)](std::exception_ptr e) mutable {
-    wrap_err_callback_for_async_api(std::move(e), std::move(handler));
-  });
+  remove(transaction_get_result(doc),
+         [handler = std::move(handler)](const std::exception_ptr& e) mutable {
+           wrap_err_callback_for_async_api(e, std::move(handler));
+         });
 }
 
 auto
@@ -3515,13 +3559,12 @@ attempt_context_impl::get(const couchbase::collection& coll,
                           couchbase::transactions::async_result_handler&& handler)
 {
   get_optional({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
-               [handler = std::move(handler)](std::exception_ptr err,
+               [handler = std::move(handler)](const std::exception_ptr& err,
                                               std::optional<transaction_get_result> res) mutable {
                  if (!res) {
                    return handler({ errc::transaction_op::document_not_found }, {});
                  }
-                 return wrap_callback_for_async_public_api(
-                   std::move(err), std::move(res), std::move(handler));
+                 return wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
                });
 }
 void
@@ -3533,11 +3576,11 @@ attempt_context_impl::query(std::string statement,
   query(statement,
         opts,
         query_context,
-        [handler = std::move(handler)](std::exception_ptr err,
+        [handler = std::move(handler)](const std::exception_ptr& err,
                                        std::optional<core::operations::query_response> resp) {
           if (err) {
             try {
-              std::rethrow_exception(std::move(err));
+              std::rethrow_exception(err);
             } catch (const transaction_operation_failed& e) {
               return handler(core::impl::make_error(e), {});
             } catch (const op_exception& ex) {
@@ -3562,10 +3605,10 @@ attempt_context_impl::existing_error(bool prev_op_failed)
 }
 
 void
-attempt_context_impl::handle_err_from_callback(std::exception_ptr e)
+attempt_context_impl::handle_err_from_callback(const std::exception_ptr& e)
 {
   try {
-    std::rethrow_exception(std::move(e));
+    std::rethrow_exception(e);
   } catch (const transaction_operation_failed& ex) {
     CB_ATTEMPT_CTX_LOG_ERROR(
       this, "op callback called a txn operation that threw exception {}", ex.what());
@@ -3600,10 +3643,10 @@ attempt_context_impl::handle_err_from_callback(std::exception_ptr e)
 }
 
 void
-attempt_context_impl::op_completed_with_error(VoidCallback cb, std::exception_ptr err)
+attempt_context_impl::op_completed_with_error(const VoidCallback& cb, const std::exception_ptr& err)
 {
   try {
-    std::rethrow_exception(std::move(err));
+    std::rethrow_exception(err);
   } catch (const transaction_operation_failed& e) {
     // if this is a transaction_operation_failed, we need to cache it before
     // moving on...
@@ -3625,4 +3668,64 @@ attempt_context_impl::op_completed_with_error(VoidCallback cb, std::exception_pt
     }
   }
 }
+
+auto
+attempt_context_impl::is_done() const -> bool
+{
+  return is_done_;
+}
+
+auto
+attempt_context_impl::overall() const -> std::shared_ptr<transaction_context>
+{
+  return overall_.lock();
+}
+
+auto
+attempt_context_impl::transaction_id() const -> const std::string&
+{
+  return overall()->transaction_id();
+}
+
+auto
+attempt_context_impl::id() const -> const std::string&
+{
+  return overall()->current_attempt().id;
+}
+
+auto
+attempt_context_impl::state() const -> attempt_state
+{
+  return overall()->current_attempt().state;
+}
+
+void
+attempt_context_impl::state(attempt_state s) const
+{
+  overall()->current_attempt_state(s);
+}
+
+auto
+attempt_context_impl::atr_id() const -> const std::string&
+{
+  return overall()->atr_id();
+}
+
+void
+attempt_context_impl::atr_id(const std::string& atr_id) const
+{
+  overall()->atr_id(atr_id);
+}
+
+auto
+attempt_context_impl::atr_collection() const -> const std::string&
+{
+  return overall()->atr_collection();
+}
+
+void
+attempt_context_impl::atr_collection_name(const std::string& coll) const
+{
+  overall()->atr_collection(coll);
+}
 } // namespace couchbase::core::transactions