couchbase 3.7.0 → 3.8.0

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

@@ -35,30 +35,28 @@
 
 namespace couchbase::core::operations
 {
-
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-using http_command_handler = utils::movable_function<void(error_union, io::http_response&&)>;
-#else
-using http_command_handler = utils::movable_function<void(std::error_code, io::http_response&&)>;
-#endif
-
 template<typename Request>
 struct http_command : public std::enable_shared_from_this<http_command<Request>> {
   using encoded_request_type = typename Request::encoded_request_type;
   using encoded_response_type = typename Request::encoded_response_type;
   using error_context_type = typename Request::error_context_type;
+  using response_type = typename Request::response_type;
+  using handler_type = utils::movable_function<void(response_type&&)>;
+
   asio::steady_timer deadline;
   Request request;
   encoded_request_type encoded;
   std::shared_ptr<tracing::tracer_wrapper> tracer_;
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
   std::shared_ptr<couchbase::tracing::request_span> span_{ nullptr };
+#endif
   std::shared_ptr<metrics::meter_wrapper> meter_{};
   std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter_{ nullptr };
   std::shared_ptr<io::http_session> session_{};
-  http_command_handler handler_{};
+  handler_type handler_{};
   std::chrono::milliseconds timeout_{};
   std::string client_context_id_;
-  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
+  std::shared_ptr<couchbase::tracing::request_span> parent_span_{ nullptr };
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
   std::chrono::milliseconds dispatch_timeout_{};
   asio::steady_timer dispatch_deadline_;
@@ -77,12 +75,10 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
     , app_telemetry_meter_(std::move(app_telemetry_meter))
     , timeout_(request.timeout.value_or(default_timeout))
     , client_context_id_(request.client_context_id.value_or(uuid::to_string(uuid::random())))
+    , parent_span_(request.parent_span)
     , dispatch_timeout_(dispatch_timeout)
     , dispatch_deadline_(ctx)
   {
-    if constexpr (io::http_traits::supports_parent_span_v<Request>) {
-      parent_span = request.parent_span;
-    }
   }
 #else
   http_command(asio::io_context& ctx,
@@ -98,34 +94,20 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
     , app_telemetry_meter_(std::move(app_telemetry_meter))
     , timeout_(request.timeout.value_or(default_timeout))
     , client_context_id_(request.client_context_id.value_or(uuid::to_string(uuid::random())))
+    , parent_span_(request.parent_span)
   {
-    if constexpr (io::http_traits::supports_parent_span_v<Request>) {
-      parent_span = request.parent_span;
-    }
   }
 #endif
 
-  void finish_dispatch(const std::string& remote_address, const std::string& local_address)
-  {
-    if (span_ == nullptr) {
-      return;
-    }
-    if (span_->uses_tags())
-      span_->add_tag(tracing::attributes::remote_socket, remote_address);
-    if (span_->uses_tags())
-      span_->add_tag(tracing::attributes::local_socket, local_address);
-    span_->end();
-    span_ = nullptr;
-  }
-
-  void start(http_command_handler&& handler)
+  void start(handler_type&& handler)
   {
-    span_ = tracer_->create_span(tracing::span_name_for_http_service(request.type), parent_span);
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
+    span_ = tracer_->create_span(tracing::span_name_for_http_service(request.type), parent_span_);
     if (span_->uses_tags()) {
-      span_->add_tag(tracing::attributes::service,
+      span_->add_tag(tracing::attributes::op::service,
                      tracing::service_name_for_http_service(request.type));
-      span_->add_tag(tracing::attributes::operation_id, client_context_id_);
     }
+#endif
 
     handler_ = std::move(handler);
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
@@ -172,11 +154,7 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
   void invoke_handler(std::error_code ec, io::http_response&& msg)
 #endif
   {
-    if (span_ != nullptr) {
-      span_->end();
-      span_ = nullptr;
-    }
-    if (auto handler = std::move(handler_); handler) {
+    if (handler_type handler = std::move(handler_); handler) {
       const auto& node_uuid = session_ ? session_->node_uuid() : "";
       auto telemetry_recorder = app_telemetry_meter_->value_recorder(node_uuid, {});
       telemetry_recorder->update_counter(total_counter_for_service_type(request.type));
@@ -193,13 +171,48 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
       } else if (ec == errc::common::request_canceled) {
         telemetry_recorder->update_counter(canceled_counter_for_service_type(request.type));
       }
+      encoded_response_type encoded_resp{ std::move(msg) };
+      error_context_type ctx{};
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-      handler(error, std::move(msg));
-    }
-    dispatch_deadline_.cancel();
+      if (!std::holds_alternative<std::monostate>(error)) {
+        if (std::holds_alternative<impl::bootstrap_error>(error)) {
+          auto bootstrap_error = std::get<impl::bootstrap_error>(error);
+          if (bootstrap_error.ec == errc::common::unambiguous_timeout) {
+            CB_LOG_DEBUG("Timeout caused by bootstrap error. code={}, ec_message={}, message={}.",
+                         bootstrap_error.ec.value(),
+                         bootstrap_error.ec.message(),
+                         bootstrap_error.error_message);
+          }
+          ctx.ec = bootstrap_error.ec;
+        } else {
+          ctx.ec = std::get<std::error_code>(error);
+        }
+      }
 #else
-      handler(ec, std::move(msg));
+      ctx.ec = ec;
+#endif
+      ctx.client_context_id = client_context_id_;
+      ctx.method = encoded.method;
+      ctx.path = encoded.path;
+      ctx.http_status = encoded_resp.status_code;
+      ctx.http_body = encoded_resp.body.data();
+      ctx.last_dispatched_from = session_->local_address();
+      ctx.last_dispatched_to = session_->remote_address();
+      ctx.hostname = session_->http_context().hostname;
+      ctx.port = session_->http_context().port;
+
+      // Can raise priv::retry_http_request when a retry is required
+      auto resp = request.make_response(std::move(ctx), std::move(encoded_resp));
+
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
+      span_->end();
+      span_ = nullptr;
+#endif
+
+      handler(std::move(resp));
     }
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    dispatch_deadline_.cancel();
 #endif
     deadline.cancel();
   }
@@ -212,9 +225,6 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
     if (!handler_) {
       return;
     }
-    if (span_->uses_tags()) {
-      span_->add_tag(tracing::attributes::local_id, session_->id());
-    }
     send();
   }
 
@@ -247,6 +257,7 @@ private:
       return invoke_handler(ec, {});
     }
     encoded.headers["client-context-id"] = client_context_id_;
+
     CB_LOG_TRACE(
       R"({} HTTP request: {}, method={}, path="{}", client_context_id="{}", timeout={}ms)",
       session_->log_prefix(),
@@ -255,19 +266,29 @@ private:
       encoded.path,
       client_context_id_,
       timeout_.count());
+
+    auto dispatch_span = create_dispatch_span();
+
     session_->write_and_subscribe(
       encoded,
       [self = this->shared_from_this(),
+       dispatch_span = std::move(dispatch_span),
        start = std::chrono::steady_clock::now()](std::error_code ec, io::http_response&& msg) {
         if (ec == asio::error::operation_aborted) {
+          dispatch_span->end();
           return self->invoke_handler(errc::common::ambiguous_timeout, std::move(msg));
         }
 
-        auto latency = std::chrono::duration_cast<std::chrono::milliseconds>(
-          std::chrono::steady_clock::now() - start);
-        self->app_telemetry_meter_->value_recorder(self->session_->node_uuid(), {})
-          ->record_latency(latency_for_service_type(self->request.type), latency);
+        dispatch_span->end();
 
+        {
+          auto latency = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now() - start);
+          self->app_telemetry_meter_->value_recorder(self->session_->node_uuid(), {})
+            ->record_latency(latency_for_service_type(self->request.type), latency);
+        }
+
+#ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
         if (self->meter_) {
           metrics::metric_attributes attrs{
             self->request.type,
@@ -276,8 +297,9 @@ private:
           };
           self->meter_->record_value(std::move(attrs), start);
         }
+#endif
+
         self->deadline.cancel();
-        self->finish_dispatch(self->session_->remote_address(), self->session_->local_address());
         CB_LOG_TRACE(R"({} HTTP response: {}, client_context_id="{}", ec={}, status={}, body={})",
                      self->session_->log_prefix(),
                      self->request.type,
@@ -295,6 +317,33 @@ private:
         }
       });
   }
