couchbase 4.4.1 → 4.4.3

package/deps/couchbase-cxx-client/core/platform/uuid.cc

@@ -42,16 +42,16 @@ couchbase::core::uuid::random(couchbase::core::uuid::uuid_t& uuid)
   uuid[6] |= 0x40;
 }
 
-couchbase::core::uuid::uuid_t
-couchbase::core::uuid::random()
+auto
+couchbase::core::uuid::random() -> couchbase::core::uuid::uuid_t
 {
   uuid_t ret;
   random(ret);
   return ret;
 }
 
-couchbase::core::uuid::uuid_t
-couchbase::core::uuid::from_string(std::string_view str)
+auto
+couchbase::core::uuid::from_string(std::string_view str) -> couchbase::core::uuid::uuid_t
 {
   uuid_t ret;
   if (str.size() != 36) {
@@ -73,14 +73,16 @@ couchbase::core::uuid::from_string(std::string_view str)
         ++ii;
         [[fallthrough]];
       default:
+        // TODO(CXXCBC-549): clang-tidy-19 reports issue with subscript
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
         ret[jj++] = static_cast<std::uint8_t>(from_hex({ str.data() + ii, 2 }));
     }
   }
   return ret;
 }
 
-inline char
-to_char(std::uint8_t c)
+inline auto
+to_char(std::uint8_t c) -> char
 {
   if (c <= 9) {
     return static_cast<char>('0' + c);
@@ -88,8 +90,8 @@ to_char(std::uint8_t c)
   return static_cast<char>('a' + (c - 10));
 }
 
-std::string
-couchbase::core::uuid::to_string(const couchbase::core::uuid::uuid_t& uuid)
+auto
+couchbase::core::uuid::to_string(const couchbase::core::uuid::uuid_t& uuid) -> std::string
 {
   std::string ret(36, '-');
   std::size_t i = 0;

package/deps/couchbase-cxx-client/core/platform/uuid.h

@@ -34,23 +34,23 @@ random(uuid_t& uuid);
 /**
  * Generate a new random uuid and return it
  */
-uuid_t
-random();
+auto
+random() -> uuid_t;
 
 /**
  * Convert a textual version of a UUID to a uuid type
  * @throw std::invalid_argument if the textual uuid is not
  *        formatted correctly
  */
-uuid_t
-from_string(std::string_view str);
+auto
+from_string(std::string_view str) -> uuid_t;
 
 /**
  * Print a textual version of the UUID in the form:
  *
  *     00000000-0000-0000-0000-000000000000
  */
-std::string
-to_string(const couchbase::core::uuid::uuid_t& uuid);
+auto
+to_string(const couchbase::core::uuid::uuid_t& uuid) -> std::string;
 
 } // namespace couchbase::core::uuid

package/deps/couchbase-cxx-client/core/row_streamer.cxx

@@ -162,7 +162,7 @@ private:
 
     feeding_ = true;
 
-    body_.next([self = shared_from_this()](auto data, auto ec) mutable {
+    body_.next([self = shared_from_this()](const auto& data, auto ec) mutable {
       if (ec) {
         self->received_all_data_ = true;
         auto signal = row_stream_end_signal{ ec };

package/deps/couchbase-cxx-client/core/sasl/context.cc

@@ -22,8 +22,8 @@
 namespace couchbase::core::sasl
 {
 
-const std::string&
-Context::get_uuid()
+auto
+Context::get_uuid() -> const std::string&
 {
   if (uuid.empty()) {
     uuid = uuid::to_string(uuid::random());

package/deps/couchbase-cxx-client/core/sasl/mechanism.cc

@@ -18,14 +18,12 @@
 #include "mechanism.h"
 
 #include <algorithm>
-#include <iterator>
-#include <vector>
 
 namespace couchbase::core::sasl
 {
 
-Mechanism
-select_mechanism(const std::vector<std::string>& available_mechanisms)
+auto
+select_mechanism(const std::vector<std::string>& available_mechanisms) -> Mechanism
 {
   // Search what we've got backends for
   const std::vector<std::pair<std::string, Mechanism>> mechs = {
@@ -42,7 +40,7 @@ select_mechanism(const std::vector<std::string>& available_mechanisms)
     }
   }
 
-  throw unknown_mechanism("unknown mechanism"); // TODO: avoid this exception
+  throw unknown_mechanism("unknown mechanism"); // TODO(SA): avoid this exception
 }
 
 } // namespace couchbase::core::sasl

package/deps/couchbase-cxx-client/core/sasl/mechanism.h

@@ -48,10 +48,7 @@ public:
  * @throws unknown_mechanism if no supported mechanism is listed in the
  *                           available mechanisms
  */
-Mechanism
-select_mechanism(const std::vector<std::string>& available_mechanisms);
+auto
+select_mechanism(const std::vector<std::string>& available_mechanisms) -> Mechanism;
 
 } // namespace couchbase::core::sasl
-
-std::string
-to_string(couchbase::core::sasl::Mechanism mechanism);

package/deps/couchbase-cxx-client/core/sasl/plain/plain.cc

@@ -21,8 +21,8 @@
 namespace couchbase::core::sasl::mechanism::plain
 {
 
-std::pair<error, std::string_view>
-ClientBackend::start()
+auto
+ClientBackend::start() -> std::pair<error, std::string_view>
 {
   auto usernm = usernameCallback();
   auto passwd = passwordCallback();

package/deps/couchbase-cxx-client/core/sasl/scram-sha/scram-sha.cc

@@ -36,6 +36,8 @@ namespace couchbase::core::sasl::mechanism::scram
 
 using AttributeMap = std::map<char, std::string>;
 
+namespace
+{
 /**
  * Decode the attribute list into a set. The attribute list looks like:
  * "k=value,y=value" etc
@@ -44,8 +46,8 @@ using AttributeMap = std::map<char, std::string>;
  * @param attributes where to store the attributes
  * @return true if success, false otherwise
  */
-static bool
-decodeAttributeList(const std::string& list, AttributeMap& attributes)
+auto
+decodeAttributeList(const std::string& list, AttributeMap& attributes) -> bool
 {
   size_t pos = 0;
 
@@ -85,12 +87,13 @@ decodeAttributeList(const std::string& list, AttributeMap& attributes)
 
   return true;
 }
+} // namespace
 
 /********************************************************************
  * Common API
  *******************************************************************/
-std::string
-ScramShaBackend::getAuthMessage()
+auto
+ScramShaBackend::getAuthMessage() -> std::string
 {
   if (client_first_message_bare.empty()) {
     throw std::logic_error("can't call getAuthMessage without client_first_message_bare is set");
@@ -168,8 +171,6 @@ ScramShaBackend::addAttribute(std::ostream& out, char key, int value, bool more)
 {
   out << key << '=';
 
-  std::string base64_encoded;
-
   switch (key) {
     case 'n': // username ..
     case 'r': // client nonce.. printable characters
@@ -201,8 +202,8 @@ ScramShaBackend::addAttribute(std::ostream& out, char key, int value, bool more)
  * ServerKey       := HMAC(SaltedPassword, "Server Key")
  * ServerSignature := HMAC(ServerKey, AuthMessage)
  */
-std::string
-ScramShaBackend::getServerSignature()
+auto
+ScramShaBackend::getServerSignature() -> std::string
 {
   auto serverKey = couchbase::core::crypto::CBC_HMAC(algorithm, getSaltedPassword(), "Server Key");
 
@@ -221,12 +222,12 @@ ScramShaBackend::getServerSignature()
  * ClientSignature := HMAC(StoredKey, AuthMessage)
  * ClientProof     := ClientKey XOR ClientSignature
  */
-std::string
-ScramShaBackend::getClientProof()
+auto
+ScramShaBackend::getClientProof() -> std::string
 {
   auto clientKey = couchbase::core::crypto::CBC_HMAC(algorithm, getSaltedPassword(), "Client Key");
   auto storedKey = couchbase::core::crypto::digest(algorithm, clientKey);
-  std::string authMessage = getAuthMessage();
+  const std::string authMessage = getAuthMessage();
   auto clientSignature = couchbase::core::crypto::CBC_HMAC(algorithm, storedKey, authMessage);
 
   // Client Proof is ClientKey XOR ClientSignature
@@ -238,7 +239,7 @@ ScramShaBackend::getClientProof()
 
   auto total = proof.size();
   for (std::size_t ii = 0; ii < total; ++ii) {
-    proof[ii] = ck[ii] ^ cs[ii];
+    proof[ii] = static_cast<char>(ck[ii] ^ cs[ii]);
   }
 
   return proof;
@@ -252,10 +253,10 @@ ClientBackend::ClientBackend(GetUsernameCallback& user_cb,
   : MechanismBackend(user_cb, password_cb, ctx)
   , ScramShaBackend(mech, algo)
 {
-  couchbase::core::RandomGenerator randomGenerator;
+  const couchbase::core::RandomGenerator randomGenerator;
 
   std::array<char, 8> nonce{};
-  if (!randomGenerator.getBytes(nonce.data(), nonce.size())) {
+  if (!couchbase::core::RandomGenerator::getBytes(nonce.data(), nonce.size())) {
     CB_LOG_ERROR_RAW("failed to generate server nonce");
     throw std::bad_alloc();
   }
@@ -263,8 +264,8 @@ ClientBackend::ClientBackend(GetUsernameCallback& user_cb,
   clientNonce = couchbase::core::to_hex({ nonce.data(), nonce.size() });
 }
 
-std::pair<error, std::string_view>
-ClientBackend::start()
+auto
+ClientBackend::start() -> std::pair<error, std::string_view>
 {
   std::stringstream out;
   out << "n,,";
@@ -277,8 +278,8 @@ ClientBackend::start()
   return { error::OK, client_first_message };
 }
 
-std::pair<error, std::string_view>
-ClientBackend::step(std::string_view input)
+auto
+ClientBackend::step(std::string_view input) -> std::pair<error, std::string_view>
 {
   if (input.empty()) {
     return { error::BAD_PARAM, {} };
@@ -365,8 +366,8 @@ ClientBackend::step(std::string_view input)
   return { error::OK, {} };
 }
 
-bool
-ClientBackend::generateSaltedPassword(const std::string& secret)
+auto
+ClientBackend::generateSaltedPassword(const std::string& secret) -> bool
 {
   try {
     saltedPassword = couchbase::core::crypto::PBKDF2_HMAC(algorithm, secret, salt, iterationCount);

package/deps/couchbase-cxx-client/core/sasl/scram-sha/stringutils.cc

@@ -43,8 +43,8 @@ namespace couchbase::core::sasl::mechanism::scram
  *         [StringPrep, C.8]
  *       - Tagging characters [StringPrep, C.9]
  */
-const std::string&
-sasl_prep(const std::string& string)
+auto
+sasl_prep(const std::string& string) -> std::string
 {
   for (const auto& c : string) {
     if ((static_cast<unsigned int>(c) & 0x80U) != 0) {
@@ -61,8 +61,8 @@ sasl_prep(const std::string& string)
   return string;
 }
 
-std::string
-encode_username(const std::string& username)
+auto
+encode_username(const std::string& username) -> std::string
 {
   std::string ret(username);
 

package/deps/couchbase-cxx-client/core/sasl/scram-sha/stringutils.h

@@ -32,8 +32,8 @@ namespace couchbase::core::sasl::mechanism::scram
  * @return a sasl_prep'd string
  * @throws std::runtime_error if we encounter a multibyte character
  */
-const std::string&
-sasl_prep(const std::string& string);
+auto
+sasl_prep(const std::string& string) -> std::string;
 
 /**
  * According to https://www.ietf.org/rfc/rfc5802.txt all occurrences
@@ -42,7 +42,7 @@ sasl_prep(const std::string& string);
  * @param username the username to encode
  * @return the escaped string
  */
-std::string
-encode_username(const std::string& username);
+auto
+encode_username(const std::string& username) -> std::string;
 
 } // namespace couchbase::core::sasl::mechanism::scram

package/deps/couchbase-cxx-client/core/topology/configuration.hxx

@@ -100,6 +100,8 @@ struct configuration {
   std::optional<std::uint64_t> collections_manifest_uid{};
   configuration_capabilities capabilities{};
   node_locator_type node_locator{ node_locator_type::unknown };
+  std::optional<std::string> cluster_name{};
+  std::optional<std::string> cluster_uuid{};
   bool force{ false };
 
   auto operator==(const configuration& other) const -> bool

package/deps/couchbase-cxx-client/core/topology/configuration_json.hxx

@@ -319,6 +319,14 @@ struct traits<couchbase::core::topology::configuration> {
         }
       }
     }
+
+    if (const auto n = v.find("clusterName"); n != nullptr) {
+      result.cluster_name = n->get_string();
+    }
+    if (const auto u = v.find("clusterUUID"); u != nullptr) {
+      result.cluster_uuid = u->get_string();
+    }
+
     return result;
   }
 };

package/deps/couchbase-cxx-client/core/tracing/constants.hxx

@@ -78,6 +78,9 @@ constexpr auto mcbp_internal = "cb.internal";
 namespace attributes
 {
 constexpr auto system = "db.system";
+constexpr auto cluster_name = "db.couchbase.cluster_name";
+constexpr auto cluster_uuid = "db.couchbase.cluster_uuid";
+
 constexpr auto span_kind = "span.kind";
 constexpr auto component = "db.couchbase.component";
 constexpr auto instance = "db.instance";

package/deps/couchbase-cxx-client/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);
   }
 }
 

package/deps/couchbase-cxx-client/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;
 

package/deps/couchbase-cxx-client/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

package/deps/couchbase-cxx-client/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