couchbase 3.4.2 → 3.4.4

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)
@@ -379,7 +379,17 @@ 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(
+                                  "{} 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()) {
@@ -394,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));
                     }
@@ -406,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;
@@ -463,7 +473,16 @@ 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=\"{}:{}\"), {}",
+                                             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_) {
@@ -762,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,
@@ -788,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);
     }
@@ -844,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();
         }
     }
 
@@ -855,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));
     }
@@ -1039,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_;
@@ -1049,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_;
@@ -1138,11 +1164,19 @@ 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) };
-                auto config = protocol::parse_config(config_text, endpoint_address_, endpoint_.port());
+                if (origin_.options().dump_configuration) {
+                    CB_LOG_TRACE("{} configuration from not_my_vbucket response (size={}, endpoint=\"{}:{}\"), {}",
+                                 log_prefix_,
+                                 config_text.size(),
+                                 bootstrap_hostname_,
+                                 bootstrap_port_number_,
+                                 config_text);
+                }
+                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));
             }
@@ -1177,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();
@@ -1239,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(),
@@ -1326,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) {
@@ -1355,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 {
@@ -1392,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_,
@@ -1435,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 };
@@ -1455,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_{};
@@ -1555,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
@@ -1597,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)
 {
@@ -1610,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/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))
     {

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);

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

@@ -22,7 +22,8 @@
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
-static const std::string logger_name{ "couchbase_cxx_client_file_logger" };
+static const std::string file_logger_name{ "couchbase_cxx_client_file_logger" };
+static const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_logger" };
 
 /**
  * Custom log pattern which the loggers will use.
@@ -39,7 +40,12 @@ static const std::string log_pattern{ "[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %
  * messages and send them to the sinks, which do the actual writing (to file,
  * to stream etc.) or further processing.
  */
-static std::shared_ptr<spdlog::logger> file_logger;
+static std::shared_ptr<spdlog::logger> file_logger{};
+
+/**
+ * Instance of the protocol logger.
+ */
+static std::shared_ptr<spdlog::logger> protocol_logger{};
 
 namespace couchbase::core::logger
 {
@@ -146,13 +152,11 @@ is_initialized()
     return file_logger != nullptr;
 }
 
-/**
- * Initialises the loggers. Called if the logger configuration is
- * specified in a separate settings object.
- */
-std::optional<std::string>
-create_file_logger(const configuration& logger_settings)
+std::pair<std::optional<std::string>, std::shared_ptr<spdlog::logger>>
+create_file_logger_impl(const std::string logger_name, const configuration& logger_settings)
 {
+    std::shared_ptr<spdlog::logger> logger{};
+
     auto fname = logger_settings.filename;
     auto buffersz = logger_settings.buffer_size;
     auto cyclesz = logger_settings.cycle_size;
@@ -218,7 +222,7 @@ create_file_logger(const configuration& logger_settings)
         spdlog::drop(logger_name);
 
         if (logger_settings.unit_test) {
-            file_logger = std::make_shared<spdlog::logger>(logger_name, sink);
+            logger = std::make_shared<spdlog::logger>(logger_name, sink);
         } else {
             // Create the default thread pool for async logging
             spdlog::init_thread_pool(buffersz, 1);
@@ -226,23 +230,71 @@ create_file_logger(const configuration& logger_settings)
             // Get the thread pool so that we can actually construct the
             // object with already created sinks...
             auto tp = spdlog::thread_pool();
-            file_logger = std::make_shared<spdlog::async_logger>(logger_name, sink, tp, spdlog::async_overflow_policy::block);
+            logger = std::make_shared<spdlog::async_logger>(logger_name, sink, tp, spdlog::async_overflow_policy::block);
         }
 
-        file_logger->set_pattern(log_pattern);
-        file_logger->set_level(translate_level(logger_settings.log_level));
+        logger->set_pattern(log_pattern);
+        logger->set_level(translate_level(logger_settings.log_level));
 
         // Set the flushing interval policy
         spdlog::flush_every(std::chrono::seconds(1));
 
-        spdlog::register_logger(file_logger);
+        spdlog::register_logger(logger);
     } catch (const spdlog::spdlog_ex& ex) {
         std::string msg = std::string{ "Log initialization failed: " } + ex.what();
-        return std::optional<std::string>{ msg };
+        return { msg, {} };
+    }
+    return { {}, logger };
+}
+
+/**
+ * Initialises the loggers. Called if the logger configuration is
+ * specified in a separate settings object.
+ */
+std::optional<std::string>
+create_file_logger(const configuration& logger_settings)
+{
+    auto [error, logger] = create_file_logger_impl(file_logger_name, logger_settings);
+    if (error) {
+        return error;
+    }
+    file_logger = std::move(logger);
+    return {};
+}
+
+std::optional<std::string>
+create_protocol_logger(const configuration& logger_settings)
+{
+    if (logger_settings.filename.empty()) {
+        return "File name is missing";
+    }
+    auto config = logger_settings;
+    config.log_level = couchbase::core::logger::level::trace;
+    auto [error, logger] = create_file_logger_impl(protocol_logger_name, config);
+    if (error) {
+        return error;
     }
+    protocol_logger = std::move(logger);
     return {};
 }
 
