couchbase 3.7.0 → 3.8.1

data/ext/couchbase/core/metrics/meter_wrapper.cxx

@@ -19,8 +19,14 @@
 
 #include <couchbase/error_codes.hxx>
 
-#include <mutex>
+#include "core/metrics/constants.hxx"
+#include "core/tracing/constants.hxx"
+
+#include <map>
+#include <memory>
+#include <string>
 #include <system_error>
+#include <utility>
 
 namespace couchbase::core::metrics
 {
@@ -57,32 +63,10 @@ extract_error_name(std::error_code ec) -> std::string
 }
 
 auto
-service_to_string(service_type s) -> std::string
-{
-  switch (s) {
-    case service_type::analytics:
-      return "analytics";
-    case service_type::search:
-      return "search";
-    case service_type::key_value:
-      return "kv";
-    case service_type::management:
-      return "management";
-    case service_type::eventing:
-      return "eventing";
-    case service_type::query:
-      return "query";
-    case service_type::view:
-      return "views";
-  }
-  return {};
-}
-
-auto
-get_standardized_outcome(std::error_code ec) -> std::string
+get_standardized_error_type(std::error_code ec) -> std::string
 {
   if (!ec) {
-    return "Success";
+    return {};
   }
 
   // SDK-specific errors
@@ -95,39 +79,62 @@ get_standardized_outcome(std::error_code ec) -> std::string
     return "CryptoError";
   }
 
-  return snake_case_to_camel_case(extract_error_name(ec));
+  static const std::array<const std::error_category*, 12> cb_categories = {
+    &impl::common_category(),      &impl::key_value_category(),
+    &impl::query_category(),       &impl::analytics_category(),
+    &impl::search_category(),      &impl::view_category(),
+    &impl::management_category(),  &impl::field_level_encryption_category(),
+    &impl::network_category(),     &impl::streaming_json_lexer_category(),
+    &impl::transaction_category(), &impl::transaction_op_category(),
+  };
+
+  if (std::any_of(
+        cb_categories.begin(), cb_categories.end(), [&ec](const std::error_category* cat) -> bool {
+          return &ec.category() == cat;
+        })) {
+    return snake_case_to_camel_case(extract_error_name(ec));
+  }
+
+  return "_OTHER";
 }
 } // namespace
 
 auto
 metric_attributes::encode() const -> std::map<std::string, std::string>
 {
-  std::map<std::string, std::string> tags = { { "db.couchbase.service",
-                                                service_to_string(service) },
-                                              { "db.operation", operation },
-                                              { "outcome", get_standardized_outcome(ec) } };
+  std::map<std::string, std::string> tags = {
+    { tracing::attributes::reserved::target_unit, "s" },
+    { tracing::attributes::common::system, "couchbase" },
+    { tracing::attributes::op::service, service },
+    { tracing::attributes::op::operation_name, operation },
+  };
 
   if (internal.cluster_name.has_value()) {
-    tags.emplace("db.couchbase.cluster_name", internal.cluster_name.value());
+    tags.emplace(tracing::attributes::common::cluster_name, internal.cluster_name.value());
   }
   if (internal.cluster_uuid.has_value()) {
-    tags.emplace("db.couchbase.cluster_uuid", internal.cluster_uuid.value());
+    tags.emplace(tracing::attributes::common::cluster_uuid, internal.cluster_uuid.value());
   }
   if (bucket_name) {
-    tags.emplace("db.name", bucket_name.value());
+    tags.emplace(tracing::attributes::op::bucket_name, bucket_name.value());
   }
   if (scope_name) {
-    tags.emplace("db.couchbase.scope", scope_name.value());
+    tags.emplace(tracing::attributes::op::scope_name, scope_name.value());
   }
   if (collection_name) {
-    tags.emplace("db.couchbase.collection", collection_name.value());
+    tags.emplace(tracing::attributes::op::collection_name, collection_name.value());
+  }
+  if (ec) {
+    tags.emplace(tracing::attributes::op::error_type, get_standardized_error_type(ec));
   }
 
   return tags;
 }
 
-meter_wrapper::meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter)
+meter_wrapper::meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter,
+                             std::shared_ptr<cluster_label_listener> label_listener)
   : meter_{ std::move(meter) }
+  , cluster_label_listener_{ std::move(label_listener) }
 {
 }
 
@@ -143,46 +150,41 @@ meter_wrapper::stop()
   meter_->stop();
 }
 
