couchbase 3.5.2 → 3.5.4

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

@@ -17,8 +17,14 @@
 
 #include "mcbp_session.hxx"
 
+#include <couchbase/build_config.hxx>
+
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+#include "core/columnar/background_bootstrap_listener.hxx"
+#endif
 #include "core/config_listener.hxx"
 #include "core/diagnostics.hxx"
+#include "core/impl/bootstrap_error.hxx"
 #include "core/impl/bootstrap_state_listener.hxx"
 #include "core/logger/logger.hxx"
 #include "core/mcbp/codec.hxx"
@@ -50,7 +56,6 @@
 #include "retry_orchestrator.hxx"
 #include "streams.hxx"
 
-#include <couchbase/build_config.hxx>
 #include <couchbase/error_codes.hxx>
 #include <couchbase/fmt/retry_reason.hxx>
 
@@ -66,7 +71,7 @@ template<typename Container>
 struct mcbp_header_view {
   const Container& buf_;
 
-  mcbp_header_view(const Container& buf)
+  explicit mcbp_header_view(const Container& buf)
     : buf_{ buf }
   {
   }
@@ -214,9 +219,14 @@ class mcbp_session_impl
     std::shared_ptr<mcbp_session_impl> session_;
     sasl::ClientContext sasl_;
     std::atomic_bool stopped_{ false };
-    std::string last_error_message_;
+    impl::bootstrap_error last_bootstrap_error_;
 
   public:
+    bootstrap_handler(const bootstrap_handler&) = delete;
+    auto operator=(const bootstrap_handler&) -> bootstrap_handler& = delete;
+    bootstrap_handler(bootstrap_handler&&) = delete;
+    auto operator=(bootstrap_handler&&) -> bootstrap_handler& = delete;
+
     ~bootstrap_handler()
     {
       stop();
@@ -241,14 +251,14 @@ class mcbp_session_impl
       return { "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1" };
     }
 
-    auto last_error_message() && -> std::string
+    auto last_bootstrap_error() && -> impl::bootstrap_error
     {
-      return std::move(last_error_message_);
+      return std::move(last_bootstrap_error_);
     }
 
-    [[nodiscard]] auto last_error_message() const& -> const std::string&
+    [[nodiscard]] auto last_bootstrap_error() const& -> const impl::bootstrap_error&
     {
-      return last_error_message_;
+      return last_bootstrap_error_;
     }
 
     explicit bootstrap_handler(std::shared_ptr<mcbp_session_impl> session)
@@ -317,10 +327,10 @@ class mcbp_session_impl
         errmap_req.opaque(session_->next_opaque());
         session_->write(errmap_req.data());
       }
-      if (session_->bucket_name_) {
+      if (auto val = session_->bucket_name_; val) {
         protocol::client_request<protocol::select_bucket_request_body> sb_req;
         sb_req.opaque(session_->next_opaque());
-        sb_req.body().bucket_name(session_->bucket_name_.value());
+        sb_req.body().bucket_name(val.value());
         session_->write(sb_req.data());
       }
       protocol::client_request<protocol::get_cluster_config_request_body> cfg_req;
@@ -343,26 +353,34 @@ class mcbp_session_impl
             case key_value_status_code::rate_limited_max_commands:
             case key_value_status_code::rate_limited_max_connections:
             case key_value_status_code::rate_limited_network_egress:
-            case key_value_status_code::rate_limited_network_ingress:
-              last_error_message_ =
+            case key_value_status_code::rate_limited_network_ingress: {
+              auto error_msg =
                 fmt::format("unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), "
                             "the user has reached rate limit",
                             session_->bucket_name_.value_or(""),
                             protocol::client_opcode(msg.header.opcode),
                             status);
-              CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
+              last_bootstrap_error_ = { errc::common::rate_limited,
+                                        std::move(error_msg),
+                                        session_->bootstrap_hostname(),
+                                        session_->bootstrap_port() };
+              CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
               return complete(errc::common::rate_limited);
-
-            case key_value_status_code::scope_size_limit_exceeded:
-              last_error_message_ =
+            }
+            case key_value_status_code::scope_size_limit_exceeded: {
+              auto error_msg =
                 fmt::format("unable to bootstrap MCBP session (bucket={}, opcode={}, status={}), "
                             "the user has reached quota limit",
                             session_->bucket_name_.value_or(""),
                             protocol::client_opcode(msg.header.opcode),
                             status);
-              CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
+              last_bootstrap_error_ = { errc::common::quota_limited,
+                                        std::move(error_msg),
+                                        session_->bootstrap_hostname(),
+                                        session_->bootstrap_port() };
+              CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
               return complete(errc::common::quota_limited);
-
+            }
             default:
               break;
           }
