couchbase 4.4.1 → 4.4.3

package/deps/couchbase-cxx-client/core/io/http_command.hxx

@@ -19,13 +19,15 @@
 
 #include <couchbase/build_config.hxx>
 
+#include "core/impl/bootstrap_error.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_session.hxx"
 #include "http_traits.hxx"
 
-#include <couchbase/metrics/meter.hxx>
 #include <couchbase/tracing/request_tracer.hxx>
 
 #include <utility>
@@ -33,7 +35,11 @@
 namespace couchbase::core::operations
 {
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+using http_command_handler = utils::movable_function<void(error_union, io::http_response&&)>;
+#else
 using http_command_handler = utils::movable_function<void(std::error_code, io::http_response&&)>;
+#endif
 
 template<typename Request>
 struct http_command : public std::enable_shared_from_this<http_command<Request>> {
@@ -43,9 +49,9 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
   asio::steady_timer deadline;
   Request request;
   encoded_request_type encoded;
-  std::shared_ptr<couchbase::tracing::request_tracer> tracer_;
+  std::shared_ptr<tracing::tracer_wrapper> tracer_;
   std::shared_ptr<couchbase::tracing::request_span> span_{ nullptr };
-  std::shared_ptr<couchbase::metrics::meter> meter_{};
+  std::shared_ptr<metrics::meter_wrapper> meter_{};
   std::shared_ptr<io::http_session> session_{};
   http_command_handler handler_{};
   std::chrono::milliseconds timeout_{};
@@ -57,8 +63,8 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
 
   http_command(asio::io_context& ctx,
                Request req,
-               std::shared_ptr<couchbase::tracing::request_tracer> tracer,
-               std::shared_ptr<couchbase::metrics::meter> meter,
+               std::shared_ptr<tracing::tracer_wrapper> tracer,
+               std::shared_ptr<metrics::meter_wrapper> meter,
                std::chrono::milliseconds default_timeout,
                std::chrono::milliseconds dispatch_timeout)
     : deadline(ctx)
@@ -77,8 +83,8 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
 #else
   http_command(asio::io_context& ctx,
                Request req,
-               std::shared_ptr<couchbase::tracing::request_tracer> tracer,
-               std::shared_ptr<couchbase::metrics::meter> meter,
+               std::shared_ptr<tracing::tracer_wrapper> tracer,
+               std::shared_ptr<metrics::meter_wrapper> meter,
                std::chrono::milliseconds default_timeout)
     : deadline(ctx)
     , request(req)
@@ -108,12 +114,13 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
 
   void start(http_command_handler&& handler)
   {
-    span_ = tracer_->start_span(tracing::span_name_for_http_service(request.type), parent_span);
-    if (span_->uses_tags())
+    span_ = tracer_->create_span(tracing::span_name_for_http_service(request.type), parent_span);
+    if (span_->uses_tags()) {
       span_->add_tag(tracing::attributes::service,
                      tracing::service_name_for_http_service(request.type));
-    if (span_->uses_tags())
       span_->add_tag(tracing::attributes::operation_id, client_context_id_);
+    }
+
     handler_ = std::move(handler);
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
     dispatch_deadline_.expires_after(dispatch_timeout_);
@@ -158,17 +165,24 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
     }
   }
 
+#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 (span_ != nullptr) {
       span_->end();
       span_ = nullptr;
     }
     if (auto handler = std::move(handler_); handler) {
-      handler(ec, std::move(msg));
-    }
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+      handler(error, std::move(msg));
+    }
     dispatch_deadline_.cancel();
+#else
+      handler(ec, std::move(msg));
+    }
 #endif
     deadline.cancel();
   }
@@ -231,15 +245,12 @@ private:
           return self->invoke_handler(errc::common::ambiguous_timeout, std::move(msg));
         }
         if (self->meter_) {
-          static std::string meter_name = "db.couchbase.operations";
-          static std::map<std::string, std::string> tags = {
-            { "db.couchbase.service", fmt::format("{}", self->request.type) },
-            { "db.operation", self->encoded.path },
+          metrics::metric_attributes attrs{
+            service_type::key_value,
+            fmt::format("{}", self->encoded.path),
+            ec,
           };
-          self->meter_->get_value_recorder(meter_name, tags)
-            ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(
-                             std::chrono::steady_clock::now() - start)
-                             .count());
+          self->meter_->record_value(std::move(attrs), start);
         }
         self->deadline.cancel();
         self->finish_dispatch(self->session_->remote_address(), self->session_->local_address());

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

