couchbase 4.1.1 → 4.1.2

package/deps/couchbase-cxx-client/.gitmodules

@@ -3,7 +3,8 @@
 	url = https://github.com/microsoft/gsl.git
 [submodule "third_party/json"]
 	path = third_party/json
-	url = https://github.com/taocpp/json.git
+	url = https://github.com/couchbasedeps/taocpp-json.git
+    branch = 1.0.0-couchbase
 [submodule "third_party/spdlog"]
 	path = third_party/spdlog
 	url = https://github.com/gabime/spdlog.git

package/deps/couchbase-cxx-client/cmake/CompilerWarnings.cmake

@@ -7,6 +7,7 @@ function(set_project_warnings project_name)
 
   set(MSVC_WARNINGS
       /W4 # Baseline reasonable warnings
+      /wd4189 # 'identifier': local variable is initialized but not referenced
       /wd4242 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
       /wd4244 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
       /w14254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data

package/deps/couchbase-cxx-client/cmake/OpenSSL.cmake

@@ -1,4 +1,5 @@
 option(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL "Rely on application to link OpenSSL library" FALSE)
+option(COUCHBASE_CXX_CLIENT_USE_HOMEBREW_TO_DETECT_OPENSSL "Use homebrew to determine OpenSSL root directory" TRUE)
 
 if(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
   message(
@@ -9,6 +10,13 @@ else()
   if(COUCHBASE_CXX_CLIENT_STATIC_OPENSSL)
     set(OPENSSL_USE_STATIC_LIBS ON)
   endif()
+  if(APPLE AND COUCHBASE_CXX_CLIENT_USE_HOMEBREW_TO_DETECT_OPENSSL)
+    execute_process(
+      COMMAND brew --prefix openssl@1.1
+      OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+    message(STATUS "Found OpenSSL prefix using homebrew: ${OPENSSL_ROOT_DIR}")
+  endif()
   include(FindOpenSSL)
   if(OPENSSL_LIBRARIES AND OPENSSL_INCLUDE_DIR)
     message(STATUS "OPENSSL_VERSION: ${OPENSSL_VERSION}")

package/deps/couchbase-cxx-client/couchbase/cluster.cxx

@@ -28,7 +28,7 @@ class ping_collector : public std::enable_shared_from_this<ping_collector>
 
   public:
     ping_collector(std::string report_id, utils::movable_function<void(diag::ping_result)>&& handler)
-      : res_{ std::move(report_id), couchbase::meta::sdk_id() }
+      : res_{ std::move(report_id), meta::sdk_id() }
       , handler_(std::move(handler))
     {
     }
@@ -45,7 +45,7 @@ class ping_collector : public std::enable_shared_from_this<ping_collector>
 
     auto build_reporter()
     {
-        expected_++;
+        ++expected_;
         return [self = this->shared_from_this()](diag::endpoint_ping_info&& info) {
             std::scoped_lock lock(self->mutex_);
             self->res_.services[info.type].emplace_back(std::move(info));
@@ -74,27 +74,40 @@ cluster::do_ping(std::optional<std::string> report_id,
         report_id = std::make_optional(uuid::to_string(uuid::random()));
     }
     if (stopped_) {
-        return handler({ report_id.value(), couchbase::meta::sdk_id() });
+        return handler({ report_id.value(), meta::sdk_id() });
     }
     if (services.empty()) {
-        services = { service_type::key_value, service_type::view, service_type::query, service_type::search, service_type::analytics };
+        services = {
+            service_type::key_value, service_type::view,       service_type::query,    service_type::search,
+            service_type::analytics, service_type::management, service_type::eventing,
+        };
     }
-    asio::post(asio::bind_executor(ctx_, [this, report_id, bucket_name, services, handler = std::move(handler)]() mutable {
-        auto collector = std::make_shared<ping_collector>(report_id.value(), std::move(handler));
-        if (bucket_name) {
-            if (services.find(service_type::key_value) != services.end()) {
-                for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
-            }
-        } else {
-            if (services.find(service_type::key_value) != services.end()) {
-                if (session_) {
-                    session_->ping(collector->build_reporter());
-                }
-                for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
-            }
-            session_manager_->ping(services, collector, origin_.credentials());
-        }
-    }));
+    asio::post(
+      asio::bind_executor(ctx_, [cluster = shared_from_this(), report_id, bucket_name, services, handler = std::move(handler)]() mutable {
+          auto collector = std::make_shared<ping_collector>(report_id.value(), std::move(handler));
+          if (bucket_name) {
+              if (services.find(service_type::key_value) != services.end()) {
+                  if (auto bucket = cluster->find_bucket_by_name(bucket_name.value()); bucket) {
+                      return bucket->ping(collector);
+                  }
+                  cluster->open_bucket(bucket_name.value(), [collector, cluster, bucket_name](std::error_code ec) {
+                      if (!ec) {
+                          if (auto bucket = cluster->find_bucket_by_name(bucket_name.value()); bucket) {
+                              return bucket->ping(collector);
+                          }
+                      }
+                  });
+              }
+          } else {
+              if (services.find(service_type::key_value) != services.end()) {
+                  if (cluster->session_) {
+                      cluster->session_->ping(collector->build_reporter());
+                  }
+                  cluster->for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
+              }
+              cluster->session_manager_->ping(services, collector, cluster->origin_.credentials());
+          }
+      }));
 }
 
 std::shared_ptr<bucket>

package/deps/couchbase-cxx-client/couchbase/crypto/cbcrypto.cc

@@ -50,7 +50,7 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
     DWORD cbHashObject = 0;
 
     // calculate the size of the buffer to hold the hash object
-    status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, (PBYTE)&cbHashObject, sizeof(DWORD), &pcbResult, 0);
+    status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, reinterpret_cast<PBYTE>(&cbHashObject), sizeof(DWORD), &pcbResult, 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptGetProperty return: " + std::to_string(status));
@@ -58,14 +58,14 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
 
     // calculate the length of the hash
     DWORD cbHash = 0;
-    status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, (PBYTE)&cbHash, sizeof(DWORD), &pcbResult, 0);
+    status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, reinterpret_cast<PBYTE>(&cbHash), sizeof(DWORD), &pcbResult, 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptGetProperty return: " + std::to_string(status));
     }
 
     // allocate the hash object on the heap
-    uniqueHeapPtr pbHashObject((PBYTE)HeapAlloc(GetProcessHeap(), 0, cbHashObject));
+    uniqueHeapPtr pbHashObject(static_cast<PBYTE>(HeapAlloc(GetProcessHeap(), 0, cbHashObject)));
     if (!pbHashObject) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::bad_alloc();
@@ -76,13 +76,13 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
 
     // create the hash
     BCRYPT_HASH_HANDLE hHash;
-    status = BCryptCreateHash(hAlg, &hHash, pbHashObject.get(), cbHashObject, (PUCHAR)key.data(), ULONG(key.size()), 0);
+    status = BCryptCreateHash(hAlg, &hHash, pbHashObject.get(), cbHashObject, (PUCHAR)key.data(), static_cast<ULONG>(key.size()), 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptCreateHash return: " + std::to_string(status));
     }
 
-    status = BCryptHashData(hHash, (PBYTE)data.data(), ULONG(data.size()), 0);
+    status = BCryptHashData(hHash, (PBYTE)data.data(), static_cast<ULONG>(data.size()), 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         BCryptDestroyHash(hHash);

package/deps/couchbase-cxx-client/couchbase/document_id.cxx

@@ -17,6 +17,9 @@
 
 #include <couchbase/document_id.hxx>
 
+#include <couchbase/utils/binary.hxx>
+#include <couchbase/utils/unsigned_leb128.hxx>
+
 #include <fmt/core.h>
 
 #include <algorithm>
@@ -25,9 +28,9 @@
 namespace couchbase
 {
 document_id::document_id()
-  : scope_("_default")
-  , collection_("_default")
-  , collection_path_("_default._default")
+  : scope_{ "_default" }
+  , collection_{ "_default" }
+  , collection_path_{ "_default._default" }
 {
 }
 
@@ -86,4 +89,18 @@ document_id::has_default_collection() const
 {
     return !use_collections_ || collection_path_ == "_default._default";
 }
+
+std::vector<std::byte>
+make_protocol_key(const document_id& id)
+{
+    std::vector<std::byte> key{};
+    if (id.is_collection_resolved()) {
+        utils::unsigned_leb128<std::uint32_t> encoded(id.collection_uid());
+        key.reserve(encoded.size());
+        key.insert(key.end(), encoded.begin(), encoded.end());
+    }
+    key.reserve(key.size() + id.key().size());
+    couchbase::utils::to_binary(id.key(), std::back_insert_iterator(key));
+    return key;
+}
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/document_id.hxx

@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace couchbase
 {
@@ -99,4 +100,8 @@ struct document_id {
     bool use_collections_{ true };
     bool use_any_session_{ false };
 };
+
+[[nodiscard]] std::vector<std::byte>
+make_protocol_key(const document_id& id);
+
 } // namespace couchbase

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

@@ -154,7 +154,7 @@ class dns_client
                             return handler({ ec2 });
                         }
                         asio::async_read(self->tcp_,
-                                         asio::buffer(&self->recv_buf_size_, sizeof(self->recv_buf_size_)),
+                                         asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
                                          [self, handler = std::forward<Handler>(handler)](std::error_code ec3,
                                                                                           std::size_t /* bytes_transferred */) mutable {
                                              if (ec3) {

package/deps/couchbase-cxx-client/couchbase/io/http_parser.cxx

@@ -125,7 +125,7 @@ http_parser::error_message() const
 
     switch (state_->parser_.http_errno) {
         HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
-    };
+    }
 #undef HTTP_ERRNO_GEN
     return "unknown error: " + std::to_string(state_->parser_.http_errno);
 }

package/deps/couchbase-cxx-client/couchbase/io/http_session.hxx

@@ -397,7 +397,11 @@ class http_session : public std::enable_shared_from_this<http_session>
                         it->endpoint().port(),
                         ec.message(),
                         (ec == asio::error::connection_refused) ? ", check server ports and cluster encryption setting" : "");
-            do_connect(++it);
+            if (stream_->is_open()) {
+                stream_->close(std::bind(&http_session::do_connect, shared_from_this(), ++it));
+            } else {
+                do_connect(++it);
+            }
         } else {
             state_ = diag::endpoint_state::connected;
             connected_ = true;
@@ -406,7 +410,6 @@ class http_session : public std::enable_shared_from_this<http_session>
                 std::scoped_lock lock(info_mutex_);
                 info_ = http_session_info(client_id_, id_, stream_->local_endpoint(), it->endpoint());
             }
-            deadline_timer_.expires_at(asio::steady_timer::time_point::max());
             deadline_timer_.cancel();
             flush();
         }
@@ -419,7 +422,8 @@ class http_session : public std::enable_shared_from_this<http_session>
         }
         if (deadline_timer_.expiry() <= asio::steady_timer::clock_type::now()) {
             stream_->close([](std::error_code) {});
-            deadline_timer_.expires_at(asio::steady_timer::time_point::max());
+            deadline_timer_.cancel();
+            return;
         }
         deadline_timer_.async_wait(std::bind(&http_session::check_deadline, shared_from_this(), std::placeholders::_1));
     }

