couchbase 4.4.2 → 4.4.3

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);
@@ -450,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;
@@ -584,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));
@@ -723,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;
@@ -756,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
@@ -787,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);
@@ -798,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();
     }
   }
@@ -881,8 +929,8 @@ 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_{};
@@ -898,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_{};

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

@@ -18,6 +18,8 @@
 #pragma once
 
 #include "core/document_id_fmt.hxx"
+#include "core/error_context/key_value_error_map_info.hxx"
+#include "core/metrics/meter_wrapper.hxx"
 #include "core/platform/uuid.h"
 #include "core/protocol/client_request.hxx"
 #include "core/protocol/client_response.hxx"
@@ -30,7 +32,6 @@
 #include "mcbp_traits.hxx"
 #include "retry_orchestrator.hxx"
 
-#include "core/error_context/key_value_error_map_info.hxx"
 #include <couchbase/durability_level.hxx>
 #include <couchbase/error_codes.hxx>
 
@@ -98,12 +99,12 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
 
   void start(mcbp_command_handler&& handler)
   {
-    span_ = manager_->tracer()->start_span(
+    span_ = manager_->tracer()->create_span(
       tracing::span_name_for_mcbp_command(encoded_request_type::body_type::opcode), parent_span);
-    if (span_->uses_tags())
+    if (span_->uses_tags()) {
       span_->add_tag(tracing::attributes::service, tracing::service::key_value);
-    if (span_->uses_tags())
       span_->add_tag(tracing::attributes::instance, request.id.bucket());
+    }
 
     handler_ = std::move(handler);
     deadline.expires_after(timeout_);
@@ -223,8 +224,9 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
   {
     opaque_ = session_->next_opaque();
     request.opaque = *opaque_;
-    if (span_->uses_tags())
+    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());
@@ -265,16 +267,15 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
         retry_reason reason,
         io::mcbp_message&& msg,
         std::optional<key_value_error_map_info> /* error_info */) mutable {
-        static std::string meter_name = "db.couchbase.operations";
-        static std::map<std::string, std::string> tags = {
-          { "db.couchbase.service", "kv" },
-          { "db.operation", fmt::format("{}", encoded_request_type::body_type::opcode) },
+        metrics::metric_attributes attrs{
+          service_type::key_value,
+          fmt::format("{}", encoded_request_type::body_type::opcode),
+          ec,
+          self->request.id.bucket(),
+          self->request.id.scope(),
+          self->request.id.collection(),
         };
-        self->manager_->meter()
-          ->get_value_recorder(meter_name, tags)
-          ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(
-                           std::chrono::steady_clock::now() - start)
-                           .count());
+        self->manager_->meter()->record_value(std::move(attrs), start);
 
         self->retry_backoff.cancel();
         if (ec == asio::error::operation_aborted) {

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

@@ -1084,20 +1084,20 @@ public:
       return;
     }
     bootstrapped_ = false;
-    if (bootstrap_handler_) {
-      last_bootstrap_error_ = std::move(bootstrap_handler_)->last_bootstrap_error();
+    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
@@ -1174,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;
@@ -1653,6 +1667,7 @@ public:
 private:
   void invoke_bootstrap_handler(std::error_code ec)
   {
+    connection_deadline_.cancel();
     retry_backoff_.cancel();
 
     if (ec && state_listener_) {
@@ -1716,6 +1731,7 @@ 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());
@@ -1734,9 +1750,7 @@ 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();
     });
   }
 
@@ -1768,12 +1782,7 @@ private:
                        port,
                        self->bootstrap_hostname_,
                        self->bootstrap_port_);
-          return self->stream_->close([self](std::error_code ec) {
-            self->last_bootstrap_error_ = {
-              ec, ec.message(), self->bootstrap_hostname_, self->bootstrap_port_
-            };
-            self->initiate_bootstrap();
-          });
+          self->initiate_bootstrap();
         });
       stream_->async_connect(it->endpoint(), [capture0 = shared_from_this(), it](auto&& PH1) {
         capture0->on_connect(std::forward<decltype(PH1)>(PH1), it);
@@ -1801,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
@@ -1853,23 +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([capture0 = shared_from_this()](auto&& PH1) {
-      capture0->check_deadline(std::forward<decltype(PH1)>(PH1));
-    });
   }
 
   void do_read()
@@ -1883,6 +1896,7 @@ 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(),
@@ -1901,6 +1915,7 @@ private:
 
         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="{}")",