couchbase 4.4.2 → 4.4.4

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_get_all.hxx

@@ -38,6 +38,8 @@ struct view_index_get_all_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::management;
+  static const inline std::string observability_identifier =
+    "manager_views_get_all_design_documents";
 
   std::string bucket_name;
   design_document_namespace ns;

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/operations/management/view_index_upsert.hxx

@@ -37,6 +37,7 @@ struct view_index_upsert_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::view;
+  static const inline std::string observability_identifier = "manager_views_upsert_design_document";
 
   std::string bucket_name;
   couchbase::core::management::views::design_document document;

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/async_attempt_context.hxx

@@ -42,7 +42,9 @@ public:
   using VoidCallback = std::function<void(std::exception_ptr)>;
   using QueryCallback =
     std::function<void(std::exception_ptr, std::optional<core::operations::query_response>)>;
+
   virtual ~async_attempt_context() = default;
+
   /**
    * Gets a document from the specified Couchbase collection matching the
    * specified id.
@@ -91,6 +93,7 @@ public:
    *
    * If the mutation fails, the transaction will automatically rollback this
    * attempt, then retry.
+   *
    * @param document the doc to be updated
    * @param content the content to replace the doc with.
    * @param cb callback function called with the updated @ref
@@ -98,11 +101,10 @@ public:
    * transaction_operation_failed
    *
    */
-  template<typename Transcoder = codec::default_json_transcoder, typename Content>
-  void replace(const transaction_get_result& document, const Content& content, Callback&& cb)
-  {
-    return replace_raw(document, Transcoder::encode(content), std::move(cb));
-  }
+  virtual void replace(const transaction_get_result& document,
+                       codec::encoded_value content,
+                       Callback&& cb) = 0;
+
   /**
    * Inserts a new document into the specified Couchbase collection.
    *
@@ -119,11 +121,8 @@ public:
    * @param cb callback function called with a @ref transaction_get_result with
    * the new CAS value when successful, or @ref transaction_operation_failed
    */
-  template<typename Transcoder = codec::default_json_transcoder, typename Content>
-  void insert(const core::document_id& id, const Content& content, Callback&& cb)
-  {
-    return insert_raw(id, Transcoder::encode(content), std::move(cb));
-  }
+  virtual void insert(const core::document_id& id, codec::encoded_value content, Callback&& cb) = 0;
+
   /**
    * Removes the specified document, using the document's last
    * TransactionDocument#cas
@@ -195,17 +194,6 @@ public:
    * @param cb callback which is called when the rollback succeeds
    */
   virtual void rollback(VoidCallback&& cb) = 0;
-
-protected:
-  /** @internal */
-  virtual void insert_raw(const core::document_id& id,
-                          codec::encoded_value content,
-                          Callback&& cb) = 0;
-
-  /** @internal */
-  virtual void replace_raw(const transaction_get_result& document,
-                           codec::encoded_value content,
-                           Callback&& cb) = 0;
 };
 
 } // namespace couchbase::core::transactions

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

@@ -101,19 +101,8 @@ public:
    * @throws transaction_operation_failed which either should not be caught by
    * the lambda, or rethrown if it is caught.
    */
-  template<typename Transcoder = codec::default_json_transcoder, typename Content>
-  auto replace(const transaction_get_result& document,
-               const Content& content) -> transaction_get_result
-  {
-    codec::encoded_value data;
-    try {
-      data = Transcoder::encode(content);
-    } catch (std::runtime_error& e) {
-      throw transaction_operation_failed(
-        FAIL_OTHER, std::string("failed to encode content as JSON: ") + e.what());
-    }
-    return replace_raw(document, data);
-  }
+  virtual auto replace(const transaction_get_result& document,
+                       codec::encoded_value content) -> transaction_get_result = 0;
 
   /**
    * Inserts a new document into the specified Couchbase collection.
@@ -135,18 +124,9 @@ public:
    * @throws transaction_operation_failed which either should not be caught by
    * the lambda, or rethrown if it is caught.
    */
-  template<typename Transcoder = codec::default_json_transcoder, typename Content>
-  auto insert(const core::document_id& id, const Content& content) -> transaction_get_result
-  {
-    codec::encoded_value data;
-    try {
-      data = Transcoder::encode(content);
-    } catch (std::runtime_error& e) {
-      throw transaction_operation_failed(
-        FAIL_OTHER, std::string("failed to encode content as JSON: ") + e.what());
-    }
-    return insert_raw(id, data);
-  }
+  virtual auto insert(const core::document_id& id,
+                      codec::encoded_value content) -> transaction_get_result = 0;
+
   /**
    * Removes the specified document, using the document's last
    * TransactionDocument#cas
@@ -179,6 +159,7 @@ public:
   {
     return do_core_query(statement, opts, query_context);
   };
+
   /**
    * Performs a Query, within the current transaction.
    *
@@ -218,14 +199,6 @@ public:
   virtual void rollback() = 0;
 
 protected:
-  /** @internal */
-  virtual auto insert_raw(const core::document_id& id,
-                          codec::encoded_value content) -> transaction_get_result = 0;
-
-  /** @internal */
-  virtual auto replace_raw(const transaction_get_result& document,
-                           codec::encoded_value content) -> transaction_get_result = 0;
-
   virtual auto do_core_query(const std::string&,
                              const couchbase::transactions::transaction_query_options& opts,
                              std::optional<std::string> query_context)