+bool
+should_log_protocol()
+{
+    return protocol_logger != nullptr;
+}
+
+namespace detail
+{
+void
+log_protocol(const char* file, int line, const char* function, std::string_view msg)
+{
+    if (should_log_protocol()) {
+        return protocol_logger->log(spdlog::source_loc{ file, line, function }, spdlog::level::level_enum::trace, msg);
+    }
+}
+} // namespace detail
+
 spdlog::logger*
 get()
 {
@@ -252,17 +304,20 @@ get()
 void
 reset()
 {
-    spdlog::drop(logger_name);
+    spdlog::drop(file_logger_name);
     file_logger.reset();
+
+    spdlog::drop(protocol_logger_name);
+    protocol_logger.reset();
 }
 
 void
 create_blackhole_logger()
 {
     // delete if already exists
-    spdlog::drop(logger_name);
+    spdlog::drop(file_logger_name);
 
-    file_logger = std::make_shared<spdlog::logger>(logger_name, std::make_shared<spdlog::sinks::null_sink_mt>());
+    file_logger = std::make_shared<spdlog::logger>(file_logger_name, std::make_shared<spdlog::sinks::null_sink_mt>());
 
     file_logger->set_level(spdlog::level::off);
     file_logger->set_pattern(log_pattern);
@@ -274,11 +329,11 @@ void
 create_console_logger()
 {
     // delete if already exists
-    spdlog::drop(logger_name);
+    spdlog::drop(file_logger_name);
 
     auto stderrsink = std::make_shared<spdlog::sinks::stderr_color_sink_mt>();
 
-    file_logger = std::make_shared<spdlog::logger>(logger_name, stderrsink);
+    file_logger = std::make_shared<spdlog::logger>(file_logger_name, stderrsink);
     file_logger->set_level(spdlog::level::info);
     file_logger->set_pattern(log_pattern);
 
@@ -322,8 +377,13 @@ void
 set_log_levels(level lvl)
 {
     auto level = translate_level(lvl);
-    // Apply the function to each registered spdlog::logger
+    // Apply the function to each registered spdlog::logger except protocol logger
     spdlog::apply_all([level](std::shared_ptr<spdlog::logger> l) {
+        if (l->name() == protocol_logger_name) {
+            l->set_level(spdlog::level::trace);
+            return;
+        }
+
         try {
             l->set_level(level);
         } catch (const spdlog::spdlog_ex& e) {

data/ext/couchbase/core/logger/logger.hxx

@@ -54,6 +54,17 @@ level_from_str(const std::string& str);
 std::optional<std::string>
 create_file_logger(const configuration& logger_settings);
 
+/**
+ * Protocol logger writes only communication logs with the nodes.
+ *
+ * It accepts the same settings as a file logger, and writes only to the filesystem.
+ *
+ * @param logger_settings
+ * @return
+ */
+std::optional<std::string>
+create_protocol_logger(const configuration& logger_settings);
+
 /**
  * Initialize the logger with the blackhole logger object
  *
@@ -144,6 +155,9 @@ set_log_levels(level lvl);
 bool
 should_log(level lvl);
 
+bool
+should_log_protocol();
+
 namespace detail
 {
 /**
@@ -153,6 +167,9 @@ namespace detail
  */
 void
 log(const char* file, int line, const char* function, level lvl, std::string_view msg);
+
+void
+log_protocol(const char* file, int line, const char* function, std::string_view msg);
 } // namespace detail
 
 /**
@@ -168,6 +185,13 @@ log(const char* file, int line, const char* function, level lvl, const String& m
     detail::log(file, line, function, lvl, fmt::format(msg, std::forward<Args>(args)...));
 }
 
+template<typename String, typename... Args>
+inline void
+log_protocol(const char* file, int line, const char* function, const String& msg, Args&&... args)
+{
+    detail::log_protocol(file, line, function, fmt::format(msg, std::forward<Args>(args)...));
+}
+
 /**
  * Tell the logger to flush its buffers
  */
@@ -214,6 +238,13 @@ is_initialized();
 #define CB_LOG_CRITICAL(...)                                                                                                               \
     COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, couchbase::core::logger::level::critical, __VA_ARGS__)
 
+#define CB_LOG_PROTOCOL(...)                                                                                                               \
+    do {                                                                                                                                   \
+        if (couchbase::core::logger::should_log_protocol()) {                                                                              \
+            couchbase::core::logger::log_protocol(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, __VA_ARGS__);                             \
+        }                                                                                                                                  \
+    } while (false)
+
 /**
  * Convenience macros which log with the given level, and message, if the given
  * level is currently enabled.

data/ext/couchbase/core/meta/features.hxx

@@ -29,3 +29,28 @@
  * couchbase::core::meta::sdk_version() function is available
  */
 #define COUCHBASE_CXX_CLIENT_HAS_SDK_SEMVER 1
+
+/**
+ * couchbase::core::cluster_options and couchbase::security_options support
+ * passing TLS trust certificate by value
+ */
+#define COUCHBASE_CXX_CLIENT_CAN_PASS_TLS_TRUST_CERTIFICATE_BY_VALUE 1
+
+/**
+ *  Range scan is available in the core
+ *  couchbase::core::range_scan_orchestrator and relevant options in the core API
+ */
+#define COUCHBASE_CXX_CLIENT_CORE_HAS_RANGE_SCAN 1
+
+/**
+ * Query with reads from replica is available:
+ *  - use_replica field in couchbase::core::operations::query_request
+ *  - couchbase::query_options::use_replica()
+ */
+#define COUCHBASE_CXX_CLIENT_QUERY_READ_FROM_REPLICA 1
+
+/**
+ * Subdoc read from replica is available in the core
+ * couchbase::core::lookup_in_replica support
+ */
+#define COUCHBASE_CXX_CLIENT_CORE_HAS_SUBDOC_READ_REPLICA 1