couchbase 3.7.0 → 3.8.1

data/ext/couchbase/core/io/http_traits.hxx

@@ -28,13 +28,6 @@ struct supports_sticky_node : public std::false_type {
 template<typename T>
 inline constexpr bool supports_sticky_node_v = supports_sticky_node<T>::value;
 
-template<typename T>
-struct supports_parent_span : public std::false_type {
-};
-
-template<typename T>
-inline constexpr bool supports_parent_span_v = supports_parent_span<T>::value;
-
 template<typename T>
 struct supports_readonly : public std::false_type {
 };

data/ext/couchbase/core/io/mcbp_command.hxx

@@ -21,6 +21,7 @@
 #include "core/document_id_fmt.hxx"
 #include "core/error_context/key_value_error_map_info.hxx"
 #include "core/metrics/meter_wrapper.hxx"
+#include "core/operations/operation_traits.hxx"
 #include "core/platform/uuid.h"
 #include "core/protocol/client_request.hxx"
 #include "core/protocol/client_response.hxx"
@@ -66,10 +67,14 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
   std::string id_{ fmt::format("{:02x}/{}",
                                static_cast<std::uint8_t>(encoded_request_type::body_type::opcode),
                                uuid::to_string(uuid::random())) };
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
   std::shared_ptr<couchbase::tracing::request_span> span_{ nullptr };
-  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
+#endif
+  std::shared_ptr<couchbase::tracing::request_span> parent_span_{ nullptr };
   std::optional<std::string> last_dispatched_from_{};
   std::optional<std::string> last_dispatched_to_{};
+  std::chrono::time_point<std::chrono::steady_clock> started_at_{};
+  std::vector<std::chrono::microseconds> server_durations_{};
 
   mcbp_command(asio::io_context& ctx,
                std::shared_ptr<Manager> manager,
@@ -80,6 +85,7 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
     , request(req)
     , manager_(manager)
     , timeout_(request.timeout.value_or(default_timeout))
+    , parent_span_(request.parent_span)
   {
     if constexpr (io::mcbp_traits::supports_durability_v<Request>) {
       if (request.durability_level != durability_level::none &&
@@ -93,19 +99,19 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
         timeout_ = durability_timeout_floor;
       }
     }
-    if constexpr (io::mcbp_traits::supports_parent_span_v<Request>) {
-      parent_span = request.parent_span;
-    }
   }
 
   void start(mcbp_command_handler&& handler)
   {
+    started_at_ = std::chrono::steady_clock::now();
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
     span_ = manager_->tracer()->create_span(
-      tracing::span_name_for_mcbp_command(encoded_request_type::body_type::opcode), parent_span);
+      tracing::span_name_for_mcbp_command(encoded_request_type::body_type::opcode), parent_span_);
     if (span_->uses_tags()) {
-      span_->add_tag(tracing::attributes::service, tracing::service::key_value);
-      span_->add_tag(tracing::attributes::instance, request.id.bucket());
+      span_->add_tag(tracing::attributes::op::service, tracing::service::key_value);
+      span_->add_tag(tracing::attributes::op::bucket_name, request.id.bucket());
     }
+#endif
 
     handler_ = std::move(handler);
     deadline.expires_after(timeout_);
@@ -115,20 +121,32 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
       }
       self->cancel(retry_reason::do_not_retry);
     });
+
+    if constexpr (is_cancellable_operation_v<Request>) {
+      request.cancel_token->setup([weak_self = this->weak_from_this()] {
+        if (auto self = weak_self.lock()) {
+          self->cancel(retry_reason::do_not_retry, false);
+        }
+      });
+    }
   }
 
