couchbase 3.5.2 → 3.5.4

data/ext/couchbase/core/tracing/threshold_logging_tracer.cxx

@@ -32,6 +32,7 @@
 #include <chrono>
 #include <mutex>
 #include <queue>
+#include <utility>
 
 namespace couchbase::core::tracing
 {
@@ -68,7 +69,7 @@ public:
   threshold_logging_span(std::string name,
                          std::shared_ptr<threshold_logging_tracer> tracer,
                          std::shared_ptr<request_span> parent = nullptr)
-    : request_span(std::move(name), parent)
+    : request_span(std::move(name), std::move(parent))
     , tracer_{ std::move(tracer) }
   {
   }
@@ -168,21 +169,11 @@ public:
   {
   }
 
-  concurrent_fixed_queue(concurrent_fixed_queue& other)
-  {
-    std::unique_lock<std::mutex> lock(other.mutex_);
-    data_ = other.data_;
-    capacity_ = other.capacity_;
-  }
-
-  concurrent_fixed_queue(const concurrent_fixed_queue& other) = delete;
-
-  concurrent_fixed_queue(concurrent_fixed_queue&& other) noexcept
-  {
-    std::unique_lock<std::mutex> lock(other.mutex_);
-    std::swap(data_, other.data_);
-    std::swap(capacity_, other.capacity_);
-  }
+  concurrent_fixed_queue(const concurrent_fixed_queue&) = delete;
+  concurrent_fixed_queue(concurrent_fixed_queue&&) = delete;
+  auto operator=(const concurrent_fixed_queue&) -> concurrent_fixed_queue& = delete;
+  auto operator=(concurrent_fixed_queue&&) -> concurrent_fixed_queue& = delete;
+  ~concurrent_fixed_queue() = default;
 
   void pop()
   {
@@ -198,13 +189,13 @@ public:
 
   auto empty() -> bool
   {
-    std::unique_lock<std::mutex> lock(mutex_);
+    const std::unique_lock<std::mutex> lock(mutex_);
     return data_.empty();
   }
 
   void emplace(const T&& item)
   {
-    std::unique_lock<std::mutex> lock(mutex_);
+    const std::unique_lock<std::mutex> lock(mutex_);
     data_.emplace(std::forward<const T>(item));
     if (data_.size() > capacity_) {
       data_.pop();
@@ -214,7 +205,7 @@ public:
   auto steal_data() -> std::priority_queue<T>
   {
     std::priority_queue<T> data;
-    std::unique_lock<std::mutex> lock(mutex_);
+    const std::unique_lock<std::mutex> lock(mutex_);
     std::swap(data, data_);
     return data;
   }
@@ -223,7 +214,7 @@ public:
 using fixed_span_queue = concurrent_fixed_queue<reported_span>;
 
 auto
-convert(std::shared_ptr<threshold_logging_span> span) -> reported_span
+convert(const std::shared_ptr<threshold_logging_span>& span) -> reported_span
 {
   tao::json::value entry{
     { "operation_name", span->name() },
@@ -276,6 +267,11 @@ public:
     threshold_queues_.try_emplace(service_type::management, options.threshold_sample_size);
   }
 
+  threshold_logging_tracer_impl(const threshold_logging_tracer_impl&) = delete;
+  threshold_logging_tracer_impl(threshold_logging_tracer_impl&&) = delete;
+  auto operator=(const threshold_logging_tracer_impl&) -> threshold_logging_tracer_impl& = delete;
+  auto operator=(threshold_logging_tracer_impl&&) -> threshold_logging_tracer_impl& = delete;
+
   ~threshold_logging_tracer_impl()
   {
     emit_orphan_report_.cancel();
@@ -297,12 +293,12 @@ public:
     emit_threshold_report_.cancel();
   }
 
-  void add_orphan(std::shared_ptr<threshold_logging_span> span)
+  void add_orphan(const std::shared_ptr<threshold_logging_span>& span)
   {
-    orphan_queue_.emplace(convert(std::move(span)));
+    orphan_queue_.emplace(convert(span));
   }
 
-  void check_threshold(std::shared_ptr<threshold_logging_span> span)
+  void check_threshold(const std::shared_ptr<threshold_logging_span>& span)
   {
     auto service = span->service();
     if (!service.has_value()) {
@@ -409,12 +405,12 @@ threshold_logging_tracer::start_span(std::string name,
 }
 
 void
-threshold_logging_tracer::report(std::shared_ptr<threshold_logging_span> span)
+threshold_logging_tracer::report(const std::shared_ptr<threshold_logging_span>& span)
 {
   if (span->orphan()) {
-    impl_->add_orphan(std::move(span));
+    impl_->add_orphan(span);
   } else {
-    impl_->check_threshold(std::move(span));
+    impl_->check_threshold(span);
   }
 }
 

data/ext/couchbase/core/tracing/threshold_logging_tracer.hxx

@@ -40,7 +40,7 @@ public:
 
   auto start_span(std::string name, std::shared_ptr<couchbase::tracing::request_span> parent)
     -> std::shared_ptr<couchbase::tracing::request_span> override;
-  void report(std::shared_ptr<threshold_logging_span> span);
+  void report(const std::shared_ptr<threshold_logging_span>& span);
   void start() override;
   void stop() override;
 

data/ext/couchbase/core/tracing/tracer_wrapper.cxx

@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "tracer_wrapper.hxx"
+
+#include "constants.hxx"
+
+#include <mutex>
+
+namespace couchbase::core::tracing
+{
+tracer_wrapper::tracer_wrapper(std::shared_ptr<couchbase::tracing::request_tracer> tracer)
+  : tracer_{ std::move(tracer) }
+{
+}
+
+void
+tracer_wrapper::start()
+{
+  tracer_->start();
+}
+
+void
+tracer_wrapper::stop()
+{
+  tracer_->stop();
+}
+
+auto
+tracer_wrapper::create_span(std::string span_name,
+                            std::shared_ptr<couchbase::tracing::request_span> parent_span)
+  -> std::shared_ptr<couchbase::tracing::request_span>
+{
+  auto span = tracer_->start_span(std::move(span_name), std::move(parent_span));
+  span->add_tag(attributes::system, "couchbase");
+
+  std::optional<std::string> cluster_name;
+  std::optional<std::string> cluster_uuid;
+  {
+    const std::shared_lock lock{ cluster_labels_mutex_ };
+    cluster_name = cluster_name_;
+    cluster_uuid = cluster_uuid_;
+  }
+
+  if (cluster_name) {
+    span->add_tag(attributes::cluster_name, cluster_name.value());
+  }
+  if (cluster_uuid) {
+    span->add_tag(attributes::cluster_uuid, cluster_uuid.value());
+  }
+
+  return span;
+}
+
+void
+tracer_wrapper::update_config(topology::configuration config)
+{
+  const std::scoped_lock<std::shared_mutex> lock{ cluster_labels_mutex_ };
+  if (config.cluster_uuid.has_value()) {
+    cluster_uuid_ = config.cluster_uuid;
+  }
+  if (config.cluster_name.has_value()) {
+    cluster_name_ = config.cluster_name;
+  }
+}
+
+auto
+tracer_wrapper::create(std::shared_ptr<couchbase::tracing::request_tracer> tracer)
+  -> std::shared_ptr<tracer_wrapper>
+{
+  return std::make_shared<tracer_wrapper>(std::move(tracer));
+}
+} // namespace couchbase::core::tracing

data/ext/couchbase/core/tracing/tracer_wrapper.hxx

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "core/config_listener.hxx"
+#include "core/topology/configuration.hxx"
+
+#include <couchbase/tracing/request_span.hxx>
+#include <couchbase/tracing/request_tracer.hxx>
+
+#include <memory>
+#include <optional>
+#include <shared_mutex>
+#include <string>
+
+namespace couchbase::core::tracing
+{
+class tracer_wrapper : public config_listener
+{
+public:
+  explicit tracer_wrapper(std::shared_ptr<couchbase::tracing::request_tracer> tracer);
+
+  void start();
+  void stop();
+
+  auto create_span(std::string span_name,
+                   std::shared_ptr<couchbase::tracing::request_span> parent_span)
+    -> std::shared_ptr<couchbase::tracing::request_span>;
+
+  void update_config(topology::configuration config) override;
+
+  [[nodiscard]] static auto create(std::shared_ptr<couchbase::tracing::request_tracer> tracer)
+    -> std::shared_ptr<tracer_wrapper>;
+
+private:
+  std::shared_ptr<couchbase::tracing::request_tracer> tracer_;
+
+  std::optional<std::string> cluster_name_{};
+  std::optional<std::string> cluster_uuid_{};
+  std::shared_mutex cluster_labels_mutex_{};
+};
+} // namespace couchbase::core::tracing

data/ext/couchbase/core/transactions/active_transaction_record.cxx

@@ -54,12 +54,12 @@ parse_mutation_cas(const std::string& cas) -> std::uint64_t
 
   std::uint64_t val = stoull(cas, nullptr, 16);
   /* byteswap */
-  std::size_t ii;
+  std::size_t ii = 0;
   std::uint64_t ret = 0;
   for (ii = 0; ii < sizeof(std::uint64_t); ii++) {
-    ret <<= 8ull;
-    ret |= val & 0xffull;
-    val >>= 8ull;
+    ret <<= 8ULL;
+    ret |= val & 0xffULL;
+    val >>= 8ULL;
   }
   return ret / 1000000;
 }
@@ -94,7 +94,7 @@ map_to_atr(const operations::lookup_in_response& resp) -> active_transaction_rec
       if (const auto* compat = val.find(ATR_FIELD_FORWARD_COMPAT); compat != nullptr) {
         forward_compat = *compat;
       }
-      std::optional<std::uint32_t> expires_after_msec =
+      const std::optional<std::uint32_t> expires_after_msec =
         std::max(val.optional<std::int32_t>(ATR_FIELD_EXPIRES_AFTER_MSECS).value_or(0), 0);
       entries.emplace_back(
         resp.ctx.bucket(),
@@ -117,10 +117,9 @@ map_to_atr(const operations::lookup_in_response& resp) -> active_transaction_rec
         val.optional<std::string>(ATR_FIELD_DURABILITY_LEVEL));
     }
   }
-  return active_transaction_record(
-    { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() },
-    resp.cas.value(),
-    std::move(entries));
+  return { { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() },
+           resp.cas.value(),
+           std::move(entries) };
 }
 
 auto
@@ -151,28 +150,28 @@ active_transaction_record::get_atr(
       lookup_in_specs::get(subdoc::lookup_in_macro::vbucket).xattr(),
     }
       .specs();
-  cluster.execute(req,
-                  [atr_id, cb = std::move(cb)](core::operations::lookup_in_response resp) mutable {
-                    try {
-                      if (resp.ctx.ec() == couchbase::errc::key_value::document_not_found) {
-                        // that's ok, just return an empty one.
-                        return cb({}, {});
-                      }
-                      if (!resp.ctx.ec()) {
-                        // success
-                        return cb(resp.ctx.ec(), map_to_atr(resp));
-                      }
-                      // otherwise, raise an error.
-                      cb(resp.ctx.ec(), {});
-                    } catch (const std::exception&) {
-                      // ok - we have a corrupt ATR.  The question is:  what should we return
-                      // for an error? Turns out, we don't much care in the code what this error
-                      // is.  Since we cannot parse the atr, but there wasn't an error, lets
-                      // select this one for now.
-                      // TODO: consider a different mechanism - not an error_code.  Or, perhaps
-                      // we need txn-specific error codes?
-                      cb(couchbase::errc::key_value::path_invalid, std::nullopt);
-                    }
-                  });
+  cluster.execute(
+    req, [atr_id, cb = std::move(cb)](const core::operations::lookup_in_response& resp) mutable {
+      try {
+        if (resp.ctx.ec() == couchbase::errc::key_value::document_not_found) {
+          // that's ok, just return an empty one.
+          return cb({}, {});
+        }
+        if (!resp.ctx.ec()) {
+          // success
+          return cb(resp.ctx.ec(), map_to_atr(resp));
+        }
+        // otherwise, raise an error.
+        cb(resp.ctx.ec(), {});
+      } catch (const std::exception&) {
+        // ok - we have a corrupt ATR.  The question is:  what should we return
+        // for an error? Turns out, we don't much care in the code what this error
+        // is.  Since we cannot parse the atr, but there wasn't an error, lets
+        // select this one for now.
+        // TODO(SA): consider a different mechanism - not an error_code.  Or, perhaps
+        // we need txn-specific error codes?
+        cb(couchbase::errc::key_value::path_invalid, std::nullopt);
+      }
+    });
 }
 } // namespace couchbase::core::transactions

data/ext/couchbase/core/transactions/async_attempt_context.hxx

@@ -16,12 +16,12 @@
 #pragma once
 
 #include "core/error_context/subdocument_error_context.hxx"
-#include "couchbase/cluster.hxx"
-#include "couchbase/transactions/transaction_query_options.hxx"
+#include "core/operations/document_query.hxx"
 #include "exceptions.hxx"
 #include "transaction_get_result.hxx"
 
-#include "core/operations/document_query.hxx"
+#include <couchbase/transactions/transaction_query_options.hxx>
+
 #include <future>
 #include <optional>
 #include <string>

data/ext/couchbase/core/transactions/atr_cleanup_entry.cxx

@@ -20,18 +20,21 @@
 #include "durability_level.hxx"
 #include "forward_compat.hxx"
 
+#include "core/operations.hxx"
 #include "core/transactions.hxx"
 #include "internal/atr_cleanup_entry.hxx"
 #include "internal/doc_record_fmt.hxx"
 #include "internal/exceptions_internal.hxx"
 #include "internal/exceptions_internal_fmt.hxx"
 #include "internal/logging.hxx"
+#include "internal/transaction_context.hxx"
 #include "internal/transactions_cleanup.hxx"
 #include "internal/utils.hxx"
 #include "result.hxx"
 #include "result_fmt.hxx"
 
 #include <optional>
+#include <utility>
 
 namespace couchbase::core::transactions
 {
@@ -46,11 +49,11 @@ compare_atr_entries::operator()(atr_cleanup_entry& lhs, atr_cleanup_entry& rhs)
 // wait a bit after an attempt is expired before cleaning it.
 const uint32_t atr_cleanup_entry::safety_margin_ms_ = 1500;
 
-atr_cleanup_entry::atr_cleanup_entry(const core::document_id& atr_id,
-                                     const std::string& attempt_id,
+atr_cleanup_entry::atr_cleanup_entry(core::document_id atr_id,
+                                     std::string attempt_id,
                                      const transactions_cleanup& cleanup)
-  : atr_id_(atr_id)
-  , attempt_id_(attempt_id)
+  : atr_id_(std::move(atr_id))
+  , attempt_id_(std::move(attempt_id))
   , check_if_expired_(false)
   , cleanup_(&cleanup)
   , atr_entry_(nullptr)
@@ -58,11 +61,10 @@ atr_cleanup_entry::atr_cleanup_entry(const core::document_id& atr_id,
 }
 
 atr_cleanup_entry::atr_cleanup_entry(const atr_entry& entry,
-                                     const core::document_id& atr_id,
+                                     core::document_id atr_id,
                                      const transactions_cleanup& cleanup,
                                      bool check_if_expired)
-  //  : atr_id_(atr_id.bucket(), atr_id.scope(), atr_id.collection(), atr_id.key())
-  : atr_id_(atr_id)
+  : atr_id_(std::move(atr_id))
   , attempt_id_(entry.attempt_id())
   , check_if_expired_(check_if_expired)
   , cleanup_(&cleanup)
@@ -70,7 +72,7 @@ atr_cleanup_entry::atr_cleanup_entry(const atr_entry& entry,
 {
 }
 
-atr_cleanup_entry::atr_cleanup_entry(std::shared_ptr<attempt_context> ctx)
+atr_cleanup_entry::atr_cleanup_entry(const std::shared_ptr<attempt_context>& ctx)
   : min_start_time_(std::chrono::steady_clock::now())
   , check_if_expired_(false)
   , atr_entry_(nullptr)
@@ -78,12 +80,17 @@ atr_cleanup_entry::atr_cleanup_entry(std::shared_ptr<attempt_context> ctx)
   // NOTE: we create these entries externally, in fit_performer tests, hence the
   // use of attempt_context rather than attempt_context_impl
   auto ctx_impl = std::dynamic_pointer_cast<attempt_context_impl>(ctx);
-  atr_id_ = { ctx_impl->atr_id_.value().bucket(),
-              ctx_impl->atr_id_.value().scope(),
-              ctx_impl->atr_id_.value().collection(),
-              ctx_impl->atr_id_.value().key() };
+  Expects(ctx_impl != nullptr);
+  if (auto atr_id = ctx_impl->atr_id_; atr_id.has_value()) {
+    atr_id_ = {
+      atr_id->bucket(),
+      atr_id->scope(),
+      atr_id->collection(),
+      atr_id->key(),
+    };
+  }
   attempt_id_ = ctx_impl->id();
-  cleanup_ = &ctx_impl->overall_->cleanup();
+  cleanup_ = &ctx_impl->overall()->cleanup();
 }
 
 void
@@ -91,7 +98,7 @@ atr_cleanup_entry::clean(transactions_cleanup_attempt* result)
 {
   CB_ATTEMPT_CLEANUP_LOG_TRACE("cleaning {}", *this);
   // get atr entry if needed
-  atr_entry entry;
+  const atr_entry entry;
   if (nullptr == atr_entry_) {
     auto atr = active_transaction_record::get_atr(cleanup_->cluster_ref(), atr_id_);
     if (atr) {
@@ -102,14 +109,12 @@ atr_cleanup_entry::clean(transactions_cleanup_attempt* result)
       if (it != atr->entries().end()) {
         atr_entry_ = &(*it);
         return check_atr_and_cleanup(result);
-      } else {
-        CB_ATTEMPT_CLEANUP_LOG_TRACE("could not find attempt {}, nothing to clean", attempt_id_);
-        return;
       }
-    } else {
-      CB_ATTEMPT_CLEANUP_LOG_TRACE("could not find atr {}, nothing to clean", atr_id_);
+      CB_ATTEMPT_CLEANUP_LOG_TRACE("could not find attempt {}, nothing to clean", attempt_id_);
       return;
     }
+    CB_ATTEMPT_CLEANUP_LOG_TRACE("could not find atr {}, nothing to clean", atr_id_);
+    return;
   }
   check_atr_and_cleanup(result);
 }
@@ -127,7 +132,7 @@ atr_cleanup_entry::check_atr_and_cleanup(transactions_cleanup_attempt* result)
     CB_ATTEMPT_CLEANUP_LOG_TRACE("not expired, nothing to clean");
     return;
   }
-  if (result) {
+  if (result != nullptr) {
     result->state(atr_entry_->state());
   }
   auto err =
@@ -149,7 +154,6 @@ atr_cleanup_entry::check_atr_and_cleanup(transactions_cleanup_attempt* result)
   if (ec) {
     throw client_error(*ec, "on_cleanup_completed hook threw error");
   }
-  return;
 }
 
 void
@@ -175,7 +179,7 @@ atr_cleanup_entry::cleanup_docs(durability_level dl)
 }
 
 void
-atr_cleanup_entry::do_per_doc(std::vector<doc_record> docs,
+atr_cleanup_entry::do_per_doc(const std::vector<doc_record>& docs,
                               bool require_crc_to_match,
                               const std::function<void(transaction_get_result&, bool)>& call)
 {
@@ -227,19 +231,21 @@ atr_cleanup_entry::do_per_doc(std::vector<doc_record> docs,
         continue;
       }
       if (require_crc_to_match) {
-        if (!doc.metadata()->crc32() || !doc.links().crc32_of_staging() ||
-            doc.links().crc32_of_staging() != doc.metadata()->crc32()) {
-          CB_ATTEMPT_CLEANUP_LOG_TRACE(
-            "document {} crc32 {} doesn't match staged value {}, skipping",
-            dr.id(),
-            doc.metadata()->crc32().value_or("<none>"),
-            doc.links().crc32_of_staging().value_or("<none>"));
-          continue;
+        if (const auto& metadata = doc.metadata(); metadata.has_value()) {
+          if (!metadata->crc32() || !doc.links().crc32_of_staging() ||
+              doc.links().crc32_of_staging() != metadata->crc32()) {
+            CB_ATTEMPT_CLEANUP_LOG_TRACE(
+              "document {} crc32 {} doesn't match staged value {}, skipping",
+              dr.id(),
+              metadata->crc32().value_or("<none>"),
+              doc.links().crc32_of_staging().value_or("<none>"));
+            continue;
+          }
         }
       }
       call(doc, res.deleted);
     } catch (const client_error& e) {
-      error_class ec = e.ec();
+      const error_class ec = e.ec();
       switch (ec) {
         case FAIL_DOC_NOT_FOUND:
           CB_ATTEMPT_CLEANUP_LOG_ERROR("document {} not found - ignoring ", dr);
@@ -270,10 +276,11 @@ atr_cleanup_entry::commit_docs(std::optional<std::vector<doc_record>> docs, dura
           req.flags = content.flags;
           auto barrier = std::make_shared<std::promise<result>>();
           auto f = barrier->get_future();
-          cleanup_->cluster_ref().execute(
-            wrap_durable_request(req, dl), [barrier](core::operations::insert_response resp) {
-              barrier->set_value(result::create_from_mutation_response(resp));
-            });
+          cleanup_->cluster_ref().execute(wrap_durable_request(req, dl),
+                                          [barrier](const core::operations::insert_response& resp) {
+                                            barrier->set_value(
+                                              result::create_from_mutation_response(resp));
+                                          });
           wrap_operation_future(f);
         } else {
           core::operations::mutate_in_request req{ doc.id() };
@@ -290,7 +297,7 @@ atr_cleanup_entry::commit_docs(std::optional<std::vector<doc_record>> docs, dura
           auto barrier = std::make_shared<std::promise<result>>();
           auto f = barrier->get_future();
           cleanup_->cluster_ref().execute(
-            req, [barrier](core::operations::mutate_in_response resp) {
+            req, [barrier](const core::operations::mutate_in_response& resp) {
               barrier->set_value(result::create_from_subdoc_response(resp));
             });
           wrap_operation_future(f);
@@ -328,9 +335,10 @@ atr_cleanup_entry::remove_docs(std::optional<std::vector<doc_record>> docs, dura
         wrap_durable_request(req, dl);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        cleanup_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
-          barrier->set_value(result::create_from_subdoc_response(resp));
-        });
+        cleanup_->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);
       } else {
         core::operations::remove_request req{ doc.id() };
@@ -338,9 +346,10 @@ atr_cleanup_entry::remove_docs(std::optional<std::vector<doc_record>> docs, dura
         wrap_durable_request(req, dl);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        cleanup_->cluster_ref().execute(req, [barrier](core::operations::remove_response resp) {
-          barrier->set_value(result::create_from_mutation_response(resp));
-        });
+        cleanup_->cluster_ref().execute(
+          req, [barrier](const core::operations::remove_response& resp) {
+            barrier->set_value(result::create_from_mutation_response(resp));
+          });
         wrap_operation_future(f);
       }
       CB_ATTEMPT_CLEANUP_LOG_TRACE("remove_docs removed doc {}", doc.id());
@@ -367,9 +376,10 @@ atr_cleanup_entry::remove_docs_staged_for_removal(std::optional<std::vector<doc_
         wrap_durable_request(req, dl);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        cleanup_->cluster_ref().execute(req, [barrier](core::operations::remove_response resp) {
-          barrier->set_value(result::create_from_mutation_response(resp));
-        });
+        cleanup_->cluster_ref().execute(
+          req, [barrier](const core::operations::remove_response& resp) {
+            barrier->set_value(result::create_from_mutation_response(resp));
+          });
         wrap_operation_future(f);
         CB_ATTEMPT_CLEANUP_LOG_TRACE("remove_docs_staged_for_removal removed doc {}", doc.id());
       } else {
@@ -405,9 +415,10 @@ atr_cleanup_entry::remove_txn_links(std::optional<std::vector<doc_record>> docs,
       wrap_durable_request(req, dl);
       auto barrier = std::make_shared<std::promise<result>>();
       auto f = barrier->get_future();
-      cleanup_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
-        barrier->set_value(result::create_from_subdoc_response(resp));
-      });
+      cleanup_->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);
       CB_ATTEMPT_CLEANUP_LOG_TRACE("remove_txn_links removed links for doc {}", doc.id());
     });
@@ -437,9 +448,10 @@ atr_cleanup_entry::cleanup_entry(durability_level dl)
     wrap_durable_request(req, dl);
     auto barrier = std::make_shared<std::promise<result>>();
     auto f = barrier->get_future();
-    cleanup_->cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
-      barrier->set_value(result::create_from_subdoc_response(resp));
-    });
+    cleanup_->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);
     CB_ATTEMPT_CLEANUP_LOG_TRACE("successfully removed attempt {}", attempt_id_);
   } catch (const client_error& e) {
@@ -467,9 +479,9 @@ atr_cleanup_entry::ready() const -> bool
 auto
 atr_cleanup_queue::pop(bool check_time) -> std::optional<atr_cleanup_entry>
 {
-  std::unique_lock<std::mutex> lock(mutex_);
+  const std::unique_lock<std::mutex> lock(mutex_);
   if (!queue_.empty()) {
-    if (!check_time || (check_time && queue_.top().ready())) {
+    if (!check_time || queue_.top().ready()) {
       // copy it
       atr_cleanup_entry top = queue_.top();
       // pop it
@@ -483,14 +495,14 @@ atr_cleanup_queue::pop(bool check_time) -> std::optional<atr_cleanup_entry>
 auto
 atr_cleanup_queue::size() const -> std::size_t
 {
-  std::unique_lock<std::mutex> lock(mutex_);
+  const std::unique_lock<std::mutex> lock(mutex_);
   return queue_.size();
 }
 
 void
-atr_cleanup_queue::push(std::shared_ptr<attempt_context> ctx)
+atr_cleanup_queue::push(const std::shared_ptr<attempt_context>& ctx)
 {
-  std::unique_lock<std::mutex> lock(mutex_);
+  const std::unique_lock<std::mutex> lock(mutex_);
   queue_.emplace(ctx);
 }
 } // namespace couchbase::core::transactions