+void
+meter_wrapper::record_value(const std::map<std::string, std::string>& raw_attrs,
+                            std::chrono::microseconds duration)
+{
+  meter_->get_value_recorder(operation_meter_name, raw_attrs)->record_value(duration.count());
+}
+
 void
 meter_wrapper::record_value(metric_attributes attrs,
                             std::chrono::steady_clock::time_point start_time)
 {
-  static const std::string meter_name{ "db.couchbase.operations" };
-
-  {
-    const std::shared_lock lock{ cluster_labels_mutex_ };
-
-    if (cluster_name_) {
-      attrs.internal.cluster_name = cluster_name_;
-    }
-    if (cluster_uuid_) {
-      attrs.internal.cluster_uuid = cluster_uuid_;
-    }
+  auto [cluster_name, cluster_uuid] = cluster_label_listener_->cluster_labels();
+  if (cluster_name) {
+    attrs.internal.cluster_name = cluster_name;
+  }
+  if (cluster_uuid) {
+    attrs.internal.cluster_uuid = cluster_uuid;
   }
 
-  auto tags = attrs.encode();
-  meter_->get_value_recorder(meter_name, tags)
-    ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(
-                     std::chrono::steady_clock::now() - start_time)
-                     .count());
+  record_value(attrs.encode(),
+               std::chrono::duration_cast<std::chrono::microseconds>(
+                 std::chrono::steady_clock::now() - start_time));
 }
 
-void
-meter_wrapper::update_config(topology::configuration config)
+auto
+meter_wrapper::wrapped() -> std::shared_ptr<couchbase::metrics::meter>
 {
-  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;
-  }
+  return meter_;
 }
 
 auto
-meter_wrapper::create(std::shared_ptr<couchbase::metrics::meter> meter)
+meter_wrapper::create(std::shared_ptr<couchbase::metrics::meter> meter,
+                      std::shared_ptr<cluster_label_listener> label_listener)
   -> std::shared_ptr<meter_wrapper>
 {
-  return std::make_shared<meter_wrapper>(std::move(meter));
+  return std::make_shared<meter_wrapper>(std::move(meter), std::move(label_listener));
 }
 } // namespace couchbase::core::metrics

data/ext/couchbase/core/metrics/meter_wrapper.hxx

@@ -26,14 +26,15 @@
 #include <chrono>
 #include <map>
 #include <optional>
-#include <shared_mutex>
 #include <string>
 #include <system_error>
 
+#include "core/cluster_label_listener.hxx"
+
 namespace couchbase::core::metrics
 {
 struct metric_attributes {
-  couchbase::core::service_type service;
+  std::string service;
   std::string operation;
   std::error_code ec;
   std::optional<std::string> bucket_name{};
@@ -48,26 +49,27 @@ struct metric_attributes {
   [[nodiscard]] auto encode() const -> std::map<std::string, std::string>;
 };
 
-class meter_wrapper : public config_listener
+class meter_wrapper
 {
 public:
-  explicit meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter);
+  explicit meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter,
+                         std::shared_ptr<cluster_label_listener> label_listener);
 
   void start();
   void stop();
 
   void record_value(metric_attributes attrs, std::chrono::steady_clock::time_point start_time);
+  void record_value(const std::map<std::string, std::string>& raw_attrs,
+                    std::chrono::microseconds duration);
 
-  void update_config(topology::configuration config) override;
+  [[nodiscard]] auto wrapped() -> std::shared_ptr<couchbase::metrics::meter>;
 
-  [[nodiscard]] static auto create(std::shared_ptr<couchbase::metrics::meter> meter)
+  [[nodiscard]] static auto create(std::shared_ptr<couchbase::metrics::meter> meter,
+                                   std::shared_ptr<cluster_label_listener> label_listener)
     -> std::shared_ptr<meter_wrapper>;
 
 private:
   std::shared_ptr<couchbase::metrics::meter> meter_;
-
-  std::optional<std::string> cluster_name_{};
-  std::optional<std::string> cluster_uuid_{};
-  std::shared_mutex cluster_labels_mutex_{};
+  std::shared_ptr<cluster_label_listener> cluster_label_listener_;
 };
 } // namespace couchbase::core::metrics

data/ext/couchbase/core/operations/document_analytics.hxx

@@ -114,11 +114,6 @@ struct analytics_request {
 } // namespace couchbase::core::operations
 namespace couchbase::core::io::http_traits
 {
-template<>
-struct supports_parent_span<couchbase::core::operations::analytics_request>
-  : public std::true_type {
-};
-
 template<>
 struct supports_readonly<couchbase::core::operations::analytics_request> : public std::true_type {
 };

data/ext/couchbase/core/operations/document_append.hxx

@@ -76,8 +76,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::append_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::append_request> : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_decrement.hxx

@@ -79,9 +79,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::decrement_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::decrement_request>
-  : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_exists.hxx

@@ -67,10 +67,3 @@ struct exists_request {
 };
 
 } // namespace couchbase::core::operations