package/deps/couchbase-cxx-client/couchbase/io/http_session_manager.hxx

@@ -99,7 +99,10 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
     template<typename Collector>
     void ping(std::set<service_type> services, std::shared_ptr<Collector> collector, const couchbase::cluster_credentials& credentials)
     {
-        std::array<service_type, 4> known_types{ service_type::query, service_type::analytics, service_type::search, service_type::view };
+        std::array known_types{
+            service_type::query, service_type::analytics, service_type::search,
+            service_type::view,  service_type::eventing,  service_type::management,
+        };
         std::vector<topology::configuration::node> nodes{};
         {
             std::scoped_lock lock(config_mutex_);
@@ -229,6 +232,7 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
 
     void close()
     {
+        std::scoped_lock lock(sessions_mutex_);
         for (auto& [type, sessions] : idle_sessions_) {
             for (auto& s : sessions) {
                 if (s) {

package/deps/couchbase-cxx-client/couchbase/io/mcbp_command.hxx

@@ -239,12 +239,12 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
               protocol::status status = protocol::status::invalid;
               std::optional<error_map::error_info> error_code{};
               if (protocol::is_valid_status(msg.header.status())) {
-                  status = protocol::status(msg.header.status());
+                  status = static_cast<protocol::status>(msg.header.status());
               } else {
                   error_code = self->session_->decode_error_code(msg.header.status());
               }
               if (status == protocol::status::not_my_vbucket) {
-                  self->session_->handle_not_my_vbucket(std::move(msg));
+                  self->session_->handle_not_my_vbucket(msg);
                   return io::retry_orchestrator::maybe_retry(self->manager_, self, io::retry_reason::kv_not_my_vbucket, ec);
               }
               if (status == protocol::status::unknown_collection) {

package/deps/couchbase-cxx-client/couchbase/io/mcbp_message.hxx

@@ -26,7 +26,7 @@ namespace couchbase
 namespace protocol
 {
 static const std::size_t header_size = 24;
-using header_buffer = std::array<std::uint8_t, header_size>;
+using header_buffer = std::array<std::byte, header_size>;
 } // namespace protocol
 
 namespace io
@@ -47,7 +47,7 @@ struct binary_header {
 
 struct mcbp_message {
     binary_header header;
-    std::vector<std::uint8_t> body;
+    std::vector<std::byte> body;
 
     [[nodiscard]] protocol::header_buffer header_data() const;
 };

package/deps/couchbase-cxx-client/couchbase/io/mcbp_parser.cxx

@@ -22,11 +22,12 @@
 #include <couchbase/protocol/magic.hxx>
 #include <couchbase/utils/byteswap.hxx>
 
-#include <cstring>
-#include <gsl/assert>
 #include <snappy.h>
 #include <spdlog/fmt/bin_to_hex.h>
 
+#include <algorithm>
+#include <cstring>
+
 namespace couchbase::io
 {
 mcbp_parser::result
@@ -44,22 +45,23 @@ mcbp_parser::next(mcbp_message& msg)
     msg.body.clear();
     msg.body.reserve(body_size);
     std::uint32_t key_size = utils::byte_swap(msg.header.keylen);
-    std::uint32_t prefix_size = std::uint32_t(msg.header.extlen) + key_size;
+    std::uint32_t prefix_size = static_cast<std::uint32_t>(msg.header.extlen) + key_size;
     if (msg.header.magic == static_cast<uint8_t>(protocol::magic::alt_client_response)) {
         std::uint8_t framing_extras_size = msg.header.keylen & 0xfU;
         key_size = (msg.header.keylen & 0xf0U) >> 8U;
-        prefix_size = std::uint32_t(framing_extras_size) + std::uint32_t(msg.header.extlen) + key_size;
+        prefix_size = static_cast<std::uint32_t>(framing_extras_size) + static_cast<std::uint32_t>(msg.header.extlen) + key_size;
     }
     std::copy(buf.begin() + header_size, buf.begin() + header_size + prefix_size, std::back_insert_iterator(msg.body));
 
-    bool is_compressed = (msg.header.datatype & static_cast<uint8_t>(protocol::datatype::snappy)) != 0;
+    bool is_compressed = (msg.header.datatype & static_cast<std::uint8_t>(protocol::datatype::snappy)) != 0;
     bool use_raw_value = true;
     if (is_compressed) {
         std::string uncompressed;
         size_t offset = header_size + prefix_size;
-        bool success = snappy::Uncompress(reinterpret_cast<const char*>(buf.data() + offset), body_size - prefix_size, &uncompressed);
-        if (success) {
-            std::copy(uncompressed.begin(), uncompressed.end(), std::back_insert_iterator(msg.body));
+        if (snappy::Uncompress(reinterpret_cast<const char*>(buf.data() + offset), body_size - prefix_size, &uncompressed)) {
+            std::transform(uncompressed.begin(), uncompressed.end(), std::back_insert_iterator(msg.body), [](auto ch) {
+                return static_cast<std::byte>(ch);
+            });
             use_raw_value = false;
             // patch header with new body size
             msg.header.bodylen = utils::byte_swap(static_cast<std::uint32_t>(prefix_size + uncompressed.size()));
@@ -69,7 +71,7 @@ mcbp_parser::next(mcbp_message& msg)
         std::copy(buf.begin() + header_size + prefix_size, buf.begin() + header_size + body_size, std::back_insert_iterator(msg.body));
     }
     buf.erase(buf.begin(), buf.begin() + header_size + body_size);
-    if (!buf.empty() && !protocol::is_valid_magic(buf[0])) {
+    if (!buf.empty() && !protocol::is_valid_magic(std::to_integer<std::uint8_t>(buf[0]))) {
         LOG_WARNING("parsed frame for magic={:x}, opcode={:x}, opaque={}, body_len={}. Invalid magic of the next frame: {:x}, {} "
                     "bytes to parse{}",
                     msg.header.magic,

package/deps/couchbase-cxx-client/couchbase/io/mcbp_parser.hxx

@@ -40,6 +40,6 @@ struct mcbp_parser {
 
     result next(mcbp_message& msg);
 
-    std::vector<std::uint8_t> buf;
+    std::vector<std::byte> buf;
 };
 } // namespace couchbase::io

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

@@ -138,11 +138,12 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                 hello_req.body().enable_compression();
             }
             hello_req.opaque(session_->next_opaque());
-            hello_req.body().user_agent(
-              meta::user_agent_for_mcbp(session_->client_id_, session_->id_, session_->origin_.options().user_agent_extra, 250));
+            auto user_agent =
+              meta::user_agent_for_mcbp(session_->client_id_, session_->id_, session_->origin_.options().user_agent_extra, 250);
+            hello_req.body().user_agent(user_agent);
             LOG_DEBUG("{} user_agent={}, requested_features=[{}]",
                       session_->log_prefix_,
-                      hello_req.body().user_agent(),
+                      user_agent,
                       utils::join_strings_fmt("{}", hello_req.body().features(), ", "));
             session_->write(hello_req.data());
 
@@ -300,7 +301,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                             session_->log_prefix_,
                                             resp.error_message(),
                                             resp.opaque(),
-                                            spdlog::to_hex(msg.header_data()));
+                                            spdlog::to_hex(resp.header()));
                                 return complete(error::network_errc::protocol_error);
                             }
                         } break;
@@ -327,7 +328,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                             session_->log_prefix_,
                                             resp.error_message(),
                                             resp.opaque(),
-                                            spdlog::to_hex(msg.header_data()));
+                                            spdlog::to_hex(resp.header()));
                                 return complete(error::common_errc::bucket_not_found);
                             }
                         } break;
@@ -357,7 +358,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                             session_->log_prefix_,
                                             resp.error_message(),
                                             resp.opaque(),
-                                            spdlog::to_hex(msg.header_data()));
+                                            spdlog::to_hex(resp.header()));
                                 return complete(error::network_errc::protocol_error);
                             }
                         } break;