-  void cancel(retry_reason reason)
+  void cancel(retry_reason reason, bool is_timeout = true)
   {
     if (opaque_ && session_) {
       if (session_->cancel(opaque_.value(), asio::error::operation_aborted, reason)) {
         handler_ = nullptr;
       }
     }
-    invoke_handler(
-      request.retries.idempotent() || !opaque_.has_value()
-        ? errc::common::unambiguous_timeout // safe to retry or has not been sent to the server
-        : errc::common::ambiguous_timeout   // non-idempotent and has been sent to the server
-    );
+    if (is_timeout) {
+      invoke_handler(
+        request.retries.idempotent() || !opaque_.has_value()
+          ? errc::common::unambiguous_timeout // safe to retry or has not been sent to the server
+          : errc::common::ambiguous_timeout   // non-idempotent and has been sent to the server
+      );
+    } else {
+      invoke_handler(errc::common::request_canceled);
+    }
   }
 
   void invoke_handler(std::error_code ec, std::optional<io::mcbp_message>&& msg = {})
@@ -137,15 +155,12 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
     deadline.cancel();
     mcbp_command_handler handler{};
     std::swap(handler, handler_);
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
     if (span_ != nullptr) {
-      if (msg) {
-        auto server_duration_us =
-          static_cast<std::uint64_t>(protocol::parse_server_duration_us(msg.value()));
-        span_->add_tag(tracing::attributes::server_duration, server_duration_us);
-      }
       span_->end();
       span_ = nullptr;
     }
