couchbase 3.4.3 → 3.4.5

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

@@ -28,6 +28,10 @@
 #include <asio/read.hpp>
 #include <asio/write.hpp>
 
+#include <fmt/chrono.h>
+
+#include <spdlog/fmt/bin_to_hex.h>
+
 #include <memory>
 #include <sstream>
 
@@ -68,22 +72,50 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
 
     void execute(std::chrono::milliseconds total_timeout, std::chrono::milliseconds udp_timeout)
     {
+        CB_LOG_TRACE("Query DNS-SRV (UDP) address=\"{}:{}\", udp_timeout={}, total_timeout={}",
+                     address_.to_string(),
+                     port_,
+                     udp_timeout,
+                     total_timeout);
         asio::ip::udp::endpoint endpoint(address_, port_);
         udp_.open(endpoint.protocol());
+        CB_LOG_PROTOCOL("[DNS, UDP, OUT] host=\"{}\", port={}, buffer_size={}{:a}",
+                        address_.to_string(),
+                        port_,
+                        send_buf_.size(),
+                        spdlog::to_hex(send_buf_));
         udp_.async_send_to(
-          asio::buffer(send_buf_), endpoint, [self = shared_from_this()](std::error_code ec1, std::size_t /* bytes_transferred */) mutable {
+          asio::buffer(send_buf_), endpoint, [self = shared_from_this()](std::error_code ec1, std::size_t bytes_transferred1) mutable {
+              CB_LOG_PROTOCOL("[DNS, UDP, OUT] host=\"{}\", port={}, rc={}, bytes_sent={}",
+                              self->address_.to_string(),
+                              self->port_,
+                              ec1 ? ec1.message() : "ok",
+                              bytes_transferred1);
               if (ec1) {
                   self->udp_deadline_.cancel();
-                  CB_LOG_DEBUG("DNS UDP write operation has got error {}, retrying with TCP", ec1.message());
+                  CB_LOG_DEBUG("DNS UDP write operation has got error, retrying with TCP, address=\"{}:{}\", ec={}",
+                               self->address_.to_string(),
+                               self->port_,
+                               ec1.message());
                   return self->retry_with_tcp();
               }
 
               self->recv_buf_.resize(512);
               self->udp_.async_receive_from(
                 asio::buffer(self->recv_buf_), self->udp_sender_, [self](std::error_code ec2, std::size_t bytes_transferred) mutable {
+                    CB_LOG_PROTOCOL("[DNS, UDP, IN] host=\"{}\", port={}, rc={}, bytes_received={}{:a}",
+                                    self->address_.to_string(),
+                                    self->port_,
+                                    ec2 ? ec2.message() : "ok",
+                                    bytes_transferred,
+                                    spdlog::to_hex(self->recv_buf_.data(), self->recv_buf_.data() + bytes_transferred));
+
                     self->udp_deadline_.cancel();
                     if (ec2) {
-                        CB_LOG_DEBUG("DNS UDP read operation has got error {}, retrying with TCP", ec2.message());
+                        CB_LOG_DEBUG("DNS UDP read operation has got error, retrying with TCP, address=\"{}:{}\", ec={}",
+                                     self->address_.to_string(),
+                                     self->port_,
+                                     ec2.message());
                         return self->retry_with_tcp();
                     }
                     self->recv_buf_.resize(bytes_transferred);
@@ -104,11 +136,13 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
                 });
           });
         udp_deadline_.expires_after(udp_timeout);
-        deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
+        udp_deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
             if (ec == asio::error::operation_aborted) {
                 return;
             }
-            CB_LOG_DEBUG("DNS UDP deadline has been reached, cancelling UDP operation and fall back to TCP");
+            CB_LOG_DEBUG("DNS UDP deadline has been reached, cancelling UDP operation and fall back to TCP, address=\"{}:{}\"",
+                         self->address_.to_string(),
+                         self->port_);
             self->udp_.cancel();
             return self->retry_with_tcp();
         });
@@ -118,7 +152,10 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
             if (ec == asio::error::operation_aborted) {
                 return;
             }
