couchbase 3.8.2 → 3.9.1

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

@@ -36,28 +36,28 @@ public:
 
     std::memcpy(&message.header.id, payload.data() + offset, sizeof(std::uint16_t));
     offset += sizeof(std::uint16_t);
-    message.header.id = utils::byte_swap(message.header.id);
+    message.header.id = utils::network_to_host(message.header.id);
 
     std::uint16_t flags = 0;
     std::memcpy(&flags, payload.data() + offset, sizeof(std::uint16_t));
     offset += sizeof(std::uint16_t);
-    message.header.flags.decode(utils::byte_swap(flags));
+    message.header.flags.decode(utils::network_to_host(flags));
 
     std::memcpy(&message.header.question_records, payload.data() + offset, sizeof(std::uint16_t));
     offset += sizeof(std::uint16_t);
-    message.header.question_records = utils::byte_swap(message.header.question_records);
+    message.header.question_records = utils::network_to_host(message.header.question_records);
 
     std::memcpy(&message.header.answer_records, payload.data() + offset, sizeof(std::uint16_t));
     offset += sizeof(std::uint16_t);
-    message.header.answer_records = utils::byte_swap(message.header.answer_records);
+    message.header.answer_records = utils::network_to_host(message.header.answer_records);
 
     std::memcpy(&message.header.authority_records, payload.data() + offset, sizeof(std::uint16_t));
     offset += sizeof(std::uint16_t);
-    message.header.authority_records = utils::byte_swap(message.header.authority_records);
+    message.header.authority_records = utils::network_to_host(message.header.authority_records);
 
     std::memcpy(&message.header.additional_records, payload.data() + offset, sizeof(std::uint16_t));
     offset += sizeof(std::uint16_t);