-
-namespace couchbase::core::io::mcbp_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::exists_request> : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_get.hxx

@@ -57,10 +57,3 @@ struct get_request {
                                    const encoded_response_type& encoded) const -> get_response;
 };
 } // namespace couchbase::core::operations
-
-namespace couchbase::core::io::mcbp_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::get_request> : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_get_all_replicas.hxx

@@ -17,14 +17,18 @@
 
 #pragma once
 
+#include <couchbase/error_codes.hxx>
+#include <couchbase/node_id.hxx>
+
 #include "core/error_context/key_value.hxx"
 #include "core/impl/get_replica.hxx"
 #include "core/impl/replica_utils.hxx"
 #include "core/logger/logger.hxx"
 #include "core/operations/document_get.hxx"
 #include "core/operations/operation_traits.hxx"
+#include "core/public_fwd.hxx"
+#include "core/tracing/constants.hxx"
 #include "core/utils/movable_function.hxx"
-#include "couchbase/error_codes.hxx"
 
 #include <memory>
 #include <mutex>
@@ -37,6 +41,7 @@ struct get_all_replicas_response {
     couchbase::cas cas{};
     std::uint32_t flags{};
     bool replica{ true };
+    couchbase::node_id dispatched_to_node_id{};
   };
   key_value_error_context ctx{};
   std::vector<entry> entries{};
