couchbase 3.8.1 → 3.9.0

data/ext/couchbase/core/operations/operation_traits.hxx

@@ -34,4 +34,22 @@ struct is_cancellable_operation : public std::false_type {
 
 template<typename T>
 inline constexpr bool is_cancellable_operation_v = is_cancellable_operation<T>::value;
+
+/**
+ * Operations that pick the node to dispatch to themselves, instead of being
+ * routed by the vbucket map alone.
+ *
+ * Specialize this only for a request that provides
+ * @c resolve_route(const topology::configuration&) returning an
+ * @c std::optional<impl::replica_route_decision>, and a writable @c partition
+ * member: that is the whole interface @c bucket::map_and_send() calls through
+ * this trait. An empty optional declines self-routing for that request, and the
+ * vbucket-map path routes it instead.
+ */
+template<typename T>
+struct resolves_own_route : public std::false_type {
+};
+
+template<typename T>
+inline constexpr bool resolves_own_route_v = resolves_own_route<T>::value;
 } // namespace couchbase::core::operations

data/ext/couchbase/core/operations/query_response_parsing.cxx

@@ -0,0 +1,211 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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 "query_response_parsing.hxx"
+
+#include "core/operations/management/error_utils.hxx"
+#include "core/utils/contains_string.hxx"
+#include "core/utils/duration_parser.hxx"
+#include "core/utils/json.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <tao/json/value.hpp>
+
+namespace couchbase::core::operations
+{
+
+auto
+parse_query_meta(const tao::json::value& payload) -> query_response::query_meta_data
+{
+  query_response::query_meta_data meta{};
+
+  if (const auto* i = payload.find("requestID"); i != nullptr) {
+    meta.request_id = i->get_string();
+  }
+  if (const auto* i = payload.find("clientContextID"); i != nullptr) {
+    meta.client_context_id = i->get_string();
+  }
+  if (const auto* s = payload.find("status"); s != nullptr) {
+    meta.status = s->get_string();
+  }
+  if (const auto* s = payload.find("signature"); s != nullptr) {
+    meta.signature = couchbase::core::utils::json::generate(*s);
+  }
+  if (const auto* p = payload.find("profile"); p != nullptr) {
+    meta.profile = couchbase::core::utils::json::generate(*p);
+  }
+
+  if (const auto* m = payload.find("metrics"); m != nullptr) {
+    query_response::query_metrics metrics{};
+    metrics.result_count = m->at("resultCount").get_unsigned();
+    metrics.result_size = m->at("resultSize").get_unsigned();
+    metrics.elapsed_time = utils::parse_duration(m->at("elapsedTime").get_string());
+    metrics.execution_time = utils::parse_duration(m->at("executionTime").get_string());
+    metrics.sort_count = m->template optional<std::uint64_t>("sortCount").value_or(0);
+    metrics.mutation_count = m->template optional<std::uint64_t>("mutationCount").value_or(0);
+    metrics.error_count = m->template optional<std::uint64_t>("errorCount").value_or(0);
+    metrics.warning_count = m->template optional<std::uint64_t>("warningCount").value_or(0);
+    meta.metrics.emplace(metrics);
+  }
+
+  if (const auto* e = payload.find("errors"); e != nullptr) {
+    std::vector<query_response::query_problem> problems{};
+    for (const auto& err : e->get_array()) {
+      query_response::query_problem problem;
+      problem.code = err.at("code").get_unsigned();
+      problem.message = err.at("msg").get_string();
+      if (const auto* reason = err.find("reason"); reason != nullptr && reason->is_object()) {
+        problem.reason = reason->optional<std::uint64_t>("code");
+        problem.retry = reason->optional<bool>("retry");
+      }
+      problems.emplace_back(problem);
+    }
+    meta.errors.emplace(problems);
+  }
+
+  if (const auto* w = payload.find("warnings"); w != nullptr) {
+    std::vector<query_response::query_problem> problems{};
+    for (const auto& warn : w->get_array()) {
+      query_response::query_problem problem;
+      problem.code = warn.at("code").get_unsigned();
+      problem.message = warn.at("msg").get_string();
+      problems.emplace_back(problem);
+    }
+    meta.warnings.emplace(problems);
+  }
+
+  return meta;
+}
+
+auto
+map_query_error(const query_response::query_meta_data& meta, std::uint32_t http_status)
+  -> std::error_code
+{
+  const auto unmatched =
+    http_status == 400 ? errc::common::invalid_argument : errc::common::internal_server_failure;
+
+  if (meta.status == "success" && http_status != 400) {
+    return {};
+  }
+
+  if (!meta.errors || meta.errors->empty()) {
+    /* Unreachable from make_response, which only calls map_query_error after confirming
+     * errors is non-empty; present for the streaming-path caller, which has no such guard. */
+    return unmatched;
+  }
+
+  const auto& first = meta.errors->front();
+  const auto first_code = first.code;
+  const auto& first_message = first.message;
+
+  std::error_code ec{};
+
+  switch (first_code) {
+    case 1065: /* IKey: "service.io.request.unrecognized_parameter" */
+      if ((first_message.find("Unrecognized parameter in request") != std::string::npos) &&
+          (first_message.find("preserve_expiry") != std::string::npos)) {
+        ec = errc::common::feature_not_available;
+      } else {
+        ec = errc::common::invalid_argument;
+      }
+      break;
+    case 1080: /* IKey: "timeout" */
+      ec = errc::common::unambiguous_timeout;
+      break;
+    case 3000: /* IKey: "parse.syntax_error" */
+      ec = errc::common::parsing_failure;
+      break;
+    case 4040: /* IKey: "plan.build_prepared.no_such_name" */
+    case 4050: /* IKey: "plan.build_prepared.unrecognized_prepared" */
+    case 4060: /* IKey: "plan.build_prepared.no_such_name" */
+    case 4070: /* IKey: "plan.build_prepared.decoding" */
+    case 4080: /* IKey: "plan.build_prepared.name_encoded_plan_mismatch" */
+    case 4090: /* IKey: "plan.build_prepared.name_not_in_encoded_plan" */
+      /* NOTE: make_response also does cache.erase + throw retry_http_request for codes
+       * 4040/4050/4070. That stateful logic stays in make_response. This pure classifier
+       * returns prepared_statement_failure so callers (e.g. streaming path) get a
+       * non-empty error_code. */
+      ec = errc::query::prepared_statement_failure;
+      break;
+    case 4300: /* IKey: "plan.new_index_already_exists" */
+      ec = errc::common::index_exists;
+      break;
+    case 5000: /* IKey: "Internal Error" */
+      if (utils::contains_string(first_message, "index", true) &&
+          utils::contains_string(first_message, "already exist", true)) {
+        ec = errc::common::index_exists;
+      } else if (utils::contains_string(first_message, "Index does not exist") ||
+                 (utils::contains_string(first_message, "index", true) &&
+                  utils::contains_string(first_message, "not found", true))) {
+        ec = errc::common::index_not_found;
+      } else if (first_message.find("Bucket Not Found") != std::string::npos) {
+        ec = errc::common::bucket_not_found;
+      }
+      break;
+    case 12009: /* IKey: "datastore.couchbase.DML_error" */
+      if (first_message.find("CAS mismatch") != std::string::npos) {
+        ec = errc::common::cas_mismatch;
+      } else {
+        switch (first.reason.value_or(0)) {
+          case 12033:
+            ec = errc::common::cas_mismatch;
+            break;
+          case 17014:
+            ec = errc::key_value::document_not_found;
+            break;
+          case 17012:
+            ec = errc::key_value::document_exists;
+            break;
+          default:
+            ec = errc::query::dml_failure;
+            break;
+        }
+      }
+      break;
+    case 12004: /* IKey: "datastore.couchbase.primary_idx_not_found" */
+    case 12016: /* IKey: "datastore.couchbase.index_not_found" */
+      ec = errc::common::index_not_found;
+      break;
+    case 13014: /* IKey: "datastore.couchbase.insufficient_credentials" */
+      ec = errc::common::authentication_failure;
+      break;
+    default:
+      if ((first_code >= 12000 && first_code < 13000) ||
+          (first_code >= 14000 && first_code < 15000)) {
+        ec = errc::query::index_failure;
+      } else if (first_code >= 4000 && first_code < 5000) {
+        ec = errc::query::planning_failure;
+      }
+      break;
+  }
+
+  if (!ec) {
+    auto common_ec = management::extract_common_query_error_code(first_code, first_message);
+    if (common_ec) {
+      ec = common_ec.value();
+    }
+  }
+
+  if (!ec) {
+    ec = unmatched;
+  }
+
+  return ec;
+}
+
+} // namespace couchbase::core::operations