+
+  [[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 =
+      tracer_->create_span(tracing::operation::step_dispatch, span_);
+#else
+    std::shared_ptr<couchbase::tracing::request_span> dispatch_span =
+      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, client_context_id_);
+      dispatch_span->add_tag(tracing::attributes::dispatch::local_id, session_->id());
+      dispatch_span->add_tag(tracing::attributes::dispatch::server_address,
+                             session_->http_context().canonical_hostname);
+      dispatch_span->add_tag(tracing::attributes::dispatch::server_port,
+                             session_->http_context().canonical_port);
+
+      const auto& peer_endpoint = session_->remote_endpoint();
+      dispatch_span->add_tag(tracing::attributes::dispatch::peer_address,
+                             peer_endpoint.address().to_string());
+      dispatch_span->add_tag(tracing::attributes::dispatch::peer_port, peer_endpoint.port());
+    }
+    return dispatch_span;
+  }
 };
 
 } // namespace couchbase::core::operations

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

@@ -29,6 +29,8 @@ struct http_context {
   query_cache& cache;
   std::string hostname;
   std::uint16_t port;
+  std::string canonical_hostname;
+  std::uint16_t canonical_port;
 };
 
 namespace priv

data/ext/couchbase/core/io/http_session.cxx

@@ -103,7 +103,7 @@ http_session::http_session(couchbase::core::service_type type,
                            std::string client_id,
                            std::string node_uuid,
                            asio::io_context& ctx,
-                           couchbase::core::cluster_credentials credentials,
+                           origin& origin,
                            std::string hostname,
                            std::string service,
                            couchbase::core::http_context http_ctx)
