couchbase 3.5.2 → 3.5.4

data/ext/couchbase/core/logger/logger.cxx

@@ -12,26 +12,40 @@
 #include "logger.hxx"
 
 #include "configuration.hxx"
+#include "core/logger/level.hxx"
 #include "custom_rotating_file_sink.hxx"
 
-#include <chrono>
-#include <mutex>
 #include <spdlog/async.h>
 #include <spdlog/async_logger.h>
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+#include <spdlog/logger.h>
 #include <spdlog/sinks/dist_sink.h>
 #include <spdlog/sinks/null_sink.h>
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
-static const std::string file_logger_name{ "couchbase_cxx_client_file_logger" };
-static const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_logger" };
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace
+{
+const std::string file_logger_name{ "couchbase_cxx_client_file_logger" };
+const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_logger" };
 
 /**
  * Custom log pattern which the loggers will use.
  * This pattern is duplicated for some test cases. If you need to update it,
  * please also update in all relevant places.
  */
-static const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t] %v" };
+const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t] %v" };
 
 /**
  * Instances of spdlog (async) file logger.
@@ -41,19 +55,17 @@ static const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t]
  * messages and send them to the sinks, which do the actual writing (to file,
  * to stream etc.) or further processing.
  */
-static std::shared_ptr<spdlog::logger> file_logger{};
-static std::mutex file_logger_mutex;
-static std::atomic_int file_logger_version{ 0 };
+std::shared_ptr<spdlog::logger> file_logger{};
+std::mutex file_logger_mutex;
+std::atomic_int file_logger_version{ 0 };
 
-namespace
-{
 auto
 get_file_logger() -> std::shared_ptr<spdlog::logger>
 {
   thread_local std::shared_ptr<spdlog::logger> logger{ nullptr };
   thread_local int version{ -1 };
   if (version != file_logger_version) {
-    std::scoped_lock lock(file_logger_mutex);
+    const std::scoped_lock lock(file_logger_mutex);
     logger = file_logger;
     version = file_logger_version;
   }
@@ -61,21 +73,23 @@ get_file_logger() -> std::shared_ptr<spdlog::logger>
 }
 
 void
-update_file_logger(std::shared_ptr<spdlog::logger> new_logger)
+update_file_logger(const std::shared_ptr<spdlog::logger>& new_logger)
 {
-  std::scoped_lock lock(file_logger_mutex);
+  const std::scoped_lock lock(file_logger_mutex);
   // delete if already exists
   spdlog::drop(file_logger_name);
-  file_logger = new_logger;
-  spdlog::register_logger(new_logger);
+  if (new_logger) {
+    file_logger = new_logger;
+    spdlog::register_logger(new_logger);
+  }
   ++file_logger_version;
 }
-} // namespace
 
 /**
  * Instance of the protocol logger.
  */
-static std::shared_ptr<spdlog::logger> protocol_logger{};
+std::shared_ptr<spdlog::logger> protocol_logger{};
+} // namespace
 
 namespace couchbase::core::logger
 {
@@ -101,6 +115,28 @@ translate_level(level level) -> spdlog::level::level_enum
   return spdlog::level::level_enum::trace;
 }
 
+auto
+translate_level(spdlog::level::level_enum spdlog_level) -> level
+{
+  switch (spdlog_level) {
+    case spdlog::level::level_enum::trace:
+      return level::trace;
+    case spdlog::level::debug:
+      return level::debug;
+    case spdlog::level::info:
+      return level::info;
+    case spdlog::level::warn:
+      return level::warn;
+    case spdlog::level::err:
+      return level::err;
+    case spdlog::level::critical:
+      return level::critical;
+    default:
+      break;
+  }
+  return level::off;
+}
+
 auto
 level_from_str(const std::string& str) -> level
 {
@@ -184,19 +220,11 @@ is_initialized() -> bool
 }
 
 auto