data/ext/couchbase/core/operations/query_response_parsing.hxx

@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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/operations/document_query.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <tao/json/forward.hpp>
+
+#include <cstdint>
+#include <system_error>
+
+namespace couchbase::core::operations
+{
+
+/**
+ * Parse query meta-data fields (status, metrics, warnings, errors, signature, profile,
+ * requestID, clientContextID) from a top-level response payload.
+ *
+ * Pure function — no side effects, no access to request state.
+ */
+auto
+parse_query_meta(const tao::json::value& payload) -> query_response::query_meta_data;
+
+/**
+ * Map query meta-data to an error_code.
+ *
+ * Pure classifier — no side effects, no cache mutations, no exceptions thrown.
+ * All prepared-statement codes (4040/4050/4060/4070/4080/4090) are classified as
+ * prepared_statement_failure here; the cache-erase + retry_http_request throw remains in
+ * make_response and applies only to the 4040/4050/4070 subset.
+ *
+ * Returns an empty error_code when the query succeeded (meta.status == "success", http_status is
+ * not 400, and no prepared-statement retry needed).
+ *
+ * http_status is the status of the response that carried the metadata, or 0 where there is none.
+ * A failure that matches no specific mapping is invalid_argument for an HTTP 400 (RFC-58) and
+ * internal_server_failure otherwise.
+ */
+[[nodiscard]] auto
+map_query_error(const query_response::query_meta_data& meta, std::uint32_t http_status = 0)
+  -> std::error_code;
+
+} // namespace couchbase::core::operations