@@ -380,23 +398,31 @@ class mcbp_session_impl
                   return auth_success();
                 }
               } else {
-                last_error_message_ =
+                auto error_msg =
                   fmt::format("unexpected message status during bootstrap: {} (opaque={})",
                               resp.error_message(),
                               resp.opaque());
-                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
+                last_bootstrap_error_ = { errc::network::handshake_failure,
+                                          std::move(error_msg),
+                                          session_->bootstrap_hostname(),
+                                          session_->bootstrap_port() };
+                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                 return complete(errc::network::handshake_failure);
               }
             } break;
             case protocol::client_opcode::sasl_list_mechs: {
-              protocol::client_response<protocol::sasl_list_mechs_response_body> resp(
+              const protocol::client_response<protocol::sasl_list_mechs_response_body> resp(
                 std::move(msg));
               if (resp.status() != key_value_status_code::success) {
-                last_error_message_ =
+                auto error_msg =
                   fmt::format("unexpected message status during bootstrap: {} (opaque={})",
                               resp.error_message(),
                               resp.opaque());
-                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
+                last_bootstrap_error_ = { errc::common::authentication_failure,
+                                          std::move(error_msg),
+                                          session_->bootstrap_hostname(),
+                                          session_->bootstrap_port() };
+                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                 return complete(errc::common::authentication_failure);
               }
             } break;
@@ -417,32 +443,45 @@ class mcbp_session_impl
                   req.body().sasl_data(sasl_payload);
                   session_->write_and_flush(req.data());
                 } else {
-                  last_error_message_ = fmt::format(
+                  auto error_msg = fmt::format(
                     "unable to authenticate: (sasl_code={}, opaque={})", sasl_code, resp.opaque());
-                  CB_LOG_ERROR("{} {}", session_->log_prefix_, last_error_message_);
+                  last_bootstrap_error_ = { errc::common::authentication_failure,
+                                            std::move(error_msg),
+                                            session_->bootstrap_hostname(),
+                                            session_->bootstrap_port() };
+                  CB_LOG_ERROR("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                   return complete(errc::common::authentication_failure);
                 }
               } else {
-                last_error_message_ =
+                auto error_msg =
                   fmt::format("{} unexpected message status during bootstrap: {} (opaque={})",
                               session_->log_prefix_,
                               resp.error_message(),
                               resp.opaque());
-                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
+                last_bootstrap_error_ = { errc::common::authentication_failure,
+                                          std::move(error_msg),
+                                          session_->bootstrap_hostname(),
+                                          session_->bootstrap_port() };
+                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                 return complete(errc::common::authentication_failure);
               }
             } break;
             case protocol::client_opcode::sasl_step: {
-              protocol::client_response<protocol::sasl_step_response_body> resp(std::move(msg));
+              const protocol::client_response<protocol::sasl_step_response_body> resp(
+                std::move(msg));
               if (resp.status() == key_value_status_code::success) {
                 return auth_success();
               }
-              last_error_message_ =
+              auto error_msg =
                 fmt::format("unable to authenticate (opcode={}, status={}, opaque={})",
                             opcode,
                             resp.status(),
                             resp.opaque());
-              CB_LOG_ERROR("{} {}", session_->log_prefix_, last_error_message_);
+              last_bootstrap_error_ = { errc::common::authentication_failure,
+                                        std::move(error_msg),
+                                        session_->bootstrap_hostname(),
+                                        session_->bootstrap_port() };
+              CB_LOG_ERROR("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
               return complete(errc::common::authentication_failure);
             }
             case protocol::client_opcode::get_error_map: {
@@ -450,12 +489,16 @@ class mcbp_session_impl
               if (resp.status() == key_value_status_code::success) {
                 session_->error_map_.emplace(resp.body().errmap());
               } else {
-                last_error_message_ =
+                auto error_msg =
                   fmt::format("unexpected message status during bootstrap: {} (opaque={}, {:n})",
                               resp.error_message(),
                               resp.opaque(),
                               spdlog::to_hex(resp.header()));
-                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
+                last_bootstrap_error_ = { errc::network::protocol_error,
+                                          std::move(error_msg),
+                                          session_->bootstrap_hostname(),
+                                          session_->bootstrap_port() };
+                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                 return complete(errc::network::protocol_error);
               }
             } break;
@@ -467,28 +510,40 @@ class mcbp_session_impl
                              session_->bucket_name_.value_or(""));
                 session_->bucket_selected_ = true;
               } else if (resp.status() == key_value_status_code::not_found) {
-                last_error_message_ =
+                auto error_msg =
                   fmt::format("kv_engine node does not have configuration propagated yet "
                               "(opcode={}, status={}, opaque={})",
                               opcode,
                               resp.status(),
                               resp.opaque());
-                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
+                last_bootstrap_error_ = { errc::network::configuration_not_available,
+                                          std::move(error_msg),
+                                          session_->bootstrap_hostname(),
+                                          session_->bootstrap_port() };
+                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                 return complete(errc::network::configuration_not_available);
               } else if (resp.status() == key_value_status_code::no_access) {
-                last_error_message_ =
+                auto error_msg =
                   fmt::format("unable to select bucket: {}, probably the bucket does not exist",
                               session_->bucket_name_.value_or(""));
-                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
+                last_bootstrap_error_ = { errc::common::bucket_not_found,
+                                          std::move(error_msg),
+                                          session_->bootstrap_hostname(),
+                                          session_->bootstrap_port() };
+                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                 session_->bucket_selected_ = false;
                 return complete(errc::common::bucket_not_found);
               } else {
-                last_error_message_ =
+                auto error_msg =
                   fmt::format("unexpected message status during bootstrap: {} (opaque={}, {:n})",
                               resp.error_message(),
                               resp.opaque(),
                               spdlog::to_hex(resp.header()));
-                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
+                last_bootstrap_error_ = { errc::common::bucket_not_found,
+                                          std::move(error_msg),
+                                          session_->bootstrap_hostname(),
+                                          session_->bootstrap_port() };
+                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                 return complete(errc::common::bucket_not_found);
               }
             } break;
@@ -497,15 +552,16 @@ class mcbp_session_impl
                                        session_->connection_endpoints_.remote.port() };
               protocol::client_response<protocol::get_cluster_config_response_body> resp(
                 std::move(msg), info);
