couchbase 4.6.0 → 4.7.0-dev.1

package/deps/couchbase-cxx-client/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

package/deps/couchbase-cxx-client/core/io/mcbp_session.cxx

@@ -240,19 +240,6 @@ class mcbp_session_impl
       stopped_.compare_exchange_strong(expected_state, true);
     }
 
-    static auto sasl_mechanisms(const std::shared_ptr<mcbp_session_impl>& session)
-      -> std::vector<std::string>
-    {
-      if (const auto user_mechanisms = session->origin_.credentials().allowed_sasl_mechanisms;
-          user_mechanisms.has_value()) {
-        return user_mechanisms.value();
-      }
-      if (session->is_tls_) {
-        return { "PLAIN" };
-      }
-      return { "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1" };
-    }
-
     auto last_bootstrap_error() && -> impl::bootstrap_error
     {
       return std::move(last_bootstrap_error_);
@@ -265,14 +252,7 @@ class mcbp_session_impl
 
     explicit bootstrap_handler(std::shared_ptr<mcbp_session_impl> session)
       : session_(std::move(session))
-      , sasl_(
-          [origin = session_->origin_]() {
-            return origin.username();
-          },
-          [origin = session_->origin_]() {
-            return origin.password();
-          },
-          sasl_mechanisms(session_))
+      , sasl_(session_->new_sasl_context())
     {
       protocol::client_request<protocol::hello_request_body> hello_req;
       if (session_->origin_.options().enable_unordered_execution) {
@@ -749,6 +729,12 @@ class mcbp_session_impl
                 if (session_) {
                   session_->update_configuration(resp.body().config());
                 }
+              } else if (resp.status() == key_value_status_code::auth_stale) {
+                CB_LOG_WARNING("{} received auth stale status for {}, opaque={}",
+                               session_->log_prefix_,
+                               resp.opcode(),
+                               resp.opaque());
+                session_->stop(retry_reason::do_not_retry);
               } else {
                 CB_LOG_WARNING("{} unexpected message status: {} (opaque={})",
                                session_->log_prefix_,
@@ -779,11 +765,20 @@ class mcbp_session_impl
             case protocol::client_opcode::range_scan_cancel:
             case protocol::client_opcode::decrement:
             case protocol::client_opcode::subdoc_multi_lookup:
-            case protocol::client_opcode::subdoc_multi_mutation: {
+            case protocol::client_opcode::subdoc_multi_mutation:
+            case protocol::client_opcode::sasl_auth: {
               const std::uint16_t status = utils::byte_swap(msg.header.specific);
               if (status == static_cast<std::uint16_t>(key_value_status_code::not_my_vbucket)) {
                 session_->handle_not_my_vbucket(msg);
               }
+              if (status == static_cast<std::uint16_t>(key_value_status_code::auth_stale)) {
+                CB_LOG_WARNING("{} received auth stale status for {}, opaque={}",
+                               session_->log_prefix_,
+                               protocol::client_opcode(msg.header.opcode),
+                               utils::byte_swap(msg.header.opaque));
+                session_->stop(retry_reason::do_not_retry);
+                return;
+              }
 
               std::uint32_t opaque = utils::byte_swap(msg.header.opaque);
               if (session_->handle_request(opcode, status, opaque, std::move(msg))) {
@@ -880,6 +875,7 @@ public:
     , bootstrap_deadline_(ctx_)
     , resolve_deadline_(ctx_)
     , connection_deadline_(ctx_)
+    , reauth_deadline_(ctx_)
     , retry_backoff_(ctx_)
     , ping_timeout_(ctx_)
     , origin_{ std::move(origin) }
@@ -896,7 +892,7 @@ public:
   mcbp_session_impl(std::string_view client_id,
                     std::string_view node_uuid,
                     asio::io_context& ctx,
-                    asio::ssl::context& tls,
+                    tls_context_provider& tls,
                     couchbase::core::origin origin,
                     std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                     std::optional<std::string> bucket_name = {},
@@ -909,6 +905,7 @@ public:
     , bootstrap_deadline_(ctx_)
     , resolve_deadline_(ctx_)
     , connection_deadline_(ctx_)
+    , reauth_deadline_(ctx_)
     , retry_backoff_(ctx_)
     , ping_timeout_(ctx_)
     , origin_(std::move(origin))
@@ -943,6 +940,16 @@ public:
     return connection_endpoints_.remote_address_with_port;
   }
 
+  auto remote_hostname() const -> std::string
+  {
+    return connection_endpoints_.remote_address;
+  }
+
+  auto remote_port() const -> std::uint16_t
+  {
+    return connection_endpoints_.remote.port();
+  }
+
   auto local_address() const -> std::string
   {
     return connection_endpoints_.local_address_with_port;
@@ -962,6 +969,37 @@ public:
              bucket_name_ };
   }
 
+  auto sasl_mechanisms() -> std::vector<std::string>
+  {
+    auto credentials = origin_.credentials();
+    if (const auto user_mechanisms = credentials.allowed_sasl_mechanisms;
+        user_mechanisms.has_value()) {
+      return user_mechanisms.value();
+    }
+    if (credentials.uses_jwt()) {
+      return { "OAUTHBEARER" };
+    }
+    if (is_tls_) {
+      return { "PLAIN" };
+    }
+    return { "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1" };
+  }
+
+  auto new_sasl_context() -> sasl::ClientContext
+  {
+    return { [this] {
+              return origin_.username();
+            },
+             [this] {
+               auto credentials = origin_.credentials();
+               if (credentials.uses_jwt()) {
+                 return credentials.jwt_token;
+               }
+               return credentials.password;
+             },
+             sasl_mechanisms() };
+  }
+
   void ping(const std::shared_ptr<diag::ping_reporter>& handler,
             std::optional<std::chrono::milliseconds> timeout)
   {
@@ -1028,6 +1066,132 @@ public:
     return { config_, supported_features_ };
   }
 
+  void reauthenticate()
+  {
+    if (!bootstrapped_ || stopped_) {
+      CB_LOG_DEBUG("{} Cannot reauthenticate as trying to reauthenticate on non-bootstrapped or "
+                   "stopped session",
+                   log_prefix_);
+      return;
+    }
+
+    if (reauth_in_progress_) {
+      CB_LOG_DEBUG("{} Attempted to reauthenticate but reauthentication already in progress",
+                   log_prefix_);
+      return;
+    }
+
+    reauth_in_progress_ = true;
+
+    auto sasl = new_sasl_context();
+    protocol::client_request<protocol::sasl_auth_request_body> req;
+    auto [sasl_code, sasl_payload] = sasl.start();
+    req.opaque(next_opaque());
+    req.body().mechanism(sasl.get_name());
+    req.body().sasl_data(sasl_payload);
+
+    CB_LOG_TRACE("{} starting reauthentication (opaque={}).", log_prefix_, req.opaque());
+
+    reauth_deadline_.expires_after(origin_.options().key_value_timeout);
+    reauth_deadline_.async_wait(
+      [self = shared_from_this(), opaque = req.opaque()](std::error_code ec) {
+        if (ec == asio::error::operation_aborted || self->stopped_) {
+          return;
+        }
+        CB_LOG_DEBUG("{} Reauthentication timed out (opaque={}).", self->log_prefix_, opaque);
+        static_cast<void>(
+          self->cancel(opaque, errc::common::ambiguous_timeout, retry_reason::do_not_retry));
+      });
+    initiate_reauthenticate(std::move(req));
+  }
+
+  void initiate_reauthenticate(protocol::client_request<protocol::sasl_auth_request_body> req)
+  {
+    auto opaque = req.opaque();
+    auto data = req.data();
+    write_and_subscribe(
+      opaque,
+      std::move(data),
+      [self = shared_from_this(), req = std::move(req)](
+        std::error_code ec,
+        retry_reason reason,
+        io::mcbp_message&& msg,
+        const std::optional<key_value_error_map_info>& /* error_info */) -> void {
+        if (ec == asio::error::operation_aborted || ec == errc::common::request_canceled) {
+          self->reauth_in_progress_ = false;
+          return;
+        }
+
+        key_value_status_code status = key_value_status_code::invalid;
+        std::optional<key_value_error_map_info> error_code;
+        if (protocol::is_valid_status(msg.header.status())) {
+          status = static_cast<key_value_status_code>(msg.header.status());
+        } else {
+          error_code = self->decode_error_code(msg.header.status());
+        }
+
+        if (status == key_value_status_code::success) {
+          self->reauth_deadline_.cancel();
+          self->reauth_in_progress_ = false;
+          CB_LOG_DEBUG(
+            "{} reauthentication succeeded (opaque={})", self->log_prefix_, req.opaque());
+          return;
+        }
+
+        if (status == key_value_status_code::auth_continue) {
+          self->reauth_deadline_.cancel();
+          self->reauth_in_progress_ = false;
+          CB_LOG_DEBUG("{} reauthentication received unexpected auth_continue (opaque={})",
+                       self->log_prefix_,
+                       req.opaque());
+          return;
+        }
+
+        if (error_code && error_code.value().has_retry_attribute()) {
+          reason = retry_reason::key_value_error_map_retry_indicated;
+        } else {
+          switch (status) {
+            case key_value_status_code::temporary_failure:
+              reason = retry_reason::key_value_temporary_failure;
+            default:
+              break;
+          }
+        }
+
+        if (reason == retry_reason::do_not_retry || reason == retry_reason::unknown) {
+          CB_LOG_WARNING("{} reauthentication failed (code={}, message={}, reason={}, opaque={})",
+                         self->log_prefix_,
+                         ec.value(),
+                         ec.message(),
+                         reason,
+                         req.opaque());
+          self->reauth_deadline_.cancel();
+          self->reauth_in_progress_ = false;
+          return;
+        }
+
+        CB_LOG_DEBUG("{} reauthentication failed (code={}, reason={}, opaque={}), scheduling retry",
+                     self->log_prefix_,
+                     ec.value(),
+                     reason,
+                     req.opaque());
+
+        auto backoff = std::chrono::milliseconds(300);
+        self->retry_backoff_.expires_after(backoff);
+        self->retry_backoff_.async_wait([self, req = req](std::error_code ec) -> void {
+          if (ec == asio::error::operation_aborted || !self->reauth_in_progress_) {
+            return;
+          }
+          self->initiate_reauthenticate(req);
+        });
+      });
+  }
+
+  void update_credentials(cluster_credentials credentials)
+  {
+    origin_.update_credentials(std::move(credentials));
+  }
+
   void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& callback,
                  bool retry_on_bucket_not_found = false)
   {
@@ -1225,6 +1389,7 @@ public:
     bootstrap_deadline_.cancel();
     resolve_deadline_.cancel();
     connection_deadline_.cancel();
+    reauth_deadline_.cancel();
     retry_backoff_.cancel();
     ping_timeout_.cancel();
     resolver_.cancel();
@@ -1533,6 +1698,16 @@ public:
     return bootstrap_port_number_;
   }
 
+  [[nodiscard]] auto canonical_hostname() const -> const std::string&
+  {
+    return canonical_hostname_;
+  }
+
+  [[nodiscard]] auto canonical_port_number() const -> std::uint16_t
+  {
+    return canonical_port_number_;
+  }
+
   [[nodiscard]] auto next_opaque() -> std::uint32_t
   {
     return ++opaque_;
@@ -1743,10 +1918,18 @@ private:
     if (ec) {
       return stop(retry_reason::node_not_available);
     }
-    if (node_uuid_.empty() && config_.has_value()) {
+    if (config_.has_value()) {
       for (const auto& node : config_.value().nodes) {
         if (node.this_node) {
-          node_uuid_ = node.node_uuid;
+          if (node_uuid_.empty()) {
+            node_uuid_ = node.node_uuid;
+          }
+          if (canonical_hostname_.empty()) {
+            canonical_hostname_ = node.hostname;
+          }
+          if (canonical_port_number_ == 0) {
+            canonical_port_number_ = node.port_or(service_type::key_value, is_tls_, 0);
+          }
         }
       }
     }
@@ -2068,6 +2251,7 @@ private:
   asio::steady_timer bootstrap_deadline_;
   asio::steady_timer resolve_deadline_;
   asio::steady_timer connection_deadline_;
+  asio::steady_timer reauth_deadline_;
   asio::steady_timer retry_backoff_;
   asio::steady_timer ping_timeout_;
   couchbase::core::origin origin_;
@@ -2085,6 +2269,7 @@ private:
 
   std::atomic_bool bootstrapped_{ false };
   std::atomic_bool stopped_{ false };
+  std::atomic_bool reauth_in_progress_{ false };
   bool authenticated_{ false };
   bool bucket_selected_{ false };
   bool supports_gcccp_{ true };
@@ -2112,6 +2297,10 @@ private:
   std::optional<error_map> error_map_;
   collection_cache collection_cache_;
 
+  // Only used for tracing & metrics. They represent the address of the node as given in the config.
+  std::string canonical_hostname_{};
+  std::uint16_t canonical_port_number_{};
+
   const bool is_tls_;
   std::shared_ptr<impl::bootstrap_state_listener> state_listener_{ nullptr };
 
@@ -2153,7 +2342,7 @@ mcbp_session::mcbp_session(const std::string& client_id,
 mcbp_session::mcbp_session(const std::string& client_id,
                            const std::string& node_uuid,
                            asio::io_context& ctx,
-                           asio::ssl::context& tls,
+                           tls_context_provider& tls,
                            core::origin origin,
                            std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                            std::optional<std::string> bucket_name,
@@ -2241,6 +2430,18 @@ mcbp_session::remote_address() const -> std::string
   return impl_->remote_address();
 }
 
+auto
+mcbp_session::remote_hostname() const -> std::string
+{
+  return impl_->remote_hostname();
+}
+
+auto
+mcbp_session::remote_port() const -> std::uint16_t
+{
+  return impl_->remote_port();
+}
+
 auto
 mcbp_session::local_address() const -> std::string
 {
@@ -2277,6 +2478,18 @@ mcbp_session::last_bootstrap_error() const& -> const std::optional<impl::bootstr
   return impl_->last_bootstrap_error();
 }
 
+auto
+mcbp_session::canonical_hostname() const -> const std::string&
+{
+  return impl_->canonical_hostname();
+}
+
+auto
+mcbp_session::canonical_port_number() const -> std::uint16_t
+{
+  return impl_->canonical_port_number();
+}
+
 void
 mcbp_session::write_and_subscribe(std::uint32_t opaque,
                                   std::vector<std::byte>&& data,
@@ -2293,6 +2506,18 @@ mcbp_session::bootstrap(
   return impl_->bootstrap(std::move(handler), retry_on_bucket_not_found);
 }
 
+void
+mcbp_session::reauthenticate()
+{
+  return impl_->reauthenticate();
+}
+
+void
+mcbp_session::update_credentials(cluster_credentials credentials)
+{
+  return impl_->update_credentials(std::move(credentials));
+}
+
 void
 mcbp_session::on_stop(utils::movable_function<void()> handler)
 {