couchbase 4.2.6-dev.1 → 4.2.6

package/CONTRIBUTING.md

@@ -0,0 +1,97 @@
+# Contributing
+
+In addition to filing bugs, you may contribute by submitting patches to fix bugs in the library. Contributions may be submitted to <http://review.couchbase.com>.  We use Gerrit as our code review system - and thus submitting a change requires an account there. While Github pull requests are not ignored, Gerrit pull requests will be responded to more quickly (and most likely with more detail).
+
+For something to be accepted into the codebase, it must be formatted properly and have undergone proper testing.
+
+## Branches and Tags
+
+* The `master` branch represents the mainline branch. The master branch typically consists of content going into the next release.
+* For older series of the Couchbase Node.js SDK see the corresponding branches: 2.x = `v2` and 3.x = `v3`.
+
+## Contributing Patches
+
+If you wish to contribute a new feature or a bug fix to the library, try to follow the following guidelines to help ensure your change gets merged upstream.
+
+### Before you begin
+
+For any code change, ensure the new code you write looks similar to the code surrounding it. We have no strict code style policies, but do request that your code stand out as little as possible from its surrounding neighborhood (unless of course your change is stylistic in nature).
+
+If your change is going to involve a substantial amount of time or effort, please attempt to discuss it with the project developers first who will provide assistance and direction where possible.
+
+#### For new features
+
+Ensure the feature you are adding does not already exist, and think about how this feature may be useful for other users. In general less intrusive changes are more likely to be accepted.
+
+#### For fixing bugs
+
+Ensure the bug you are fixing is actually a bug (and not a usage) error, and that it has not been fixed in a more recent version. Please read the [release notes](https://docs.couchbase.com/nodejs-sdk/current/project-docs/sdk-release-notes.html) as well as the [issue tracker](https://issues.couchbase.com/projects/JSCBC/issues/) to see a list of open and resolved issues.
+
+### Code Review
+
+#### Signing up on Gerrit
+
+Everything that is merged into the library goes through a code review process.  The code review process is done via [Gerrit](http://review.couchbase.org).
+
+To sign up for a Gerrit account, go to http://review.couchbase.org and click on the _Register_ link at the top right. Once you've signed in you will need to agree to the CLA (Contributor License Agreement) by going you your Gerrit account page and selecting the _Agreements_ link on the left. When you've done that, everything should flow through just fine.  Be sure that you have registered your email address at http://review.couchbase.org/#/settings/contact as many sign-up methods won't pass emails along.  Note that your email address in your code commit and in the Gerrit settings must match.
+
+Add your public SSH key to Gerrit before submitting.
+
+#### Setting up your fork with Gerrit
+
+Assuming you have a repository created like so:
+
+```
+$ git clone https://github.com/couchbase/couchnode.git
+```
+
+you can simply perform two simple steps to get started with Gerrit:
+
+```
+$ git remote add gerrit ssh://${USERNAME}@review.couchbase.org:29418/couchnode
+$ scp -P 29418 ${USERNAME}@review.couchbase.org:hooks/commit-msg .git/hooks
+$ chmod a+x .git/hooks/commit-msg
+```
+
+The last change is required for annotating each commit message with a special header known as `Change-Id`. This allows Gerrit to group together different revisions of the same patch.
+
+#### Pushing a changeset
+
+Now that you have your change and a Gerrit account to push to, you need to upload the change for review. To do so, invoke the following incantation:
+
+```
+$ git push gerrit HEAD:refs/for/master
+```
+
+Where `gerrit` is the name of the _remote_ added earlier.
+
+#### Pushing a new patchset
+
+After a change has been pushed to Gerrit, further revisions can be made and then uploaded.  These revisions are called patchsets and are associated with the the `Change-Id` created from the initial commit (see above).  To push a new revision, simply ammend the commit (can also add the `--no-edit` option if no edits to the commit message are needed):
+
+```
+$ git commit --amend
+```
+
+Then push the revision to Gerrit:
+
+```
+$ git push gerrit HEAD:refs/for/master
+```
+
+Where `gerrit` is the name of the _remote_ added earlier.
+
+#### Troubleshooting
+
+You may encounter some errors when pushing. The most common are:
+
+* "You are not authorized to push to this repository". You will get this if your account has not yet been approved.  Please reach out in the [forums](https://www.couchbase.com/forums/c/node-js-sdk/12) if blocked.
+* "Missing Change-Id". You need to install the `commit-msg` hook as described above.  Note that even once you do this, you will need to ensure that any prior commits already have this header - this may be done by doing an interactive rebase (e.g.  `git rebase -i origin/master` and selecting `reword` for all the commits; which will automatically fill in the Change-Id).
+
+#### Reviewers
+
+Once you've pushed your changeset you can add people to review. Currently these are:
+
+* Jared Casey
+* Matt Wozakowski
+* Brett Lawson

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

@@ -72,16 +72,25 @@ 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={}{:a}",
+        CB_LOG_TRACE("Query DNS-SRV (UDP) address=\"{}:{}\", udp_timeout={}, total_timeout={}",
                      address_.to_string(),
                      port_,
                      udp_timeout,
-                     total_timeout,
-                     spdlog::to_hex(send_buf_));
+                     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, address=\"{}:{}\", ec={}",
@@ -94,6 +103,13 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
               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, address=\"{}:{}\", ec={}",
@@ -168,10 +184,18 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
             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_TRACE(
-              "Query DNS-SRV (TCP) address=\"{}:{}\"{:a}", self->address_.to_string(), self->port_, spdlog::to_hex(self->send_buf_));
+            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, address=\"{}:{}\", ec={}",
                                    self->address_.to_string(),
@@ -186,7 +210,14 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
                   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 {
+                    [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(),
@@ -199,8 +230,15 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
                         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->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(),
@@ -208,7 +246,7 @@ class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
                                                ec4.message());
                                   return self->handler_({ ec4 });
                               }
-                              self->recv_buf_.resize(bytes_transferred);
+                              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());

package/deps/couchbase-cxx-client/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;
             }

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

@@ -1365,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) {
@@ -1433,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_,

package/deps/couchbase-cxx-client/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);