-            CB_LOG_DEBUG("DNS deadline has been reached, cancelling in-flight operations (tcp.is_open={})", self->tcp_.is_open());
+            CB_LOG_DEBUG("DNS deadline has been reached, cancelling in-flight operations (tcp.is_open={}, address=\"{}:{}\")",
+                         self->tcp_.is_open(),
+                         self->address_.to_string(),
+                         self->port_);
             self->udp_.cancel();
             if (self->tcp_.is_open()) {
                 self->tcp_.cancel();
@@ -140,53 +177,87 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
         tcp_.async_connect(endpoint, [self = shared_from_this()](std::error_code ec1) mutable {
             if (ec1) {
                 self->deadline_.cancel();
-                CB_LOG_DEBUG("DNS TCP connection has been aborted, {}", ec1.message());
+                CB_LOG_DEBUG(
+                  "DNS TCP connection has been aborted, address=\"{}:{}\", ec={}", self->address_.to_string(), self->port_, ec1.message());
                 return self->handler_({ ec1 });
             }
             auto send_size = static_cast<std::uint16_t>(self->send_buf_.size());
             self->send_buf_.insert(self->send_buf_.begin(), static_cast<std::uint8_t>(send_size & 0xffU));
             self->send_buf_.insert(self->send_buf_.begin(), static_cast<std::uint8_t>(send_size >> 8U));
+            CB_LOG_PROTOCOL("[DNS, TCP, OUT] host=\"{}\", port={}, buffer_size={}{:a}",
+                            self->address_.to_string(),
+                            self->port_,
+                            self->send_buf_.size(),
+                            spdlog::to_hex(self->send_buf_));
             asio::async_write(
-              self->tcp_, asio::buffer(self->send_buf_), [self](std::error_code ec2, std::size_t /* bytes_transferred */) mutable {
+              self->tcp_, asio::buffer(self->send_buf_), [self](std::error_code ec2, std::size_t bytes_transferred2) mutable {
+                  CB_LOG_PROTOCOL("[DNS, TCP, OUT] host=\"{}\", port={}, rc={}, bytes_sent={}",
+                                  self->address_.to_string(),
+                                  self->port_,
+                                  ec2 ? ec2.message() : "ok",
+                                  bytes_transferred2);
                   if (ec2) {
-                      CB_LOG_DEBUG("DNS TCP write operation has been aborted, {}", ec2.message());
+                      CB_LOG_DEBUG("DNS TCP write operation has been aborted, address=\"{}:{}\", ec={}",
+                                   self->address_.to_string(),
+                                   self->port_,
+                                   ec2.message());
                       self->deadline_.cancel();
                       if (ec2 == asio::error::operation_aborted) {
                           ec2 = errc::common::unambiguous_timeout;
                       }
                       return self->handler_({ ec2 });
                   }
-                  asio::async_read(self->tcp_,
-                                   asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
-                                   [self](std::error_code ec3, std::size_t /* bytes_transferred */) mutable {
-                                       if (ec3) {
-                                           CB_LOG_DEBUG("DNS TCP buf size read operation has been aborted, {}", ec3.message());
-                                           self->deadline_.cancel();
-                                           return self->handler_({ ec3 });
-                                       }
-                                       self->recv_buf_size_ = utils::byte_swap(self->recv_buf_size_);
-                                       self->recv_buf_.resize(self->recv_buf_size_);
-                                       CB_LOG_DEBUG("DNS TCP schedule read of {} bytes", self->recv_buf_size_);
-                                       asio::async_read(self->tcp_,
-                                                        asio::buffer(self->recv_buf_),
-                                                        [self](std::error_code ec4, std::size_t bytes_transferred) mutable {
-                                                            self->deadline_.cancel();
-                                                            if (ec4) {
-                                                                CB_LOG_DEBUG("DNS TCP read operation has been aborted, {}", ec4.message());
-                                                                return self->handler_({ ec4 });
-                                                            }
-                                                            self->recv_buf_.resize(bytes_transferred);
-                                                            const dns_message message = dns_codec::decode(self->recv_buf_);
-                                                            dns_srv_response resp{ ec4 };
-                                                            resp.targets.reserve(message.answers.size());
-                                                            for (const auto& answer : message.answers) {
-                                                                resp.targets.emplace_back(dns_srv_response::address{
-                                                                  utils::join_strings(answer.target.labels, "."), answer.port });
-                                                            }
-                                                            CB_LOG_DEBUG("DNS TCP returned {} records", resp.targets.size());
-                                                            return self->handler_(std::move(resp));
-                                                        });
-                                   });
+                  asio::async_read(
+                    self->tcp_,
+                    asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
+                    [self](std::error_code ec3, std::size_t bytes_transferred3) mutable {
+                        CB_LOG_PROTOCOL("[DNS, TCP, IN] host=\"{}\", port={}, rc={}, bytes_received={}{:a}",
+                                        self->address_.to_string(),
+                                        self->port_,
+                                        ec3 ? ec3.message() : "ok",
+                                        bytes_transferred3,
+                                        spdlog::to_hex(reinterpret_cast<std::uint8_t*>(&self->recv_buf_size_),
+                                                       reinterpret_cast<std::uint8_t*>(&self->recv_buf_size_) + bytes_transferred3));
+                        if (ec3) {
+                            CB_LOG_DEBUG("DNS TCP buf size read operation has been aborted, address=\"{}:{}\", ec={}",
+                                         self->address_.to_string(),
+                                         self->port_,
+                                         ec3.message());
+                            self->deadline_.cancel();
+                            return self->handler_({ ec3 });
+                        }
+                        self->recv_buf_size_ = utils::byte_swap(self->recv_buf_size_);
+                        self->recv_buf_.resize(self->recv_buf_size_);
+                        CB_LOG_DEBUG("DNS TCP schedule read of {} bytes", self->recv_buf_size_);
+                        asio::async_read(
+                          self->tcp_, asio::buffer(self->recv_buf_), [self](std::error_code ec4, std::size_t bytes_transferred4) mutable {
+                              self->deadline_.cancel();
+                              CB_LOG_PROTOCOL("[DNS, TCP, IN] host=\"{}\", port={}, rc={}, bytes_received={}{:a}",
+                                              self->address_.to_string(),
+                                              self->port_,
+                                              ec4 ? ec4.message() : "ok",
+                                              bytes_transferred4,
+                                              spdlog::to_hex(self->recv_buf_.data(), self->recv_buf_.data() + bytes_transferred4));
+
+                              if (ec4) {
+                                  CB_LOG_DEBUG("DNS TCP read operation has been aborted, address=\"{}:{}\", ec={}",
+                                               self->address_.to_string(),
+                                               self->port_,
+                                               ec4.message());
+                                  return self->handler_({ ec4 });
+                              }
+                              self->recv_buf_.resize(bytes_transferred4);
+                              const dns_message message = dns_codec::decode(self->recv_buf_);
+                              dns_srv_response resp{ ec4 };
+                              resp.targets.reserve(message.answers.size());
+                              for (const auto& answer : message.answers) {
+                                  resp.targets.emplace_back(
+                                    dns_srv_response::address{ utils::join_strings(answer.target.labels, "."), answer.port });
+                              }
+                              CB_LOG_DEBUG("DNS TCP returned {} records", resp.targets.size());
+                              return self->handler_(std::move(resp));
+                          });
+                    });
               });
         });
     }

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

@@ -87,7 +87,7 @@ load_resolv_conf()
 
     if (dns_servers.size() > 0) {
         CB_LOG_DEBUG(
-          "Found DNS Servers: [{}], using nameserver: {}", couchbase::core::utils::join_strings(dns_servers, ", "), dns_servers[0]);
+          "Found DNS Servers: [{}], selected nameserver: \"{}\"", couchbase::core::utils::join_strings(dns_servers, ", "), dns_servers[0]);
         return dns_servers[0];
     }
     CB_LOG_WARNING("Unable to find DNS nameserver");
