couchbase 3.4.1 → 3.4.3

data/ext/couchbase/core/impl/wildcard_query.cxx

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "encoded_search_query.hxx"
+
+#include <couchbase/wildcard_query.hxx>
+
+namespace couchbase
+{
+auto
+wildcard_query::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+
+    built.query["wildcard"] = wildcard_;
+    if (field_) {
+        built.query["field"] = field_.value();
+    }
+
+    return built;
+}
+} // namespace couchbase

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

@@ -0,0 +1,225 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "dns_client.hxx"
+
+#include "core/logger/logger.hxx"
+#include "core/utils/join_strings.hxx"
+#include "dns_codec.hxx"
+#include "dns_config.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <asio/ip/tcp.hpp>
+#include <asio/read.hpp>
+#include <asio/write.hpp>
+
+#include <memory>
+#include <sstream>
+
+namespace couchbase::core::io::dns
+{
+class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
+{
+  public:
+    dns_srv_command(asio::io_context& ctx,
+                    const std::string& name,
+                    const std::string& service,
+                    const asio::ip::address& address,
+                    std::uint16_t port,
+                    utils::movable_function<void(couchbase::core::io::dns::dns_srv_response&& resp)> handler)
+      : deadline_(ctx)
+      , udp_deadline_(ctx)
+      , udp_(ctx)
+      , tcp_(ctx)
+      , address_(address)
+      , port_(port)
+      , handler_(std::move(handler))
+    {
+        static std::string protocol{ "_tcp" };
+        dns_message request{};
+        question_record qr;
+        qr.klass = resource_class::in;
+        qr.type = resource_type::srv;
+        qr.name.labels.push_back(service);
+        qr.name.labels.push_back(protocol);
+        std::string label;
+        std::istringstream name_stream(name);
+        while (std::getline(name_stream, label, '.')) {
+            qr.name.labels.push_back(label);
+        }
+        request.questions.emplace_back(qr);
+        send_buf_ = dns_codec::encode(request);
+    }
+
+    void execute(std::chrono::milliseconds total_timeout, std::chrono::milliseconds udp_timeout)
+    {
+        asio::ip::udp::endpoint endpoint(address_, port_);
+        udp_.open(endpoint.protocol());
+        udp_.async_send_to(
+          asio::buffer(send_buf_), endpoint, [self = shared_from_this()](std::error_code ec1, std::size_t /* bytes_transferred */) mutable {
+              if (ec1) {
+                  self->udp_deadline_.cancel();
+                  CB_LOG_DEBUG("DNS UDP write operation has got error {}, retrying with TCP", 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 {
+                    self->udp_deadline_.cancel();
+                    if (ec2) {
+                        CB_LOG_DEBUG("DNS UDP read operation has got error {}, retrying with TCP", ec2.message());
+                        return self->retry_with_tcp();
+                    }
+                    self->recv_buf_.resize(bytes_transferred);
+                    const dns_message message = dns_codec::decode(self->recv_buf_);
+                    if (message.header.flags.tc == truncation::yes) {
+                        self->udp_.close();
+                        CB_LOG_DEBUG("DNS UDP read operation returned truncated response, retrying with TCP");
+                        return self->retry_with_tcp();
+                    }
+                    self->deadline_.cancel();
+                    dns_srv_response resp{ ec2 };
+                    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 UDP returned {} records", resp.targets.size());
+                    return self->handler_(std::move(resp));
+                });
+          });
+        udp_deadline_.expires_after(udp_timeout);
+        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");
+            self->udp_.cancel();
+            return self->retry_with_tcp();
+        });
+
+        deadline_.expires_after(total_timeout);
+        deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
+            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());
+            self->udp_.cancel();
+            if (self->tcp_.is_open()) {
+                self->tcp_.cancel();
+            }
+        });
+    }
+
+  private:
+    void retry_with_tcp()
+    {
+        if (bool expected_state{ false }; !retrying_with_tcp_.compare_exchange_strong(expected_state, true)) {
+            return;
+        }
+
+        const asio::ip::tcp::no_delay no_delay(true);
+        std::error_code ignore_ec;
+        tcp_.set_option(no_delay, ignore_ec);
+        const asio::ip::tcp::endpoint endpoint(address_, port_);
+        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());
+                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));
+            asio::async_write(
+              self->tcp_, asio::buffer(self->send_buf_), [self](std::error_code ec2, std::size_t /* bytes_transferred */) mutable {
+                  if (ec2) {
+                      CB_LOG_DEBUG("DNS TCP write operation has been aborted, {}", 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::steady_timer deadline_;
+    asio::steady_timer udp_deadline_;
+    asio::ip::udp::socket udp_;
+    asio::ip::udp::endpoint udp_sender_{};
+    asio::ip::tcp::socket tcp_;
+
+    asio::ip::address address_;
+    std::uint16_t port_;
+    utils::movable_function<void(couchbase::core::io::dns::dns_srv_response&& resp)> handler_;
+
+    std::vector<std::uint8_t> send_buf_{};
+    std::uint16_t recv_buf_size_{ 0 };
+    std::vector<std::uint8_t> recv_buf_{};
+
+    std::atomic_bool retrying_with_tcp_{ false };
+};
+
+void
+dns_client::query_srv(const std::string& name,
+                      const std::string& service,
+                      const dns_config& config,
+                      utils::movable_function<void(dns_srv_response&&)>&& handler)
+{
+    std::error_code ec;
+    auto address = asio::ip::address::from_string(config.nameserver(), ec);
+    if (ec) {
+        return handler({ ec });
+    }
+    auto cmd = std::make_shared<dns_srv_command>(ctx_, name, service, address, config.port(), std::move(handler));
+    return cmd->execute(config.timeout(), config.timeout() / 2);
+}
+} // namespace couchbase::core::io::dns

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

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -17,207 +17,38 @@
 
 #pragma once
 
-#include "core/utils/join_strings.hxx"
-#include "dns_codec.hxx"
+#include "core/utils/movable_function.hxx"
 #include "dns_config.hxx"
 
-#include <couchbase/error_codes.hxx>
+#include <asio/io_context.hpp>
 
-#include <asio/ip/tcp.hpp>
-#include <asio/read.hpp>
-#include <asio/write.hpp>
-
-#include <memory>
-#include <sstream>
+#include <cinttypes>
+#include <string>
+#include <vector>
 
 namespace couchbase::core::io::dns
 {
+struct dns_srv_response {
+    struct address {
+        std::string hostname;
+        std::uint16_t port;
+    };
+    std::error_code ec;
+    std::vector<address> targets{};
+};
+
 class dns_client
 {
   public:
-    struct dns_srv_response {
-        struct address {
-            std::string hostname;
-            std::uint16_t port;
-        };
-        std::error_code ec;
-        std::vector<address> targets{};
-    };
-
-    class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
-    {
-      public:
-        dns_srv_command(asio::io_context& ctx,
-                        const std::string& name,
-                        const std::string& service,
-                        const asio::ip::address& address,
-                        std::uint16_t port)
-          : deadline_(ctx)
-          , udp_(ctx)
-          , tcp_(ctx)
-          , address_(address)
-          , port_(port)
-        {
-            static std::string protocol{ "_tcp" };
-            dns_message request{};
-            question_record qr;
-            qr.klass = resource_class::in;
-            qr.type = resource_type::srv;
-            qr.name.labels.push_back(service);
-            qr.name.labels.push_back(protocol);
-            std::string label;
-            std::istringstream name_stream(name);
-            while (std::getline(name_stream, label, '.')) {
-                qr.name.labels.push_back(label);
-            }
-            request.questions.emplace_back(qr);
-            send_buf_ = dns_codec::encode(request);
-        }
-
-        template<class Handler>
-        void execute(std::chrono::milliseconds timeout, Handler&& handler)
-        {
-            asio::ip::udp::endpoint endpoint(address_, port_);
-            udp_.open(endpoint.protocol());
-            udp_.async_send_to(asio::buffer(send_buf_),
-                               endpoint,
-                               [self = shared_from_this(), handler = std::forward<Handler>(handler)](
-                                 std::error_code ec1, std::size_t /* bytes_transferred */) mutable {
-                                   if (ec1 == asio::error::operation_aborted) {
-                                       self->deadline_.cancel();
-                                       return handler({ errc::common::unambiguous_timeout });
-                                   }
-                                   if (ec1) {
-                                       self->deadline_.cancel();
-                                       return handler({ ec1 });
-                                   }
-
-                                   self->recv_buf_.resize(512);
-                                   self->udp_.async_receive_from(asio::buffer(self->recv_buf_),
-                                                                 self->udp_sender_,
-                                                                 [self, handler = std::forward<Handler>(handler)](
-                                                                   std::error_code ec2, std::size_t bytes_transferred) mutable {
-                                                                     self->deadline_.cancel();
-                                                                     if (ec2) {
-                                                                         return handler({ ec2 });
-                                                                     }
-                                                                     self->recv_buf_.resize(bytes_transferred);
-                                                                     dns_message message = dns_codec::decode(self->recv_buf_);
-                                                                     if (message.header.flags.tc == truncation::yes) {
-                                                                         self->udp_.close();
-                                                                         return self->retry_with_tcp(std::forward<Handler>(handler));
-                                                                     }
-                                                                     dns_srv_response resp{ ec2 };
-                                                                     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 });
-                                                                     }
-                                                                     return handler(std::move(resp));
-                                                                 });
-                               });
-            deadline_.expires_after(timeout);
-            deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
-                if (ec == asio::error::operation_aborted) {
-                    return;
-                }
-                self->udp_.cancel();
-                if (self->tcp_.is_open()) {
-                    self->tcp_.cancel();
-                }
-            });
-        }
-
-      private:
-        template<class Handler>
-        void retry_with_tcp(Handler&& handler)
-        {
-            asio::ip::tcp::no_delay no_delay(true);
-            std::error_code ignore_ec;
-            tcp_.set_option(no_delay, ignore_ec);
-            asio::ip::tcp::endpoint endpoint(address_, port_);
-            tcp_.async_connect(
-              endpoint, [self = shared_from_this(), handler = std::forward<Handler>(handler)](std::error_code ec1) mutable {
-                  if (ec1) {
-                      self->deadline_.cancel();
-                      return handler({ ec1 });
-                  }
-                  auto send_size = static_cast<std::uint16_t>(self->send_buf_.size());
-                  self->send_buf_.insert(self->send_buf_.begin(), std::uint8_t(send_size & 0xffU));
-                  self->send_buf_.insert(self->send_buf_.begin(), std::uint8_t(send_size >> 8U));
-                  asio::async_write(
-                    self->tcp_,
-                    asio::buffer(self->send_buf_),
-                    [self, handler = std::forward<Handler>(handler)](std::error_code ec2, std::size_t /* bytes_transferred */) mutable {
-                        if (ec2) {
-                            self->deadline_.cancel();
-                            if (ec2 == asio::error::operation_aborted) {
-                                ec2 = errc::common::unambiguous_timeout;
-                            }
-                            return handler({ ec2 });
-                        }
-                        asio::async_read(self->tcp_,
-                                         asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
-                                         [self, handler = std::forward<Handler>(handler)](std::error_code ec3,
-                                                                                          std::size_t /* bytes_transferred */) mutable {
-                                             if (ec3) {
-                                                 self->deadline_.cancel();
-                                                 return handler({ ec3 });
-                                             }
-                                             self->recv_buf_size_ = utils::byte_swap(self->recv_buf_size_);
-                                             self->recv_buf_.resize(self->recv_buf_size_);
-                                             asio::async_read(self->tcp_,
-                                                              asio::buffer(self->recv_buf_),
-                                                              [self, handler = std::forward<Handler>(handler)](
-                                                                std::error_code ec4, std::size_t bytes_transferred) mutable {
-                                                                  self->deadline_.cancel();
-                                                                  if (ec4) {
-                                                                      return handler({ ec4 });
-                                                                  }
-                                                                  self->recv_buf_.resize(bytes_transferred);
-                                                                  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 });
-                                                                  }
-                                                                  return handler(std::move(resp));
-                                                              });
-                                         });
-                    });
-              });
-        }
-
-        asio::steady_timer deadline_;
-        asio::ip::udp::socket udp_;
-        asio::ip::udp::endpoint udp_sender_{};
-        asio::ip::tcp::socket tcp_;
-
-        asio::ip::address address_;
-        std::uint16_t port_;
-
-        std::vector<std::uint8_t> send_buf_{};
-        std::uint16_t recv_buf_size_{ 0 };
-        std::vector<std::uint8_t> recv_buf_{};
-    };
-
     explicit dns_client(asio::io_context& ctx)
       : ctx_(ctx)
     {
     }
 