package/deps/couchbase-cxx-client/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) {

package/deps/couchbase-cxx-client/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.

package/deps/couchbase-cxx-client/core/meta/features.hxx

@@ -35,3 +35,9 @@
  * 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

package/deps/couchbase-cxx-client/core/range_scan_orchestrator.cxx

@@ -412,13 +412,33 @@ class range_scan_orchestrator_impl
             return tl::unexpected(errc::common::invalid_argument);
         }
 
+        // Get the collection ID before starting any of the streams
+        {
+            auto barrier = std::make_shared<std::promise<tl::expected<get_collection_id_result, std::error_code>>>();
+            auto f = barrier->get_future();
+            get_collection_id_options const get_cid_options{ options_.retry_strategy, options_.timeout, options_.parent_span };
+            agent_.get_collection_id(scope_name_, collection_name_, get_cid_options, [barrier](auto result, auto ec) {
+                if (ec) {
+                    return barrier->set_value(tl::unexpected(ec));
+                }
+                barrier->set_value(result);
+            });
+            auto get_cid_res = f.get();
+            if (!get_cid_res.has_value()) {
+                return tl::unexpected(get_cid_res.error());
+            }
+            collection_id_ = get_cid_res->collection_id;
+        }
+
         auto batch_time_limit = std::chrono::duration_cast<std::chrono::milliseconds>(0.9 * options_.timeout);
         range_scan_continue_options const continue_options{
             options_.batch_item_limit, options_.batch_byte_limit, batch_time_limit, options_.timeout, options_.retry_strategy,
         };
         for (std::uint16_t vbucket = 0; vbucket < gsl::narrow_cast<std::uint16_t>(vbucket_map_.size()); ++vbucket) {
             const range_scan_create_options create_options{
-                scope_name_,       collection_name_,        scan_type_, options_.timeout, {}, vbucket_to_snapshot_requirements_[vbucket],
+                scope_name_,       {},
+                scan_type_,        options_.timeout,
+                collection_id_,    vbucket_to_snapshot_requirements_[vbucket],
                 options_.ids_only, options_.retry_strategy,
             };
 
@@ -653,6 +673,7 @@ class range_scan_orchestrator_impl
     topology::configuration::vbucket_map vbucket_map_;
     std::string scope_name_;
     std::string collection_name_;
+    std::uint32_t collection_id_;
     std::variant<std::monostate, range_scan, prefix_scan, sampling_scan> scan_type_;
     range_scan_orchestrator_options options_;
     std::map<std::size_t, std::optional<range_snapshot_requirements>> vbucket_to_snapshot_requirements_;

package/deps/couchbase-cxx-client/core/topology/capabilities.hxx

@@ -31,6 +31,7 @@ enum class bucket_capability {
     collections,
     durable_write,
     tombstoned_user_xattrs,
+    range_scan,
 };
 
 enum class cluster_capability {

package/deps/couchbase-cxx-client/core/topology/capabilities_fmt.hxx

@@ -67,6 +67,9 @@ struct fmt::formatter<couchbase::core::bucket_capability> {
             case couchbase::core::bucket_capability::tombstoned_user_xattrs:
                 name = "tombstoned_user_xattrs";
                 break;
+            case couchbase::core::bucket_capability::range_scan:
+                name = "range_scan";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }

package/deps/couchbase-cxx-client/core/topology/configuration.hxx

@@ -117,6 +117,11 @@ struct configuration {
         return cluster_capabilities.find(cluster_capability::n1ql_read_from_replica) != cluster_capabilities.end();
     }
 
+    [[nodiscard]] bool supports_range_scan() const
+    {
+        return bucket_capabilities.find(bucket_capability::range_scan) != bucket_capabilities.end();
+    }
+
     [[nodiscard]] bool ephemeral() const
     {
         // Use bucket capabilities to identify if couchapi is missing (then its ephemeral). If its null then

package/deps/couchbase-cxx-client/core/topology/configuration_json.hxx

@@ -233,6 +233,8 @@ struct traits<couchbase::core::topology::configuration> {
                     result.bucket_capabilities.insert(couchbase::core::bucket_capability::nodes_ext);
                 } else if (name == "xattr") {
                     result.bucket_capabilities.insert(couchbase::core::bucket_capability::xattr);
+                } else if (name == "rangeScan") {
+                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::range_scan);
                 }
             }
         }