@@ -118,13 +118,13 @@ load_resolv_conf(const char* conf_path)
             if (space == std::string::npos || space == offset || line.size() < space + 2) {
                 continue;
             }
-            if (std::string keyword = line.substr(offset, space); keyword != "nameserver") {
+            if (const auto keyword = line.substr(offset, space); keyword != "nameserver") {
                 continue;
             }
             offset = space + 1;
             space = line.find(' ', offset);
-            auto nameserver = line.substr(offset, space);
-            CB_LOG_DEBUG("Using nameserver: {}", nameserver);
+            auto nameserver = (space == std::string::npos) ? line.substr(offset) : line.substr(offset, space - offset);
+            CB_LOG_DEBUG("Selected nameserver: \"{}\" from \"{}\"", nameserver, conf_path);
             return nameserver;
         }
     }
@@ -147,6 +147,7 @@ dns_config::system_config()
         std::error_code ec;
         asio::ip::address::from_string(nameserver, ec);
         if (ec) {
+            CB_LOG_DEBUG("Unable to parse \"{}\" as a network address, fall back to \"{}\"", nameserver, default_nameserver);
             nameserver = default_nameserver;
         }
         instance.nameserver_ = nameserver;

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

@@ -31,7 +31,10 @@
 
 #include <couchbase/error_codes.hxx>
 