-    template<class Handler>
-    void query_srv(const std::string& name, const std::string& service, const dns_config& config, Handler&& handler)
-    {
-        std::error_code ec;
-        auto address = asio::ip::address::from_string(config.nameserver(), ec);
-        if (ec) {
-            return handler({ ec });
-        }
-        auto cmd = std::make_shared<dns_srv_command>(ctx_, name, service, address, config.port());
-        cmd->execute(config.timeout(), std::forward<Handler>(handler));
-    }
+    void query_srv(const std::string& name,
+                   const std::string& service,
+                   const dns_config& config,
+                   utils::movable_function<void(couchbase::core::io::dns::dns_srv_response&& resp)>&& handler);
 
     asio::io_context& ctx_;
 };

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

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "core/cluster_options.hxx"
+#include "core/cluster_options_fwd.hxx"
 #include "core/topology/configuration.hxx"
 #include "query_cache.hxx"
 

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

@@ -216,11 +216,21 @@ class http_session : public std::enable_shared_from_this<http_session>
         return id_;
     }
 
+    [[nodiscard]] service_type type() const
+    {
+        return type_;
+    }
+
     [[nodiscard]] const std::string& hostname() const
     {
         return hostname_;
     }
 
+    [[nodiscard]] const std::string& port() const
+    {
+        return service_;
+    }
+
     [[nodiscard]] const asio::ip::tcp::endpoint& endpoint()
     {
         std::scoped_lock lock(info_mutex_);

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

@@ -61,8 +61,9 @@ class http_session_manager
         std::scoped_lock config_lock(config_mutex_, sessions_mutex_);
         config_ = std::move(config);
         for (auto& [type, sessions] : idle_sessions_) {
-            sessions.remove_if(
-              [&cfg = config_](const auto& session) { return session && !cfg.has_node_with_hostname(session->hostname()); });
+            sessions.remove_if([&opts = options_, &cfg = config_](const auto& session) {
+                return session && !cfg.has_node(opts.network, session->type(), opts.enable_tls, session->hostname(), session->port());
+            });
         }
     }
 