-              if (session_->origin_.options().dump_configuration &&
-                  resp.body().config_text().has_value()) {
-                CB_LOG_TRACE("{} configuration from get_cluster_config request (bootstrap, "
-                             "size={}, endpoint=\"{}:{}\"), {}",
-                             session_->log_prefix_,
-                             resp.body().config_text().value().size(),
-                             info.endpoint_address,
-                             info.endpoint_port,
-                             resp.body().config_text().value());
+              if (session_->origin_.options().dump_configuration) {
+                if (const auto& text = resp.body().config_text(); text.has_value()) {
+                  CB_LOG_TRACE("{} configuration from get_cluster_config request (bootstrap, "
+                               "size={}, endpoint=\"{}:{}\"), {}",
+                               session_->log_prefix_,
+                               text.value().size(),
+                               info.endpoint_address,
+                               info.endpoint_port,
+                               text.value());
+                }
               }
               if (resp.status() == key_value_status_code::success) {
                 // MB-60405 fixes this for 7.6.2, but for earlier versions we need to protect
@@ -513,7 +569,8 @@ class mcbp_session_impl
                 // if we retry here, but a timeout would be more acceptable than a crash and if we
                 // do timeout, we have a clear indication of the problem (i.e. it is a server bug
                 // and we cannot use a config w/ an empty vbucket map).
-                if (resp.body().config().vbmap && resp.body().config().vbmap->size() == 0) {
+                if (const auto vbmap = resp.body().config().vbmap;
+                    vbmap.has_value() && vbmap->empty()) {
                   CB_LOG_WARNING("{} received a configuration with an empty vbucket map, retrying",
                                  session_->log_prefix_);
                   return complete(errc::network::configuration_not_available);
@@ -521,13 +578,17 @@ class mcbp_session_impl
                 session_->update_configuration(resp.body().config());
                 complete({});
               } else if (resp.status() == key_value_status_code::not_found) {
-                last_error_message_ =
+                auto error_msg =
                   fmt::format("kv_engine node does not have configuration propagated yet "
                               "(opcode={}, status={}, opaque={})",
                               opcode,
                               resp.status(),
                               resp.opaque());
-                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_error_message_);
+                last_bootstrap_error_ = { errc::network::configuration_not_available,
+                                          std::move(error_msg),
+                                          session_->bootstrap_hostname(),
+                                          session_->bootstrap_port() };
+                CB_LOG_DEBUG("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                 return complete(errc::network::configuration_not_available);
               } else if (resp.status() == key_value_status_code::no_bucket &&
                          !session_->bucket_name_) {
@@ -542,18 +603,26 @@ class mcbp_session_impl
                                                      0));
                 complete({});
               } else {
-                last_error_message_ =
+                auto error_msg =
                   fmt::format("unexpected message status during bootstrap: {} (opaque={}, {:n})",
                               resp.error_message(),
                               resp.opaque(),
                               spdlog::to_hex(resp.header()));
-                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
+                last_bootstrap_error_ = { errc::network::protocol_error,
+                                          std::move(error_msg),
+                                          session_->bootstrap_hostname(),
+                                          session_->bootstrap_port() };
+                CB_LOG_WARNING("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
                 return complete(errc::network::protocol_error);
               }
             } break;
             default:
-              last_error_message_ = fmt::format("unexpected message during bootstrap: {}", opcode);
-              CB_LOG_WARNING("{} {}", session_->log_prefix_, last_error_message_);
+              auto error_msg = fmt::format("unexpected message during bootstrap: {}", opcode);
+              last_bootstrap_error_ = { errc::network::protocol_error,
+                                        std::move(error_msg),
+                                        session_->bootstrap_hostname(),
+                                        session_->bootstrap_port() };
+              CB_LOG_WARNING("{} {}", session_->log_prefix_, last_bootstrap_error_.error_message);
               return complete(errc::network::protocol_error);
           }
           break;
@@ -565,20 +634,23 @@ class mcbp_session_impl
                                        session_->bootstrap_port_number_ };
               protocol::server_request<protocol::cluster_map_change_notification_request_body> req(
                 std::move(msg), info);