+#endif
     if (handler) {
       const auto& node_uuid = session_ ? session_->node_uuid() : "";
       auto telemetry_recorder =
@@ -232,9 +247,6 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
   {
     opaque_ = session_->next_opaque();
     request.opaque = *opaque_;
-    if (span_->uses_tags()) {
-      span_->add_tag(tracing::attributes::operation_id, fmt::format("0x{:x}", request.opaque));
-    }
     if (request.id.use_collections() && !request.id.is_collection_resolved()) {
       if (session_->supports_feature(protocol::hello_feature::collections)) {
         auto collection_id = session_->get_collection_uid(request.id.collection_path());
@@ -267,14 +279,23 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
       }
     }
 
+    auto dispatch_span = create_dispatch_span();
     session_->write_and_subscribe(
       request.opaque,
       encoded.data(session_->supports_feature(protocol::hello_feature::snappy)),
-      [self = this->shared_from_this(), start = std::chrono::steady_clock::now()](
+      [self = this->shared_from_this(),
+       start = std::chrono::steady_clock::now(),
+       dispatch_span = std::move(dispatch_span)](
         std::error_code ec,
         retry_reason reason,
         io::mcbp_message&& msg,
         std::optional<key_value_error_map_info> /* error_info */) mutable {
+        {
+          const auto server_duration_us =
+            static_cast<std::uint64_t>(protocol::parse_server_duration_us(msg));
+          self->server_durations_.emplace_back(std::chrono::microseconds(server_duration_us));
+          self->close_dispatch_span(dispatch_span, server_duration_us);
+        }
         {
           auto latency = std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::steady_clock::now() - start);
@@ -304,30 +325,30 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
           telemetry_recorder->record_latency(category, latency);
         }
 
-        metrics::metric_attributes attrs{
-          service_type::key_value,
-          self->request.observability_identifier,
-          ec,
-          self->request.id.bucket(),
-          self->request.id.scope(),
-          self->request.id.collection(),
-        };
-        self->manager_->meter()->record_value(std::move(attrs), start);
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
+        {
+          metrics::metric_attributes attrs{
+            service_type::key_value,
+            self->request.observability_identifier,
+            ec,
+            self->request.id.bucket(),
+            self->request.id.scope(),
+            self->request.id.collection(),
+          };
+          self->manager_->meter()->record_value(std::move(attrs), start);
+        }
+#endif
 
         self->retry_backoff.cancel();
         if (ec == asio::error::operation_aborted) {
-          if (self->span_->uses_tags()) {
-            self->span_->add_tag(tracing::attributes::orphan, "aborted");
-          }
+          self->manager_->orphan_reporter()->add_orphan(self->create_orphan_attributes());
           return self->invoke_handler(make_error_code(self->request.retries.idempotent()
                                                         ? errc::common::unambiguous_timeout
                                                         : errc::common::ambiguous_timeout));
         }
         if (ec == errc::common::request_canceled) {
           if (!self->request.retries.idempotent() && !allows_non_idempotent_retry(reason)) {
-            if (self->span_->uses_tags()) {
-              self->span_->add_tag(tracing::attributes::orphan, "canceled");
-            }
+            self->manager_->orphan_reporter()->add_orphan(self->create_orphan_attributes());
             return self->invoke_handler(ec);
           }
           return io::retry_orchestrator::maybe_retry(self->manager_, self, reason, ec);
@@ -395,18 +416,76 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
 
   void send_to(io::mcbp_session session)
   {
-    if (!handler_ || !span_) {
+    if (!handler_) {
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
+      if (!span_) {
+        // TODO(DC): Is this necessary? Background:
+        // https://github.com/couchbase/couchbase-cxx-client/pull/160
+        return;
+      }
+#endif
       return;
     }
     session_ = std::move(session);
-    if (span_->uses_tags())
-      span_->add_tag(tracing::attributes::remote_socket, session_->remote_address());
-    if (span_->uses_tags())
-      span_->add_tag(tracing::attributes::local_socket, session_->local_address());
-    if (span_->uses_tags())
-      span_->add_tag(tracing::attributes::local_id, session_->id());
     send();
   }
+
+private:
+  [[nodiscard]] auto create_orphan_attributes() -> orphan_attributes
+  {
+    orphan_attributes attrs;
+
+    attrs.operation_name = Request::observability_identifier;
+    attrs.connection_id = session_->id();
+    attrs.operation_id = fmt::format("0x{:x}", request.opaque);
+    attrs.last_remote_socket = session_->remote_address();
+    attrs.last_local_socket = session_->local_address();
+    if (!server_durations_.empty()) {
+      attrs.last_server_duration = server_durations_.back();
+      for (const auto d : server_durations_) {
+        attrs.total_server_duration += d;
+      }
+    }
+    attrs.total_duration = std::chrono::duration_cast<std::chrono::microseconds>(
+      std::chrono::steady_clock::now() - started_at_);
+
+    return attrs;
+  }
+
+  [[nodiscard]] auto create_dispatch_span() const
+    -> std::shared_ptr<couchbase::tracing::request_span>
+  {
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
+    std::shared_ptr<couchbase::tracing::request_span> dispatch_span =
+      manager_->tracer()->create_span(tracing::operation::step_dispatch, span_);
+#else
+    std::shared_ptr<couchbase::tracing::request_span> dispatch_span =
+      manager_->tracer()->create_span(tracing::operation::step_dispatch, parent_span_);
+#endif
+    if (dispatch_span->uses_tags()) {
+      dispatch_span->add_tag(tracing::attributes::dispatch::network_transport, "tcp");
+      dispatch_span->add_tag(tracing::attributes::dispatch::operation_id,
+                             fmt::format("0x{:x}", request.opaque));
+      dispatch_span->add_tag(tracing::attributes::dispatch::local_id, session_->id());
+    }
+    return dispatch_span;
+  }
+
+  void close_dispatch_span(const std::shared_ptr<couchbase::tracing::request_span>& dispatch_span,
+                           const std::uint64_t server_duration_us) const
+  {
+    if (dispatch_span->uses_tags()) {
+      dispatch_span->add_tag(tracing::attributes::dispatch::server_duration, server_duration_us);
+      dispatch_span->add_tag(tracing::attributes::dispatch::server_address,
+                             session_->canonical_hostname());
+      dispatch_span->add_tag(tracing::attributes::dispatch::server_port,
+                             session_->canonical_port_number());
+      dispatch_span->add_tag(tracing::attributes::dispatch::peer_address,
+                             session_->remote_hostname());
+      dispatch_span->add_tag(tracing::attributes::dispatch::peer_port, session_->remote_port());
+    }
+    dispatch_span->end();
+  }
 };
 
 } // namespace couchbase::core::operations