+#include <spdlog/fmt/bin_to_hex.h>
+
 #include <asio.hpp>
+
 #include <list>
 #include <memory>
 #include <utility>
@@ -448,7 +451,20 @@ class http_session : public std::enable_shared_from_this<http_session>
         stream_->async_read_some(
           asio::buffer(input_buffer_), [self = shared_from_this()](std::error_code ec, std::size_t bytes_transferred) {
               if (ec == asio::error::operation_aborted || self->stopped_) {
+                  CB_LOG_PROTOCOL("[HTTP, IN] type={}, host=\"{}\", rc={}, bytes_received={}",
+                                  self->type_,
+                                  self->info_.remote_address(),
+                                  ec ? ec.message() : "ok",
+                                  bytes_transferred);
                   return;
+              } else {
+                  CB_LOG_PROTOCOL("[HTTP, IN] type={}, host=\"{}\", rc={}, bytes_received={}{:a}",
+                                  self->type_,
+                                  self->info_.remote_address(),
+                                  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) {
@@ -495,9 +511,16 @@ class http_session : public std::enable_shared_from_this<http_session>
         std::vector<asio::const_buffer> buffers;
         buffers.reserve(writing_buffer_.size());
         for (auto& buf : writing_buffer_) {
+            CB_LOG_PROTOCOL(
+              "[HTTP, OUT] type={}, host=\"{}\", buffer_size={}{:a}", type_, info_.remote_address(), buf.size(), spdlog::to_hex(buf));
             buffers.emplace_back(asio::buffer(buf));
         }
-        stream_->async_write(buffers, [self = shared_from_this()](std::error_code ec, std::size_t /* bytes_transferred */) {
+        stream_->async_write(buffers, [self = shared_from_this()](std::error_code ec, std::size_t bytes_transferred) {
+            CB_LOG_PROTOCOL("[HTTP, OUT] type={}, host=\"{}\", rc={}, bytes_sent={}",
+                            self->type_,
+                            self->info_.remote_address(),
+                            ec ? ec.message() : "ok",
+                            bytes_transferred);
             if (ec == asio::error::operation_aborted || self->stopped_) {
                 return;
             }

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

@@ -59,9 +59,13 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
     mcbp_command_handler handler_{};
     std::shared_ptr<Manager> manager_{};
     std::chrono::milliseconds timeout_{};
-    std::string id_{ uuid::to_string(uuid::random()) };
+    std::string id_{
+        fmt::format("{:02x}/{}", static_cast<std::uint8_t>(encoded_request_type::body_type::opcode), uuid::to_string(uuid::random()))
+    };
     std::shared_ptr<couchbase::tracing::request_span> span_{ nullptr };
     std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
+    std::optional<std::string> last_dispatched_from_{};
+    std::optional<std::string> last_dispatched_to_{};
 
     mcbp_command(asio::io_context& ctx, std::shared_ptr<Manager> manager, Request req, std::chrono::milliseconds default_timeout)
       : deadline(ctx)
@@ -109,7 +113,10 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
                 handler_ = nullptr;
             }
         }
-        invoke_handler(request.retries.idempotent() ? errc::common::unambiguous_timeout : errc::common::ambiguous_timeout);
+        invoke_handler(request.retries.idempotent() || !opaque_.has_value()
+                         ? errc::common::unambiguous_timeout // safe to retry or has not been sent to the server
+                         : errc::common::ambiguous_timeout   // non-idempotent and has been sent to the server
+        );
     }
 
     void invoke_handler(std::error_code ec, std::optional<io::mcbp_message>&& msg = {})

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

@@ -379,7 +379,7 @@ class mcbp_session_impl
                     Expects(protocol::is_valid_server_request_opcode(msg.header.opcode));
                     switch (static_cast<protocol::server_opcode>(msg.header.opcode)) {
                         case protocol::server_opcode::cluster_map_change_notification: {
-                            protocol::cmd_info info{ session_->endpoint_address_, session_->endpoint_.port() };
+                            protocol::cmd_info info{ session_->bootstrap_hostname_, session_->bootstrap_port_number_ };
                             if (session_->origin_.options().dump_configuration) {
                                 std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()), msg.body.size() };
                                 CB_LOG_TRACE(
@@ -404,7 +404,7 @@ class mcbp_session_impl
                             CB_LOG_WARNING("{} unexpected server request: opcode={:x}, opaque={}{:a}{:a}",
                                            session_->log_prefix_,
                                            msg.header.opcode,
-                                           msg.header.opaque,
+                                           utils::byte_swap(msg.header.opaque),
                                            spdlog::to_hex(msg.header_data()),
                                            spdlog::to_hex(msg.body));
                     }
@@ -416,7 +416,7 @@ class mcbp_session_impl
                                    session_->log_prefix_,
                                    magic,
                                    msg.header.opcode,
-                                   msg.header.opaque,
+                                   utils::byte_swap(msg.header.opaque),
                                    spdlog::to_hex(msg.header_data()),
                                    spdlog::to_hex(msg.body));
                     break;
@@ -473,7 +473,7 @@ class mcbp_session_impl
                     Expects(protocol::is_valid_client_opcode(msg.header.opcode));
                     switch (auto opcode = static_cast<protocol::client_opcode>(msg.header.opcode)) {
                         case protocol::client_opcode::get_cluster_config: {
-                            protocol::cmd_info info{ session_->endpoint_address_, session_->endpoint_.port() };
+                            protocol::cmd_info info{ session_->bootstrap_hostname_, session_->bootstrap_port_number_ };
                             if (session_->origin_.options().dump_configuration) {
                                 std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()), msg.body.size() };
                                 CB_LOG_TRACE("{} configuration from get_cluster_config response (size={}, endpoint=\"{}:{}\"), {}",
@@ -781,13 +781,10 @@ class mcbp_session_impl
             return;
         }
         std::tie(bootstrap_hostname_, bootstrap_port_) = origin_.next_address();
-        log_prefix_ = fmt::format("[{}/{}/{}/{}] <{}:{}>",
-                                  client_id_,
-                                  id_,
-                                  stream_->log_prefix(),
-                                  bucket_name_.value_or("-"),
-                                  bootstrap_hostname_,
-                                  bootstrap_port_);
+        bootstrap_port_number_ = gsl::narrow_cast<std::uint16_t>(std::stoul(bootstrap_port_, nullptr, 10));
+        bootstrap_address_ = fmt::format("{}:{}", bootstrap_hostname_, bootstrap_port_);
+        log_prefix_ =
+          fmt::format("[{}/{}/{}/{}] <{}>", client_id_, id_, stream_->log_prefix(), bucket_name_.value_or("-"), bootstrap_address_);
         CB_LOG_DEBUG("{} attempt to establish MCBP connection", log_prefix_);
 
         async_resolve(origin_.options().use_ip_protocol,
@@ -807,7 +804,7 @@ class mcbp_session_impl
         return stopped_;
     }
 
-    void on_stop(utils::movable_function<void(retry_reason)> handler)
+    void on_stop(utils::movable_function<void()> handler)
     {
         on_stop_handler_ = std::move(handler);
     }
@@ -863,7 +860,7 @@ class mcbp_session_impl
         config_listeners_.clear();
         state_ = diag::endpoint_state::disconnected;
         if (auto on_stop = std::move(on_stop_handler_); on_stop) {
-            on_stop(reason);
+            on_stop();
         }
     }
 
@@ -874,7 +871,7 @@ class mcbp_session_impl
         }
         std::uint32_t opaque{ 0 };
         std::memcpy(&opaque, buf.data() + 12, sizeof(opaque));
-        CB_LOG_TRACE("{} MCBP send, opaque={}, {:n}", log_prefix_, opaque, spdlog::to_hex(buf.begin(), buf.begin() + 24));
+        CB_LOG_TRACE("{} MCBP send, opaque={}, {:n}", log_prefix_, utils::byte_swap(opaque), spdlog::to_hex(buf.begin(), buf.begin() + 24));
         std::scoped_lock lock(output_buffer_mutex_);
         output_buffer_.emplace_back(std::move(buf));
     }
@@ -1058,6 +1055,11 @@ class mcbp_session_impl
         return config_->index_for_this_node();
     }
 
+    [[nodiscard]] const std::string& bootstrap_address() const
+    {
+        return bootstrap_address_;
+    }
+
     [[nodiscard]] const std::string& bootstrap_hostname() const
     {
         return bootstrap_hostname_;
@@ -1068,6 +1070,11 @@ class mcbp_session_impl
         return bootstrap_port_;
     }
 
+    [[nodiscard]] std::uint16_t bootstrap_port_number() const
+    {
+        return bootstrap_port_number_;
+    }
+
     [[nodiscard]] std::uint32_t next_opaque()
     {
         return ++opaque_;
@@ -1161,15 +1168,15 @@ class mcbp_session_impl
                     CB_LOG_TRACE("{} configuration from not_my_vbucket response (size={}, endpoint=\"{}:{}\"), {}",
                                  log_prefix_,
                                  config_text.size(),
-                                 endpoint_address_,
-                                 endpoint_.port(),
+                                 bootstrap_hostname_,
+                                 bootstrap_port_number_,
                                  config_text);
                 }
-                auto config = protocol::parse_config(config_text, endpoint_address_, endpoint_.port());
+                auto config = protocol::parse_config(config_text, bootstrap_hostname_, bootstrap_port_number_);
                 CB_LOG_DEBUG("{} received not_my_vbucket status for {}, opaque={} with config rev={} in the payload",
                              log_prefix_,
                              protocol::client_opcode(msg.header.opcode),
-                             msg.header.opaque,
+                             utils::byte_swap(msg.header.opaque),
                              config.rev_str());
                 update_configuration(std::move(config));
             }
@@ -1204,6 +1211,12 @@ class mcbp_session_impl
             CB_LOG_DEBUG(R"({} server returned {} ({}), it must be transient condition, retrying)", log_prefix_, ec.value(), ec.message());
             return initiate_bootstrap();
         }