@@ -243,7 +243,10 @@ http_session::endpoint() -> const asio::ip::tcp::endpoint&
 void
 http_session::connect(utils::movable_function<void()>&& callback)
 {
-  connect_callback_ = std::move(callback);
+  {
+    const std::scoped_lock lock(connect_callback_mutex_);
+    connect_callback_ = std::move(callback);
+  }
   initiate_connect();
 }
 
@@ -276,9 +279,7 @@ http_session::initiate_connect()
       if (ec == asio::error::operation_aborted || self->stopped_) {
         return;
       }
-      if (auto callback = std::move(self->connect_callback_); callback) {
-        callback();
-      }
+      self->invoke_connect_callback();
     });
     return;
   }
@@ -309,6 +310,19 @@ http_session::cancel_current_response(std::error_code ec)
   }
 }
 
+void
+http_session::invoke_connect_callback()
+{
+  utils::movable_function<void()> cb;
+  {
+    const std::scoped_lock lock(connect_callback_mutex_);
+    cb = std::move(connect_callback_);
+  }
+  if (cb) {
+    cb();
+  }
+}
+
 void
 http_session::stop()
 {
@@ -319,12 +333,10 @@ http_session::stop()
   state_ = diag::endpoint_state::disconnecting;
   stream_->close([](std::error_code) {
   });
+  invoke_connect_callback();
   connect_deadline_timer_.cancel();
   idle_timer_.cancel();
   retry_backoff_.cancel();
-  if (connect_callback_) {
-    connect_callback_ = nullptr;
-  }
 
   cancel_current_response(errc::common::request_canceled);
 
@@ -383,10 +395,17 @@ http_session::flush()
 void
 http_session::write_and_stream(
   io::http_request& request,
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+  utils::movable_function<void(couchbase::core::error_union, io::http_streaming_response)>
+    resp_handler,
+#else
   utils::movable_function<void(std::error_code, io::http_streaming_response)> resp_handler,
+#endif
   utils::movable_function<void()> stream_end_handler)
 {
   if (stopped_) {
+    resp_handler(errc::common::request_canceled, {});
+    stream_end_handler();
     return;
   }
   {
@@ -627,9 +646,7 @@ http_session::on_connect(const std::error_code& ec,
       info_ = http_session_info(client_id_, id_, stream_->local_endpoint(), it->endpoint());
     }
     connect_deadline_timer_.cancel();
-    if (auto callback = std::move(connect_callback_); callback) {
-      callback();
-    }
+    invoke_connect_callback();
     flush();
   }
 }

package/deps/couchbase-cxx-client/core/io/http_session.hxx

@@ -17,7 +17,10 @@
 
 #pragma once
 
+#include <couchbase/build_config.hxx>
+
 #include "core/diagnostics.hxx"
+#include "core/impl/bootstrap_error.hxx"
 #include "core/origin.hxx"
 #include "core/platform/base64.h"
 #include "core/utils/movable_function.hxx"
@@ -140,10 +143,15 @@ public:
     flush();
   }
 
-  void write_and_stream(
-    io::http_request& request,
-    utils::movable_function<void(std::error_code, io::http_streaming_response)> resp_handler,
-    utils::movable_function<void()> stream_end_handler);
+  void write_and_stream(io::http_request& request,
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+                        utils::movable_function<void(couchbase::core::error_union,
+                                                     io::http_streaming_response)> resp_handler,
+#else
+                        utils::movable_function<void(std::error_code, io::http_streaming_response)>
+                          resp_handler,
+#endif
+                        utils::movable_function<void()> stream_end_handler);
 
   void set_idle(std::chrono::milliseconds timeout);
   auto reset_idle() -> bool;
