couchbase 3.7.0 → 3.8.0

data/ext/couchbase/core/tracing/wrapper_sdk_tracer.hxx

@@ -0,0 +1,85 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025. 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 <couchbase/tracing/request_tracer.hxx>
+
+#include "core/tracing/noop_tracer.hxx"
+
+#include <chrono>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace couchbase::core::tracing
+{
+/**
+ * Tracer for use by C++ SDK wrappers. It is intended for storing spans & tags in memory, so that
+ * wrappers can then use their own tracing infrastructure to create them.
+ */
+class wrapper_sdk_tracer : public couchbase::tracing::request_tracer
+{
+public:
+  auto start_span(std::string name, std::shared_ptr<couchbase::tracing::request_span> parent)
+    -> std::shared_ptr<couchbase::tracing::request_span> override;
+
+private:
+  std::shared_ptr<noop_span> noop_instance_{ std::make_shared<noop_span>() };
+};
+
+class wrapper_sdk_span : public couchbase::tracing::request_span
+{
+public:
+  wrapper_sdk_span() = default;
+  explicit wrapper_sdk_span(std::string name);
+  wrapper_sdk_span(std::string name,
+                   const std::shared_ptr<couchbase::tracing::request_span>& parent);
+
+  void add_child(const std::shared_ptr<wrapper_sdk_span>& child);
+
+  void add_tag(const std::string& name, std::uint64_t value) override;
+  void add_tag(const std::string& name, const std::string& value) override;
+
+  void end() override;
+
+  [[nodiscard]] auto uint_tags() const -> const std::map<std::string, std::uint64_t>&;
+  [[nodiscard]] auto string_tags() const -> const std::map<std::string, std::string>&;
+  [[nodiscard]] auto children() -> std::vector<std::shared_ptr<wrapper_sdk_span>>;
+  [[nodiscard]] auto start_time() const -> const std::chrono::system_clock::time_point&;
+  [[nodiscard]] auto end_time() const -> const std::chrono::system_clock::time_point&;
+
+  [[nodiscard]] auto parent() const -> std::shared_ptr<couchbase::tracing::request_span> override;
+
+private:
+  std::map<std::string, std::uint64_t> uint_tags_{};
+  std::map<std::string, std::string> string_tags_{};
+  std::chrono::system_clock::time_point start_time_{ std::chrono::system_clock::now() };
+  std::chrono::system_clock::time_point end_time_{};
+
+  // The only way to access spans is through their parents, so parents must hold owning references
+  // to their children.
+  std::vector<std::shared_ptr<wrapper_sdk_span>> children_{};
+  std::mutex children_mutex_;
+
+  // A weak pointer is used instead of the shared pointer in the parent class, to avoid circular
+  // references.
+  std::weak_ptr<couchbase::tracing::request_span> parent_{};
+};
+} // namespace couchbase::core::tracing

data/ext/couchbase/core/transactions/attempt_context_impl.cxx