@@ -224,7 +225,8 @@ class http_session_manager
     {
         {
             std::scoped_lock lock(config_mutex_);
-            if (!session->keep_alive() || !config_.has_node_with_hostname(session->hostname())) {
+            if (!session->keep_alive() ||
+                !config_.has_node(options_.network, session->type(), options_.enable_tls, session->hostname(), session->port())) {
                 return asio::post(session->get_executor(), [session]() { session->stop(); });
             }
         }

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

@@ -72,7 +72,7 @@ class collection_cache
         if (auto ptr = cid_map_.find(path); ptr != cid_map_.end()) {
             return ptr->second;
         }
-        return {};
+        return std::nullopt;
     }
 
     void update(const std::string& path, std::uint32_t id)
@@ -380,6 +380,16 @@ class mcbp_session_impl
                     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() };
+                            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 cluster_map_change_notification request (size={}, endpoint=\"{}:{}\"), {}",
+                                  session_->log_prefix_,
+                                  config_text.size(),
+                                  info.endpoint_address,
+                                  info.endpoint_port,
+                                  config_text);
+                            }
                             protocol::server_request<protocol::cluster_map_change_notification_request_body> req(std::move(msg), info);
                             std::optional<topology::configuration> config = req.body().config();
                             if (session_ && config.has_value()) {
@@ -464,6 +474,15 @@ class mcbp_session_impl
                     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() };