package/deps/couchbase-cxx-client/docs/cbc-analytics.md

@@ -34,8 +34,9 @@ Execute one or more Analytics queries and print results to standard output.
 ### LOGGER OPTIONS
 
 <dl>
-<dt>`--log-level=LEVEL`</dt><dd>Log level (allowed values are: `trace`, `debug`, `info`, `warning`, `error`, `critical`, `off`). [default: `off`]
-<dt>`--log-output=PATH`</dt><dd>File to send logs (when is not set, logs will be written to STDERR).
+<dt>`--log-level=LEVEL`</dt><dd>Log level (allowed values are: `trace`, `debug`, `info`, `warning`, `error`, `critical`, `off`). [default: `off`]</dd>
+<dt>`--log-output=PATH`</dt><dd>File to send logs (when is not set, logs will be written to STDERR).</dd>
+<dt>`--log-protocol=PATH`</dt><dd>File to send protocol logs.</dd>
 </dl>
 
 ### CONNECTION OPTIONS

package/deps/couchbase-cxx-client/docs/cbc-get.md

@@ -34,8 +34,9 @@ Retrieve one or more documents from the server and print them to standard output
 ### LOGGER OPTIONS
 
 <dl>
-<dt>`--log-level=LEVEL`</dt><dd>Log level (allowed values are: `trace`, `debug`, `info`, `warning`, `error`, `critical`, `off`). [default: `off`]
-<dt>`--log-output=PATH`</dt><dd>File to send logs (when is not set, logs will be written to STDERR).
+<dt>`--log-level=LEVEL`</dt><dd>Log level (allowed values are: `trace`, `debug`, `info`, `warning`, `error`, `critical`, `off`). [default: `off`]</dd>
+<dt>`--log-output=PATH`</dt><dd>File to send logs (when is not set, logs will be written to STDERR).</dd>
+<dt>`--log-protocol=PATH`</dt><dd>File to send protocol logs.</dd>
 </dl>
 
 ### CONNECTION OPTIONS