@@ -155,7 +163,12 @@ public:
 
 private:
   struct streaming_response_context {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    utils::movable_function<void(couchbase::core::error_union, io::http_streaming_response)>
+      resp_handler{};
+#else
     utils::movable_function<void(std::error_code, io::http_streaming_response)> resp_handler{};
+#endif
     utils::movable_function<void()> stream_end_handler{};
     std::optional<io::http_streaming_response> resp{};
     http_streaming_parser parser{};
@@ -177,6 +190,7 @@ private:
   void write(const std::string_view& buf);
   void flush();
   void cancel_current_response(std::error_code ec);
+  void invoke_connect_callback();
 
   service_type type_{};
   std::string client_id_;
@@ -199,6 +213,7 @@ private:
   std::atomic_bool reading_{ false };
 
   utils::movable_function<void()> connect_callback_{};
+  std::mutex connect_callback_mutex_{};
   std::function<void()> on_stop_handler_{ nullptr };
 
   response_context current_response_{};

package/deps/couchbase-cxx-client/core/io/http_session_manager.hxx

@@ -24,10 +24,11 @@
 #include "core/columnar/bootstrap_notification_subscriber.hxx"
 #endif
 #include "core/logger/logger.hxx"
+#include "core/metrics/meter_wrapper.hxx"
 #include "core/operations/http_noop.hxx"
 #include "core/service_type.hxx"
 #include "core/tracing/noop_tracer.hxx"
-#include "couchbase/metrics/meter.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 #include "http_command.hxx"
 #include "http_context.hxx"
 #include "http_session.hxx"
@@ -63,12 +64,12 @@ public:
   {
   }
 
-  void set_tracer(std::shared_ptr<couchbase::tracing::request_tracer> tracer)
+  void set_tracer(std::shared_ptr<tracing::tracer_wrapper> tracer)
   {
     tracer_ = std::move(tracer);
   }
 
-  void set_meter(std::shared_ptr<couchbase::metrics::meter> meter)
+  void set_meter(std::shared_ptr<metrics::meter_wrapper> meter)
   {
     meter_ = std::move(meter);
   }
@@ -91,6 +92,7 @@ public:
     if (allow_fast_fail_) {
       std::scoped_lock bootstrap_error_lock(last_bootstrap_error_mutex_);
       last_bootstrap_error_ = error;
+      drain_deferred_queue(last_bootstrap_error_.value());
     }
   }
 
@@ -222,14 +224,19 @@ public:
             ctx_, request, tracer_, meter_, options_.default_timeout_for(request.type));
 #endif
 
