couchbase 4.4.3 → 4.4.4

package/deps/couchbase-cxx-client/core/operations/management/user_get_all.hxx

@@ -37,6 +37,7 @@ struct user_get_all_request {
   using encoded_response_type = io::http_response;
   using error_context_type = error_context::http;
 
+  static const inline std::string observability_identifier = "manager_users_get_all_users";
   static const inline service_type type = service_type::management;
 
   couchbase::core::management::rbac::auth_domain domain{

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

@@ -51,11 +51,11 @@ user_upsert_request::encode_to(encoded_request_type& encoded,
   for (const auto& role : user.roles) {
     std::string spec = role.name;
     if (role.bucket) {
-      spec += fmt::format("[{}", role.bucket.value());
+      spec += fmt::format("[{}", utils::string_codec::v2::path_escape(role.bucket.value()));
       if (role.scope) {
-        spec += fmt::format(":{}", role.scope.value());
+        spec += fmt::format(":{}", utils::string_codec::v2::path_escape(role.scope.value()));
         if (role.collection) {
-          spec += fmt::format(":{}", role.collection.value());
+          spec += fmt::format(":{}", utils::string_codec::v2::path_escape(role.collection.value()));
         }
       }
       spec += "]";

package/deps/couchbase-cxx-client/core/operations/management/user_upsert.hxx

@@ -37,6 +37,7 @@ struct user_upsert_request {
   using encoded_response_type = io::http_response;
   using error_context_type = error_context::http;
 
+  static const inline std::string observability_identifier = "manager_users_upsert_user";
   static const inline service_type type = service_type::management;
 
   couchbase::core::management::rbac::auth_domain domain{

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

@@ -37,6 +37,7 @@ struct view_index_drop_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_drop_design_document";
 
   std::string bucket_name;
   std::string document_name;

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

@@ -38,6 +38,7 @@ struct view_index_get_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_get_design_document";
 
   std::string bucket_name;
   std::string document_name;

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

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

@@ -587,9 +587,9 @@ attempt_context_impl::create_document_metadata(
 }
 
 void
-attempt_context_impl::replace_raw(const transaction_get_result& document,
-                                  codec::encoded_value content,
-                                  Callback&& cb)
+attempt_context_impl::replace(const transaction_get_result& document,
+                              codec::encoded_value content,
+                              Callback&& cb)
 {
 
   if (op_list_.get_mode().is_query()) {
@@ -852,19 +852,19 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
 }
 
 auto
-attempt_context_impl::replace_raw(const transaction_get_result& document,
-                                  codec::encoded_value content) -> transaction_get_result
+attempt_context_impl::replace(const transaction_get_result& document,
+                              codec::encoded_value content) -> transaction_get_result
 {
   auto barrier = std::make_shared<std::promise<transaction_get_result>>();
   auto f = barrier->get_future();
-  replace_raw(document,
-              std::move(content),
-              [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
-                if (err) {
-                  return barrier->set_exception(err);
-                }
-                barrier->set_value(std::move(*res));
-              });
+  replace(document,
+          std::move(content),
+          [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
+            if (err) {
+              return barrier->set_exception(err);
+            }
+            barrier->set_value(std::move(*res));
+          });
   return f.get();
 }
 
@@ -873,12 +873,12 @@ attempt_context_impl::replace_raw(couchbase::transactions::transaction_get_resul
                                   codec::encoded_value content,
                                   couchbase::transactions::async_result_handler&& handler)
 {
-  replace_raw(core::transactions::transaction_get_result(doc),
-              std::move(content),
-              [handler = std::move(handler)](const std::exception_ptr& err,
-                                             std::optional<transaction_get_result> res) mutable {
-                wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
-              });
+  replace(core::transactions::transaction_get_result(doc),
+          std::move(content),
+          [handler = std::move(handler)](const std::exception_ptr& err,
+                                         std::optional<transaction_get_result> res) mutable {
+            wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
+          });
 }
 
 auto
@@ -888,7 +888,7 @@ attempt_context_impl::replace_raw(const couchbase::transactions::transaction_get
 {
   return wrap_call_for_public_api(
     [self = shared_from_this(), doc, content = std::move(content)]() -> transaction_get_result {
-      return self->replace_raw(transaction_get_result(doc), content);
+      return self->replace(transaction_get_result(doc), content);
     });
 }
 
@@ -900,8 +900,8 @@ attempt_context_impl::insert_raw(const collection& coll,
 {
   return wrap_call_for_public_api(
     [self = shared_from_this(), coll, &id, content = std::move(content)]() mutable {
-      return self->insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), id },
-                              std::move(content));
+      return self->insert({ coll.bucket_name(), coll.scope_name(), coll.name(), id },
+                          std::move(content));
     });
 }
 
@@ -911,35 +911,35 @@ attempt_context_impl::insert_raw(const collection& coll,
                                  codec::encoded_value content,
                                  couchbase::transactions::async_result_handler&& handler)
 {
-  insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
-             std::move(content),
-             [handler = std::move(handler)](const std::exception_ptr& err,
-                                            std::optional<transaction_get_result> res) mutable {
-               wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
-             });
+  insert({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
+         std::move(content),
+         [handler = std::move(handler)](const std::exception_ptr& err,
+                                        std::optional<transaction_get_result> res) mutable {
+           wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
+         });
 }
 
 auto
-attempt_context_impl::insert_raw(const core::document_id& id,
-                                 codec::encoded_value content) -> transaction_get_result
+attempt_context_impl::insert(const core::document_id& id,
+                             codec::encoded_value content) -> transaction_get_result
 {
   auto barrier = std::make_shared<std::promise<transaction_get_result>>();
   auto f = barrier->get_future();
-  insert_raw(id,
-             std::move(content),
-             [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
-               if (err) {
-                 return barrier->set_exception(err);
-               }
-               barrier->set_value(std::move(*res));
-             });
+  insert(id,
+         std::move(content),
+         [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
+           if (err) {
+             return barrier->set_exception(err);
+           }
+           barrier->set_value(std::move(*res));
+         });
   return f.get();
 }
 
 void
-attempt_context_impl::insert_raw(const core::document_id& id,
-                                 codec::encoded_value content,
-                                 Callback&& cb)
+attempt_context_impl::insert(const core::document_id& id,
+                             codec::encoded_value content,
+                             Callback&& cb)
 {
   if (op_list_.get_mode().is_query()) {
     return insert_raw_with_query(id, std::move(content), std::move(cb));

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

@@ -92,37 +92,36 @@ private:
   // transaction_context needs access to the two functions below
   friend class transaction_context;
 
+  void insert(const core::document_id& id,
+              codec::encoded_value content,
+              core::transactions::async_attempt_context::Callback&& cb) override;
+
+  auto insert(const core::document_id& id,
+              codec::encoded_value content) -> core::transactions::transaction_get_result override;
+
+  void replace(const transaction_get_result& document,
+               codec::encoded_value content,
+               core::transactions::async_attempt_context::Callback&& cb) override;
+
+  auto replace(const transaction_get_result& document,
+               codec::encoded_value content) -> transaction_get_result override;
+
   auto insert_raw(const collection& coll, const std::string& id, codec::encoded_value content)
     -> std::pair<couchbase::error, couchbase::transactions::transaction_get_result> override;
-  auto insert_raw(const core::document_id& id, codec::encoded_value content)
-    -> core::transactions::transaction_get_result override;
 
   void insert_raw(const collection& coll,
                   std::string id,
                   codec::encoded_value content,
                   couchbase::transactions::async_result_handler&& handler) override;
 
-  void insert_raw(
-    const core::document_id& id,
-    codec::encoded_value content,
-    std::function<void(std::exception_ptr, std::optional<transaction_get_result>)>&& cb) override;
-
   auto replace_raw(const couchbase::transactions::transaction_get_result& doc,
                    codec::encoded_value content)
     -> std::pair<couchbase::error, couchbase::transactions::transaction_get_result> override;
 
-  auto replace_raw(const transaction_get_result& document,
-                   codec::encoded_value content) -> transaction_get_result override;
-
   void replace_raw(couchbase::transactions::transaction_get_result doc,
                    codec::encoded_value content,
                    couchbase::transactions::async_result_handler&& handler) override;
 
-  void replace_raw(
-    const transaction_get_result& document,
-    codec::encoded_value content,
-    std::function<void(std::exception_ptr, std::optional<transaction_get_result>)>&& cb) override;
-
   void remove_staged_insert(const core::document_id& id, VoidCallback&& cb);
 
   void get_with_query(
@@ -200,7 +199,7 @@ private:
                                std::exception_ptr&& err)
   {
     try {
-      std::rethrow_exception(std::move(err));
+      std::rethrow_exception(err);
     } catch (const transaction_operation_failed& e) {
       // if this is a transaction_operation_failed, we need to cache it before
       // moving on...

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

@@ -180,7 +180,7 @@ transaction_context::insert(const core::document_id& id,
                             async_attempt_context::Callback&& cb)
 {
   if (current_attempt_context_) {
-    return current_attempt_context_->insert_raw(id, std::move(content), std::move(cb));
+    return current_attempt_context_->insert(id, std::move(content), std::move(cb));
   }
   throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
 }
@@ -191,7 +191,7 @@ transaction_context::replace(const transaction_get_result& doc,
                              async_attempt_context::Callback&& cb)
 {
   if (current_attempt_context_) {
-    return current_attempt_context_->replace_raw(doc, std::move(content), std::move(cb));
+    return current_attempt_context_->replace(doc, std::move(content), std::move(cb));
   }
   throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
 }

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

@@ -199,26 +199,6 @@ public:
     return os;
   }
 
-  /**
-   * Content of the document.
-   *
-   * @return content of the document.
-   */
-  template<typename Document,
-           typename Transcoder = codec::default_json_transcoder,
-           std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true,
-           std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
-  [[nodiscard]] auto content() const -> Document
-  {
-    return Transcoder::template decode<Document>(content_);
-  }
-
-  template<typename Transcoder, std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
-  [[nodiscard]] auto content() const -> typename Transcoder::document_type
-  {
-    return Transcoder::decode(content_);
-  }
-
   /**
    * Content of the document as raw byte vector
    *

package/deps/couchbase-cxx-client/couchbase/common_options.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/retry_strategy.hxx>
+#include <couchbase/tracing/request_span.hxx>
 
 #include <chrono>
 #include <memory>
@@ -69,6 +70,18 @@ public:
     return self();
   }
 
+  /**
+   * @param span
+   *
+   * @since 1.0.4
+   * @volatile
+   */
+  auto parent_span(std::shared_ptr<tracing::request_span> span) -> derived_class&
+  {
+    parent_span_ = std::move(span);
+    return self();
+  }
+
   /**
    * Immutable value object representing consistent options.
    *
@@ -78,6 +91,7 @@ public:
   struct built {
     const std::optional<std::chrono::milliseconds> timeout;
     const std::shared_ptr<couchbase::retry_strategy> retry_strategy;
+    const std::shared_ptr<tracing::request_span> parent_span;
   };
 
 protected:
@@ -88,7 +102,7 @@ protected:
    */
   [[nodiscard]] auto build_common_options() const -> built
   {
-    return { timeout_, retry_strategy_ };
+    return { timeout_, retry_strategy_, parent_span_ };
   }
 
   /**
@@ -107,6 +121,7 @@ protected:
 private:
   std::optional<std::chrono::milliseconds> timeout_{};
   std::shared_ptr<couchbase::retry_strategy> retry_strategy_{ nullptr };
+  std::shared_ptr<tracing::request_span> parent_span_{ nullptr };
 };
 
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/metrics/otel_meter.hxx

@@ -20,6 +20,7 @@
 #include "opentelemetry/sdk/metrics/meter.h"
 #include <couchbase/metrics/meter.hxx>
 
+#include <algorithm>
 #include <iostream>
 #include <thread>
 #include <utility>
@@ -37,44 +38,39 @@ namespace couchbase::metrics
 class otel_sync_histogram
 {
 public:
-  otel_sync_histogram(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter)
+  otel_sync_histogram(nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter)
     : histogram_counter_(histogram_counter)
   {
   }
-  void record(uint64_t value,
+
+  void record(std::uint64_t value,
               const opentelemetry::common::KeyValueIterable& tags,
               opentelemetry::context::Context& ctx)
   {
-    // overflow
-    if (value > LONG_MAX) {
-      value = LONG_MAX;
-    }
-    long lvalue = static_cast<long>(value);
-    histogram_counter_->Record(lvalue, tags, ctx);
+    histogram_counter_->Record(value, tags, ctx);
   }
 
 private:
-  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+  nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter_;
   std::mutex mutex_;
 };
 
 class otel_value_recorder : public couchbase::metrics::value_recorder
 {
 public:
-  explicit otel_value_recorder(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter,
-                               const std::map<std::string, std::string>& tags)
+  explicit otel_value_recorder(
+    nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter,
+    const std::map<std::string, std::string>& tags)
     : histogram_counter_(histogram_counter)
     , tags_(tags)
   {
   }
   void record_value(std::int64_t value) override
   {
-    if (value > LONG_MAX) {
-      value = LONG_MAX;
-    }
-    long lvalue = static_cast<long>(value);
+    value = std::max<int64_t>(value, 0);
+    auto uvalue = static_cast<std::uint64_t>(value);
     histogram_counter_->Record(
-      value, opentelemetry::common::KeyValueIterableView<decltype(tags_)>{ tags_ }, context_);
+      uvalue, opentelemetry::common::KeyValueIterableView<decltype(tags_)>{ tags_ }, context_);
   }
 
   const std::map<std::string, std::string> tags()
@@ -82,13 +78,13 @@ public:
     return tags_;
   }
 
-  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter()
+  nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter()
   {
     return histogram_counter_;
   }
 
 private:
-  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+  nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter_;
   const std::map<std::string, std::string> tags_;
   opentelemetry::context::Context context_{};
   std::mutex mutex_;
@@ -115,8 +111,8 @@ public:
       // api doesn't seem to allow this.
       return recorders_
         .insert({ name,
-                  std::make_shared<otel_value_recorder>(meter_->CreateLongHistogram(name, "", "us"),
-                                                        tags) })
+                  std::make_shared<otel_value_recorder>(
+                    meter_->CreateUInt64Histogram(name, "", "us"), tags) })
         ->second;
     }
     // so it is already, lets see if we already have one with those tags, or need