data/ext/couchbase/core/operations_fwd.hxx

@@ -28,8 +28,6 @@ struct s3_external_link;
 
 namespace impl
 {
-struct get_replica_request;
-struct get_replica_response;
 struct lookup_in_replica_request;
 struct lookup_in_replica_response;
 struct observe_seqno_request;
@@ -51,6 +49,8 @@ struct decrement_response;
 struct exists_request;
 struct exists_response;
 struct get_request;
+struct get_replica_request;
+struct get_replica_response;
 struct get_response;
 struct get_all_replicas_request;
 struct get_all_replicas_response;
@@ -106,7 +106,7 @@ using replace_request_with_legacy_durability = impl::with_legacy_durability<repl
 using upsert_request_with_legacy_durability = impl::with_legacy_durability<upsert_request>;
 
 using get_request_with_cancellation = impl::with_cancellation<get_request>;
-using get_replica_request_with_cancellation = impl::with_cancellation<impl::get_replica_request>;
+using get_replica_request_with_cancellation = impl::with_cancellation<get_replica_request>;
 using lookup_in_request_with_cancellation = impl::with_cancellation<lookup_in_request>;
 using lookup_in_replica_request_with_cancellation =
   impl::with_cancellation<impl::lookup_in_replica_request>;

data/ext/couchbase/core/origin.cxx

@@ -16,7 +16,6 @@
  */
 
 #include "origin.hxx"
-#include <couchbase/build_config.hxx>
 
 #include "core/utils/connection_string.hxx"
 #include "topology/configuration.hxx"
@@ -224,24 +223,6 @@ struct traits<couchbase::transactions::transactions_config::built> {
   }
 };
 
-template<>
-struct traits<couchbase::core::columnar::security_options> {
-  template<template<typename...> class Traits>
-  static void assign(tao::json::basic_value<Traits>& v,
-                     const couchbase::core::columnar::security_options& o)
-  {
-    v = {
-      { "trust_only_capella", o.trust_only_capella },
-      { "trust_only_pem_file", o.trust_only_pem_file },
-      { "trust_only_pem_string", o.trust_only_pem_string },
-      { "trust_only_platform", o.trust_only_platform },
-      { "trust_only_certificates", o.trust_only_certificates.size() },
-      // TODO(JC): add if/when we support the cipher_suites option
-      // { "cipher_suites", utils::join_strings(o.cipher_suites, ":") },
-    };
-  }
-};
-
 } // namespace tao::json
 
 namespace couchbase::core