@@ -666,7 +667,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         protocol::client_request<protocol::mcbp_noop_request_body> req;
         req.opaque(next_opaque());
         write_and_subscribe(req.opaque(),
-                            req.data(false),
+                            std::move(req.data(false)),
                             [start = std::chrono::steady_clock::now(), self = shared_from_this(), handler](
                               std::error_code ec, retry_reason reason, io::mcbp_message&& /* msg */) {
                                 diag::ping_state state = diag::ping_state::ok;
@@ -812,7 +813,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         state_ = diag::endpoint_state::disconnected;
     }
 
-    void write(const std::vector<uint8_t>& buf)
+    void write(std::vector<std::byte>&& buf)
     {
         if (stopped_) {
             return;
@@ -821,7 +822,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         std::memcpy(&opaque, buf.data() + 12, sizeof(opaque));
         LOG_TRACE("{} MCBP send, opaque={}, {:n}", log_prefix_, opaque, spdlog::to_hex(buf.begin(), buf.begin() + 24));
         std::scoped_lock lock(output_buffer_mutex_);
-        output_buffer_.push_back(buf);
+        output_buffer_.emplace_back(std::move(buf));
     }
 
     void flush()
@@ -832,17 +833,17 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         do_write();
     }
 
-    void write_and_flush(const std::vector<uint8_t>& buf)
+    void write_and_flush(std::vector<std::byte>&& buf)
     {
         if (stopped_) {
             return;
         }
-        write(buf);
+        write(std::move(buf));
         flush();
     }
 
-    void write_and_subscribe(uint32_t opaque,
-                             std::vector<std::uint8_t>& data,
+    void write_and_subscribe(std::uint32_t opaque,
+                             std::vector<std::byte>&& data,
                              std::function<void(std::error_code, retry_reason, io::mcbp_message&&)> handler)
     {
         if (stopped_) {
@@ -855,14 +856,14 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             command_handlers_.try_emplace(opaque, std::move(handler));
         }
         if (bootstrapped_ && stream_->is_open()) {
-            write_and_flush(data);
+            write_and_flush(std::move(data));
         } else {
             LOG_DEBUG("{} the stream is not ready yet, put the message into pending buffer, opaque={}", log_prefix_, opaque);
             std::scoped_lock lock(pending_buffer_mutex_);
             if (bootstrapped_ && stream_->is_open()) {
-                write_and_flush(data);
+                write_and_flush(std::move(data));
             } else {
-                pending_buffer_.push_back(data);
+                pending_buffer_.emplace_back(data);
             }
         }
     }
@@ -990,7 +991,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                 }
             }
         }