-              if (session_->origin_.options().dump_configuration &&
-                  req.body().config_text().has_value()) {
-                CB_LOG_TRACE("{} configuration from cluster_map_change_notification request "
-                             "(size={}, endpoint=\"{}:{}\"), {}",
-                             session_->log_prefix_,
-                             req.body().config_text().value().size(),
-                             info.endpoint_address,
-                             info.endpoint_port,
-                             req.body().config_text().value());
+              if (session_->origin_.options().dump_configuration) {
+                if (const auto& text = req.body().config_text(); text.has_value()) {
+                  CB_LOG_TRACE("{} configuration from cluster_map_change_notification request "
+                               "(size={}, endpoint=\"{}:{}\"), {}",
+                               session_->log_prefix_,
+                               text.value().size(),
+                               info.endpoint_address,
+                               info.endpoint_port,
+                               text.value());
+                }
               }
               std::optional<topology::configuration> config = req.body().config();
               if (session_ && config.has_value()) {
                 if ((!config->bucket.has_value() && req.body().bucket().empty()) ||
                     (session_->bucket_name_.has_value() && !req.body().bucket().empty() &&
+                     // TODO(CXXCBC-549)
+                     // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                      session_->bucket_name_.value() == req.body().bucket())) {
                   session_->update_configuration(std::move(config.value()));
                 }
@@ -620,6 +692,11 @@ class mcbp_session_impl
     {
     }
 
+    message_handler(const message_handler&) = delete;
+    auto operator=(const message_handler&) -> message_handler& = delete;
+    message_handler(message_handler&&) = delete;
+    auto operator=(message_handler&&) -> message_handler& = delete;
+
     ~message_handler()
     {
       stop();
@@ -649,15 +726,16 @@ class mcbp_session_impl
                                        session_->bootstrap_port_number_ };
               protocol::client_response<protocol::get_cluster_config_response_body> resp(
                 std::move(msg), info);
-              if (session_->origin_.options().dump_configuration &&
-                  resp.body().config_text().has_value()) {
-                CB_LOG_TRACE("{} configuration from get_cluster_config response (size={}, "
-                             "endpoint=\"{}:{}\"), {}",
-                             session_->log_prefix_,
-                             resp.body().config_text().value().size(),
-                             info.endpoint_address,
-                             info.endpoint_port,
-                             resp.body().config_text().value());
+              if (session_->origin_.options().dump_configuration) {
+                if (const auto& text = resp.body().config_text(); text.has_value()) {
+                  CB_LOG_TRACE("{} configuration from get_cluster_config response (size={}, "
+                               "endpoint=\"{}:{}\"), {}",
+                               session_->log_prefix_,
+                               text.value().size(),
+                               info.endpoint_address,
+                               info.endpoint_port,
+                               text.value());
+                }
               }
               if (resp.status() == key_value_status_code::success) {
                 if (session_) {
@@ -694,7 +772,7 @@ class mcbp_session_impl
             case protocol::client_opcode::decrement:
             case protocol::client_opcode::subdoc_multi_lookup:
             case protocol::client_opcode::subdoc_multi_mutation: {
-              std::uint16_t status = utils::byte_swap(msg.header.specific);
+              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);
               }
@@ -731,20 +809,23 @@ class mcbp_session_impl
                                        session_->bootstrap_port_number_ };
               protocol::server_request<protocol::cluster_map_change_notification_request_body> req(
                 std::move(msg), info);
-              if (session_->origin_.options().dump_configuration &&
-                  req.body().config_text().has_value()) {
-                CB_LOG_TRACE("{} configuration from cluster_map_change_notification request "
-                             "(size={}, endpoint=\"{}:{}\"), {}",
-                             session_->log_prefix_,
-                             req.body().config_text().value().size(),
-                             info.endpoint_address,
-                             info.endpoint_port,
-                             req.body().config_text().value());
+              if (session_->origin_.options().dump_configuration) {
+                if (const auto& text = req.body().config_text(); text.has_value()) {
+                  CB_LOG_TRACE("{} configuration from cluster_map_change_notification request "
+                               "(size={}, endpoint=\"{}:{}\"), {}",
+                               session_->log_prefix_,
+                               text.value().size(),
+                               info.endpoint_address,
+                               info.endpoint_port,
+                               text.value());
+                }
               }
               std::optional<topology::configuration> config = req.body().config();
               if (session_ && config.has_value()) {
                 if ((!config->bucket.has_value() && req.body().bucket().empty()) ||
                     (session_->bucket_name_.has_value() && !req.body().bucket().empty() &&
+                     // TODO(CXXCBC-549)
+                     // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
                      session_->bucket_name_.value() == req.body().bucket())) {
                   session_->update_configuration(std::move(config.value()));
                 }
@@ -827,7 +908,12 @@ public:
       "[{}/{}/{}/{}]", client_id_, id_, stream_->log_prefix(), bucket_name_.value_or("-"));
   }
 
-  ~mcbp_session_impl()
+  mcbp_session_impl(const mcbp_session_impl&) = delete;
+  auto operator=(const mcbp_session_impl&) -> mcbp_session_impl& = delete;
+  mcbp_session_impl(mcbp_session_impl&&) = delete;
+  auto operator=(mcbp_session_impl&&) -> mcbp_session_impl& = delete;
+
+  ~mcbp_session_impl() override
   {
     CB_LOG_DEBUG("{} destroy MCBP connection", log_prefix_);
     stop(retry_reason::do_not_retry);
@@ -862,7 +948,7 @@ public:
              bucket_name_ };
   }
 
-  void ping(std::shared_ptr<diag::ping_reporter> handler,
+  void ping(const std::shared_ptr<diag::ping_reporter>& handler,
             std::optional<std::chrono::milliseconds> timeout)
   {
     if (!bootstrapped_) {
@@ -874,8 +960,8 @@ public:
         local_address(),
         diag::ping_state::error,
         bucket_name_,
-        last_bootstrap_error_message_.has_value() ? last_bootstrap_error_message_.value()
-                                                  : "Bootstrap incomplete, cannot perform ping.",
+        last_bootstrap_error_.has_value() ? last_bootstrap_error_.value().error_message
+                                          : "Bootstrap incomplete, cannot perform ping.",
       });
       return;
     }
@@ -888,7 +974,7 @@ public:
         std::error_code ec,
         retry_reason reason,
         io::mcbp_message&& /* msg */,
-        std::optional<key_value_error_map_info> /* error_info */) {
+        const std::optional<key_value_error_map_info>& /* error_info */) {
         diag::ping_state state = diag::ping_state::ok;
         std::optional<std::string> error{};
         if (ec) {
@@ -938,18 +1024,56 @@ public:
       if (ec == asio::error::operation_aborted || self->stopped_) {
         return;
       }
-      if (!ec) {
-        ec = errc::common::unambiguous_timeout;
-      }
       if (self->state_listener_) {
         self->state_listener_->report_bootstrap_error(
           fmt::format("{}:{}", self->bootstrap_hostname_, self->bootstrap_port_), ec);
       }
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+      // an existing background bootstrap listener means we want to infinitely
+      // attempt to connect.
+      if (self->background_bootstrap_listener_) {
+        if (self->last_bootstrap_error_.has_value()) {
+          self->background_bootstrap_listener_->notify_bootstrap_error(
+            self->last_bootstrap_error_.value());
+        } else {
+          self->background_bootstrap_listener_->notify_bootstrap_error(
+            { make_error_code(errc::common::unambiguous_timeout),
+              "Unable to connect in time.",
+              self->bootstrap_hostname_,
+              self->bootstrap_port_ });
+        }
+        auto backoff = std::chrono::milliseconds(500);
+        CB_LOG_DEBUG("{} unable to connect in time, waiting for {}ms before retry",
+                     self->log_prefix_,
+                     backoff.count());
+        self->retry_backoff_.expires_after(backoff);
+        self->retry_backoff_.async_wait([self](std::error_code ec) mutable {
+          if (ec == asio::error::operation_aborted || self->stopped_) {
+            return;
+          }
+          self->origin_.restart();
+          self->initiate_bootstrap();
+        });
+      } else {
+        if (!ec) {
+          ec = errc::common::unambiguous_timeout;
+        }
+        CB_LOG_WARNING("{} unable to bootstrap in time", self->log_prefix_);
+        if (auto h = std::move(self->bootstrap_callback_); h) {
+          h(ec, {});
+        }
+        self->stop(retry_reason::do_not_retry);
+      }
+#else
+      if (!ec) {
+        ec = errc::common::unambiguous_timeout;
+      }
       CB_LOG_WARNING("{} unable to bootstrap in time", self->log_prefix_);
       if (auto h = std::move(self->bootstrap_callback_); h) {
         h(ec, {});
       }
       self->stop(retry_reason::do_not_retry);
+#endif
     });
     initiate_bootstrap();
   }
@@ -960,22 +1084,35 @@ public:
       return;
     }
     bootstrapped_ = false;