-          cmd->start(
-            [start = std::chrono::steady_clock::now(),
-             self = shared_from_this(),
-             type,
-             cmd,
-             handler = collector->build_reporter()](std::error_code ec, io::http_response&& msg) {
-              diag::ping_state state = diag::ping_state::ok;
-              std::optional<std::string> error{};
+          cmd->start([start = std::chrono::steady_clock::now(),
+                      self = shared_from_this(),
+                      type,
+                      cmd,
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+                      handler = collector->build_reporter()](error_union err,
+                                                             io::http_response&& msg) {
+            diag::ping_state state = diag::ping_state::ok;
+            std::optional<std::string> error{};
+            if (!std::holds_alternative<std::monostate>(err)) {
+              auto ec = std::holds_alternative<impl::bootstrap_error>(err)
+                          ? std::get<impl::bootstrap_error>(err).ec
+                          : std::get<std::error_code>(err);
               if (ec) {
                 if (ec == errc::common::unambiguous_timeout ||
                     ec == errc::common::ambiguous_timeout) {
@@ -240,25 +247,42 @@ public:
                 error.emplace(fmt::format(
                   "code={}, message={}, http_code={}", ec.value(), ec.message(), msg.status_code));
               }
-              auto remote_address = cmd->session_->remote_address();
-              // If not connected, the remote address will be empty.  Better to
-              // give the user some context on the "attempted" remote address.
-              if (remote_address.empty()) {
-                remote_address =
-                  fmt::format("{}:{}", cmd->session_->hostname(), cmd->session_->port());
+            }
+#else
+                      handler = collector->build_reporter()](std::error_code ec,
+                                                             io::http_response&& msg) {
+            diag::ping_state state = diag::ping_state::ok;
+            std::optional<std::string> error{};
+            if (ec) {
+              if (ec == errc::common::unambiguous_timeout ||
+                  ec == errc::common::ambiguous_timeout) {
+                state = diag::ping_state::timeout;
+              } else {
+                state = diag::ping_state::error;
               }
-              handler->report(
-                diag::endpoint_ping_info{ type,
-                                          cmd->session_->id(),
-                                          std::chrono::duration_cast<std::chrono::microseconds>(
-                                            std::chrono::steady_clock::now() - start),
-                                          remote_address,
-                                          cmd->session_->local_address(),
-                                          state,
-                                          {},
-                                          error });
-              self->check_in(type, cmd->session_);
-            });
+              error.emplace(fmt::format(
+                "code={}, message={}, http_code={}", ec.value(), ec.message(), msg.status_code));
+            }
+#endif
+            auto remote_address = cmd->session_->remote_address();
+            // If not connected, the remote address will be empty.  Better to
+            // give the user some context on the "attempted" remote address.
+            if (remote_address.empty()) {
+              remote_address =
+                fmt::format("{}:{}", cmd->session_->hostname(), cmd->session_->port());
+            }
+            handler->report(
+              diag::endpoint_ping_info{ type,
+                                        cmd->session_->id(),
+                                        std::chrono::duration_cast<std::chrono::microseconds>(
+                                          std::chrono::steady_clock::now() - start),
+                                        remote_address,
+                                        cmd->session_->local_address(),
+                                        state,
+                                        {},
+                                        error });
+            self->check_in(type, cmd->session_);
+          });
           cmd->set_command_session(session);
           if (!session->is_connected()) {
             connect_then_send(session, cmd, {}, true);
@@ -283,13 +307,16 @@ public:
       }
     }
 
-    std::scoped_lock lock(sessions_mutex_);
+    const std::scoped_lock lock(sessions_mutex_);
     idle_sessions_[type].remove_if([](const auto& s) {
       return !s;
     });
     busy_sessions_[type].remove_if([](const auto& s) {
       return !s;
     });
+    pending_sessions_[type].remove_if([](const auto& s) {
+      return !s;
+    });
     std::shared_ptr<http_session> session{};
     while (!idle_sessions_[type].empty()) {
       if (preferred_node.empty()) {
@@ -337,6 +364,8 @@ public:
     }
     if (session->is_connected()) {
       busy_sessions_[type].push_back(session);
+    } else {
+      pending_sessions_[type].push_back(session);
     }
     return { {}, session };
   }
@@ -370,6 +399,9 @@ public:
       busy_sessions_[type].remove_if([id = session->id()](const auto& s) -> bool {
         return !s || s->id() == id;
       });
+      pending_sessions_[type].remove_if([id = session->id()](const auto& s) -> bool {
+        return !s || s->id() == id;
+      });
     }
   }
 
@@ -378,8 +410,15 @@ public:
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
     drain_deferred_queue(errc::common::request_canceled);
 #endif
-    std::scoped_lock lock(sessions_mutex_);
-    for (auto& [type, sessions] : idle_sessions_) {
+    std::map<service_type, std::list<std::shared_ptr<http_session>>> busy_sessions, idle_sessions,
+      pending_sessions;
+    {
+      const std::scoped_lock lock(sessions_mutex_);
+      busy_sessions = std::move(busy_sessions_);
+      idle_sessions = std::move(idle_sessions_);
+      pending_sessions = std::move(pending_sessions_);
+    }
+    for (auto& [type, sessions] : idle_sessions) {
       for (auto& s : sessions) {
         if (s) {
           s->reset_idle();
@@ -387,7 +426,20 @@ public:
         }
       }
     }
-    busy_sessions_.clear();
+    for (auto& [type, sessions] : busy_sessions) {
+      for (auto& s : sessions) {
+        if (s) {
+          s->stop();
+        }
+      }
+    }
+    for (auto& [type, sessions] : pending_sessions) {
+      for (auto& s : sessions) {
+        if (s) {
+          s->stop();
+        }
+      }
+    }
   }
 
   template<typename Request, typename Handler>
@@ -422,18 +474,37 @@ public:
       meter_,
       options_.default_timeout_for(request.type),
       dispatch_timeout_);