-    message.header.additional_records = utils::byte_swap(message.header.additional_records);
+    message.header.additional_records = utils::network_to_host(message.header.additional_records);
 
     for (std::uint16_t idx = 0; idx < message.header.question_records; ++idx) {
       question_record qr;
@@ -66,12 +66,12 @@ public:
       std::uint16_t val = 0;
       std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
-      val = utils::byte_swap(val);
+      val = utils::network_to_host(val);
       qr.type = resource_type(val);
 
       std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
-      val = utils::byte_swap(val);
+      val = utils::network_to_host(val);
       qr.klass = static_cast<resource_class>(val);
 
       message.questions.emplace_back(qr);
@@ -85,22 +85,22 @@ public:
       std::uint16_t val = 0;
       std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
-      val = utils::byte_swap(val);
+      val = utils::network_to_host(val);
       ar.type = resource_type(val);
 
       std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
-      val = utils::byte_swap(val);
+      val = utils::network_to_host(val);
       ar.klass = resource_class(val);
 
       std::memcpy(&ar.ttl, payload.data() + offset, sizeof(std::uint32_t));
       offset += static_cast<std::uint16_t>(4U);
-      ar.ttl = utils::byte_swap(ar.ttl);
+      ar.ttl = utils::network_to_host(ar.ttl);
 
       std::uint16_t size = 0;
       std::memcpy(&size, payload.data() + offset, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
-      size = utils::byte_swap(size);
+      size = utils::network_to_host(size);
 
       if (ar.klass != resource_class::in || ar.type != resource_type::srv) {
         // ignore everything except SRV answers
@@ -110,15 +110,15 @@ public:
 
       std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
-      ar.priority = utils::byte_swap(val);
+      ar.priority = utils::network_to_host(val);
 
       std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
-      ar.weight = utils::byte_swap(val);
+      ar.weight = utils::network_to_host(val);
 
       std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
-      ar.port = utils::byte_swap(val);
+      ar.port = utils::network_to_host(val);
 
       ar.target = get_name(payload, offset);
 
@@ -137,15 +137,15 @@ public:
     {
       std::uint16_t val;
 
-      val = utils::byte_swap(message.header.id);
+      val = utils::host_to_network(message.header.id);
       std::memcpy(payload.data() + offset, &val, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
 
-      val = utils::byte_swap(message.header.flags.encode());
+      val = utils::host_to_network(message.header.flags.encode());
       std::memcpy(payload.data() + offset, &val, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
 
-      val = utils::byte_swap(static_cast<std::uint16_t>(message.questions.size()));
+      val = utils::host_to_network(static_cast<std::uint16_t>(message.questions.size()));
       std::memcpy(payload.data() + offset, &val, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t) +
                 3 * sizeof(std::uint16_t); // answer, authority, additional are all zeros
@@ -164,11 +164,11 @@ public:
 
       std::uint16_t val;
 
-      val = utils::byte_swap(static_cast<std::uint16_t>(question.type));
+      val = utils::host_to_network(static_cast<std::uint16_t>(question.type));
       std::memcpy(payload.data() + offset, &val, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
 
-      val = utils::byte_swap(static_cast<std::uint16_t>(question.klass));
+      val = utils::host_to_network(static_cast<std::uint16_t>(question.klass));
       std::memcpy(payload.data() + offset, &val, sizeof(std::uint16_t));
       offset += sizeof(std::uint16_t);
     }
@@ -194,7 +194,7 @@ private:
       if ((len & 0b1100'0000U) != 0) {
         std::uint16_t ptr = 0;
         std::memcpy(&ptr, payload.data() + offset, sizeof(std::uint16_t));
-        ptr = utils::byte_swap(ptr);
+        ptr = utils::network_to_host(ptr);
         ptr &= 0b0011'1111'1111'1111U;
         // store old offset and jump to pointer
         save_offset = offset + sizeof(std::uint16_t);

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

@@ -24,11 +24,10 @@
 
 #include <iphlpapi.h>
 #include <winsock2.h>
-
-#include "core/utils/join_strings.hxx"
 #endif
 
 #include "core/logger/logger.hxx"
+#include "core/logger/redaction.hxx"
 #include "dns_config.hxx"
 
 #include <asio/ip/address.hpp>
@@ -36,7 +35,9 @@
 #include <filesystem>
 #include <fstream>
 #include <mutex>
+#include <string>
 #include <utility>
+#include <vector>
 
 namespace couchbase::core::io::dns
 {
@@ -98,8 +99,8 @@ load_resolv_conf()
 
   if (dns_servers.size() > 0) {
     CB_LOG_DEBUG("Found DNS Servers: [{}], selected nameserver: \"{}\"",
-                 couchbase::core::utils::join_strings(dns_servers, ", "),
-                 dns_servers[0]);
+                 logger::system_data_list(dns_servers),
+                 logger::system_data(dns_servers[0]));
     return dns_servers[0];
   }
   CB_LOG_WARNING("Unable to find DNS nameserver");
@@ -137,7 +138,8 @@ load_resolv_conf(const char* conf_path) -> std::string
       space = line.find(' ', offset);
       auto nameserver =
         (space == std::string::npos) ? line.substr(offset) : line.substr(offset, space - offset);
-      CB_LOG_DEBUG("Selected nameserver: \"{}\" from \"{}\"", nameserver, conf_path);
+      CB_LOG_DEBUG(
+        "Selected nameserver: \"{}\" from \"{}\"", logger::system_data(nameserver), conf_path);
       return nameserver;
     }
   }
@@ -158,6 +160,19 @@ dns_config::system_config() -> const dns_config&
 #else
         auto nameserver = load_resolv_conf(default_resolv_conf_path);
 #endif
+    if (nameserver.empty()) {
+#ifdef _WIN32
+      CB_LOG_WARNING("No DNS nameserver found via GetNetworkParams. DNS-SRV bootstrap is "
+                     "disabled. Set the nameserver explicitly in the cluster options if SRV "
+                     "records are needed.");
+#else
+          CB_LOG_WARNING("No \"nameserver\" line found in \"{}\". DNS-SRV bootstrap is disabled. "
+                         "Set the nameserver explicitly in the cluster options if SRV records are "
+                         "needed.",
+                         default_resolv_conf_path);
+#endif
+      return;
+    }
     std::error_code ec;
     asio::ip::make_address(nameserver, ec);
     if (ec) {
@@ -168,7 +183,7 @@ dns_config::system_config() -> const dns_config&
       CB_LOG_WARNING("System DNS detection failed: unable to parse \"{}\" as a network address{}. "
                      "DNS-SRV will not work "
                      "unless nameserver is specified explicitly in the options.",
-                     nameserver,
+                     logger::system_data(nameserver),
                      extra_info);
     } else {
       instance.nameserver_ = nameserver;

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

@@ -21,16 +21,20 @@
 
 #include "core/app_telemetry_meter.hxx"
 #include "core/impl/bootstrap_error.hxx"
+#include "core/logger/redaction.hxx"
 #include "core/metrics/meter_wrapper.hxx"
 #include "core/service_type_fmt.hxx"
 #include "core/tracing/constants.hxx"
 #include "core/tracing/tracer_wrapper.hxx"
 #include "core/utils/movable_function.hxx"
+#include "http_error.hxx"
 #include "http_session.hxx"
 #include "http_traits.hxx"
 
 #include <couchbase/tracing/request_tracer.hxx>
 
+#include <mutex>
+#include <string_view>
 #include <utility>
 
 namespace couchbase::core::operations
@@ -52,35 +56,24 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
 #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_{};
+  // Not an owner: null once nothing else holds the session.
+  std::weak_ptr<io::http_session> session_{};
   handler_type handler_{};
+  std::mutex handler_mutex_{};
+  // Set by send_to() if the request had not completed, guarded by handler_mutex_. Until then
+  // session_for_check_in() returns null, so a completion before send_to() never pools the session.
+  bool sent_{ false };
+  // Guarded by handler_mutex_. complete() reports these, so its report does not depend on the
+  // session still being alive. The target fields belong to the session set_command_session()
+  // last assigned. The dispatched fields stay empty until send() dispatches.
+  std::string target_node_uuid_{};
+  std::string dispatched_from_{};
+  std::string dispatched_to_{};
+  std::string target_hostname_{};
+  std::uint16_t target_port_{};
   std::chrono::milliseconds timeout_{};
   std::string client_context_id_;
   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_;
-
-  http_command(asio::io_context& ctx,
-               Request req,
-               std::shared_ptr<tracing::tracer_wrapper> tracer,
-               std::shared_ptr<metrics::meter_wrapper> meter,
-               std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter,
-               std::chrono::milliseconds default_timeout,
-               std::chrono::milliseconds dispatch_timeout)
-    : deadline(ctx)
-    , request(req)
-    , tracer_(std::move(tracer))
-    , meter_(std::move(meter))
-    , 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)
-  {
-  }
-#else
   http_command(asio::io_context& ctx,
                Request req,
                std::shared_ptr<tracing::tracer_wrapper> tracer,
@@ -97,7 +90,6 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
     , parent_span_(request.parent_span)
   {
   }
-#endif
 
   void start(handler_type&& handler)
   {
@@ -110,99 +102,108 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
 #endif
 
     handler_ = std::move(handler);
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-    dispatch_deadline_.expires_after(dispatch_timeout_);
-    dispatch_deadline_.async_wait([self = this->shared_from_this()](std::error_code ec) {
-      if (ec == asio::error::operation_aborted) {
-        return;
-      }
-      CB_LOG_DEBUG(R"(HTTP request timed out before dispatch: {}, client_context_id="{}")",
-                   self->request.type,
-                   self->client_context_id_);
-      self->cancel(errc::common::unambiguous_timeout);
-    });
-#endif
     deadline.expires_after(timeout_);
     deadline.async_wait([self = this->shared_from_this()](std::error_code ec) {
       if (ec == asio::error::operation_aborted) {
         return;
       }
-      CB_LOG_DEBUG(R"(HTTP request timed out: {}, client_context_id="{}")",
-                   self->request.type,
-                   self->client_context_id_);
+      std::error_code timeout = errc::common::ambiguous_timeout;
       if constexpr (io::http_traits::supports_readonly_v<Request>) {
         if (self->request.readonly) {
-          self->cancel(errc::common::unambiguous_timeout);
-          return;
+          timeout = errc::common::unambiguous_timeout;
         }
       }
-      self->cancel(errc::common::ambiguous_timeout);
+      if (!self->cancel(timeout)) {
+        return;
+      }
+      CB_LOG_DEBUG(R"(HTTP request timed out: {}, client_context_id="{}")",
+                   self->request.type,
+                   self->client_context_id_);
     });
   }
 
-  void cancel(std::error_code ec)
+  // Stops the session, then completes the request with `ec`: the completion checks the session in,
+  // and check_in refuses a stopped one. Returns false, and stops nothing, when the handler was
+  // already taken, as by a response handled before a deadline completion already queued:
+  // deadline.cancel() does not retract it, and the session then belongs to the pool.
+  auto cancel(std::error_code ec) -> bool
   {
-    invoke_handler(ec, {});
-    if (session_) {
-      session_->stop();
+    handler_type handler{};
+    std::shared_ptr<io::http_session> session;
+    {
+      const std::scoped_lock lock(handler_mutex_);
+      handler = std::move(handler_);
+      session = session_.lock();
+    }
+    if (!handler) {
+      return false;
+    }
+    if (session) {
+      session->stop();
     }
+    complete(std::move(handler), ec, {});
+    return true;
   }
 
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-  void invoke_handler(error_union error, io::http_response&& msg)
-#else
   void invoke_handler(std::error_code ec, io::http_response&& msg)
-#endif
   {
-    if (handler_type handler = std::move(handler_); handler) {
-      const auto& node_uuid = session_ ? session_->node_uuid() : "";
+    complete(take_handler(), ec, std::move(msg));
+  }
+
+  // The handler is the token for completing the request. The deadline completion runs on the
+  // io_context and the response on the session strand, so it is taken under handler_mutex_.
+  auto take_handler() -> handler_type
+  {
+    const std::scoped_lock lock(handler_mutex_);
+    return std::move(handler_);
+  }
+
+  void complete(handler_type handler, std::error_code ec, io::http_response&& msg)
+  {
+    if (handler) {
+      std::string node_uuid;
+      {
+        const std::scoped_lock lock(handler_mutex_);
+        node_uuid = target_node_uuid_;
+      }
       auto telemetry_recorder = app_telemetry_meter_->value_recorder(node_uuid, {});
       telemetry_recorder->update_counter(total_counter_for_service_type(request.type));
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-      std::error_code ec{};
-      if (std::holds_alternative<std::error_code>(error)) {
-        ec = std::get<std::error_code>(error);
-      } else if (std::holds_alternative<impl::bootstrap_error>(error)) {
-        ec = std::get<impl::bootstrap_error>(error).ec;
-      }
-#endif
       if (ec == errc::common::ambiguous_timeout || ec == errc::common::unambiguous_timeout) {
         telemetry_recorder->update_counter(timedout_counter_for_service_type(request.type));
       } 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
-      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);
+      auto make_context = [&]() {
+        error_context_type ctx{};
+        ctx.ec = ec;
+        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();
+        {
+          const std::scoped_lock lock(handler_mutex_);
+          // A request completed before any dispatch leaves last_dispatched_from/to unset.
+          if (!dispatched_to_.empty()) {
+            // A resend after a refused client certificate writes the request on a new connection.
+            if (const auto session = session_.lock(); session) {
+              if (auto [from, to] = session->dispatched_endpoints(); !to.empty()) {
+                dispatched_from_ = std::move(from);
+                dispatched_to_ = std::move(to);
+              }
+            }
+            ctx.last_dispatched_from = dispatched_from_;
+            ctx.last_dispatched_to = dispatched_to_;
           }
-          ctx.ec = bootstrap_error.ec;
-        } else {
-          ctx.ec = std::get<std::error_code>(error);
+          ctx.hostname = target_hostname_;
+          ctx.port = target_port_;
         }
-      }
-#else
-      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;
+        return ctx;
+      };
 
       // Can raise priv::retry_http_request when a retry is required
-      auto resp = request.make_response(std::move(ctx), std::move(encoded_resp));
+      auto resp = io::complete_http_response(request, make_context, encoded_resp);
 
 #ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
       span_->end();
@@ -211,41 +212,49 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
 
       handler(std::move(resp));
     }
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-    dispatch_deadline_.cancel();
-#endif
     deadline.cancel();
   }
 
   void send_to()
   {
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-    dispatch_deadline_.cancel();
-#endif
-    if (!handler_) {
+    bool completed = false;
+    {
+      const std::scoped_lock lock(handler_mutex_);
+      completed = !handler_;
+      sent_ = !completed;
+    }
+    if (completed) {
+      // The completion ran with sent_ false, so session_for_check_in() gave it no session. Stopped
+      // here unless cancel() already stopped it; on_stop takes it off the busy list.
+      if (const auto session = session_.lock(); session) {
+        session->stop();
+      }
       return;
     }
     send();
   }
 
-  void set_command_session(std::shared_ptr<io::http_session> session)
+  void set_command_session(const std::shared_ptr<io::http_session>& session)
   {
-    session_.reset();
-    session_ = std::move(session);
+    const std::scoped_lock lock(handler_mutex_);
+    session_ = session;
+    target_node_uuid_ = session->node_uuid();
+    target_hostname_ = session->http_context().hostname;
+    target_port_ = session->http_context().port;
   }
 
-  [[nodiscard]] auto deadline_expiry() const -> std::chrono::time_point<std::chrono::steady_clock>
+  // The session the completion checks in: the one send_to() sent on, or null. A completion before
+  // send_to() gets null, so a session send_to() is about to stop is never pooled first.
+  [[nodiscard]] auto session_for_check_in() -> std::shared_ptr<io::http_session>
   {
-    return deadline.expiry();
+    const std::scoped_lock lock(handler_mutex_);
+    return sent_ ? session_.lock() : nullptr;
   }
 
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-  [[nodiscard]] auto dispatch_deadline_expiry() const
-    -> std::chrono::time_point<std::chrono::steady_clock>
+  [[nodiscard]] auto deadline_expiry() const -> std::chrono::time_point<std::chrono::steady_clock>
   {
-    return dispatch_deadline_.expiry();
+    return deadline.expiry();
   }
-#endif
 
 private:
   void send()
@@ -253,25 +262,36 @@ private:
     encoded.type = request.type;
     encoded.client_context_id = client_context_id_;
     encoded.timeout = timeout_;
-    if (auto ec = request.encode_to(encoded, session_->http_context()); ec) {
+    const auto session = session_.lock();
+    if (!session) {
+      return invoke_handler(errc::common::request_canceled, {});
+    }
+    if (auto ec = request.encode_to(encoded, session->http_context()); ec) {
       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(),
+      session->log_prefix(),
       encoded.type,
       encoded.method,
-      encoded.path,
+      logger::user_data(encoded.path),
       client_context_id_,
       timeout_.count());
 
-    auto dispatch_span = create_dispatch_span();
+    auto dispatch_span = create_dispatch_span(*session);
+
+    {
+      const std::scoped_lock lock(handler_mutex_);
+      dispatched_from_ = session->local_address();
+      dispatched_to_ = session->remote_address();
+    }
 
-    session_->write_and_subscribe(
+    session->write_and_subscribe(
       encoded,
       [self = this->shared_from_this(),
+       session,
        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) {
@@ -284,16 +304,16 @@ private:
         {
           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(), {})
+          self->app_telemetry_meter_->value_recorder(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,
+            tracing::service_name_for_http_service(self->request.type),
             self->request.observability_identifier,
-            ec,
+            metrics::standardized_error_type(ec),
           };
           self->meter_->record_value(std::move(attrs), start);
         }
@@ -301,12 +321,20 @@ private:
 
         self->deadline.cancel();
         CB_LOG_TRACE(R"({} HTTP response: {}, client_context_id="{}", ec={}, status={}, body={})",
-                     self->session_->log_prefix(),
+                     session->log_prefix(),
                      self->request.type,
                      self->client_context_id_,
                      ec.message(),
                      msg.status_code,
-                     msg.status_code == 200 ? "[hidden]" : msg.body.data());
+                     // Views, not strings: the arms have different types, so a plain ternary
+                     // built a std::string and copied the whole body in on every non-200.
+                     // Only the arm that carries a body is tagged. "[hidden]" is a constant the
+                     // SDK substituted, and hashing it would leave a reader unable to tell a body
+                     // the SDK withheld from one the redaction tool replaced.
+                     logger::user_data_if(msg.status_code != 200,
+                                          msg.status_code == 200
+                                            ? std::string_view{ "[hidden]" }
+                                            : std::string_view{ msg.body.data() }));
         if (auto parser_ec = msg.body.ec(); !ec && parser_ec) {
           ec = parser_ec;
         }
@@ -318,7 +346,7 @@ private:
       });
   }
 
-  [[nodiscard]] auto create_dispatch_span() const
+  [[nodiscard]] auto create_dispatch_span(io::http_session& session) const
     -> std::shared_ptr<couchbase::tracing::request_span>
   {
 #ifdef COUCHBASE_CXX_CLIENT_CREATE_OPERATION_SPAN_IN_CORE
@@ -331,13 +359,13 @@ private:
     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::local_id, session.id());
       dispatch_span->add_tag(tracing::attributes::dispatch::server_address,
-                             session_->http_context().canonical_hostname);
+                             session.http_context().canonical_hostname);
       dispatch_span->add_tag(tracing::attributes::dispatch::server_port,
-                             session_->http_context().canonical_port);
+                             session.http_context().canonical_port);
 
-      const auto& peer_endpoint = session_->remote_endpoint();
+      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());