@@ -54,6 +59,7 @@ struct get_all_replicas_request {
   core::document_id id;
   std::optional<std::chrono::milliseconds> timeout{};
   couchbase::read_preference read_preference{ couchbase::read_preference::no_preference };
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
   template<typename Core, typename Handler>
   void execute(Core core, Handler handler)
@@ -64,6 +70,7 @@ struct get_all_replicas_request {
        id = id,
        timeout = timeout,
        read_preference = read_preference,
+       parent_span = std::move(parent_span),
        h = std::forward<Handler>(handler)](
         std::error_code ec, std::shared_ptr<topology::configuration> config) mutable {
         if (ec) {
@@ -104,11 +111,40 @@ struct get_all_replicas_request {
         auto ctx = std::make_shared<replica_context>(std::move(h), nodes.size());
 
         for (const auto& node : nodes) {
+          auto subop_span = core->tracer()->create_span(
+            node.is_replica ? tracing::operation::mcbp_get_replica : tracing::operation::mcbp_get,
+            parent_span);
+
+          if (subop_span->uses_tags()) {
+            subop_span->add_tag(tracing::attributes::op::service, tracing::service::key_value);
+            subop_span->add_tag(tracing::attributes::op::operation_name,
+                                node.is_replica ? tracing::operation::mcbp_get_replica
+                                                : tracing::operation::mcbp_get);
+            subop_span->add_tag(tracing::attributes::op::bucket_name, id.bucket());
+            subop_span->add_tag(tracing::attributes::op::scope_name, id.scope());
+            subop_span->add_tag(tracing::attributes::op::collection_name, id.collection());
+          }
+
           if (node.is_replica) {
             document_id replica_id{ id };
             replica_id.node_index(node.index);
             core->execute(
-              impl::get_replica_request{ std::move(replica_id), timeout }, [ctx](auto&& resp) {
+              impl::get_replica_request{
+                std::move(replica_id),
+                timeout,
+                {},
+                {},
+                {},
+                subop_span,
+              },
+              [ctx, subop_span](auto&& resp) {
+                {
+                  if (subop_span->uses_tags()) {
+                    subop_span->add_tag(tracing::attributes::op::retry_count,
+                                        resp.ctx.retry_attempts());
+                  }
+                  subop_span->end();
+                }
                 handler_type local_handler{};
                 {
                   std::scoped_lock lock(ctx->mutex_);
@@ -122,8 +158,12 @@ struct get_all_replicas_request {
                       return;
                     }
                   } else {
-                    ctx->result_.emplace_back(get_all_replicas_response::entry{
-                      std::move(resp.value), resp.cas, resp.flags, true /* replica */ });
+                    ctx->result_.emplace_back(
+                      get_all_replicas_response::entry{ std::move(resp.value),
+                                                        resp.cas,
+                                                        resp.flags,
+                                                        true /* replica */,
+                                                        resp.ctx.last_dispatched_to_node_id() });
                   }
                   if (ctx->expected_responses_ == 0) {
                     ctx->done_ = true;
@@ -139,36 +179,56 @@ struct get_all_replicas_request {
                 }
               });
           } else {
-            core->execute(get_request{ document_id{ id }, {}, {}, timeout }, [ctx](auto&& resp) {
-              handler_type local_handler{};
-              {
-                std::scoped_lock lock(ctx->mutex_);
-                if (ctx->done_) {
-                  return;
+            core->execute(
+              get_request{
+                document_id{ id },
+                {},
+                {},
+                timeout,
+                {},
+                subop_span,
+              },
+              [ctx, subop_span](auto&& resp) {
+                {
+                  if (subop_span->uses_tags()) {
+                    subop_span->add_tag(tracing::attributes::op::retry_count,
+                                        resp.ctx.retry_attempts());
+                  }
+                  subop_span->end();
                 }
-                --ctx->expected_responses_;
-                if (resp.ctx.ec()) {
-                  if (ctx->expected_responses_ > 0) {
-                    // just ignore the response
+                handler_type local_handler{};
+                {
+                  std::scoped_lock lock(ctx->mutex_);
+                  if (ctx->done_) {
                     return;
                   }
-                } else {
-                  ctx->result_.emplace_back(get_all_replicas_response::entry{
-                    std::move(resp.value), resp.cas, resp.flags, false /* active */ });
-                }
-                if (ctx->expected_responses_ == 0) {
-                  ctx->done_ = true;
-                  std::swap(local_handler, ctx->handler_);
+                  --ctx->expected_responses_;
+                  if (resp.ctx.ec()) {
+                    if (ctx->expected_responses_ > 0) {
+                      // just ignore the response
+                      return;
+                    }
+                  } else {
+                    ctx->result_.emplace_back(
+                      get_all_replicas_response::entry{ std::move(resp.value),
+                                                        resp.cas,
+                                                        resp.flags,
+                                                        false /* active */,
+                                                        resp.ctx.last_dispatched_to_node_id() });
+                  }
+                  if (ctx->expected_responses_ == 0) {
+                    ctx->done_ = true;
+                    std::swap(local_handler, ctx->handler_);
+                  }
                 }
-              }
-              if (local_handler) {
-                if (ctx->result_.empty()) {
-                  // Return an error only when we have no results from any replica.
-                  return local_handler({ std::move(resp.ctx), {} });
+                if (local_handler) {
+                  if (ctx->result_.empty()) {
+                    // Return an error only when we have no results from any replica.
+                    return local_handler({ std::move(resp.ctx), {} });
+                  }
+                  return local_handler({ {}, std::move(ctx->result_) });
                 }
-                return local_handler({ {}, std::move(ctx->result_) });
-              }
-            });
+              });
           }
         }
       });

data/ext/couchbase/core/operations/document_get_and_lock.hxx

@@ -58,13 +58,4 @@ struct get_and_lock_request {
                                    const encoded_response_type& encoded) const
     -> get_and_lock_response;
 };
-
 } // namespace couchbase::core::operations
-
-namespace couchbase::core::io::mcbp_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::get_and_lock_request>
-  : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_get_and_touch.hxx

@@ -59,13 +59,4 @@ struct get_and_touch_request {
                                    const encoded_response_type& encoded) const
     -> get_and_touch_response;
 };
-
 } // namespace couchbase::core::operations
-
-namespace couchbase::core::io::mcbp_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::get_and_touch_request>
-  : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_get_any_replica.hxx

@@ -20,6 +20,7 @@
 #include "core/error_context/key_value.hxx"
 #include "core/impl/get_replica.hxx"
 #include "core/impl/replica_utils.hxx"
+#include "core/impl/with_cancellation.hxx"
 #include "core/operations/document_get.hxx"
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
@@ -51,6 +52,7 @@ struct get_any_replica_request {
   core::document_id id;
   std::optional<std::chrono::milliseconds> timeout{};
   couchbase::read_preference read_preference{ couchbase::read_preference::no_preference };
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
   template<typename Core, typename Handler>
   void execute(Core core, Handler handler)
@@ -61,6 +63,7 @@ struct get_any_replica_request {
        id = id,
        timeout = timeout,
        read_preference = read_preference,
+       parent_span = std::move(parent_span),
        h = std::forward<Handler>(handler)](
         std::error_code ec, std::shared_ptr<topology::configuration> config) mutable {
         const auto [e, origin] = core->origin();
@@ -91,20 +94,71 @@ struct get_any_replica_request {
           {
           }
 
+          void add_cancellation_token(std::shared_ptr<impl::cancellation_token> token)
+          {
+            std::scoped_lock<std::mutex> lock(cancel_tokens_mutex_);
+            cancel_tokens_.emplace_back(std::move(token));
+          }
+
+          auto get_cancellation_tokens() -> std::vector<std::shared_ptr<impl::cancellation_token>>
+          {
+            std::vector<std::shared_ptr<impl::cancellation_token>> tokens{};
+            {
+              std::scoped_lock<std::mutex> lock(cancel_tokens_mutex_);
+              std::swap(tokens, cancel_tokens_);
+            }
+            return tokens;
+          }
+
           handler_type handler_;
           std::size_t expected_responses_;
           bool done_{ false };
           std::mutex mutex_{};
+          std::vector<std::shared_ptr<impl::cancellation_token>> cancel_tokens_{};
+          std::mutex cancel_tokens_mutex_{};
         };
         auto ctx = std::make_shared<replica_context>(std::move(h), nodes.size());
 
         for (const auto& node : nodes) {
+          auto subop_span = core->tracer()->create_span(
+            node.is_replica ? tracing::operation::mcbp_get_replica : tracing::operation::mcbp_get,
+            parent_span);
+
+          if (subop_span->uses_tags()) {
+            subop_span->add_tag(tracing::attributes::op::service, tracing::service::key_value);
+            subop_span->add_tag(tracing::attributes::op::operation_name,
+                                node.is_replica ? tracing::operation::mcbp_get_replica
+                                                : tracing::operation::mcbp_get);
+            subop_span->add_tag(tracing::attributes::op::bucket_name, id.bucket());
+            subop_span->add_tag(tracing::attributes::op::scope_name, id.scope());
+            subop_span->add_tag(tracing::attributes::op::collection_name, id.collection());
+          }
+
           if (node.is_replica) {
             document_id replica_id{ id };
             replica_id.node_index(node.index);
+            impl::with_cancellation<impl::get_replica_request> req{
+              {
+                std::move(replica_id),
+                timeout,
+                {},
+                {},
+                {},
+                subop_span,
+              },
+            };
+            ctx->add_cancellation_token(req.cancel_token);
             core->execute(
-              impl::get_replica_request{ std::move(replica_id), timeout }, [ctx](auto&& resp) {
+              std::move(req), [ctx, subop_span](auto&& resp) {
+                {
+                  if (subop_span->uses_tags()) {
+                    subop_span->add_tag(tracing::attributes::op::retry_count,
+                                        resp.ctx.retry_attempts());
+                  }
+                  subop_span->end();
+                }
                 handler_type local_handler;
+                std::vector<std::shared_ptr<impl::cancellation_token>> cancel_tokens;
                 {
                   std::scoped_lock lock(ctx->mutex_);
                   if (ctx->done_) {
@@ -121,6 +175,10 @@ struct get_any_replica_request {
                   }
                   ctx->done_ = true;
                   std::swap(local_handler, ctx->handler_);
+                  cancel_tokens = ctx->get_cancellation_tokens();
+                }
+                for (const auto& token : cancel_tokens) {
+                  token->cancel();
                 }
                 if (local_handler) {
                   return local_handler(response_type{
@@ -128,8 +186,27 @@ struct get_any_replica_request {
                 }
               });
           } else {
-            core->execute(get_request{ id, {}, {}, timeout }, [ctx](auto&& resp) {
+            impl::with_cancellation<get_request> req{
+              {
+                id,
+                {},
+                {},
+                timeout,
+                {},
+                subop_span,
+              },
+            };
+            ctx->add_cancellation_token(req.cancel_token);
+            core->execute(std::move(req), [ctx, subop_span](auto&& resp) {
+              {
+                if (subop_span->uses_tags()) {
+                  subop_span->add_tag(tracing::attributes::op::retry_count,
+                                      resp.ctx.retry_attempts());
+                }
+                subop_span->end();
+              }
               handler_type local_handler{};
+              std::vector<std::shared_ptr<impl::cancellation_token>> cancel_tokens;
               {
                 std::scoped_lock lock(ctx->mutex_);
                 if (ctx->done_) {
@@ -146,6 +223,10 @@ struct get_any_replica_request {
                 }
                 ctx->done_ = true;
                 std::swap(local_handler, ctx->handler_);
+                cancel_tokens = ctx->get_cancellation_tokens();
+              }
+              for (const auto& token : cancel_tokens) {
+                token->cancel();
               }
               if (local_handler) {
                 return local_handler(response_type{