+                            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=\"{}:{}\"), {}",
+                                             session_->log_prefix_,
+                                             config_text.size(),
+                                             info.endpoint_address,
+                                             info.endpoint_port,
+                                             config_text);
+                            }
                             protocol::client_response<protocol::get_cluster_config_response_body> resp(std::move(msg), info);
                             if (resp.status() == key_value_status_code::success) {
                                 if (session_) {
@@ -1138,6 +1157,14 @@ class mcbp_session_impl
             if (utils::byte_swap(msg.header.bodylen) - offset > 0) {
                 std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()) + offset,
                                               msg.body.size() - static_cast<std::size_t>(offset) };
+                if (origin_.options().dump_configuration) {
+                    CB_LOG_TRACE("{} configuration from not_my_vbucket response (size={}, endpoint=\"{}:{}\"), {}",
+                                 log_prefix_,
+                                 config_text.size(),
+                                 endpoint_address_,
+                                 endpoint_.port(),
+                                 config_text);
+                }
                 auto config = protocol::parse_config(config_text, endpoint_address_, endpoint_.port());
                 CB_LOG_DEBUG("{} received not_my_vbucket status for {}, opaque={} with config rev={} in the payload",
                              log_prefix_,

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

@@ -55,13 +55,14 @@ retry_with_duration(std::shared_ptr<Manager> manager,
                     std::chrono::milliseconds duration)
 {
     command->request.retries.record_retry_attempt(reason);
-    CB_LOG_TRACE(R"({} retrying operation {} (duration={}ms, id="{}", reason={}, attempts={}))",
+    CB_LOG_TRACE(R"({} retrying operation {} (duration={}ms, id="{}", reason={}, attempts={}, last_dispatched_to=\"{}\"))",
                  manager->log_prefix(),
                  decltype(command->request)::encoded_request_type::body_type::opcode,
                  duration.count(),
                  command->id_,
                  reason,
-                 command->request.retries.retry_attempts());
+                 command->request.retries.retry_attempts(),
+                 command->session_ ? command->session_->remote_address() : "");
     manager->schedule_for_retry(command, duration);
 }
 

data/ext/couchbase/core/json_string.hxx

@@ -37,6 +37,11 @@ struct json_string {
         return *this;
     }
 
+    json_string(const std::vector<std::byte>& value)
+      : value_(value)
+    {
+    }
+
     json_string(std::vector<std::byte>&& value)
       : value_(std::move(value))
     {