package/deps/couchbase-cxx-client/docs/cbc-pillowfight.md

@@ -41,8 +41,9 @@ Run simple workload generator that sends GET/UPSERT requests with optional N1QL
 ### LOGGER OPTIONS
 
 <dl>
-<dt>`--log-level=LEVEL`</dt><dd>Log level (allowed values are: `trace`, `debug`, `info`, `warning`, `error`, `critical`, `off`). [default: `off`]
-<dt>`--log-output=PATH`</dt><dd>File to send logs (when is not set, logs will be written to STDERR).
+<dt>`--log-level=LEVEL`</dt><dd>Log level (allowed values are: `trace`, `debug`, `info`, `warning`, `error`, `critical`, `off`). [default: `off`]</dd>
+<dt>`--log-output=PATH`</dt><dd>File to send logs (when is not set, logs will be written to STDERR).</dd>
+<dt>`--log-protocol=PATH`</dt><dd>File to send protocol logs.</dd>
 </dl>
 
 ### CONNECTION OPTIONS

package/deps/couchbase-cxx-client/docs/cbc-query.md

@@ -42,8 +42,9 @@ Execute one or more N1QL queries and print results to standard output.
 ### LOGGER OPTIONS
 
 <dl>
-<dt>`--log-level=LEVEL`</dt><dd>Log level (allowed values are: `trace`, `debug`, `info`, `warning`, `error`, `critical`, `off`). [default: `off`]
-<dt>`--log-output=PATH`</dt><dd>File to send logs (when is not set, logs will be written to STDERR).
+<dt>`--log-level=LEVEL`</dt><dd>Log level (allowed values are: `trace`, `debug`, `info`, `warning`, `error`, `critical`, `off`). [default: `off`]</dd>
+<dt>`--log-output=PATH`</dt><dd>File to send logs (when is not set, logs will be written to STDERR).</dd>
+<dt>`--log-protocol=PATH`</dt><dd>File to send protocol logs.</dd>
 </dl>
 
 ### CONNECTION OPTIONS

package/deps/couchbase-cxx-client/test/utils/logger.cxx

@@ -16,6 +16,7 @@
  */
 
 #include "core/logger/logger.hxx"
+#include "core/logger/configuration.hxx"
 
 #include <spdlog/details/os.h>
 #include <spdlog/spdlog.h>
@@ -32,9 +33,15 @@ init_logger()
         if (auto env_val = spdlog::details::os::getenv("TEST_LOG_LEVEL"); !env_val.empty()) {
             couchbase::core::logger::set_log_levels(couchbase::core::logger::level_from_str(env_val));
         }
+        if (auto env_val = spdlog::details::os::getenv("TEST_LOG_PROTOCOL"); !env_val.empty()) {
+            couchbase::core::logger::configuration configuration{};
+            configuration.filename = env_val;
+            couchbase::core::logger::create_protocol_logger(configuration);
+        }
         if (auto env_val = spdlog::details::os::getenv("TEST_LOG_INCLUDE_LOCATION"); !env_val.empty()) {
             spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v at %@ %!");
         }
+
         initialized = true;
     }
 }

package/deps/couchbase-cxx-client/tools/utils.cxx

@@ -367,8 +367,9 @@ usage_block_for_logger() -> std::string
 
     return fmt::format(R"(
 Logger options:
-  --log-level=LEVEL  Log level (allowed values are: {allowed_levels}). CBC_LOG_LEVEL. [default: {log_level}]
-  --log-output=PATH  File to send logs (when is not set, logs will be written to STDERR).
+  --log-level=LEVEL    Log level (allowed values are: {allowed_levels}). CBC_LOG_LEVEL. [default: {log_level}]
+  --log-output=PATH    File to send logs (when is not set, logs will be written to STDERR).
+  --log-protocol=PATH  File to send protocol logs.
 )",
                        fmt::arg("allowed_levels", fmt::join(allowed_log_levels, ", ")),
                        fmt::arg("log_level", default_log_level()));