+        if (!origin_.exhausted() && ec == errc::common::authentication_failure) {
+            CB_LOG_DEBUG(
+              R"({} server returned authentication_failure, but the bootstrap list is not exhausted yet. It must be transient condition, retrying)",
+              log_prefix_);
+            return initiate_bootstrap();
+        }
 
         if (!bootstrapped_ && bootstrap_callback_) {
             bootstrap_deadline_.cancel();
@@ -1266,16 +1279,15 @@ class mcbp_session_impl
         }
         last_active_ = std::chrono::steady_clock::now();
         if (it != endpoints_.end()) {
-            CB_LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
-                         log_prefix_,
-                         it->endpoint().address().to_string(),
-                         it->endpoint().port(),
-                         origin_.options().connect_timeout.count());
+            auto hostname = it->endpoint().address().to_string();
+            auto port = it->endpoint().port();
+            CB_LOG_DEBUG("{} connecting to {}:{}, timeout={}ms", log_prefix_, hostname, port, origin_.options().connect_timeout.count());
             connection_deadline_.expires_after(origin_.options().connect_timeout);
-            connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
+            connection_deadline_.async_wait([self = shared_from_this(), hostname, port](const auto timer_ec) {
                 if (timer_ec == asio::error::operation_aborted || self->stopped_) {
                     return;
                 }
+                CB_LOG_DEBUG("{} unable to connect to {}:{} in time, reconnecting", self->log_prefix_, hostname, port);
                 return self->stream_->close([self](std::error_code) { self->initiate_bootstrap(); });
             });
             stream_->async_connect(it->endpoint(),
@@ -1353,7 +1365,20 @@ class mcbp_session_impl
           asio::buffer(input_buffer_),
           [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_) {
+                  CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", port={}, rc={}, bytes_received={}",
+                                  self->endpoint_address_,
+                                  self->endpoint_.port(),
+                                  ec ? ec.message() : "ok",
+                                  bytes_transferred);
                   return;
+              } else {
+                  CB_LOG_PROTOCOL("[MCBP, IN] host=\"{}\", port={}, rc={}, bytes_received={}{:a}",
+                                  self->endpoint_address_,
+                                  self->endpoint_.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) {
@@ -1382,8 +1407,10 @@ class mcbp_session_impl
                           if (self->stopped_) {
                               return;
                           }
-                          CB_LOG_TRACE(
-                            "{} MCBP recv, opaque={}, {:n}", self->log_prefix_, msg.header.opaque, spdlog::to_hex(msg.header_data()));
+                          CB_LOG_TRACE("{} MCBP recv, opaque={}, {:n}",
+                                       self->log_prefix_,
+                                       utils::byte_swap(msg.header.opaque),
+                                       spdlog::to_hex(msg.header_data()));
                           if (self->bootstrapped_) {
                               self->handler_->handle(std::move(msg));
                           } else {
@@ -1419,13 +1446,21 @@ class mcbp_session_impl
         std::vector<asio::const_buffer> buffers;
         buffers.reserve(writing_buffer_.size());
         for (auto& buf : writing_buffer_) {
+            CB_LOG_PROTOCOL(
+              "[MCBP, OUT] host=\"{}\", port={}, buffer_size={}{:a}", endpoint_address_, endpoint_.port(), buf.size(), spdlog::to_hex(buf));
             buffers.emplace_back(asio::buffer(buf));
         }
-        stream_->async_write(buffers, [self = shared_from_this()](std::error_code ec, std::size_t /*unused*/) {
+        stream_->async_write(buffers, [self = shared_from_this()](std::error_code ec, std::size_t bytes_transferred) {
+            CB_LOG_PROTOCOL("[MCBP, OUT] host=\"{}\", port={}, rc={}, bytes_sent={}",
+                            self->endpoint_address_,
+                            self->endpoint_.port(),
+                            ec ? ec.message() : "ok",
+                            bytes_transferred);
             if (ec == asio::error::operation_aborted || self->stopped_) {
                 return;
             }
             self->last_active_ = std::chrono::steady_clock::now();
+
             if (ec) {
                 CB_LOG_ERROR(R"({} IO error while writing to the socket("{}"): {} ({}))",
                              self->log_prefix_,
@@ -1462,7 +1497,7 @@ class mcbp_session_impl
     std::mutex command_handlers_mutex_{};
     std::map<std::uint32_t, command_handler> command_handlers_{};
     std::vector<std::shared_ptr<config_listener>> config_listeners_{};
-    utils::movable_function<void(retry_reason)> on_stop_handler_{};
+    utils::movable_function<void()> on_stop_handler_{};
 
     std::atomic_bool bootstrapped_{ false };
     std::atomic_bool stopped_{ false };
@@ -1482,6 +1517,8 @@ class mcbp_session_impl
     std::mutex writing_buffer_mutex_{};
     std::string bootstrap_hostname_{};
     std::string bootstrap_port_{};
+    std::string bootstrap_address_{};
+    std::uint16_t bootstrap_port_number_{};
     asio::ip::tcp::endpoint endpoint_{}; // connected endpoint
     std::string endpoint_address_{};     // cached string with endpoint address
     asio::ip::tcp::endpoint local_endpoint_{};
@@ -1582,22 +1619,16 @@ mcbp_session::supports_feature(protocol::hello_feature feature)
     return impl_->supports_feature(feature);
 }
 
-// const std::string&
-// mcbp_session::id() const
-// {
-//     return impl_->id();
-// }
-std::string
+const std::string&
 mcbp_session::id() const
 {
-    if (impl_) {
-        return fmt::format("{}, {}, {}, refcnt={}",
-                           reinterpret_cast<const void*>(this),
-                           reinterpret_cast<const void*>(impl_.get()),
-                           impl_->id(),
-                           impl_.use_count());
-    }
-    return fmt::format("{}, nullptr", reinterpret_cast<const void*>(this));
+    return impl_->id();
+}
+
+const std::string&
+mcbp_session::bootstrap_address() const
+{
+    return impl_->bootstrap_address();
 }
 
 std::string
@@ -1624,6 +1655,12 @@ mcbp_session::bootstrap_port() const
     return impl_->bootstrap_port();
 }
 
+std::uint16_t
+mcbp_session::bootstrap_port_number() const
+{
+    return impl_->bootstrap_port_number();
+}
+
 void
 mcbp_session::write_and_subscribe(std::uint32_t opaque, std::vector<std::byte>&& data, command_handler&& handler)
 {
@@ -1637,7 +1674,7 @@ mcbp_session::bootstrap(utils::movable_function<void(std::error_code, topology::
 }
 
 void
-mcbp_session::on_stop(utils::movable_function<void(retry_reason)> handler)
+mcbp_session::on_stop(utils::movable_function<void()> handler)
 {
     return impl_->on_stop(std::move(handler));
 }

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

@@ -101,17 +101,18 @@ class mcbp_session
     [[nodiscard]] mcbp_context context() const;
     [[nodiscard]] bool supports_feature(protocol::hello_feature feature);
     [[nodiscard]] std::vector<protocol::hello_feature> supported_features() const;
-    //[[nodiscard]] const std::string& id() const;
-    [[nodiscard]] std::string id() const;
+    [[nodiscard]] const std::string& id() const;
     [[nodiscard]] std::string remote_address() const;
     [[nodiscard]] std::string local_address() const;
+    [[nodiscard]] const std::string& bootstrap_address() const;
     [[nodiscard]] const std::string& bootstrap_hostname() const;
     [[nodiscard]] const std::string& bootstrap_port() const;
+    [[nodiscard]] std::uint16_t bootstrap_port_number() const;
     void write_and_subscribe(std::shared_ptr<mcbp::queue_request>, std::shared_ptr<response_handler> handler);
     void write_and_subscribe(std::uint32_t opaque, std::vector<std::byte>&& data, command_handler&& handler);
     void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler,
                    bool retry_on_bucket_not_found = false);
-    void on_stop(utils::movable_function<void(retry_reason)> handler);
+    void on_stop(utils::movable_function<void()> handler);
     void stop(retry_reason reason);
     [[nodiscard]] std::size_t index() const;
     [[nodiscard]] bool has_config() const;

data/ext/couchbase/core/logger/custom_rotating_file_sink.cxx

@@ -127,7 +127,7 @@ custom_rotating_file_sink<Mutex>::add_hook(const std::string& hook)
 
     // Payload shouldn't contain anything yet, overwrite it
     Expects(msg.payload.size() == 0);
-    msg.payload = hook;
+    msg.payload = hookToAdd;
 
     spdlog::memory_buf_t formatted;
     formatter->format(msg, formatted);