@@ -267,13 +248,10 @@ origin::to_json() const -> std::string
         { "config_poll_floor", options_.config_poll_floor },
         { "user_agent_extra", options_.user_agent_extra },
         { "dump_configuration", options_.dump_configuration },
+        { "log_redaction", options_.log_redaction },
         { "disable_mozilla_ca_certificates", options_.disable_mozilla_ca_certificates },
         { "network", options_.network },
         { "tls_verify", options_.tls_verify },
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-        { "dispatch_timeout", options_.dispatch_timeout },
-        { "security_options", options_.security_options },
-#else
         { "key_value_timeout", options_.key_value_timeout },
         { "key_value_durable_timeout", options_.key_value_durable_timeout },
         { "view_timeout", options_.view_timeout },
@@ -297,7 +275,6 @@ origin::to_json() const -> std::string
         { "orphan_reporter_options", options_.orphan_options },
         { "transactions_options", options_.transactions },
         { "server_group", options_.server_group },
-#endif
       },
     },
   };
@@ -311,6 +288,9 @@ origin::to_json() const -> std::string
     }
     json["bootstrap_nodes"] = nodes;
   }
+  // Every value in here is left as it is. The document this returns is annotated as a whole at
+  // the log site, because a tag written into one of its string values would be read back as part
+  // of that value by anything that parses the line as JSON.
   return tao::json::to_string(json);
 }
 
@@ -319,9 +299,15 @@ origin::to_json() const -> std::string
 couchbase::core::origin::origin(origin&& other) noexcept
   : options_(std::move(other.options_))
   , nodes_(std::move(other.nodes_))
-  , next_node_(other.next_node_)
+  // next_node_ is an iterator into nodes_. Container move construction transfers the buffer, so
+  // iterators into the source stay valid and now denote elements of nodes_ -- other.next_node_ can
+  // be adopted as-is, preserving the round-robin position. The empty case is guarded separately
+  // because that guarantee does not extend to a past-the-end iterator. nodes_ is declared before
+  // next_node_, so it is already initialized here.
+  , next_node_(nodes_.empty() ? nodes_.begin() : other.next_node_)
   , exhausted_(other.exhausted_)
   , connection_string_(std::move(other.connection_string_))
+  , uses_protostellar_(other.uses_protostellar_)
   , credentials_(std::move(other.credentials_))
 {
 }
@@ -330,20 +316,38 @@ auto
 couchbase::core::origin::operator=(origin&& other) noexcept -> origin&
 {
   if (this != &other) {
+    const auto offset = other.nodes_.empty() ? 0 : other.next_node_ - other.nodes_.begin();
     options_ = std::move(other.options_);
     nodes_ = std::move(other.nodes_);
-    next_node_ = other.next_node_;
+    next_node_ = nodes_.begin() + offset;
     exhausted_ = other.exhausted_;
     connection_string_ = std::move(other.connection_string_);
+    uses_protostellar_ = other.uses_protostellar_;
     credentials_ = std::move(other.credentials_);
   }
   return *this;
 }
 
+// A copy is a fresh origin that has not attempted anything, so the rotation cursor is deliberately
+// reset rather than carried. This matters: next_address() marks an origin exhausted as it hands out
+// the *last* node, which on a single-node cluster is the very first call, so a cluster origin is
+// normally exhausted immediately after bootstrap. open_bucket() copies that origin into every
+// bucket and on into every session, and mcbp_session::initiate_bootstrap() tests exhausted()
+// before it ever calls next_address() -- so carrying the flag would send a session that has tried
+// nothing down the "reached the end of the list of bootstrap nodes" path: an unconditional 500 ms
+// backoff.
+//
+// Moving, by contrast, does carry it: a move transfers identity rather than producing an
+// independent origin.
+//
+// connection_string_ and uses_protostellar_ *are* copied. They were being dropped entirely, which
+// left connection_string() returning "" on any copied origin.
 couchbase::core::origin::origin(const couchbase::core::origin& other)
   : options_(other.options_)
   , nodes_(other.nodes_)
   , next_node_(nodes_.begin())