@@ -393,6 +394,12 @@ apply_logger_options(const docopt::Options& options)
         couchbase::core::logger::create_file_logger(configuration);
     }
 
+    if (options.find("--log-protocol") != options.end() && options.at("--log-protocol")) {
+        couchbase::core::logger::configuration configuration{};
+        configuration.filename = options.at("--log-protocol").asString();
+        couchbase::core::logger::create_protocol_logger(configuration);
+    }
+
     spdlog::set_level(spdlog::level::from_str(log_level));
     couchbase::core::logger::set_log_levels(level);
 }

package/dist/binding.d.ts

@@ -2671,6 +2671,8 @@ export interface CppTransaction {
 export interface CppBinding extends CppBindingAutogen {
     cbppVersion: string;
     cbppMetadata: string;
+    enableProtocolLogger: (filename: string) => void;
+    shutdownLogger: () => void;
     Connection: {
         new (): CppConnection;
     };

package/dist/couchbase.d.ts

@@ -23,6 +23,21 @@ export declare const lcbVersion: string;
  */
 export declare const cbppVersion: string;
 export declare const cbppMetadata: string;
+/**
+ * Volatile: This API is subject to change at any time.
+ *
+ * Exposes the underlying couchbase++ library protocol logger.  This method is for
+ * logging/debugging purposes and must be used with caution as network details will
+ * be logged to the provided file.
+ */
+export declare function enableProtocolLoggerToSaveNetworkTrafficToFile(filename: string): void;
+/**
+ * Volatile: This API is subject to change at any time.
+ *
+ * Shutdowns the underlying couchbase++ logger.
+ *
+ */
+export declare function shutdownLogger(): void;
 export * from './analyticsindexmanager';
 export * from './analyticstypes';
 export * from './authenticators';

package/dist/couchbase.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cbppMetadata = exports.cbppVersion = exports.lcbVersion = exports.connect = void 0;
+exports.shutdownLogger = exports.enableProtocolLoggerToSaveNetworkTrafficToFile = exports.cbppMetadata = exports.cbppVersion = exports.lcbVersion = exports.connect = void 0;
 const binding_1 = __importDefault(require("./binding"));
 const cluster_1 = require("./cluster");
 /**
@@ -46,6 +46,27 @@ exports.lcbVersion = binding_1.default.cbppVersion;
  */
 exports.cbppVersion = binding_1.default.cbppVersion;
 exports.cbppMetadata = binding_1.default.cbppMetadata;
+/**
+ * Volatile: This API is subject to change at any time.
+ *
+ * Exposes the underlying couchbase++ library protocol logger.  This method is for
+ * logging/debugging purposes and must be used with caution as network details will
+ * be logged to the provided file.
+ */
+function enableProtocolLoggerToSaveNetworkTrafficToFile(filename) {
+    binding_1.default.enableProtocolLogger(filename);
+}
+exports.enableProtocolLoggerToSaveNetworkTrafficToFile = enableProtocolLoggerToSaveNetworkTrafficToFile;
+/**
+ * Volatile: This API is subject to change at any time.
+ *
+ * Shutdowns the underlying couchbase++ logger.
+ *
+ */
+function shutdownLogger() {
+    binding_1.default.shutdownLogger();
+}
+exports.shutdownLogger = shutdownLogger;
 __exportStar(require("./analyticsindexmanager"), exports);
 __exportStar(require("./analyticstypes"), exports);
 __exportStar(require("./authenticators"), exports);

package/package.json

@@ -55,7 +55,7 @@
     "type": "git",
     "url": "http://github.com/couchbase/couchnode.git"
   },
-  "version": "4.2.6-dev.1",
+  "version": "4.2.6",
   "config": {
     "native": false
   },
@@ -80,17 +80,17 @@
     ]
   },
   "optionalDependencies": {
-    "@couchbase/couchbase-darwin-arm64-openssl1": "4.2.6-dev.1",
-    "@couchbase/couchbase-darwin-arm64-openssl3": "4.2.6-dev.1",
-    "@couchbase/couchbase-darwin-x64-openssl1": "4.2.6-dev.1",
-    "@couchbase/couchbase-darwin-x64-openssl3": "4.2.6-dev.1",
-    "@couchbase/couchbase-linux-arm64-openssl1": "4.2.6-dev.1",
-    "@couchbase/couchbase-linux-arm64-openssl3": "4.2.6-dev.1",
-    "@couchbase/couchbase-linux-x64-openssl1": "4.2.6-dev.1",
-    "@couchbase/couchbase-linux-x64-openssl3": "4.2.6-dev.1",
-    "@couchbase/couchbase-linuxmusl-x64-openssl1": "4.2.6-dev.1",
-    "@couchbase/couchbase-linuxmusl-x64-openssl3": "4.2.6-dev.1",
-    "@couchbase/couchbase-win32-x64-openssl1": "4.2.6-dev.1",
-    "@couchbase/couchbase-win32-x64-openssl3": "4.2.6-dev.1"
+    "@couchbase/couchbase-darwin-arm64-openssl1": "4.2.6",
+    "@couchbase/couchbase-darwin-arm64-openssl3": "4.2.6",
+    "@couchbase/couchbase-darwin-x64-openssl1": "4.2.6",
+    "@couchbase/couchbase-darwin-x64-openssl3": "4.2.6",
+    "@couchbase/couchbase-linux-arm64-openssl1": "4.2.6",
+    "@couchbase/couchbase-linux-arm64-openssl3": "4.2.6",
+    "@couchbase/couchbase-linux-x64-openssl1": "4.2.6",
+    "@couchbase/couchbase-linux-x64-openssl3": "4.2.6",
+    "@couchbase/couchbase-linuxmusl-x64-openssl1": "4.2.6",
+    "@couchbase/couchbase-linuxmusl-x64-openssl3": "4.2.6",
+    "@couchbase/couchbase-win32-x64-openssl1": "4.2.6",
+    "@couchbase/couchbase-win32-x64-openssl3": "4.2.6"
   }
 }