-        config_.emplace(config);
+        config_.emplace(std::move(config));
         configured_ = true;
         LOG_DEBUG("{} received new configuration: {}", log_prefix_, config_.value());
         for (const auto& listener : config_listeners_) {
@@ -998,7 +999,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
     }
 
-    void handle_not_my_vbucket(io::mcbp_message&& msg)
+    void handle_not_my_vbucket(const io::mcbp_message& msg)
     {
         if (stopped_) {
             return;
@@ -1006,7 +1007,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         Expects(msg.header.magic == static_cast<std::uint8_t>(protocol::magic::alt_client_response) ||
                 msg.header.magic == static_cast<std::uint8_t>(protocol::magic::client_response));
         if (protocol::has_json_datatype(msg.header.datatype)) {
-            auto magic = protocol::magic(msg.header.magic);
+            auto magic = static_cast<protocol::magic>(msg.header.magic);
             uint8_t extras_size = msg.header.extlen;
             uint8_t framing_extras_size = 0;
             uint16_t key_size = utils::byte_swap(msg.header.keylen);
@@ -1017,8 +1018,9 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
             std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
             if (utils::byte_swap(msg.header.bodylen) - offset > 0) {
-                auto config =
-                  protocol::parse_config(std::string(msg.body.begin() + offset, msg.body.end()), endpoint_address_, endpoint_.port());
+                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());
                 LOG_DEBUG("{} received not_my_vbucket status for {}, opaque={} with config rev={} in the payload",
                           log_prefix_,
                           protocol::client_opcode(msg.header.opcode),
@@ -1071,8 +1073,8 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         std::scoped_lock lock(pending_buffer_mutex_);
         bootstrapped_ = true;
         if (!pending_buffer_.empty()) {
-            for (const auto& buf : pending_buffer_) {
-                write(buf);
+            for (auto& buf : pending_buffer_) {
+                write(std::move(buf));
             }
             pending_buffer_.clear();
             flush();
@@ -1301,10 +1303,10 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
     std::atomic<std::uint32_t> opaque_{ 0 };
 
-    std::array<std::uint8_t, 16384> input_buffer_{};
-    std::vector<std::vector<std::uint8_t>> output_buffer_{};
-    std::vector<std::vector<std::uint8_t>> pending_buffer_{};
-    std::vector<std::vector<std::uint8_t>> writing_buffer_{};
+    std::array<std::byte, 16384> input_buffer_{};
+    std::vector<std::vector<std::byte>> output_buffer_{};
+    std::vector<std::vector<std::byte>> pending_buffer_{};
+    std::vector<std::vector<std::byte>> writing_buffer_{};
     std::mutex output_buffer_mutex_{};
     std::mutex pending_buffer_mutex_{};
     std::mutex writing_buffer_mutex_{};

package/deps/couchbase-cxx-client/couchbase/logger/configuration.hxx

@@ -47,6 +47,11 @@ struct configuration {
      * The default log level to initialize the logger to
      */
     level log_level{ level::info };
+
+    /**
+     * Custom sink to use, if desired
+     */
+    std::shared_ptr<spdlog::sinks::sink> sink{ nullptr };
 };
 
 } // namespace couchbase::logger

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

@@ -68,8 +68,7 @@ translate_level(level level)
 level
 level_from_str(const std::string& str)
 {
-    auto level = spdlog::level::from_str(str);
-    switch (level) {
+    switch (spdlog::level::from_str(str)) {
         case spdlog::level::level_enum::trace:
             return level::trace;
         case spdlog::level::level_enum::debug:
@@ -211,6 +210,10 @@ create_file_logger(const configuration& logger_settings)
             }
             sink->add_sink(stderrsink);
         }
+        if (nullptr != logger_settings.sink) {
+            logger_settings.sink->set_pattern(log_pattern);
+            sink->add_sink(logger_settings.sink);
+        }
 
         spdlog::drop(logger_name);
 

package/deps/couchbase-cxx-client/couchbase/logger/logger.hxx

@@ -128,14 +128,14 @@ unregister_spdlog_logger(const std::string& n);
  * @return true if all registered loggers have the specified severity level
  */
 bool
-check_log_levels(level level);
+check_log_levels(level lvl);
 
 /**
  * Set the log level of all registered spdLoggers
  * @param log severity level
  */
 void
-set_log_levels(level level);
+set_log_levels(level lvl);
 
 /**
  * Checks whether a specific level should be logged based on the current

package/deps/couchbase-cxx-client/couchbase/operations/document_append.hxx

@@ -41,9 +41,9 @@ struct append_request {
     using encoded_response_type = protocol::client_response<protocol::append_response_body>;
 
     document_id id;
-    std::string value;
-    uint16_t partition{};
-    uint32_t opaque{};
+    std::vector<std::byte> value;
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };

package/deps/couchbase-cxx-client/couchbase/operations/document_get.cxx

@@ -35,7 +35,7 @@ get_request::make_response(error_context::key_value&& ctx, const encoded_respons
 {
     get_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
-        response.value = std::move(encoded.body().value());
+        response.value = encoded.body().value();
         response.cas = encoded.cas();
         response.flags = encoded.body().flags();
     }