+  , connection_string_(other.connection_string_)
+  , uses_protostellar_(other.uses_protostellar_)
 {
   update_credentials(other.credentials());
 }
@@ -378,6 +382,7 @@ couchbase::core::origin::origin(couchbase::core::cluster_credentials auth,
                                 const couchbase::core::utils::connection_string& connstr)
   : options_(connstr.options)
   , connection_string_(connstr.input)
+  , uses_protostellar_(connstr.uses_protostellar())
   , credentials_(std::move(auth))
 {
   nodes_.reserve(connstr.bootstrap_nodes.size());
@@ -396,10 +401,13 @@ couchbase::core::origin::operator=(const couchbase::core::origin& other) -> couc
 {
   if (this != &other) {
     options_ = other.options_;
+    connection_string_ = other.connection_string_;
     update_credentials(other.credentials());
     nodes_ = other.nodes_;
+    // Rotation state is reset, not carried -- see the copy constructor for why.
     next_node_ = nodes_.begin();
     exhausted_ = false;
+    uses_protostellar_ = other.uses_protostellar_;
   }
   return *this;
 }
@@ -409,6 +417,11 @@ couchbase::core::origin::connection_string() const -> const std::string&
   return connection_string_;
 }
 auto
+couchbase::core::origin::uses_protostellar() const -> bool
+{
+  return uses_protostellar_;
+}
+auto
 couchbase::core::origin::username() const -> std::string
 {
   const std::shared_lock lock(credentials_mutex_);
@@ -458,6 +471,16 @@ couchbase::core::origin::get_nodes() const -> std::vector<std::string>
   }
   return res;
 }
+auto
+couchbase::core::origin::get_node_addresses() const -> std::vector<std::string>
+{
+  std::vector<std::string> res;
+  res.reserve(nodes_.size());
+  for (const auto& [hostname, port] : nodes_) {
+    res.emplace_back(fmt::format("{}:{}", hostname, port));
+  }
+  return res;
+}
 
 void
 couchbase::core::origin::shuffle_nodes()
@@ -502,6 +525,11 @@ couchbase::core::origin::set_nodes_from_config(const topology::configuration& co
     shuffle_nodes();
   }
   next_node_ = nodes_.begin();
+  // Matches set_nodes(): the node list has just been replaced, so any exhaustion recorded against
+  // the previous list is meaningless. Without this an origin that was exhausted stays exhausted
+  // across every config update -- cluster.cxx calls this on a long-lived origin that
+  // next_address() will have marked exhausted.
+  exhausted_ = false;
 }
 void
 couchbase::core::origin::update_credentials(cluster_credentials auth)

data/ext/couchbase/core/origin.hxx

