couchbase 4.4.2 → 4.4.3

package/deps/couchbase-cxx-client/core/operations/management/view_index_drop.cxx

@@ -17,6 +17,7 @@
 
 #include "view_index_drop.hxx"
 
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -30,7 +31,7 @@ view_index_drop_request::encode_to(encoded_request_type& encoded,
 {
   encoded.method = "DELETE";
   encoded.path = fmt::format("/{}/_design/{}{}",
-                             bucket_name,
+                             utils::string_codec::v2::path_escape(bucket_name),
                              ns == design_document_namespace::development ? "dev_" : "",
                              document_name);
   return {};

package/deps/couchbase-cxx-client/core/operations/management/view_index_get.cxx

@@ -18,6 +18,7 @@
 #include "view_index_get.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -31,7 +32,7 @@ view_index_get_request::encode_to(encoded_request_type& encoded,
 {
   encoded.method = "GET";
   encoded.path = fmt::format("/{}/_design/{}{}",
-                             bucket_name,
+                             utils::string_codec::v2::path_escape(bucket_name),
                              ns == design_document_namespace::development ? "dev_" : "",
                              document_name);
   return {};

package/deps/couchbase-cxx-client/core/operations/management/view_index_get_all.cxx

@@ -18,6 +18,7 @@
 #include "view_index_get_all.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -30,7 +31,8 @@ view_index_get_all_request::encode_to(encoded_request_type& encoded,
                                       http_context& /* context */) const -> std::error_code
 {
   encoded.method = "GET";
-  encoded.path = fmt::format("/pools/default/buckets/{}/ddocs", bucket_name);
+  encoded.path = fmt::format("/pools/default/buckets/{}/ddocs",
+                             utils::string_codec::v2::path_escape(bucket_name));
   return {};
 }
 

package/deps/couchbase-cxx-client/core/operations/management/view_index_upsert.cxx

@@ -18,6 +18,7 @@
 #include "view_index_upsert.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -45,7 +46,7 @@ view_index_upsert_request::encode_to(encoded_request_type& encoded,
   encoded.headers["content-type"] = "application/json";
   encoded.method = "PUT";
   encoded.path = fmt::format("/{}/_design/{}{}",
-                             bucket_name,
+                             utils::string_codec::v2::path_escape(bucket_name),
                              document.ns == design_document_namespace::development ? "dev_" : "",
                              document.name);
   encoded.body = utils::json::generate(body);

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

@@ -210,6 +210,24 @@ 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
@@ -222,45 +240,47 @@ origin::to_json() const -> std::string
       "options",
       {
         { "bootstrap_timeout", options_.bootstrap_timeout },
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-        { "dispatch_timeout", options_.dispatch_timeout },
-#endif
         { "resolve_timeout", options_.resolve_timeout },
         { "connect_timeout", options_.connect_timeout },
+        { "query_timeout", options_.query_timeout },
+        { "management_timeout", options_.management_timeout },
+        { "trust_certificate", options_.trust_certificate },
+        { "use_ip_protocol", options_.use_ip_protocol },
+        { "enable_dns_srv", options_.enable_dns_srv },
+        { "dns_config", options_.dns_config },
+        { "enable_clustermap_notification", options_.enable_clustermap_notification },
+        { "config_poll_interval", options_.config_poll_interval },
+        { "config_poll_floor", options_.config_poll_floor },
+        { "user_agent_extra", options_.user_agent_extra },
+        { "dump_configuration", options_.dump_configuration },
+        { "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 },
-        { "query_timeout", options_.query_timeout },
         { "analytics_timeout", options_.analytics_timeout },
         { "search_timeout", options_.search_timeout },
-        { "management_timeout", options_.management_timeout },
         { "enable_tls", options_.enable_tls },
-        { "trust_certificate", options_.trust_certificate },
         { "enable_mutation_tokens", options_.enable_mutation_tokens },
         { "enable_tcp_keep_alive", options_.enable_tcp_keep_alive },
-        { "use_ip_protocol", options_.use_ip_protocol },
-        { "enable_dns_srv", options_.enable_dns_srv },
-        { "dns_config", options_.dns_config },
         { "show_queries", options_.show_queries },
         { "enable_unordered_execution", options_.enable_unordered_execution },
-        { "enable_clustermap_notification", options_.enable_clustermap_notification },
         { "enable_compression", options_.enable_compression },
         { "enable_tracing", options_.enable_tracing },
         { "enable_metrics", options_.enable_metrics },
         { "tcp_keep_alive_interval", options_.tcp_keep_alive_interval },
-        { "config_poll_interval", options_.config_poll_interval },
-        { "config_poll_floor", options_.config_poll_floor },
         { "config_idle_redial_timeout", options_.config_idle_redial_timeout },
         { "max_http_connections", options_.max_http_connections },
         { "idle_http_connection_timeout", options_.idle_http_connection_timeout },
-        { "user_agent_extra", options_.user_agent_extra },
-        { "dump_configuration", options_.dump_configuration },
-        { "disable_mozilla_ca_certificates", options_.disable_mozilla_ca_certificates },
         { "metrics_options", options_.metrics_options },
-        { "network", options_.network },
-        { "tls_verify", options_.tls_verify },
         { "tracing_options", options_.tracing_options },
         { "transactions_options", options_.transactions },
+#endif
       },
     },
   };

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

@@ -182,7 +182,7 @@ encode(gsl::span<const std::byte> blob, bool pretty_print) -> std::string
   if (pretty_print) {
     // In pretty-print mode we insert a newline after adding
     // 16 chunks (four characters).
-    result.reserve(chunks * 4 + chunks / 16);
+    result.reserve((chunks * 4) + (chunks / 16));
   } else {
     result.reserve(chunks * 4);
   }

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

@@ -82,6 +82,8 @@ public:
 #ifdef WIN32
     return CryptGenRandom(handle, (DWORD)size, static_cast<BYTE*>(dest));
 #else
+    // TODO(CXXCBC-549)
+    // NOLINTNEXTLINE(clang-analyzer-unix.BlockInCriticalSection)
     return static_cast<std::size_t>(read(handle, dest, size)) == size;
 #endif
   }

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/scram-sha/stringutils.cc