+    cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
+                 error_union err, io::http_response&& msg) mutable {
 #else
     auto cmd = std::make_shared<operations::http_command<Request>>(
       ctx_, request, tracer_, meter_, options_.default_timeout_for(request.type));
-#endif
     cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
                  std::error_code ec, io::http_response&& msg) mutable {
+#endif
       using command_type = typename decltype(cmd)::element_type;
       using encoded_response_type = typename command_type::encoded_response_type;
       using error_context_type = typename command_type::error_context_type;
       encoded_response_type resp{ std::move(msg) };
       error_context_type ctx{};
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+      if (!std::holds_alternative<std::monostate>(err)) {
+        if (std::holds_alternative<impl::bootstrap_error>(err)) {
+          auto bootstrap_error = std::get<impl::bootstrap_error>(err);
+          if (bootstrap_error.ec == errc::common::unambiguous_timeout) {
+            CB_LOG_DEBUG("Timeout caused by bootstrap error. code={}, ec_message={}, message={}.",
+                         bootstrap_error.ec.value(),
+                         bootstrap_error.ec.message(),
+                         bootstrap_error.error_message);
+          }
+          ctx.ec = bootstrap_error.ec;
+        } else {
+          ctx.ec = std::get<std::error_code>(err);
+        }
+      }
+#else
       ctx.ec = ec;
+#endif
       ctx.client_context_id = cmd->client_context_id_;
       ctx.method = cmd->encoded.method;
       ctx.path = cmd->encoded.path;
@@ -471,7 +542,7 @@ public:
   {
     session->connect([self = shared_from_this(),
                       session,
-                      preferred_node = std::move(preferred_node),
+                      preferred_node,
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
                       dispatch_deadline,
 #endif
@@ -480,13 +551,20 @@ public:
       if (!session->is_connected()) {
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
         auto now = std::chrono::steady_clock::now();
+        if (session->is_stopped()) {
+          // Session was forced to stop (e.g. due to cluster being closed or cancellation)
+          cb(errc::common::request_canceled, {});
+          return;
+        }
         if (dispatch_deadline < now || deadline < now) {
           session->stop();
+          cb(errc::common::unambiguous_timeout, {});
           return;
         }
 #else
         if (deadline < std::chrono::steady_clock::now()) {
           session->stop();
+          return cb(errc::common::unambiguous_timeout, {});
           return;
         }
 #endif
@@ -504,12 +582,16 @@ public:
           self->create_session(session->type(), session->credentials(), hostname, port);
         if (new_session->is_connected()) {
           {
-            std::scoped_lock inner_lock(self->sessions_mutex_);
+            const std::scoped_lock inner_lock(self->sessions_mutex_);
             self->busy_sessions_[new_session->type()].push_back(new_session);
           }
           cb({}, new_session);
         } else {
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+          {
+            const std::scoped_lock inner_lock(self->sessions_mutex_);
+            self->pending_sessions_[new_session->type()].push_back(new_session);
+          }
           self->connect_then_send_pending_op(
             new_session, preferred_node, dispatch_deadline, deadline, cb);
 #else
@@ -521,17 +603,23 @@ public:
         auto now = std::chrono::steady_clock::now();
         if (dispatch_deadline < now || deadline < now) {
           session->stop();
+          cb(errc::common::unambiguous_timeout, {});
           return;
         }
 #else
         if (deadline < std::chrono::steady_clock::now()) {
           session->stop();
+          cb(errc::common::unambiguous_timeout, {});
           return;
         }
 #endif
         {
-          std::scoped_lock inner_lock(self->sessions_mutex_);
+          const std::scoped_lock inner_lock(self->sessions_mutex_);
           self->busy_sessions_[session->type()].push_back(session);
+          self->pending_sessions_[session->type()].remove_if(
+            [id = session->id()](const auto& s) -> bool {
+              return !s || s->id() == id;
+            });
         }
         cb({}, session);
       }
@@ -539,7 +627,7 @@ public:
   }
 
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-  void add_to_deferred_queue(utils::movable_function<void(std::error_code)> command)
+  void add_to_deferred_queue(utils::movable_function<void(error_union)> command)
   {
     const std::scoped_lock lock_for_deferred_commands(deferred_commands_mutex_);
     deferred_commands_.emplace(std::move(command));
@@ -678,20 +766,25 @@ private:
       options_.default_timeout_for(request.type),
       dispatch_timeout_);
     cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
-                 std::error_code ec, io::http_response&& msg) mutable {
+                 error_union err, io::http_response&& msg) mutable {
       using command_type = typename decltype(cmd)::element_type;
       using encoded_response_type = typename command_type::encoded_response_type;
       using error_context_type = typename command_type::error_context_type;
       encoded_response_type resp{ std::move(msg) };
       error_context_type ctx{};
-      if (self->last_bootstrap_error_.has_value() && ec == errc::common::unambiguous_timeout) {
-        CB_LOG_DEBUG("Timeout caused by bootstrap error. code={}, ec_message={}, message={}.",
-                     self->last_bootstrap_error_.value().ec.value(),
-                     self->last_bootstrap_error_.value().ec.message(),
-                     self->last_bootstrap_error_.value().error_message);
-        ctx.ec = self->last_bootstrap_error_.value().ec;
-      } else {
-        ctx.ec = ec;
+      if (!std::holds_alternative<std::monostate>(err)) {
+        if (std::holds_alternative<impl::bootstrap_error>(err)) {
+          auto bootstrap_error = std::get<impl::bootstrap_error>(err);
+          if (bootstrap_error.ec == errc::common::unambiguous_timeout) {
+            CB_LOG_DEBUG("Timeout caused by bootstrap error. code={}, ec_message={}, message={}.",
+                         bootstrap_error.ec.value(),
+                         bootstrap_error.ec.message(),
+                         bootstrap_error.error_message);
+          }
+          ctx.ec = bootstrap_error.ec;
+        } else {
+          ctx.ec = std::get<std::error_code>(err);
+        }
       }
       ctx.client_context_id = cmd->client_context_id_;
       ctx.method = cmd->encoded.method;
@@ -711,10 +804,10 @@ private:
                  cmd->request.type,
                  cmd->client_context_id_);
     add_to_deferred_queue(
-      [self = shared_from_this(), cmd, request, credentials](std::error_code ec) mutable {
-        if (ec) {
+      [self = shared_from_this(), cmd, request, credentials](error_union err) mutable {
+        if (!std::holds_alternative<std::monostate>(err)) {
           using response_type = typename Request::encoded_response_type;
-          return cmd->invoke_handler(ec, response_type{});
+          return cmd->invoke_handler(err, response_type{});
         }
 
         // don't do anything if the command wasn't dispatched or has already timed out
@@ -742,9 +835,9 @@ private:
       });
   }
 
-  void drain_deferred_queue(std::error_code ec)
+  void drain_deferred_queue(error_union err)
   {
-    std::queue<utils::movable_function<void(std::error_code)>> commands{};
+    std::queue<utils::movable_function<void(error_union)>> commands{};
     {
       const std::scoped_lock lock(deferred_commands_mutex_);
       std::swap(deferred_commands_, commands);
@@ -753,7 +846,7 @@ private:
       CB_LOG_TRACE("Draining deferred operation queue, size={}", commands.size());
     }
     while (!commands.empty()) {
-      commands.front()(ec);
+      commands.front()(err);
       commands.pop();
     }
   }
@@ -836,14 +929,15 @@ private:
   std::string client_id_;
   asio::io_context& ctx_;
   asio::ssl::context& tls_;
-  std::shared_ptr<couchbase::tracing::request_tracer> tracer_{ nullptr };
-  std::shared_ptr<couchbase::metrics::meter> meter_{ nullptr };
+  std::shared_ptr<tracing::tracer_wrapper> tracer_{ nullptr };
+  std::shared_ptr<metrics::meter_wrapper> meter_{ nullptr };
   cluster_options options_{};
 
   topology::configuration config_{};
   mutable std::mutex config_mutex_{};
   std::map<service_type, std::list<std::shared_ptr<http_session>>> busy_sessions_{};
   std::map<service_type, std::list<std::shared_ptr<http_session>>> idle_sessions_{};
+  std::map<service_type, std::list<std::shared_ptr<http_session>>> pending_sessions_{};
   std::size_t next_index_{ 0 };
   std::mutex next_index_mutex_{};
   std::mutex sessions_mutex_{};
@@ -852,7 +946,7 @@ private:
   std::atomic_bool configured_{ false };
   std::chrono::milliseconds dispatch_timeout_{};
   std::atomic_bool allow_fast_fail_{ true };
-  std::queue<utils::movable_function<void(std::error_code)>> deferred_commands_{};
+  std::queue<utils::movable_function<void(error_union)>> deferred_commands_{};
   std::mutex deferred_commands_mutex_{};
   std::optional<impl::bootstrap_error> last_bootstrap_error_;
   std::mutex last_bootstrap_error_mutex_{};