@@ -60,6 +60,9 @@ struct origin {
   auto operator=(const origin& other) -> origin&;
 
   [[nodiscard]] auto connection_string() const -> const std::string&;
+  // True when built from a couchbase2:// connection string (Protostellar transport). Lets the
+  // connect path branch to the gRPC client without re-parsing the connection string.
+  [[nodiscard]] auto uses_protostellar() const -> bool;
   [[nodiscard]] auto username() const -> std::string;
   [[nodiscard]] auto password() const -> std::string;
   [[nodiscard]] auto certificate_path() const -> std::string;
@@ -68,6 +71,10 @@ struct origin {
 
   [[nodiscard]] auto get_hostnames() const -> std::vector<std::string>;
   [[nodiscard]] auto get_nodes() const -> std::vector<std::string>;
+  // The same addresses as get_nodes(), without the display quotes baked into each entry. Log
+  // statements want them bare so that logger::system_data_list() can put a tag inside the quotes it
+  // renders; a tag around a pre-quoted entry hashes the punctuation with the value.
+  [[nodiscard]] auto get_node_addresses() const -> std::vector<std::string>;
 
   void shuffle_nodes();
   void set_nodes(node_list nodes);
@@ -84,6 +91,10 @@ struct origin {
   [[nodiscard]] auto options() const -> const couchbase::core::cluster_options&;
   [[nodiscard]] auto options() -> couchbase::core::cluster_options&;
   [[nodiscard]] auto credentials() const -> couchbase::core::cluster_credentials;
+  // A JSON dump of the whole origin, less the credentials. Its only callers are the log
+  // statements in the cluster open paths, and they annotate the whole document: a tag written
+  // into one of these values instead would be read back as part of that value by anything that
+  // parses the line as JSON. So nothing in here is annotated.
   [[nodiscard]] auto to_json() const -> std::string;
 
 private:
@@ -92,6 +103,7 @@ private:
   node_list::iterator next_node_{};
   bool exhausted_{ false };
   std::string connection_string_{};
+  bool uses_protostellar_{ false };
   cluster_credentials credentials_{};
   mutable std::shared_mutex credentials_mutex_{};
 };

data/ext/couchbase/core/orphan_reporter.cxx

@@ -20,6 +20,7 @@
 #include <couchbase/build_info.hxx>
 
 #include "logger/logger.hxx"
+#include "logger/redaction.hxx"
 #include "utils/concurrent_fixed_priority_queue.hxx"
 #include "utils/json.hxx"
 
@@ -120,7 +121,7 @@ private:
       }
 
       if (auto report = self->flush_and_create_output(); report.has_value()) {
-        CB_LOG_WARNING("Orphan responses observed: {}", report.value());
+        CB_LOG_WARNING("Orphan responses observed: {}", logger::system_data(report.value()));
       }
 
       self->rearm();

data/ext/couchbase/core/platform/random.cc

@@ -25,7 +25,7 @@
 #include <mutex>
 #include <system_error>
 
-#ifdef WIN32
+#ifdef _WIN32
 // We need to include windows.h _before_ wincrypt.h
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
@@ -45,7 +45,7 @@ class RandomGeneratorProvider
 public:
   RandomGeneratorProvider()
   {
-#ifdef WIN32
+#ifdef _WIN32
     if (!CryptAcquireContext(
           &handle, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
       throw std::system_error(int(GetLastError()),
@@ -69,7 +69,7 @@ public:
 
   virtual ~RandomGeneratorProvider()
   {
-#ifdef WIN32
+#ifdef _WIN32
     CryptReleaseContext(handle, 0);
 #else
     close(handle);
@@ -78,8 +78,8 @@ public:
 
   auto getBytes(void* dest, std::size_t size) -> bool
   {
-    const std::lock_guard<std::mutex> lock(mutex);
-#ifdef WIN32
+    const std::scoped_lock<std::mutex> lock(mutex);
+#ifdef _WIN32
     return CryptGenRandom(handle, (DWORD)size, static_cast<BYTE*>(dest));
 #else
 #if defined(__clang__) && defined(__clang_analyzer__)
@@ -92,7 +92,7 @@ public:
   }
 
 private:
-#ifdef WIN32
+#ifdef _WIN32
   HCRYPTPROV handle{};
 #else
   int handle = -1;
@@ -107,7 +107,7 @@ RandomGenerator::RandomGenerator()
 {
   if (!shared_provider) {
     // This might be the first one, lets lock and create
-    const std::lock_guard<std::mutex> guard(shared_provider_lock);
+    const std::scoped_lock<std::mutex> guard(shared_provider_lock);
     if (!shared_provider) { // cppcheck-suppress identicalInnerCondition; DCLP
       shared_provider = std::make_unique<RandomGeneratorProvider>();
     }

data/ext/couchbase/core/protocol/client_request.cxx

@@ -23,8 +23,8 @@
 namespace couchbase::core::protocol
 {
 auto
-compress_value(const std::vector<std::byte>& value,
-               std::vector<std::byte>::iterator& output) -> std::pair<bool, std::uint32_t>
+compress_value(const std::vector<std::byte>& value, const std::vector<std::byte>::iterator& output)
+  -> std::pair<bool, std::uint32_t>
 {
   static const double min_ratio = 0.83;