package/src/binding.cpp

@@ -6,12 +6,36 @@
 #include "scan_iterator.hpp"
 #include "transaction.hpp"
 #include "transactions.hpp"
+#include <core/logger/configuration.hxx>
 #include <napi.h>
 #include <spdlog/spdlog.h>
 
 namespace couchnode
 {
 
+Napi::Value enable_protocol_logger(const Napi::CallbackInfo &info)
+{
+    try {
+        auto filename = info[0].ToString().Utf8Value();
+        couchbase::core::logger::configuration configuration{};
+        configuration.filename = filename;
+        couchbase::core::logger::create_protocol_logger(configuration);
+    } catch (...) {
+        return Napi::Error::New(info.Env(), "Unexpected C++ error").Value();
+    }
+    return info.Env().Null();
+}
+
+Napi::Value shutdown_logger(const Napi::CallbackInfo &info)
+{
+    try {
+        couchbase::core::logger::shutdown();
+    } catch (...) {
+        return Napi::Error::New(info.Env(), "Unexpected C++ error").Value();
+    }
+    return info.Env().Null();
+}
+
 Napi::Object Init(Napi::Env env, Napi::Object exports)
 {
     spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v");
@@ -63,6 +87,10 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     exports.Set(
         Napi::String::New(env, "cbppMetadata"),
         Napi::String::New(env, couchbase::core::meta::sdk_build_info_json()));
+    exports.Set(Napi::String::New(env, "enableProtocolLogger"),
+                Napi::Function::New<enable_protocol_logger>(env));
+    exports.Set(Napi::String::New(env, "shutdownLogger"),
+                Napi::Function::New<shutdown_logger>(env));
     return exports;
 }