@@ -117,7 +117,7 @@ http_session::http_session(couchbase::core::service_type type,
   , connect_deadline_timer_(stream_->get_executor())
   , idle_timer_(stream_->get_executor())
   , retry_backoff_(stream_->get_executor())
-  , credentials_(std::move(credentials))
+  , origin_(origin)
   , hostname_(std::move(hostname))
   , service_(std::move(service))
   , user_agent_(meta::user_agent_for_http(client_id_, id_, http_ctx.options.user_agent_extra))
@@ -130,8 +130,8 @@ http_session::http_session(couchbase::core::service_type type,
                            std::string client_id,
                            std::string node_uuid,
                            asio::io_context& ctx,
-                           asio::ssl::context& tls,
-                           couchbase::core::cluster_credentials credentials,
+                           tls_context_provider& tls,
+                           origin& origin,
                            std::string hostname,
                            std::string service,
                            couchbase::core::http_context http_ctx)
@@ -145,7 +145,7 @@ http_session::http_session(couchbase::core::service_type type,
   , connect_deadline_timer_(ctx_)
   , idle_timer_(ctx_)
   , retry_backoff_(ctx_)
-  , credentials_(std::move(credentials))
+  , origin_(origin)
   , hostname_(std::move(hostname))
   , service_(std::move(service))
   , user_agent_(meta::user_agent_for_http(client_id_, id_, http_ctx.options.user_agent_extra))
@@ -185,6 +185,13 @@ http_session::local_address() -> std::string
   return info_.local_address();
 }
 
+auto
+http_session::remote_endpoint() -> const asio::ip::tcp::endpoint&
+{
+  const std::scoped_lock lock(info_mutex_);
+  return info_.remote_endpoint();
+}
+
 auto
 http_session::diag_info() -> diag::endpoint_diag_info
 {
@@ -219,9 +226,9 @@ http_session::node_uuid() const -> const std::string&
 }
 
 auto
-http_session::credentials() const -> const cluster_credentials&
+http_session::credentials() const -> cluster_credentials
 {
-  return credentials_;
+  return origin_.credentials();
 }
 
 auto
@@ -433,9 +440,15 @@ http_session::write_and_stream(
     keep_alive_ = true;
   }
   request.headers["user-agent"] = user_agent_;
-  auto credentials = fmt::format("{}:{}", credentials_.username, credentials_.password);
-  request.headers["authorization"] = fmt::format(
-    "Basic {}", base64::encode(gsl::as_bytes(gsl::span{ credentials.data(), credentials.size() })));
+  auto creds = credentials();
+  if (creds.uses_jwt()) {
+    request.headers["authorization"] = fmt::format("Bearer {}", creds.jwt_token);
+  } else {
+    const auto credentials = fmt::format("{}:{}", creds.username, creds.password);
+    request.headers["authorization"] = fmt::format(
+      "Basic {}",
+      base64::encode(gsl::as_bytes(gsl::span{ credentials.data(), credentials.size() })));
+  }
   write(fmt::format(
     "{} {} HTTP/1.1\r\nhost: {}:{}\r\n", request.method, request.path, hostname_, service_));
   if (!request.body.empty()) {

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

@@ -33,6 +33,8 @@
 #include "core/impl/bootstrap_error.hxx"
 #endif
 
+#include "core/tls_context_provider.hxx"
+
 #include <asio.hpp>
 #include <spdlog/fmt/bundled/chrono.h>
 
@@ -73,7 +75,7 @@ public:
                std::string client_id,
                std::string node_uuid,
                asio::io_context& ctx,
-               cluster_credentials credentials,
+               origin& origin,
                std::string hostname,
                std::string service,
                http_context http_ctx);
@@ -82,8 +84,8 @@ public:
                std::string client_id,
                std::string node_uuid,
                asio::io_context& ctx,
-               asio::ssl::context& tls,
-               cluster_credentials credentials,
+               tls_context_provider& tls,
+               origin& origin,
                std::string hostname,
                std::string service,
                http_context http_ctx);
