couchbase 3.4.3 → 3.4.4

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

@@ -0,0 +1,130 @@
+/* -*- 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 <couchbase/manager_error_context.hxx>
+#include <utility>
+
+#include "core/cluster.hxx"
+#include "core/operations/management/bucket_update.hxx"
+#include "couchbase/bucket_manager.hxx"
+
+namespace couchbase
+{
+template<typename Response>
+static manager_error_context
+build_context(Response& resp)
+{
+    return manager_error_context(internal_manager_error_context{ resp.ctx.ec,
+                                                                 resp.ctx.last_dispatched_to,
+                                                                 resp.ctx.last_dispatched_from,
+                                                                 resp.ctx.retry_attempts,
+                                                                 std::move(resp.ctx.retry_reasons),
+                                                                 std::move(resp.ctx.client_context_id),
+                                                                 resp.ctx.http_status,
+                                                                 std::move(resp.ctx.http_body),
+                                                                 std::move(resp.ctx.path) });
+}
+
+static core::operations::management::bucket_update_request
+build_update_bucket_request(couchbase::core::management::cluster::bucket_settings bucket_settings,
+                            const update_bucket_options::built& options)
+{
+    core::operations::management::bucket_update_request request{ std::move(bucket_settings), {}, options.timeout };
+    return request;
+}
+
+static couchbase::core::management::cluster::bucket_settings
+map_bucket_settings(const couchbase::management::cluster::bucket_settings& bucket)
+{
+    couchbase::core::management::cluster::bucket_settings bucket_settings{};
+
+    bucket_settings.name = bucket.name;
+    bucket_settings.ram_quota_mb = bucket.ram_quota_mb;
+    bucket_settings.max_expiry = bucket.max_expiry;
+    bucket_settings.minimum_durability_level = bucket.minimum_durability_level;
+    bucket_settings.num_replicas = bucket.num_replicas;
+    bucket_settings.replica_indexes = bucket.replica_indexes;
+    bucket_settings.flush_enabled = bucket.flush_enabled;
+    switch (bucket.conflict_resolution_type) {
+        case management::cluster::bucket_conflict_resolution::unknown:
+            bucket_settings.conflict_resolution_type = core::management::cluster::bucket_conflict_resolution::unknown;
+            break;
+        case management::cluster::bucket_conflict_resolution::timestamp:
+            bucket_settings.conflict_resolution_type = core::management::cluster::bucket_conflict_resolution::timestamp;
+            break;
+        case management::cluster::bucket_conflict_resolution::sequence_number:
+            bucket_settings.conflict_resolution_type = core::management::cluster::bucket_conflict_resolution::sequence_number;
+            break;
+        case management::cluster::bucket_conflict_resolution::custom:
+            bucket_settings.conflict_resolution_type = core::management::cluster::bucket_conflict_resolution::custom;
+            break;
+    }
+    switch (bucket.eviction_policy) {
+        case management::cluster::bucket_eviction_policy::unknown:
+            bucket_settings.eviction_policy = core::management::cluster::bucket_eviction_policy::unknown;
+            break;
+        case management::cluster::bucket_eviction_policy::full:
+            bucket_settings.eviction_policy = core::management::cluster::bucket_eviction_policy::full;
+            break;
+        case management::cluster::bucket_eviction_policy::value_only:
+            bucket_settings.eviction_policy = core::management::cluster::bucket_eviction_policy::value_only;
+            break;
+        case management::cluster::bucket_eviction_policy::no_eviction:
+            bucket_settings.eviction_policy = core::management::cluster::bucket_eviction_policy::no_eviction;
+            break;
+        case management::cluster::bucket_eviction_policy::not_recently_used:
+            bucket_settings.eviction_policy = core::management::cluster::bucket_eviction_policy::not_recently_used;
+            break;
+    }
+    switch (bucket.bucket_type) {
+        case management::cluster::bucket_type::unknown:
+            bucket_settings.bucket_type = core::management::cluster::bucket_type::unknown;
+            break;
+        case management::cluster::bucket_type::couchbase:
+            bucket_settings.bucket_type = core::management::cluster::bucket_type::couchbase;
+            break;
+        case management::cluster::bucket_type::memcached:
+            bucket_settings.bucket_type = core::management::cluster::bucket_type::memcached;
+            break;
+        case management::cluster::bucket_type::ephemeral:
+            bucket_settings.bucket_type = core::management::cluster::bucket_type::ephemeral;
+            break;
+    }
+    return bucket_settings;
+}
+
+void
+bucket_manager::update_bucket(const management::cluster::bucket_settings& bucket_settings,
+                              const update_bucket_options& options,
+                              update_bucket_handler&& handler) const
+{
+    auto request = build_update_bucket_request(map_bucket_settings(bucket_settings), options.build());
+
+    core_->execute(std::move(request), [handler = std::move(handler)](core::operations::management::bucket_update_response resp) mutable {
+        return handler(build_context(resp));
+    });
+}
+
+auto
+bucket_manager::update_bucket(const management::cluster::bucket_settings& bucket_settings, const update_bucket_options& options) const
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    update_bucket(bucket_settings, options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+} // namespace couchbase

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

@@ -24,16 +24,6 @@
 
 namespace couchbase::core::impl
 {
-
-template<typename Response>
-static manager_error_context
-build_context(Response& resp, std::optional<std::error_code> ec = {})
-{
-    return { ec ? ec.value() : resp.ctx.ec, resp.ctx.last_dispatched_to,       resp.ctx.last_dispatched_from,
-             resp.ctx.retry_attempts,       std::move(resp.ctx.retry_reasons), std::move(resp.ctx.client_context_id),
-             resp.ctx.http_status,          std::move(resp.ctx.http_body),     std::move(resp.ctx.path) };
-}
-
 class watch_context : public std::enable_shared_from_this<watch_context>
 {
 
@@ -50,9 +40,18 @@ class watch_context : public std::enable_shared_from_this<watch_context>
     std::chrono::milliseconds timeout_{ options_.timeout.value_or(core_->origin().second.options().query_timeout) };
     std::atomic<size_t> attempts_{ 0 };
 
-    void finish(manager_error_context error_ctx)
+    template<typename Response>
+    void finish(Response& resp, std::optional<std::error_code> ec = {})
     {
-        handler_(error_ctx);
+        handler_({ manager_error_context(internal_manager_error_context{ ec ? ec.value() : resp.ctx.ec,
+                                                                         resp.ctx.last_dispatched_to,
+                                                                         resp.ctx.last_dispatched_from,
+                                                                         resp.ctx.retry_attempts,
+                                                                         std::move(resp.ctx.retry_reasons),
+                                                                         std::move(resp.ctx.client_context_id),
+                                                                         resp.ctx.http_status,
+                                                                         std::move(resp.ctx.http_body),
+                                                                         std::move(resp.ctx.path) }) });
         timer_.cancel();
     }
     std::chrono::milliseconds remaining()
@@ -79,9 +78,9 @@ class watch_context : public std::enable_shared_from_this<watch_context>
             complete &= it != resp.indexes.end() && it->state == "online";
         }
         if (complete || resp.ctx.ec == couchbase::errc::common::ambiguous_timeout) {
-            finish(build_context(resp));
+            finish(resp);
         } else if (remaining().count() <= 0) {
-            finish(build_context(resp, couchbase::errc::common::ambiguous_timeout));
+            finish(resp, couchbase::errc::common::ambiguous_timeout);
             complete = true;
         }
         return complete;
@@ -141,28 +140,53 @@ class watch_context : public std::enable_shared_from_this<watch_context>
         core_->execute(req, resp_fn);
     }
 };
+} // namespace couchbase::core::impl
 
+namespace couchbase
+{
 void
-initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
-                             std::string bucket_name,
-                             std::vector<std::string> index_names,
-                             couchbase::watch_query_indexes_options::built options,
-                             query_context query_ctx,
-                             std::string collection_name,
-                             watch_query_indexes_handler&& handler)
+query_index_manager::watch_indexes(std::string bucket_name,
+                                   std::vector<std::string> index_names,
+                                   const couchbase::watch_query_indexes_options& options,
+                                   couchbase::watch_query_indexes_handler&& handler)
 {
-    auto ctx = std::make_shared<watch_context>(core, bucket_name, index_names, options, query_ctx, collection_name, std::move(handler));
+    auto ctx = std::make_shared<couchbase::core::impl::watch_context>(
+      core_, std::move(bucket_name), std::move(index_names), options.build(), core::query_context{}, "", std::move(handler));
     ctx->execute();
 }
 
+auto
+query_index_manager::watch_indexes(std::string bucket_name,
+                                   std::vector<std::string> index_names,
+                                   const couchbase::watch_query_indexes_options& options) -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    watch_indexes(
+      std::move(bucket_name), std::move(index_names), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+
 void
-initiate_watch_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
-                             std::string bucket_name,
-                             std::vector<std::string> index_names,
-                             couchbase::watch_query_indexes_options::built options,
-                             watch_query_indexes_handler&& handler)
+collection_query_index_manager::watch_indexes(std::vector<std::string> index_names,
+                                              const watch_query_indexes_options& options,
+                                              watch_query_indexes_handler&& handler) const
 {
-    initiate_watch_query_indexes(core, std::move(bucket_name), std::move(index_names), options, {}, "", std::move(handler));
+    auto ctx = std::make_shared<couchbase::core::impl::watch_context>(core_,
+                                                                      bucket_name_,
+                                                                      std::move(index_names),
+                                                                      options.build(),
+                                                                      core::query_context(bucket_name_, scope_name_),
+                                                                      collection_name_,
+                                                                      std::move(handler));
+    ctx->execute();
 }
 
-} // namespace couchbase::core::impl
+auto
+collection_query_index_manager::watch_indexes(std::vector<std::string> index_names, const couchbase::watch_query_indexes_options& options)
+  -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    watch_indexes(std::move(index_names), options, [barrier](auto ctx) mutable { barrier->set_value(std::move(ctx)); });
+    return barrier->get_future();
+}
+} // namespace couchbase

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 = {})