-    if (bootstrap_handler_) {
-      last_bootstrap_error_message_ = std::move(bootstrap_handler_)->last_error_message();
+    if (auto handler = std::move(bootstrap_handler_); handler) {
+      last_bootstrap_error_ = handler->last_bootstrap_error();
     }
-    bootstrap_handler_ = nullptr;
     state_ = diag::endpoint_state::connecting;
     if (stream_->is_open()) {
-      std::string old_id = stream_->id();
-      stream_->reopen();
-      CB_LOG_TRACE(R"({} reopen socket connection "{}" -> "{}", host="{}", port={})",
-                   log_prefix_,
-                   old_id,
-                   stream_->id(),
-                   bootstrap_hostname_,
-                   bootstrap_port_);
+      return stream_->close([self = shared_from_this(), old_id = stream_->id()](std::error_code) {
+        CB_LOG_DEBUG(R"({} reopened socket connection "{}" -> "{}", host="{}", port={})",
+                     self->log_prefix_,
+                     old_id,
+                     self->stream_->id(),
+                     self->bootstrap_hostname_,
+                     self->bootstrap_port_);
+        return self->initiate_bootstrap();
+      });
     }
     if (origin_.exhausted()) {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+      if (background_bootstrap_listener_) {
+        if (last_bootstrap_error_.has_value()) {
+          background_bootstrap_listener_->notify_bootstrap_error(last_bootstrap_error_.value());
+        } else {
+          background_bootstrap_listener_->notify_bootstrap_error(
+            { errc::network::no_endpoints_left,
+              "Reached end of list of bootstrap nodes.",
+              bootstrap_hostname_,
+              bootstrap_port_ });
+        }
+      }
+#endif
       auto backoff = std::chrono::milliseconds(500);
       CB_LOG_DEBUG("{} reached the end of list of bootstrap nodes, waiting for {}ms before restart",
                    log_prefix_,
@@ -1006,10 +1143,10 @@ public:
                   resolver_,
                   bootstrap_hostname_,
                   bootstrap_port_,
-                  std::bind(&mcbp_session_impl::on_resolve,
-                            shared_from_this(),
-                            std::placeholders::_1,
-                            std::placeholders::_2));
+                  [capture0 = shared_from_this()](auto&& PH1, auto&& PH2) {
+                    capture0->on_resolve(std::forward<decltype(PH1)>(PH1),
+                                         std::forward<decltype(PH2)>(PH2));
+                  });
   }
 
   [[nodiscard]] auto id() const -> const std::string&
@@ -1037,6 +1174,20 @@ public:
     if (stopped_) {
       return;
     }
+
+    if (reason == retry_reason::socket_closed_while_in_flight && !bootstrapped_) {
+      return stream_->close([self = shared_from_this(), old_id = stream_->id()](std::error_code) {
+        CB_LOG_DEBUG(
+          R"({} reopened socket connection due to IO error, "{}" -> "{}", host="{}", port={})",
+          self->log_prefix_,
+          old_id,
+          self->stream_->id(),
+          self->bootstrap_hostname_,
+          self->bootstrap_port_);
+        return self->initiate_bootstrap();
+      });
+    }
+
     state_ = diag::endpoint_state::disconnecting;
     CB_LOG_DEBUG("{} stop MCBP connection, reason={}", log_prefix_, reason);
     stopped_ = true;
@@ -1053,14 +1204,14 @@ public:
     if (auto h = std::move(handler_); h) {
       h->stop();
     }