@@ -94,11 +96,12 @@ public:
   [[nodiscard]] auto http_context() -> couchbase::core::http_context&;
   [[nodiscard]] auto remote_address() -> std::string;
   [[nodiscard]] auto local_address() -> std::string;
+  [[nodiscard]] auto remote_endpoint() -> const asio::ip::tcp::endpoint&;
   [[nodiscard]] auto diag_info() -> diag::endpoint_diag_info;
   [[nodiscard]] auto log_prefix() -> std::string;
   [[nodiscard]] auto id() const -> const std::string&;
   [[nodiscard]] auto node_uuid() const -> const std::string&;
-  [[nodiscard]] auto credentials() const -> const cluster_credentials&;
+  [[nodiscard]] auto credentials() const -> cluster_credentials;
   [[nodiscard]] auto is_connected() const -> bool;
   [[nodiscard]] auto type() const -> service_type;
   [[nodiscard]] auto hostname() const -> const std::string&;
@@ -131,10 +134,15 @@ public:
       keep_alive_ = true;
     }
     request.headers["user-agent"] = user_agent_;
-    auto credentials = fmt::format("{}:{}", credentials_.username, credentials_.password);
-    request.headers["authorization"] = fmt::format(
-      "Basic {}",
-      base64::encode(gsl::as_bytes(gsl::span{ credentials.data(), credentials.size() })));
+    auto creds = origin_.credentials();
+    if (creds.uses_jwt()) {
+      request.headers["authorization"] = fmt::format("Bearer {}", creds.jwt_token);
+    } else {
+      const auto credentials = fmt::format("{}:{}", creds.username, creds.password);
+      request.headers["authorization"] = fmt::format(
+        "Basic {}",
+        base64::encode(gsl::as_bytes(gsl::span{ credentials.data(), credentials.size() })));
+    }
     write(fmt::format(
       "{} {} HTTP/1.1\r\nhost: {}:{}\r\n", request.method, request.path, hostname_, service_));
     if (!request.body.empty()) {
@@ -208,7 +216,7 @@ private:
   asio::steady_timer idle_timer_;
   asio::steady_timer retry_backoff_;
 
-  cluster_credentials credentials_;
+  core::origin& origin_;
   std::string hostname_;
   std::string service_;
   std::string user_agent_;