-create_file_logger_impl(const std::string logger_name, const configuration& logger_settings)
+create_file_logger_impl(const std::string& logger_name, const configuration& logger_settings)
   -> std::pair<std::optional<std::string>, std::shared_ptr<spdlog::logger>>
 {
   std::shared_ptr<spdlog::logger> logger{};
 
-  auto fname = logger_settings.filename;
-  auto buffersz = logger_settings.buffer_size;
-  auto cyclesz = logger_settings.cycle_size;
-
-  if (!spdlog::details::os::getenv("COUCHBASE_CXX_CLIENT_MAXIMIZE_LOGGER_CYCLE_SIZE").empty()) {
-    cyclesz = 1024LLU * 1024 * 1024; // use up to 1 GB log file size
-  }
-
   try {
     // Initialise the loggers.
     //
@@ -228,7 +256,13 @@ create_file_logger_impl(const std::string logger_name, const configuration& logg
     auto sink = std::make_shared<spdlog::sinks::dist_sink_mt>();
     sink->set_level(spdlog::level::trace);
 
-    if (!fname.empty()) {
+    if (const auto& fname = logger_settings.filename; !fname.empty()) {
+      auto cyclesz = logger_settings.cycle_size;
+
+      if (!spdlog::details::os::getenv("COUCHBASE_CXX_CLIENT_MAXIMIZE_LOGGER_CYCLE_SIZE").empty()) {
+        cyclesz = 1024LLU * 1024 * 1024; // use up to 1 GB log file size
+      }
+
       auto fsink = std::make_shared<custom_rotating_file_sink_mt>(fname, cyclesz, log_pattern);
       fsink->set_level(spdlog::level::trace);
       sink->add_sink(fsink);
@@ -239,11 +273,7 @@ create_file_logger_impl(const std::string logger_name, const configuration& logg
 
       // Set the formatting pattern of this sink
       stderrsink->set_pattern(log_pattern);
-      if (logger_settings.unit_test) {
-        stderrsink->set_level(spdlog::level::trace);
-      } else {
-        stderrsink->set_level(spdlog::level::err);
-      }
+      stderrsink->set_level(translate_level(logger_settings.console_sink_log_level));
       sink->add_sink(stderrsink);
     }
     if (nullptr != logger_settings.sink) {
@@ -256,6 +286,7 @@ create_file_logger_impl(const std::string logger_name, const configuration& logg
     if (logger_settings.unit_test) {
       logger = std::make_shared<spdlog::logger>(logger_name, sink);
     } else {
+      auto buffersz = logger_settings.buffer_size;
       // Create the default thread pool for async logging
       spdlog::init_thread_pool(buffersz, 1);
 
@@ -366,7 +397,7 @@ create_console_logger()
 }
 
 void
-register_spdlog_logger(std::shared_ptr<spdlog::logger> l)
+register_spdlog_logger(const std::shared_ptr<spdlog::logger>& l)
 {
   try {
     get_file_logger()->debug("Registering logger {}", l->name());
@@ -392,7 +423,7 @@ check_log_levels(level lvl) -> bool
 {
   auto level = translate_level(lvl);
   bool correct = true;
-  spdlog::apply_all([level, &correct](std::shared_ptr<spdlog::logger> l) {
+  spdlog::apply_all([level, &correct](const std::shared_ptr<spdlog::logger>& l) {
     if (l->level() != level) {
       correct = false;
     }
@@ -400,12 +431,23 @@ check_log_levels(level lvl) -> bool
   return correct;
 }
 
+auto
+get_lowest_log_level() -> level
+{
+  auto lowest = spdlog::level::off;
+  // Apply the function to each registered spdlog::logger except protocol logger
+  spdlog::apply_all([&lowest](const std::shared_ptr<spdlog::logger>& l) {
+    lowest = std::min(l->level(), lowest);
+  });
+  return translate_level(lowest);
+}
+
 void
 set_log_levels(level lvl)
 {
   auto level = translate_level(lvl);
   // Apply the function to each registered spdlog::logger except protocol logger
-  spdlog::apply_all([level](std::shared_ptr<spdlog::logger> l) {
+  spdlog::apply_all([level](const std::shared_ptr<spdlog::logger>& l) {
     if (l->name() == protocol_logger_name) {
       l->set_level(spdlog::level::trace);
       return;

data/ext/couchbase/core/logger/logger.hxx

@@ -121,7 +121,7 @@ reset();
  * @param l spdlog::logger instance
  */
 void
-register_spdlog_logger(std::shared_ptr<spdlog::logger> l);
+register_spdlog_logger(const std::shared_ptr<spdlog::logger>& l);
 
 /**
  * Engines that create their own instances of an spdlog::logger should unregister
@@ -148,6 +148,13 @@ check_log_levels(level lvl) -> bool;
 void
 set_log_levels(level lvl);
 
+/**
+ * Get the lowest (most verbose) level among the registered loggers
+ * @return log severity level
+ */
+auto
+get_lowest_log_level() -> level;
+
 /**
  * Checks whether a specific level should be logged based on the current
  * configuration.

data/ext/couchbase/core/management/search_index.cxx

@@ -19,6 +19,8 @@
 
 #include "core/utils/json.hxx"
 
+#include <tao/json/value.hpp>
+
 namespace
 {
 auto
@@ -68,12 +70,9 @@ index::is_vector_index() const -> bool
   if (types == nullptr || !types->is_object()) {
     return false;
   }
-  for (const auto& [_, val] : types->get_object()) {
-    const auto* properties = val.find("properties");
-    if (properties != nullptr && has_vector_mapping_properties(*properties)) {
-      return true;
-    }
-  }
-  return false;
+  return std::any_of(types->get_object().begin(), types->get_object().end(), [](const auto& pair) {
+    const auto* properties = pair.second.find("properties");
+    return properties != nullptr && has_vector_mapping_properties(*properties);
+  });
 }
 } // namespace couchbase::core::management::search

data/ext/couchbase/core/mcbp/buffer_writer.cxx

@@ -30,7 +30,7 @@ buffer_writer::buffer_writer(std::size_t size)
 void
 buffer_writer::write(const std::vector<std::byte>& val)
 {
-  if (val.size() == 0 || val.data() == nullptr) {
+  if (val.empty() || val.data() == nullptr) {
     return;
   }
   std::memcpy(store_.data() + offset_, val.data(), val.size());

data/ext/couchbase/core/mcbp/codec.cxx

@@ -24,7 +24,9 @@
 #include "core/logger/logger.hxx"
 #include "core/utils/unsigned_leb128.hxx"
 
+#include <algorithm>
 #include <couchbase/error_codes.hxx>
+#include <cstdint>
 
 namespace couchbase::core::mcbp
 {
@@ -50,7 +52,7 @@ codec::is_feature_enabled(protocol::hello_feature feature) const -> bool
 }
 
 auto
-codec::encode_packet(const couchbase::core::mcbp::packet& packet)
+codec::encode_packet(const couchbase::core::mcbp::packet& packet) const
   -> tl::expected<std::vector<std::byte>, std::error_code>
 {
   auto encoded_key = packet.key_;
@@ -65,7 +67,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
       return tl::unexpected(errc::common::unsupported_operation);
     }
     if (supports_collection_id(packet.command_)) {
-      core::utils::unsigned_leb128<std::uint32_t> encoded(packet.collection_id_);
+      const core::utils::unsigned_leb128<std::uint32_t> encoded(packet.collection_id_);
       encoded_key.reserve(encoded_key.size() + encoded.size());
       encoded_key.insert(encoded_key.begin(), encoded.begin(), encoded.end());
     } else if (packet.command_ == protocol::client_opcode::get_random_key) {
@@ -81,9 +83,9 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     }
   }
 
-  std::size_t ext_len = extras.size();
-  std::size_t key_len = encoded_key.size();
-  std::size_t val_len = packet.value_.size();
+  const std::size_t ext_len = extras.size();
+  const std::size_t key_len = encoded_key.size();
+  const std::size_t val_len = packet.value_.size();
   std::size_t frames_len = 0;
 
   if (packet.barrier_frame_) {
@@ -99,7 +101,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     frames_len += 3;
   }
   if (packet.open_tracing_frame_) {
-    std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
+    const std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
     frames_len = trace_ctx_len;
     if (trace_ctx_len < 15) {
       frames_len += 1;
@@ -111,7 +113,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     frames_len += 3;
   }
   if (packet.user_impersonation_frame_) {
-    std::size_t user_len = packet.user_impersonation_frame_->user.size();
+    const std::size_t user_len = packet.user_impersonation_frame_->user.size();
     frames_len += user_len;
     if (user_len < 15) {
       frames_len += 1;
@@ -143,7 +145,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
         return tl::unexpected(errc::common::unsupported_operation);
     }
   }
-  std::size_t packet_len = 24 + ext_len + frames_len + key_len + val_len;
+  const std::size_t packet_len = 24 + ext_len + frames_len + key_len + val_len;
   buffer_writer buffer{ packet_len };
   buffer.write_byte(static_cast<std::byte>(packet_magic));
   buffer.write_byte(static_cast<std::byte>(packet.command_));
@@ -209,10 +211,9 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
     }
 
     if (packet.durability_timeout_frame_) {
-      auto millis = packet.durability_timeout_frame_->timeout.count();
-      if (millis > 65535) {
-        millis = 65535;
-      }
+      std::int64_t millis = packet.durability_timeout_frame_->timeout.count();
+      millis =
+        std::min(millis, static_cast<std::int64_t>(std::numeric_limits<std::uint16_t>::max()));
       buffer.write_frame_header(mcbp::request_sync_durability, 3);
       buffer.write_byte(static_cast<std::byte>(packet.durability_level_frame_->level));
       buffer.write_uint16(static_cast<std::uint16_t>(millis));
@@ -243,7 +244,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
       return tl::unexpected(errc::common::feature_not_available);
     }
 
-    std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
+    const std::size_t trace_ctx_len = packet.open_tracing_frame_->trace_context.size();
     if (trace_ctx_len < 15) {
       buffer.write_frame_header(mcbp::request_open_tracing, trace_ctx_len);
       buffer.write(packet.open_tracing_frame_->trace_context);
@@ -273,7 +274,7 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
       return tl::unexpected(errc::common::invalid_argument);
     }
 
-    std::size_t user_len = packet.user_impersonation_frame_->user.size();
+    const std::size_t user_len = packet.user_impersonation_frame_->user.size();
     if (user_len < 15) {
       buffer.write_frame_header(mcbp::request_user_impersonation, user_len);
       buffer.write(packet.user_impersonation_frame_->user);
@@ -316,7 +317,8 @@ codec::encode_packet(const couchbase::core::mcbp::packet& packet)
 }
 
 auto
-codec::decode_packet(gsl::span<std::byte> input) -> std::tuple<packet, std::size_t, std::error_code>
+codec::decode_packet(gsl::span<std::byte> input) const
+  -> std::tuple<packet, std::size_t, std::error_code>
 {
   if (input.empty()) {
     return { {}, {}, errc::network::end_of_stream };
@@ -327,22 +329,22 @@ codec::decode_packet(gsl::span<std::byte> input) -> std::tuple<packet, std::size
   if (input.size() < header_len) {
     return { {}, {}, errc::network::need_more_data };
   }
-  gsl::span<std::byte> header{ input.data(), header_len };
+  const gsl::span<std::byte> header{ input.data(), header_len };
 
   // grab the length of the full body
-  std::uint32_t body_len = big_endian::read_uint32(header, 8);
+  const std::uint32_t body_len = big_endian::read_uint32(header, 8);
   // Read the remaining bytes of the body
   if (input.size() < header_len + body_len) {
     return { {}, {}, errc::network::need_more_data };
   }
-  gsl::span<std::byte> body{ input.data() + header_len, body_len };
+  const gsl::span<std::byte> body{ input.data() + header_len, body_len };
 
   return decode_packet(header, body);
 }
 
 auto
-codec::decode_packet(gsl::span<std::byte> header,
-                     gsl::span<std::byte> body) -> std::tuple<packet, std::size_t, std::error_code>
+codec::decode_packet(gsl::span<std::byte> header, gsl::span<std::byte> body) const
+  -> std::tuple<packet, std::size_t, std::error_code>
 {
   packet pkt;
 
@@ -376,7 +378,7 @@ codec::decode_packet(gsl::span<std::byte> header,
   pkt.opaque_ = big_endian::read_uint32(header, 12);
   pkt.cas_ = big_endian::read_uint64(header, 16);
 
-  std::size_t header_len = header.size();
+  const std::size_t header_len = header.size();
   std::size_t body_len = body.size();
   std::size_t ext_len = big_endian::read_uint8(header, 4);
   std::size_t key_len = big_endian::read_uint16(header, 2);
@@ -401,13 +403,13 @@ codec::decode_packet(gsl::span<std::byte> header,
                  body_len);
     return { {}, {}, errc::network::protocol_error };
   }
-  std::size_t value_len = body_len - (frames_len + ext_len + key_len);
+  const std::size_t value_len = body_len - (frames_len + ext_len + key_len);
 
   if (frames_len > 0) {
     std::size_t frame_offset = 0;
 
     while (frame_offset < frames_len) {
-      std::byte frame_header = body[frame_offset];
+      const std::byte frame_header = body[frame_offset];
       ++frame_offset;
 
       auto frame_type = std::to_integer<std::uint8_t>((frame_header & std::byte{ 0xf0 }) >> 4);

data/ext/couchbase/core/mcbp/codec.hxx

@@ -38,11 +38,12 @@ class codec
 public:
   explicit codec(std::set<protocol::hello_feature> enabled_features);
 
-  auto encode_packet(const packet& packet) -> tl::expected<std::vector<std::byte>, std::error_code>;
-  auto decode_packet(gsl::span<std::byte> input)
+  auto encode_packet(const packet& packet) const
+    -> tl::expected<std::vector<std::byte>, std::error_code>;
+  auto decode_packet(gsl::span<std::byte> input) const
+    -> std::tuple<packet, std::size_t, std::error_code>;
+  auto decode_packet(gsl::span<std::byte> header, gsl::span<std::byte> body) const
     -> std::tuple<packet, std::size_t, std::error_code>;
-  auto decode_packet(gsl::span<std::byte> header,
-                     gsl::span<std::byte> body) -> std::tuple<packet, std::size_t, std::error_code>;
   void enable_feature(protocol::hello_feature feature);
   [[nodiscard]] auto is_feature_enabled(protocol::hello_feature feature) const -> bool;
 

data/ext/couchbase/core/mcbp/operation_queue.cxx

@@ -26,6 +26,7 @@
 #include <fmt/core.h>
 
 #include <algorithm>
+#include <iterator>
 #include <memory>
 
 namespace couchbase::core::mcbp
@@ -33,7 +34,7 @@ namespace couchbase::core::mcbp
 auto
 operation_queue::debug_string() const -> std::string
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   std::vector<char> out;
   fmt::format_to(
     std::back_insert_iterator(out), "num_items: {}, is_open: {}", items_.size(), is_open_);
@@ -47,9 +48,9 @@ operation_queue::consumer() -> std::shared_ptr<operation_consumer>
 }
 
 void
-operation_queue::close_consumer(std::shared_ptr<operation_consumer> consumer)
+operation_queue::close_consumer(const std::shared_ptr<operation_consumer>& consumer)
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   consumer->close();
   signal_.notify_all();
 }
@@ -57,7 +58,7 @@ operation_queue::close_consumer(std::shared_ptr<operation_consumer> consumer)
 void
 operation_queue::close()
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   is_open_ = false;
   signal_.notify_all();
 }
@@ -66,7 +67,7 @@ auto
 operation_queue::push(std::shared_ptr<queue_request> request,
                       std::size_t max_items) -> std::error_code
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
 
   if (!is_open_) {
     return errc::network::operation_queue_closed;
@@ -93,9 +94,9 @@ operation_queue::push(std::shared_ptr<queue_request> request,
 }
 
 auto
-operation_queue::remove(std::shared_ptr<queue_request> request) -> bool
+operation_queue::remove(const std::shared_ptr<queue_request>& request) -> bool
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
 
   if (!is_open_) {
     return false;
@@ -115,7 +116,8 @@ operation_queue::remove(std::shared_ptr<queue_request> request) -> bool
 }
 
 auto
-operation_queue::pop(std::shared_ptr<operation_consumer> consumer) -> std::shared_ptr<queue_request>
+operation_queue::pop(const std::shared_ptr<operation_consumer>& consumer)
+  -> std::shared_ptr<queue_request>
 {
   std::unique_lock lock(mutex_);
 
@@ -134,7 +136,7 @@ operation_queue::pop(std::shared_ptr<operation_consumer> consumer) -> std::share
 }
 
 void
-operation_queue::drain(operation_queue::drain_callback callback)
+operation_queue::drain(const operation_queue::drain_callback& callback)
 {
   for (const auto& request : items_to_drain()) {
     callback(request);
@@ -144,7 +146,7 @@ operation_queue::drain(operation_queue::drain_callback callback)
 auto
 operation_queue::items_to_drain() -> std::list<std::shared_ptr<queue_request>>
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
 
   if (is_open_) {
     CB_LOG_ERROR("attempted to drain open MCBP operation queue, ignoring");

data/ext/couchbase/core/mcbp/operation_queue.hxx

@@ -36,16 +36,16 @@ public:
 
   [[nodiscard]] auto push(std::shared_ptr<queue_request> request,
                           std::size_t max_items) -> std::error_code;
-  auto remove(std::shared_ptr<queue_request> request) -> bool;
-  void drain(drain_callback callback);
+  auto remove(const std::shared_ptr<queue_request>& request) -> bool;
+  void drain(const drain_callback& callback);
 
   [[nodiscard]] auto consumer() -> std::shared_ptr<operation_consumer>;
   void close();
   [[nodiscard]] auto debug_string() const -> std::string;
 
 private:
-  void close_consumer(std::shared_ptr<operation_consumer> consumer);
-  auto pop(std::shared_ptr<operation_consumer> consumer) -> std::shared_ptr<queue_request>;
+  void close_consumer(const std::shared_ptr<operation_consumer>& consumer);
+  auto pop(const std::shared_ptr<operation_consumer>& consumer) -> std::shared_ptr<queue_request>;
   auto items_to_drain() -> std::list<std::shared_ptr<queue_request>>;
 
   std::list<std::shared_ptr<queue_request>> items_{};

data/ext/couchbase/core/mcbp/packet.cxx

@@ -25,6 +25,8 @@
 #include <fmt/core.h>
 #include <spdlog/fmt/bin_to_hex.h>
 
+#include <iterator>
+
 namespace couchbase::core::mcbp
 {
 auto

data/ext/couchbase/core/mcbp/queue_request.cxx

@@ -38,7 +38,7 @@ queue_request::queue_request(protocol::magic magic,
 auto
 queue_request::retry_attempts() const -> std::size_t
 {
-  std::scoped_lock lock(retry_mutex_);
+  const std::scoped_lock lock(retry_mutex_);
   return retry_count_;
 }
 
@@ -57,14 +57,14 @@ queue_request::idempotent() const -> bool
 auto
 queue_request::retry_reasons() const -> std::set<retry_reason>
 {
-  std::scoped_lock lock(retry_mutex_);
+  const std::scoped_lock lock(retry_mutex_);
   return retry_reasons_;
 }
 
 void
 queue_request::record_retry_attempt(retry_reason reason)
 {
-  std::scoped_lock lock(retry_mutex_);
+  const std::scoped_lock lock(retry_mutex_);
   ++retry_count_;
   retry_reasons_.insert(reason);
 }
@@ -72,14 +72,14 @@ queue_request::record_retry_attempt(retry_reason reason)
 auto
 queue_request::retries() const -> std::pair<std::size_t, std::set<retry_reason>>
 {
-  std::scoped_lock lock(retry_mutex_);
+  const std::scoped_lock lock(retry_mutex_);
   return { retry_count_, retry_reasons_ };
 }
 
 auto
 queue_request::connection_info() const -> queue_request_connection_info
 {
-  std::scoped_lock lock(connection_info_mutex_);
+  const std::scoped_lock lock(connection_info_mutex_);
   return connection_info_;
 }
 
@@ -89,18 +89,21 @@ queue_request::is_cancelled() const -> bool
   return is_completed_.load();
 }
 
-static inline void
+namespace
+{
+inline void
 cancel_timer(std::shared_ptr<asio::steady_timer> timer)
 {
   if (auto t = std::move(timer); t) {
     t->cancel();
   }
 }
+} // namespace
 
 auto
 queue_request::internal_cancel() -> bool
 {
-  std::scoped_lock lock(processing_mutex_);
+  const std::scoped_lock lock(processing_mutex_);
 
   if (bool expected_state{ false }; !is_completed_.compare_exchange_strong(expected_state, true)) {
     // someone already completed this request