-    std::error_code ec = errc::common::request_canceled;
+    const std::error_code ec = errc::common::request_canceled;
     if (!bootstrapped_) {
       if (auto h = std::move(bootstrap_callback_); h) {
         h(ec, {});
       }
     }
     {
-      std::scoped_lock lock(command_handlers_mutex_);
+      const std::scoped_lock lock(command_handlers_mutex_);
       for (auto& [opaque, handler] : command_handlers_) {
         if (handler) {
           CB_LOG_DEBUG("{} MCBP cancel operation during session close, opaque={}, ec={}",
@@ -1074,7 +1225,7 @@ public:
       command_handlers_.clear();
     }
     {
-      std::scoped_lock lock(operations_mutex_);
+      const std::scoped_lock lock(operations_mutex_);
       auto operations = std::move(operations_);
       for (auto& [opaque, operation] : operations) {
         auto& [request, handler] = operation;
@@ -1093,6 +1244,11 @@ public:
     if (auto on_stop = std::move(on_stop_handler_); on_stop) {
       on_stop();
     }
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    if (background_bootstrap_listener_) {
+      background_bootstrap_listener_ = nullptr;
+    }
+#endif
   }
 
   void write(std::vector<std::byte>&& buf)
@@ -1101,7 +1257,7 @@ public:
       return;
     }
     CB_LOG_TRACE("{} MCBP send {}", log_prefix_, mcbp_header_view(buf));
-    std::scoped_lock lock(output_buffer_mutex_);
+    const std::scoped_lock lock(output_buffer_mutex_);
     output_buffer_.emplace_back(std::move(buf));
   }
 
@@ -1126,19 +1282,19 @@ public:
 
   void remove_request(std::shared_ptr<mcbp::queue_request> request) override
   {
-    std::scoped_lock lock(operations_mutex_);
+    const std::scoped_lock lock(operations_mutex_);
     if (auto iter = operations_.find(request->opaque_); iter != operations_.end()) {
       operations_.erase(iter);
     }
   }
 
   void enqueue_request(std::uint32_t opaque,
-                       std::shared_ptr<mcbp::queue_request> request,
-                       std::shared_ptr<response_handler> handler)
+                       const std::shared_ptr<mcbp::queue_request>& request,
+                       const std::shared_ptr<response_handler>& handler)
   {
-    std::scoped_lock lock(operations_mutex_);
+    const std::scoped_lock lock(operations_mutex_);
     request->waiting_in_ = this;
-    operations_.try_emplace(opaque, std::move(request), std::move(handler));
+    operations_.try_emplace(opaque, request, handler);
   }
 
   auto handle_request(protocol::client_opcode opcode,
@@ -1149,7 +1305,7 @@ public:
     // handle request old style
     command_handler fun{};
     {
-      std::scoped_lock lock(command_handlers_mutex_);
+      const std::scoped_lock lock(command_handlers_mutex_);
       if (auto handler = command_handlers_.find(opaque);
           handler != command_handlers_.end() && handler->second) {
         fun = std::move(handler->second);
@@ -1172,7 +1328,7 @@ public:
     std::shared_ptr<mcbp::queue_request> request{};
     std::shared_ptr<response_handler> handler{};
     {
-      std::scoped_lock lock(operations_mutex_);
+      const std::scoped_lock lock(operations_mutex_);
       if (auto pair = operations_.find(opaque); pair != operations_.end() && pair->second.first) {
         request = pair->second.first;
         handler = pair->second.second;
@@ -1192,8 +1348,8 @@ public:
     return false;
   }
 
-  void write_and_subscribe(std::shared_ptr<mcbp::queue_request> request,
-                           std::shared_ptr<response_handler> handler)
+  void write_and_subscribe(const std::shared_ptr<mcbp::queue_request>& request,
+                           const std::shared_ptr<response_handler>& handler)
   {
     auto opaque = request->opaque_;
     auto data = codec_.encode_packet(*request);
@@ -1213,14 +1369,14 @@ public:
                                {});
       return;
     }
-    enqueue_request(opaque, std::move(request), std::move(handler));
+    enqueue_request(opaque, request, handler);
     if (bootstrapped_ && stream_->is_open()) {
       write_and_flush(std::move(data.value()));
     } else {
       CB_LOG_DEBUG("{} the stream is not ready yet, put the message into pending buffer, opaque={}",
                    log_prefix_,
                    opaque);
-      std::scoped_lock lock(pending_buffer_mutex_);
+      const std::scoped_lock lock(pending_buffer_mutex_);
       if (bootstrapped_ && stream_->is_open()) {
         write_and_flush(std::move(data.value()));
       } else {
@@ -1241,7 +1397,7 @@ public:
       return;
     }
     {
-      std::scoped_lock lock(command_handlers_mutex_);
+      const std::scoped_lock lock(command_handlers_mutex_);
       command_handlers_.try_emplace(opaque, std::move(handler));
     }
     if (bootstrapped_ && stream_->is_open()) {
@@ -1250,7 +1406,7 @@ public:
       CB_LOG_DEBUG("{} the stream is not ready yet, put the message into pending buffer, opaque={}",
                    log_prefix_,
                    opaque);
-      std::scoped_lock lock(pending_buffer_mutex_);
+      const std::scoped_lock lock(pending_buffer_mutex_);
       if (bootstrapped_ && stream_->is_open()) {
         write_and_flush(std::move(data));
       } else {
@@ -1311,13 +1467,16 @@ public:
 
   [[nodiscard]] auto config() -> topology::configuration
   {
-    std::scoped_lock lock(config_mutex_);
-    return config_.value();
+    const std::scoped_lock lock(config_mutex_);
+    if (config_) {
+      return config_.value();
+    }
+    return {};
   }
 
   [[nodiscard]] auto index() const -> std::size_t
   {
-    std::scoped_lock lock(config_mutex_);
+    const std::scoped_lock lock(config_mutex_);
     Expects(config_.has_value());
     return config_->index_for_this_node();
   }
@@ -1347,6 +1506,16 @@ public:
     return ++opaque_;
   }
 
+  [[nodiscard]] auto last_bootstrap_error() && -> std::optional<impl::bootstrap_error>
+  {
+    return std::move(last_bootstrap_error_);
+  }
+
+  [[nodiscard]] auto last_bootstrap_error() const& -> const std::optional<impl::bootstrap_error>&
+  {
+    return last_bootstrap_error_;
+  }
+
   auto decode_error_code(std::uint16_t code) -> std::optional<key_value_error_map_info>
   {
     if (error_map_) {
@@ -1363,17 +1532,17 @@ public:
     config_listeners_.emplace_back(std::move(handler));
   }
 
-  void update_configuration(topology::configuration&& config)
+  void update_configuration(topology::configuration config)
   {
     if (stopped_) {
       return;
     }
-    std::scoped_lock lock(config_mutex_);
+    const std::scoped_lock lock(config_mutex_);
     // MB-60405 fixes this for 7.6.2, but for earlier versions we need to protect against using a
     // config that has an empty vbucket map.  We should be okay to ignore at this point b/c we
     // should already have a config w/ a non-empty vbucket map (bootstrap will not complete
     // successfully unless we have a config w/ a non-empty vbucket map).
-    if (config.vbmap && config.vbmap->size() == 0) {
+    if (config.vbmap && config.vbmap->empty()) {
       CB_LOG_DEBUG("{} received a configuration with an empty vbucket map, ignoring", log_prefix_);
       return;
     }
@@ -1439,7 +1608,7 @@ public:
             msg.header.magic == static_cast<std::uint8_t>(protocol::magic::client_response));
     if (protocol::has_json_datatype(msg.header.datatype)) {
       auto magic = static_cast<protocol::magic>(msg.header.magic);
-      std::uint8_t extras_size = msg.header.extlen;
+      const std::uint8_t extras_size = msg.header.extlen;
       std::uint8_t framing_extras_size = 0;
       std::uint16_t key_size = utils::byte_swap(msg.header.keylen);
       if (magic == protocol::magic::alt_client_response) {
@@ -1447,7 +1616,7 @@ public:
         key_size = msg.header.keylen & 0xffU;
       }
 
-      std::vector<std::uint8_t>::difference_type offset =
+      const std::vector<std::uint8_t>::difference_type offset =
         framing_extras_size + key_size + extras_size;
       if (utils::byte_swap(msg.header.bodylen) - offset > 0) {
         std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()) + offset,
@@ -1487,9 +1656,18 @@ public:
     collection_cache_.update(path, uid);
   }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  void add_background_bootstrap_listener(
+    std::shared_ptr<columnar::background_bootstrap_listener> listener)
+  {
+    background_bootstrap_listener_ = std::move(listener);
+  }
+#endif
+
 private:
   void invoke_bootstrap_handler(std::error_code ec)
   {
+    connection_deadline_.cancel();
     retry_backoff_.cancel();
 
     if (ec && state_listener_) {
@@ -1534,7 +1712,7 @@ private:
       return stop(retry_reason::node_not_available);
     }
     state_ = diag::endpoint_state::connected;
-    std::scoped_lock lock(pending_buffer_mutex_);
+    const std::scoped_lock lock(pending_buffer_mutex_);
     bootstrapped_ = true;
     bootstrap_handler_->stop();
     handler_ = std::make_shared<message_handler>(shared_from_this());
@@ -1553,9 +1731,11 @@ private:
     if (ec == asio::error::operation_aborted || stopped_) {
       return;
     }
+    connection_deadline_.cancel();
     last_active_ = std::chrono::steady_clock::now();
     if (ec) {
       CB_LOG_ERROR("{} error on resolve: {} ({})", log_prefix_, ec.value(), ec.message());
+      last_bootstrap_error_ = { ec, ec.message(), bootstrap_hostname_, bootstrap_port_ };
       return initiate_bootstrap();
     }
     endpoints_ = endpoints;
@@ -1570,13 +1750,11 @@ private:
       if (timer_ec == asio::error::operation_aborted || self->stopped_) {
         return;
       }
-      return self->stream_->close([self](std::error_code) {
-        self->initiate_bootstrap();
-      });
+      self->initiate_bootstrap();
     });
   }
 
-  void do_connect(asio::ip::tcp::resolver::results_type::iterator it)
+  void do_connect(const asio::ip::tcp::resolver::results_type::iterator& it)
   {
     if (stopped_) {
       return;
@@ -1604,18 +1782,20 @@ private:
                        port,
                        self->bootstrap_hostname_,
                        self->bootstrap_port_);
-          return self->stream_->close([self](std::error_code) {
-            self->initiate_bootstrap();
-          });
+          self->initiate_bootstrap();
         });
-      stream_->async_connect(
-        it->endpoint(),
-        std::bind(&mcbp_session_impl::on_connect, shared_from_this(), std::placeholders::_1, it));
+      stream_->async_connect(it->endpoint(), [capture0 = shared_from_this(), it](auto&& PH1) {
+        capture0->on_connect(std::forward<decltype(PH1)>(PH1), it);
+      });
     } else {
-      CB_LOG_ERROR("{} no more endpoints left to connect to \"{}:{}\", will try another address",
-                   log_prefix_,
-                   bootstrap_hostname_,
-                   bootstrap_port_);
+      auto error_msg =
+        fmt::format("no more endpoints left to connect to \"{}:{}\", will try another address",
+                    bootstrap_hostname_,
+                    bootstrap_port_);
+      last_bootstrap_error_ = {
+        errc::network::no_endpoints_left, std::move(error_msg), bootstrap_hostname_, bootstrap_port_
+      };
+      CB_LOG_ERROR("{} {}", log_prefix_, last_bootstrap_error_.value().error_message);
       if (state_listener_) {
         state_listener_->report_bootstrap_error(
           fmt::format("{}:{}", bootstrap_hostname_, bootstrap_port_),
@@ -1630,6 +1810,7 @@ private:
     if (ec == asio::error::operation_aborted || stopped_) {
       return;
     }
+    connection_deadline_.cancel();
     last_active_ = std::chrono::steady_clock::now();
     if (!stream_->is_open() || ec) {
 #ifdef COUCHBASE_CXX_CLIENT_STATIC_BORINGSSL
@@ -1652,7 +1833,17 @@ private:
                        : "",
                      stream_->is_open());
       if (stream_->is_open()) {
-        stream_->close(std::bind(&mcbp_session_impl::do_connect, shared_from_this(), ++it));
+        stream_->close([self = shared_from_this(), next_address = ++it](std::error_code ec) {
+          if (ec) {
+            CB_LOG_WARNING(
+              "{} unable to close socket, but continue connecting attempt to {}:{}: {}",
+              self->log_prefix_,
+              next_address->endpoint().address().to_string(),
+              next_address->endpoint().port(),
+              ec.value());
+          }
+          self->do_connect(next_address);
+        });
       } else {
         do_connect(++it);
       }
@@ -1672,22 +1863,26 @@ private:
                                 connection_endpoints_.remote_address,
                                 connection_endpoints_.remote.port());
       parser_.reset();
+      {
+        const std::scoped_lock lock(output_buffer_mutex_);
+        output_buffer_.clear();
+      }
       bootstrap_handler_ = std::make_shared<bootstrap_handler>(shared_from_this());
-      connection_deadline_.cancel();
-    }
-  }
 
-  void check_deadline(std::error_code ec)
-  {
-    if (ec == asio::error::operation_aborted || stopped_) {
-      return;
-    }
-    if (connection_deadline_.expiry() <= asio::steady_timer::clock_type::now()) {
-      stream_->close([](std::error_code) {
+      connection_deadline_.expires_after(origin_.options().key_value_timeout);
+      connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
+        if (timer_ec == asio::error::operation_aborted || self->stopped_) {
+          return;
+        }
+        CB_LOG_DEBUG("{} unable to boostrap single node at {}:{} (\"{}:{}\") in time, reconnecting",
+                     self->log_prefix_,
+                     self->connection_endpoints_.remote_address,
+                     self->connection_endpoints_.remote.port(),
+                     self->bootstrap_hostname_,
+                     self->bootstrap_port_);
+        return self->initiate_bootstrap();
       });
     }
-    connection_deadline_.async_wait(
-      std::bind(&mcbp_session_impl::check_deadline, shared_from_this(), std::placeholders::_1));
   }
 
   void do_read()
@@ -1701,24 +1896,26 @@ private:
       [self = shared_from_this(), stream_id = stream_->id()](std::error_code ec,
                                                              std::size_t bytes_transferred) {
         if (ec == asio::error::operation_aborted || self->stopped_) {
+          self->reading_ = false;
           CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", port={}, rc={}, bytes_received={}",
                           self->connection_endpoints_.remote_address,
                           self->connection_endpoints_.remote.port(),
                           ec ? ec.message() : "ok",
                           bytes_transferred);
           return;
-        } else {
-          CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", port={}, rc={}, bytes_received={}{:a}",
-                          self->connection_endpoints_.remote_address,
-                          self->connection_endpoints_.remote.port(),
-                          ec ? ec.message() : "ok",
-                          bytes_transferred,
-                          spdlog::to_hex(self->input_buffer_.data(),
-                                         self->input_buffer_.data() +
-                                           static_cast<std::ptrdiff_t>(bytes_transferred)));
         }
+        CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", port={}, rc={}, bytes_received={}{:a}",
+                        self->connection_endpoints_.remote_address,
+                        self->connection_endpoints_.remote.port(),
+                        ec ? ec.message() : "ok",
+                        bytes_transferred,
+                        spdlog::to_hex(self->input_buffer_.data(),
+                                       self->input_buffer_.data() +
+                                         static_cast<std::ptrdiff_t>(bytes_transferred)));
+
         self->last_active_ = std::chrono::steady_clock::now();
         if (ec) {
+          self->reading_ = false;
           if (stream_id != self->stream_->id()) {
             CB_LOG_ERROR(
               R"({} ignore IO error while reading from the socket: {} ({}), old_id="{}", new_id="{}")",
@@ -1776,7 +1973,7 @@ private:
     if (stopped_ || !stream_->is_open()) {
       return;
     }
-    std::scoped_lock lock(writing_buffer_mutex_, output_buffer_mutex_);
+    const std::scoped_lock lock(writing_buffer_mutex_, output_buffer_mutex_);
     if (!writing_buffer_.empty() || output_buffer_.empty()) {
       return;
     }
@@ -1812,7 +2009,7 @@ private:
           return self->stop(retry_reason::socket_closed_while_in_flight);
         }
         {
-          std::scoped_lock inner_lock(self->writing_buffer_mutex_);
+          const std::scoped_lock inner_lock(self->writing_buffer_mutex_);
           self->writing_buffer_.clear();
         }
         asio::post(asio::bind_executor(self->ctx_, [self]() {
@@ -1835,7 +2032,7 @@ private:
   std::optional<std::string> bucket_name_;
   mcbp_parser parser_;
   std::shared_ptr<bootstrap_handler> bootstrap_handler_{ nullptr };
-  std::optional<std::string> last_bootstrap_error_message_;
+  std::optional<impl::bootstrap_error> last_bootstrap_error_;
   std::shared_ptr<message_handler> handler_{ nullptr };
   utils::movable_function<void(std::error_code, const topology::configuration&)>
     bootstrap_callback_{};
@@ -1887,15 +2084,20 @@ private:
   std::string log_prefix_{};
   std::chrono::time_point<std::chrono::steady_clock> last_active_{};
   std::atomic<diag::endpoint_state> state_{ diag::endpoint_state::disconnected };
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  std::shared_ptr<columnar::background_bootstrap_listener> background_bootstrap_listener_{
+    nullptr
+  };
+#endif
 };
 
-mcbp_session::mcbp_session(std::string client_id,
+mcbp_session::mcbp_session(const std::string& client_id,
                            asio::io_context& ctx,
                            core::origin origin,
                            std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                            std::optional<std::string> bucket_name,
                            std::vector<protocol::hello_feature> known_features)
-  : impl_{ std::make_shared<mcbp_session_impl>(std::move(client_id),
+  : impl_{ std::make_shared<mcbp_session_impl>(client_id,
                                                ctx,
                                                std::move(origin),
                                                std::move(state_listener),
@@ -1904,14 +2106,14 @@ mcbp_session::mcbp_session(std::string client_id,
 {
 }
 
-mcbp_session::mcbp_session(std::string client_id,
+mcbp_session::mcbp_session(const std::string& client_id,
                            asio::io_context& ctx,
                            asio::ssl::context& tls,
                            core::origin origin,
                            std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                            std::optional<std::string> bucket_name,
                            std::vector<protocol::hello_feature> known_features)
-  : impl_{ std::make_shared<mcbp_session_impl>(std::move(client_id),
+  : impl_{ std::make_shared<mcbp_session_impl>(client_id,
                                                ctx,
                                                tls,
                                                std::move(origin),
@@ -2011,6 +2213,18 @@ mcbp_session::bootstrap_port_number() const -> std::uint16_t
   return impl_->bootstrap_port_number();
 }
 
+auto
+mcbp_session::last_bootstrap_error() && -> std::optional<impl::bootstrap_error>
+{
+  return std::move(impl_)->last_bootstrap_error();
+}
+
+auto
+mcbp_session::last_bootstrap_error() const& -> const std::optional<impl::bootstrap_error>&
+{
+  return impl_->last_bootstrap_error();
+}
+
 void
 mcbp_session::write_and_subscribe(std::uint32_t opaque,
                                   std::vector<std::byte>&& data,
@@ -2076,10 +2290,10 @@ mcbp_session::supported_features() const -> std::vector<protocol::hello_feature>
 }
 
 void
-mcbp_session::ping(std::shared_ptr<diag::ping_reporter> handler,
+mcbp_session::ping(const std::shared_ptr<diag::ping_reporter>& handler,
                    std::optional<std::chrono::milliseconds> timeout) const
 {
-  return impl_->ping(std::move(handler), std::move(timeout));
+  return impl_->ping(handler, timeout);
 }
 
 auto
@@ -2107,10 +2321,10 @@ mcbp_session::update_collection_uid(const std::string& path, std::uint32_t uid)
 }
 
 void
-mcbp_session::write_and_subscribe(std::shared_ptr<mcbp::queue_request> request,
-                                  std::shared_ptr<response_handler> handler)
+mcbp_session::write_and_subscribe(const std::shared_ptr<mcbp::queue_request>& request,
+                                  const std::shared_ptr<response_handler>& handler)
 {
-  return impl_->write_and_subscribe(std::move(request), std::move(handler));
+  return impl_->write_and_subscribe(request, handler);
 }
 
 void
@@ -2119,4 +2333,13 @@ mcbp_session::write_and_flush(std::vector<std::byte>&& buffer)
   return impl_->write_and_flush(std::move(buffer));
 }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+void
+mcbp_session::add_background_bootstrap_listener(
+  std::shared_ptr<columnar::background_bootstrap_listener> listener)
+{
+  return impl_->add_background_bootstrap_listener(std::move(listener));
+}
+#endif
+
 } // namespace couchbase::core::io