@@ -634,8 +634,8 @@ void
 attempt_context_impl::get_multi(
   const std::vector<couchbase::transactions::transaction_get_multi_spec>& specs,
   const couchbase::transactions::transaction_get_multi_options& options,
-  std::function<void(error, std::optional<couchbase::transactions::transaction_get_multi_result>)>&&
-    cb)
+  std::function<void(couchbase::error,
+                     std::optional<couchbase::transactions::transaction_get_multi_result>)>&& cb)
 {
   std::vector<core::document_id> ids;
   ids.reserve(specs.size());
@@ -666,17 +666,19 @@ auto
 attempt_context_impl::get_multi(
   const std::vector<couchbase::transactions::transaction_get_multi_spec>& specs,
   const couchbase::transactions::transaction_get_multi_options& options)
-  -> std::pair<error, std::optional<couchbase::transactions::transaction_get_multi_result>>
+  -> std::pair<couchbase::error,
+               std::optional<couchbase::transactions::transaction_get_multi_result>>
 {
   auto barrier = std::make_shared<std::promise<
-    std::pair<error, std::optional<couchbase::transactions::transaction_get_multi_result>>>>();
+    std::pair<couchbase::error,
+              std::optional<couchbase::transactions::transaction_get_multi_result>>>>();
   auto f = barrier->get_future();
-  get_multi(
-    specs,
-    options,
-    [barrier](error err, std::optional<couchbase::transactions::transaction_get_multi_result> res) {
-      return barrier->set_value(std::make_pair(std::move(err), std::move(res)));
-    });
+  get_multi(specs,
+            options,
+            [barrier](couchbase::error err,
+                      std::optional<couchbase::transactions::transaction_get_multi_result> res) {
+              return barrier->set_value(std::make_pair(std::move(err), std::move(res)));
+            });
   return f.get();
 }
 
@@ -749,7 +751,7 @@ attempt_context_impl::get_multi_replicas_from_preferred_server_group(
   const couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_options&
     options,
   std::function<
-    void(error,
+    void(couchbase::error,
          std::optional<couchbase::transactions::
                          transaction_get_multi_replicas_from_preferred_server_group_result>)>&& cb)
 {
@@ -790,12 +792,12 @@ attempt_context_impl::get_multi_replicas_from_preferred_server_group(
   const couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_options&
     options)
   -> std::pair<
-    error,
+    couchbase::error,
     std::optional<
       couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<
-    error,
+    couchbase::error,
     std::optional<couchbase::transactions::
                     transaction_get_multi_replicas_from_preferred_server_group_result>>>>();
   auto f = barrier->get_future();
@@ -803,7 +805,7 @@ attempt_context_impl::get_multi_replicas_from_preferred_server_group(
     specs,
     options,
     [barrier](
-      error err,
+      couchbase::error err,
       std::optional<
         couchbase::transactions::transaction_get_multi_replicas_from_preferred_server_group_result>
         res) {

data/ext/couchbase/core/transactions/attempt_context_impl.hxx

@@ -357,12 +357,12 @@ public:
                                     std::optional<transaction_get_multi_result>)>&& cb) override;
   auto get_multi(const std::vector<couchbase::transactions::transaction_get_multi_spec>& specs,
                  const couchbase::transactions::transaction_get_multi_options& options)
-    -> std::pair<error,
+    -> std::pair<couchbase::error,
                  std::optional<couchbase::transactions::transaction_get_multi_result>> override;
   void get_multi(
     const std::vector<couchbase::transactions::transaction_get_multi_spec>& specs,
     const couchbase::transactions::transaction_get_multi_options& options,
-    std::function<void(error,
+    std::function<void(couchbase::error,
                        std::optional<couchbase::transactions::transaction_get_multi_result>)>&& cb)
     override;
 
@@ -384,7 +384,7 @@ public:
     const couchbase::transactions::
       transaction_get_multi_replicas_from_preferred_server_group_options& options)
     -> std::pair<
-      error,
+      couchbase::error,
       std::optional<couchbase::transactions::
                       transaction_get_multi_replicas_from_preferred_server_group_result>> override;
   void get_multi_replicas_from_preferred_server_group(
@@ -394,7 +394,7 @@ public:
     const couchbase::transactions::
       transaction_get_multi_replicas_from_preferred_server_group_options& options,
     std::function<void(
-      error,
+      couchbase::error,
       std::optional<couchbase::transactions::
                       transaction_get_multi_replicas_from_preferred_server_group_result>)>&& cb)
     override;

data/ext/couchbase/core/transactions/transactions.cxx

@@ -204,7 +204,7 @@ transactions::run(const couchbase::transactions::transaction_options& config, lo
 auto
 transactions::run(couchbase::transactions::txn_logic&& code,
                   const couchbase::transactions::transaction_options& config)
-  -> std::pair<error, couchbase::transactions::transaction_result>
+  -> std::pair<couchbase::error, couchbase::transactions::transaction_result>
 {
   try {
     return { {}, wrap_public_api_run(*this, config, max_attempts_, std::move(code)) };

data/ext/couchbase/core/transactions/transactions_cleanup.cxx

@@ -77,8 +77,7 @@ parse_mutation_cas(const std::string& cas) -> std::uint64_t
   if (cas.empty()) {
     return 0;
   }
-  return core::utils::byte_swap(static_cast<std::uint64_t>(std::stoull(cas, nullptr, 16))) /
-         1000000;
+  return core::utils::byte_swap(std::stoull(cas, nullptr, 16)) / 1000000;
 }
 
 // TODO(CXXCBC-549)

data/ext/couchbase/core/utils/byteswap.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <cstdint>
+#include <type_traits>
 
 namespace couchbase::core::utils
 {
@@ -46,4 +47,15 @@ byte_swap(std::uint64_t value) -> std::uint64_t
   std::uint32_t lo = byte_swap(static_cast<std::uint32_t>(value >> 32));
   return (hi << 32) | lo;
 }
+
+// when 'unsigned long long' is not the same as 'std::uint64_t'
+template<typename Dummy = void>
+static constexpr auto
+byte_swap(unsigned long long value,
+          std::enable_if_t<!std::is_same_v<unsigned long long, std::uint64_t>, Dummy>* /* dummy */ =
+            nullptr) -> std::uint64_t
+{
+  return byte_swap(static_cast<std::uint64_t>(value));
+}
+
 } // namespace couchbase::core::utils

data/ext/couchbase/core/utils/concurrent_fixed_priority_queue.hxx

@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025 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 <mutex>
+#include <queue>
+
+namespace couchbase::core::utils
+{
+template<typename T>
+class concurrent_fixed_priority_queue
+{
+private:
+  std::mutex mutex_;
+  std::priority_queue<T, std::vector<T>, std::greater<T>> data_;
+  std::size_t dropped_count_{ 0 };
+  std::size_t capacity_{};
+
+public:
+  using size_type = typename std::priority_queue<T, std::vector<T>, std::greater<T>>::size_type;
+
+  explicit concurrent_fixed_priority_queue(std::size_t capacity)
+    : capacity_(capacity)
+  {
+  }
+
+  concurrent_fixed_priority_queue(const concurrent_fixed_priority_queue&) = delete;
+  concurrent_fixed_priority_queue(concurrent_fixed_priority_queue&&) = delete;
+  auto operator=(const concurrent_fixed_priority_queue&)
+    -> concurrent_fixed_priority_queue& = delete;
+  auto operator=(concurrent_fixed_priority_queue&&) -> concurrent_fixed_priority_queue& = delete;
+  ~concurrent_fixed_priority_queue() = default;
+
+  auto size() -> size_type
+  {
+    std::unique_lock<std::mutex> lock(mutex_);
+    return data_.size();
+  }
+
+  auto empty() -> bool
+  {
+    const std::unique_lock<std::mutex> lock(mutex_);
+    return data_.empty();
+  }
+
+  void emplace(const T&& item)
+  {
+    const std::unique_lock<std::mutex> lock(mutex_);
+
+    if (data_.size() < capacity_) {
+      data_.emplace(std::forward<const T>(item));
+    } else {
+      // We need to either drop the new item, or an existing item
+      ++dropped_count_;
+      if (item > data_.top()) {
+        // The new item is greater than the smallest item, so we will replace the smallest with the
+        // new item
+        data_.pop();
+        data_.emplace(std::forward<const T>(item));
+      }
+    }
+  }
+
+  /**
+   * Clears the internal queue, and returns the data along with the number of items that have been
+   * dropped.
+   */
+  auto steal_data() -> std::pair<std::priority_queue<T>, std::size_t>
+  {
+    std::priority_queue<T, std::vector<T>, std::greater<T>> reversed_data;
+    std::size_t dropped_count{};
+    {
+      const std::unique_lock<std::mutex> lock(mutex_);
+      std::swap(reversed_data, data_);
+      std::swap(dropped_count, dropped_count_);
+    }
+
+    std::priority_queue<T> data{};
+    while (!reversed_data.empty()) {
+      data.emplace(std::move(reversed_data.top()));
+      reversed_data.pop();
+    }
+
+    return std::make_pair(std::move(data), dropped_count);
+  }
+};
+} // namespace couchbase::core::utils

data/ext/couchbase/core/utils/connection_string.cxx

@@ -590,6 +590,8 @@ extract_options(connection_string& connstr)
       parse_option(connstr.options.preserve_bootstrap_nodes_order, name, value, connstr.warnings);
     } else if (name == "allow_enterprise_analytics") {
       parse_option(connstr.options.allow_enterprise_analytics, name, value, connstr.warnings);
+    } else if (name == "enable_lazy_connections") {
+      parse_option(connstr.options.enable_lazy_connections, name, value, connstr.warnings);
     } else {
       connstr.warnings.push_back(
         fmt::format(R"(unknown parameter "{}" in connection string (value "{}"))", name, value));

data/ext/couchbase/couchbase/certificate_authenticator.hxx

@@ -35,5 +35,6 @@ private:
   std::string key_path_;
 
   friend class cluster_options;
+  friend class cluster;
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/cluster.hxx

@@ -102,6 +102,53 @@ public:
   void close(std::function<void()>&& handler);
   [[nodiscard]] auto close() -> std::future<void>;
 
+  /**
+   * Replaces the current authenticator used by this cluster.
+   *
+   * NOTE: Setting a new authenticator does not change the authentication status of existing
+   * connections.
+   *
+   * @param authenticator the authenticator to replace
+   *
+   * @return error
+   *
+   * @since 1.3.0
+   * @committed
+   */
+  auto set_authenticator(const password_authenticator& authenticator) -> error;
+
+  /**
+   * Replaces the current authenticator used by this cluster.
+   *
+   * NOTE: Setting a new authenticator does not change the authentication status of existing
+   connections.
+   *
+   * @param authenticator the authenticator to replace
+
+   * @exception errc::common::invalid_argument if TLS is not enabled.
+   *
+   * @return error
+   *
+   * @since 1.3.0
+   * @committed
+   */
+  auto set_authenticator(const certificate_authenticator& authenticator) -> error;
+
+  /**
+   * Replaces the current authenticator used by this cluster.
+   *
+   * NOTE: Setting a new authenticator does not change the authentication status of existing
+   connections.
+   *
+   * @param authenticator the authenticator to replace
+   *
+   * @return error
+   *
+   * @since 1.3.0
+   * @uncommitted
+   */
+  auto set_authenticator(const jwt_authenticator& authenticator) -> error;
+
   /**
    * Opens a {@link bucket} with the given name.
    *

data/ext/couchbase/couchbase/cluster_options.hxx

@@ -24,6 +24,7 @@
 #include <couchbase/configuration_profiles_registry.hxx>
 #include <couchbase/dns_options.hxx>
 #include <couchbase/error.hxx>
+#include <couchbase/jwt_authenticator.hxx>
 #include <couchbase/metrics_options.hxx>
 #include <couchbase/network_options.hxx>
 #include <couchbase/password_authenticator.hxx>
@@ -93,6 +94,18 @@ public:
   {
   }
 
+  /**
+   *
+   * @param authenticator
+   *
+   * @since 1.3.0
+   * @uncommitted
+   */
+  explicit cluster_options(jwt_authenticator authenticator)
+    : jwt_token_{ std::move(authenticator.token_) }
+  {
+  }
+
   /**
    * Apply settings profile by name.
    *
@@ -272,6 +285,7 @@ public:
     std::string password;
     std::string certificate_path;
     std::string key_path;
+    std::string jwt_token;
     std::optional<std::vector<std::string>> allowed_sasl_mechanisms;
     compression_options::built compression;
     timeout_options::built timeouts;
@@ -294,6 +308,7 @@ public:
       password_,
       certificate_path_,
       key_path_,
+      jwt_token_,
       sasl_mechanisms_,
       compression_.build(),
       timeouts_.build(),
@@ -315,6 +330,7 @@ private:
   std::string password_{};
   std::string certificate_path_{};
   std::string key_path_{};
+  std::string jwt_token_{};
   std::optional<std::vector<std::string>> sasl_mechanisms_{};
 
   compression_options compression_{};

data/ext/couchbase/couchbase/collection.hxx

@@ -463,8 +463,10 @@ public:
               const upsert_options& options,
               upsert_handler&& handler) const
   {
-    return upsert(
-      std::move(document_id), encode_document<Transcoder>(document), options, std::move(handler));
+    return upsert(std::move(document_id),
+                  create_encode_fn<Transcoder, Document>(std::move(document)),
+                  options,
+                  std::move(handler));
   }
 
   /**
@@ -506,11 +508,12 @@ public:
    */
   template<typename Transcoder = codec::default_json_transcoder, typename Document>
   [[nodiscard]] auto upsert(std::string document_id,
-                            const Document& document,
+                            Document document,
                             const upsert_options& options = {}) const
     -> std::future<std::pair<error, mutation_result>>
   {
-    return upsert(std::move(document_id), encode_document<Transcoder>(document), options);
+    return upsert(
+      std::move(document_id), create_encode_fn<Transcoder, Document>(std::move(document)), options);
   }
 
   /**
@@ -559,8 +562,10 @@ public:
               const insert_options& options,
               insert_handler&& handler) const
   {
-    return insert(
-      std::move(document_id), encode_document<Transcoder>(document), options, std::move(handler));
+    return insert(std::move(document_id),
+                  create_encode_fn<Transcoder, Document>(std::move(document)),
+                  options,
+                  std::move(handler));
   }
 
   /**
@@ -605,11 +610,12 @@ public:
            typename Document,
            std::enable_if_t<!std::is_same_v<codec::encoded_value, Document>, bool> = true>
   [[nodiscard]] auto insert(std::string document_id,
-                            const Document& document,
+                            Document document,
                             const insert_options& options = {}) const
     -> std::future<std::pair<error, mutation_result>>
   {
-    return insert(std::move(document_id), encode_document<Transcoder>(document), options);
+    return insert(
+      std::move(document_id), create_encode_fn<Transcoder, Document>(std::move(document)), options);
   }
 
   /**
@@ -660,8 +666,10 @@ public:
                const replace_options& options,
                replace_handler&& handler) const
   {
-    return replace(
-      std::move(document_id), encode_document<Transcoder>(document), options, std::move(handler));
+    return replace(std::move(document_id),
+                   create_encode_fn<Transcoder, Document>(std::move(document)),
+                   options,
+                   std::move(handler));
   }
 
   /**
@@ -708,11 +716,12 @@ public:
            typename Document,
            std::enable_if_t<!std::is_same_v<codec::encoded_value, Document>, bool> = true>
   [[nodiscard]] auto replace(std::string document_id,
-                             const Document& document,
+                             Document document,
                              const replace_options& options = {}) const
     -> std::future<std::pair<error, mutation_result>>
   {
-    return replace(std::move(document_id), encode_document<Transcoder>(document), options);
+    return replace(
+      std::move(document_id), create_encode_fn<Transcoder, Document>(std::move(document)), options);
   }
 
   /**
@@ -1090,15 +1099,51 @@ private:
   [[nodiscard]] auto crypto_manager() const -> const std::shared_ptr<crypto::manager>&;
 
   template<typename Transcoder, typename Document>
-  [[nodiscard]] auto encode_document(const Document& document) const -> codec::encoded_value
+  [[nodiscard]] auto create_encode_fn(Document document) const
+    -> std::function<codec::encoded_value()>
   {
     if constexpr (codec::is_crypto_transcoder_v<Transcoder>) {
-      return Transcoder::encode(document, crypto_manager());
+      return [crypto_manager = crypto_manager(),
+              document = std::move(document)]() -> codec::encoded_value {
+        return Transcoder::encode(document, crypto_manager);
+      };
     } else {
-      return Transcoder::encode(document);
+      return [document = std::move(document)]() -> codec::encoded_value {
+        return Transcoder::encode(document);
+      };
     }
   }
 
+  void replace(std::string document_id,
+               std::function<codec::encoded_value()> document_fn,
+               const replace_options& options,
+               replace_handler&& handler) const;
+
+  auto replace(std::string document_id,
+               std::function<codec::encoded_value()> document_fn,
+               const replace_options& options) const
+    -> std::future<std::pair<error, mutation_result>>;
+
+  void upsert(std::string document_id,
+              std::function<codec::encoded_value()> document_fn,
+              const upsert_options& options,
+              upsert_handler&& handler) const;
+
+  auto upsert(std::string document_id,
+              std::function<codec::encoded_value()> document_fn,
+              const upsert_options& options) const
+    -> std::future<std::pair<error, mutation_result>>;
+
+  void insert(std::string document_id,
+              std::function<codec::encoded_value()> document_fn,
+              const insert_options& options,
+              insert_handler&& handler) const;
+
+  auto insert(std::string document_id,
+              std::function<codec::encoded_value()> document_fn,
+              const insert_options& options) const
+    -> std::future<std::pair<error, mutation_result>>;
+
   collection(core::cluster core,
              std::string_view bucket_name,
              std::string_view scope_name,