@@ -44,7 +44,7 @@ namespace couchbase::core::sasl::mechanism::scram
  *       - Tagging characters [StringPrep, C.9]
  */
 auto
-sasl_prep(const std::string& string) -> const std::string&
+sasl_prep(const std::string& string) -> std::string
 {
   for (const auto& c : string) {
     if ((static_cast<unsigned int>(c) & 0x80U) != 0) {

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/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

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

@@ -2975,7 +2975,7 @@ attempt_context_impl::do_get(const core::document_id& id,
            allow_replica,
            resolving_missing_atr_entry = std::move(resolving_missing_atr_entry),
            cb = std::move(cb)](std::optional<error_class> ec,
-                               std::optional<std::string> err_message,
+                               const std::optional<std::string>& err_message,
                                std::optional<transaction_get_result> doc) mutable {
             if (!ec && !doc) {
               // it just isn't there.
@@ -3101,20 +3101,21 @@ template<typename LookupInRequest, typename Callback>
 void
 execute_lookup(attempt_context_impl* ctx, LookupInRequest& req, Callback&& cb)
 {
-  ctx->overall()->cluster_ref().execute(req, [ctx, cb = std::forward<Callback>(cb)](auto resp) {
-    auto ec = error_class_from_response(resp);
-    if (ec) {
-      CB_ATTEMPT_CTX_LOG_TRACE(ctx, "get_doc got error {} : {}", resp.ctx.ec().message(), *ec);
-      switch (*ec) {
-        case FAIL_PATH_NOT_FOUND:
-          return cb(ec, resp.ctx.ec().message(), transaction_get_result::create_from(resp));
-        default:
-          return cb(ec, resp.ctx.ec().message(), std::nullopt);
+  ctx->overall()->cluster_ref().execute(
+    req, [ctx, cb = std::forward<Callback>(cb)](const auto& resp) {
+      auto ec = error_class_from_response(resp);
+      if (ec) {
+        CB_ATTEMPT_CTX_LOG_TRACE(ctx, "get_doc got error {} : {}", resp.ctx.ec().message(), *ec);
+        switch (*ec) {
+          case FAIL_PATH_NOT_FOUND:
+            return cb(ec, resp.ctx.ec().message(), transaction_get_result::create_from(resp));
+          default:
+            return cb(ec, resp.ctx.ec().message(), std::nullopt);
+        }
+      } else {
+        return cb({}, {}, transaction_get_result::create_from(resp));
       }
-    } else {
-      return cb({}, {}, transaction_get_result::create_from(resp));
-    }
-  });
+    });
 }
 } // namespace
 
@@ -3161,7 +3162,7 @@ attempt_context_impl::get_doc(const core::document_id& id,
 template<typename Handler, typename Delay>
 void
 attempt_context_impl::create_staged_insert_error_handler(const core::document_id& id,
-                                                         codec::encoded_value content,
+                                                         const codec::encoded_value& content,
                                                          std::uint64_t cas,
                                                          Delay&& delay,
                                                          const std::string& op_id,

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

@@ -463,8 +463,8 @@ private:
 
   template<typename Handler, typename Delay>
   void create_staged_insert_error_handler(const core::document_id& id,
-                                          codec::encoded_value content,
-                                          uint64_t cas,
+                                          const codec::encoded_value& content,
+                                          std::uint64_t cas,
                                           Delay&& delay,
                                           const std::string& op_id,
                                           Handler&& cb,

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

@@ -568,7 +568,7 @@ staged_mutation_queue::commit_doc(const std::shared_ptr<attempt_context_impl>& c
                   res,
                   item,
                   [ambiguity_resolution_mode, cas_zero_mode, handler = std::move(handler)](
-                    auto e) mutable {
+                    const auto& e) mutable {
                     if (e) {
                       return handler(e, ambiguity_resolution_mode, cas_zero_mode);
                     }
@@ -610,7 +610,7 @@ staged_mutation_queue::commit_doc(const std::shared_ptr<attempt_context_impl>& c
                 res,
                 item,
                 [ambiguity_resolution_mode, cas_zero_mode, handler = std::move(handler)](
-                  auto e) mutable {
+                  const auto& e) mutable {
                   if (e) {
                     return handler(e, ambiguity_resolution_mode, cas_zero_mode);
                   }

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

@@ -99,7 +99,7 @@ transactions::create(core::cluster cluster,
 {
   auto barrier =
     std::make_shared<std::promise<std::pair<std::error_code, std::shared_ptr<transactions>>>>();
-  create(std::move(cluster), config, [barrier](auto ec, auto txns) mutable {
+  create(std::move(cluster), config, [barrier](auto ec, const auto& txns) mutable {
     barrier->set_value({ ec, txns });
   });
   return barrier->get_future();
@@ -171,7 +171,7 @@ wrap_public_api_run(transactions& txns,
                     std::size_t max_attempts,
                     Handler&& fn) -> ::couchbase::transactions::transaction_result
 {
-  return wrap_run(txns, config, max_attempts, [fn = std::forward<Handler>(fn)](auto ctx) {
+  return wrap_run(txns, config, max_attempts, [fn = std::forward<Handler>(fn)](const auto& ctx) {
     const couchbase::error err = fn(ctx);
     if (err && err.ec() != errc::transaction_op::transaction_op_failed) {
       if (err.ec().category() == core::impl::transaction_op_category()) {