couchbase 4.2.0 → 4.2.1

package/deps/couchbase-cxx-client/core/io/http_command.hxx

@@ -18,10 +18,14 @@
 #pragma once
 
 #include "core/service_type_fmt.hxx"
+#include "core/tracing/constants.hxx"
 #include "core/utils/movable_function.hxx"
-#include "couchbase/metrics/meter.hxx"
-#include "couchbase/tracing/request_tracer.hxx"
 #include "http_session.hxx"
+#include "http_traits.hxx"
+
+#include <couchbase/metrics/meter.hxx>
+#include <couchbase/tracing/request_tracer.hxx>
+
 #include <utility>
 
 namespace couchbase::core::operations
@@ -133,13 +137,13 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
             return invoke_handler(ec, {});
         }
         encoded.headers["client-context-id"] = client_context_id_;
-        LOG_TRACE(R"({} HTTP request: {}, method={}, path="{}", client_context_id="{}", timeout={}ms)",
-                  session_->log_prefix(),
-                  encoded.type,
-                  encoded.method,
-                  encoded.path,
-                  client_context_id_,
-                  timeout_.count());
+        CB_LOG_TRACE(R"({} HTTP request: {}, method={}, path="{}", client_context_id="{}", timeout={}ms)",
+                     session_->log_prefix(),
+                     encoded.type,
+                     encoded.method,
+                     encoded.path,
+                     client_context_id_,
+                     timeout_.count());
         session_->write_and_subscribe(
           encoded,
           [self = this->shared_from_this(), start = std::chrono::steady_clock::now()](std::error_code ec, io::http_response&& msg) {
@@ -157,12 +161,12 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
               }
               self->deadline.cancel();
               self->finish_dispatch(self->session_->remote_address(), self->session_->local_address());
-              LOG_TRACE(R"({} HTTP response: {}, client_context_id="{}", status={}, body={})",
-                        self->session_->log_prefix(),
-                        self->request.type,
-                        self->client_context_id_,
-                        msg.status_code,
-                        msg.status_code == 200 ? "[hidden]" : msg.body.data());
+              CB_LOG_TRACE(R"({} HTTP response: {}, client_context_id="{}", status={}, body={})",
+                           self->session_->log_prefix(),
+                           self->request.type,
+                           self->client_context_id_,
+                           msg.status_code,
+                           msg.status_code == 200 ? "[hidden]" : msg.body.data());
               if (auto parser_ec = msg.body.ec(); !ec && parser_ec) {
                   ec = parser_ec;
               }

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

@@ -293,7 +293,7 @@ class http_session : public std::enable_shared_from_this<http_session>
         if (stopped_) {
             return;
         }
-        do_write();
+        asio::post(asio::bind_executor(ctx_, [self = shared_from_this()]() { self->do_write(); }));
     }
 
     template<typename Handler>
@@ -314,8 +314,9 @@ class http_session : public std::enable_shared_from_this<http_session>
             keep_alive_ = true;
         }
         request.headers["user-agent"] = user_agent_;
+        auto credentials = fmt::format("{}:{}", credentials_.username, credentials_.password);
         request.headers["authorization"] =
-          fmt::format("Basic {}", base64::encode(fmt::format("{}:{}", credentials_.username, credentials_.password)));
+          fmt::format("Basic {}", base64::encode(gsl::as_bytes(gsl::span{ credentials.data(), credentials.size() })));
         write(fmt::format("{} {} HTTP/1.1\r\nhost: {}:{}\r\n", request.method, request.path, hostname_, service_));
         if (!request.body.empty()) {
             request.headers["content-length"] = std::to_string(request.body.size());
@@ -356,7 +357,7 @@ class http_session : public std::enable_shared_from_this<http_session>
             return;
         }
         if (ec) {
-            LOG_ERROR("{} error on resolve: {}", info_.log_prefix(), ec.message());
+            CB_LOG_ERROR("{} error on resolve: {}", info_.log_prefix(), ec.message());
             return;
         }
         last_active_ = std::chrono::steady_clock::now();
@@ -371,15 +372,15 @@ class http_session : public std::enable_shared_from_this<http_session>
             return;
         }
         if (it != endpoints_.end()) {
-            LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
-                      info_.log_prefix(),
-                      it->endpoint().address().to_string(),
-                      it->endpoint().port(),
-                      http_ctx_.options.connect_timeout.count());
+            CB_LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
+                         info_.log_prefix(),
+                         it->endpoint().address().to_string(),
+                         it->endpoint().port(),
+                         http_ctx_.options.connect_timeout.count());
             deadline_timer_.expires_after(http_ctx_.options.connect_timeout);
             stream_->async_connect(it->endpoint(), std::bind(&http_session::on_connect, shared_from_this(), std::placeholders::_1, it));
         } else {
-            LOG_ERROR("{} no more endpoints left to connect", info_.log_prefix());
+            CB_LOG_ERROR("{} no more endpoints left to connect", info_.log_prefix());
             stop();
         }
     }
@@ -391,12 +392,12 @@ class http_session : public std::enable_shared_from_this<http_session>
         }
         last_active_ = std::chrono::steady_clock::now();
         if (!stream_->is_open() || ec) {
-            LOG_WARNING("{} unable to connect to {}:{}: {}{}",
-                        info_.log_prefix(),
-                        it->endpoint().address().to_string(),
-                        it->endpoint().port(),
-                        ec.message(),
-                        (ec == asio::error::connection_refused) ? ", check server ports and cluster encryption setting" : "");
+            CB_LOG_WARNING("{} unable to connect to {}:{}: {}{}",
+                           info_.log_prefix(),
+                           it->endpoint().address().to_string(),
+                           it->endpoint().port(),
+                           ec.message(),
+                           (ec == asio::error::connection_refused) ? ", check server ports and cluster encryption setting" : "");
             if (stream_->is_open()) {
                 stream_->close(std::bind(&http_session::do_connect, shared_from_this(), ++it));
             } else {
@@ -405,7 +406,7 @@ class http_session : public std::enable_shared_from_this<http_session>
         } else {
             state_ = diag::endpoint_state::connected;
             connected_ = true;
-            LOG_DEBUG("{} connected to {}:{}", info_.log_prefix(), it->endpoint().address().to_string(), it->endpoint().port());
+            CB_LOG_DEBUG("{} connected to {}:{}", info_.log_prefix(), it->endpoint().address().to_string(), it->endpoint().port());
             {
                 std::scoped_lock lock(info_mutex_);
                 info_ = http_session_info(client_id_, id_, stream_->local_endpoint(), it->endpoint());
@@ -441,7 +442,7 @@ class http_session : public std::enable_shared_from_this<http_session>
               }
               self->last_active_ = std::chrono::steady_clock::now();
               if (ec) {
-                  LOG_ERROR("{} IO error while reading from the socket: {}", self->info_.log_prefix(), ec.message());
+                  CB_LOG_ERROR("{} IO error while reading from the socket: {}", self->info_.log_prefix(), ec.message());
                   return self->stop();
               }
 
@@ -492,7 +493,7 @@ class http_session : public std::enable_shared_from_this<http_session>
             }
             self->last_active_ = std::chrono::steady_clock::now();
             if (ec) {
-                LOG_ERROR("{} IO error while writing to the socket: {}", self->info_.log_prefix(), ec.message());
+                CB_LOG_ERROR("{} IO error while writing to the socket: {}", self->info_.log_prefix(), ec.message());
                 return self->stop();
             }
             {

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

@@ -27,6 +27,8 @@
 #include "http_session.hxx"
 #include "http_traits.hxx"
 
+#include <gsl/narrow>
+
 #include <random>
 
 namespace couchbase::core::io
@@ -156,14 +158,14 @@ class http_session_manager
                                 self = shared_from_this(),
                                 type,
                                 cmd,
-                                handler = std::move(collector->build_reporter())](std::error_code ec, io::http_response&& msg) {
+                                handler = collector->build_reporter()](std::error_code ec, io::http_response&& msg) {
                         diag::ping_state state = diag::ping_state::ok;
                         std::optional<std::string> error{};
                         if (ec) {
                             state = diag::ping_state::error;
                             error.emplace(fmt::format("code={}, message={}, http_code={}", ec.value(), ec.message(), msg.status_code));
                         }
-                        handler(diag::endpoint_ping_info{
+                        handler->report(diag::endpoint_ping_info{
                           type,
                           cmd->session_->id(),
                           std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start),
@@ -228,7 +230,7 @@ class http_session_manager
         }
         if (!session->is_stopped()) {
             session->set_idle(options_.idle_http_connection_timeout);
-            LOG_DEBUG("{} put HTTP session back to idle connections", session->log_prefix());
+            CB_LOG_DEBUG("{} put HTTP session back to idle connections", session->log_prefix());
             std::scoped_lock lock(sessions_mutex_);
             idle_sessions_[type].push_back(session);
             busy_sessions_[type].remove_if([id = session->id()](const auto& s) -> bool { return !s || s->id() == id; });
@@ -341,14 +343,14 @@ class http_session_manager
                 return { node.hostname_for(options_.network), port };
             }
         }
-        return { "", std::uint16_t(0U) };
+        return { "", static_cast<std::uint16_t>(0U) };
     }
 
     std::pair<std::string, std::uint16_t> split_host_port(const std::string& address)
     {
         auto last_colon = address.find_last_of(':');
         if (last_colon == std::string::npos || address.size() - 1 == last_colon) {
-            return { "", std::uint16_t(0U) };
+            return { "", static_cast<std::uint16_t>(0U) };
         }
         auto hostname = address.substr(0, last_colon);
         auto port = gsl::narrow_cast<std::uint16_t>(std::stoul(address.substr(last_colon + 1)));
@@ -362,7 +364,7 @@ class http_session_manager
         if (std::none_of(config_.nodes.begin(), config_.nodes.end(), [this, type, &h = hostname, &p = port](const auto& node) {
                 return node.hostname == h && node.port_or(options_.network, type, options_.enable_tls, 0) == p;
             })) {
-            return { "", std::uint16_t(0U) };
+            return { "", static_cast<std::uint16_t>(0U) };
         }
         return { hostname, port };
     }

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

@@ -19,6 +19,8 @@
 
 #include "core/document_id_fmt.hxx"
 #include "core/platform/uuid.h"
+#include "core/protocol/client_request.hxx"
+#include "core/protocol/client_response.hxx"
 #include "core/protocol/cmd_get_collection_id.hxx"
 #include "core/tracing/constants.hxx"
 #include "core/utils/movable_function.hxx"
@@ -29,6 +31,10 @@
 #include "retry_orchestrator.hxx"
 
 #include <couchbase/durability_level.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/key_value_error_map_info.hxx>
+
+#include <asio/steady_timer.hpp>
 
 #include <functional>
 #include <utility>
@@ -36,7 +42,7 @@
 namespace couchbase::core::operations
 {
 
-using mcbp_command_handler = utils::movable_function<void(std::error_code, std::optional<io::mcbp_message>)>;
+using mcbp_command_handler = utils::movable_function<void(std::error_code, std::optional<io::mcbp_message>&&)>;
 
 template<typename Manager, typename Request>
 struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager, Request>> {
@@ -49,7 +55,7 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
     Request request;
     encoded_request_type encoded;
     std::optional<std::uint32_t> opaque_{};
-    std::shared_ptr<io::mcbp_session> session_{};
+    std::optional<io::mcbp_session> session_{};
     mcbp_command_handler handler_{};
     std::shared_ptr<Manager> manager_{};
     std::chrono::milliseconds timeout_{};
@@ -66,9 +72,8 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
     {
         if constexpr (io::mcbp_traits::supports_durability_v<Request>) {
             if (request.durability_level != durability_level::none && timeout_ < durability_timeout_floor) {
-                LOG_DEBUG(
-                  R"({} Timeout is too low for operation with durability, increasing to sensible value. timeout={}ms, floor={}ms, id="{}")",
-                  session_->log_prefix(),
+                CB_LOG_DEBUG(
+                  R"(Timeout is too low for operation with durability, increasing to sensible value. timeout={}ms, floor={}ms, id="{}")",
                   request.id,
                   timeout_.count(),
                   durability_timeout_floor.count(),
@@ -104,10 +109,10 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
                 handler_ = nullptr;
             }
         }
-        invoke_handler(request.retries.idempotent ? errc::common::unambiguous_timeout : errc::common::ambiguous_timeout);
+        invoke_handler(request.retries.idempotent() ? errc::common::unambiguous_timeout : errc::common::ambiguous_timeout);
     }
 
-    void invoke_handler(std::error_code ec, std::optional<io::mcbp_message> msg = {})
+    void invoke_handler(std::error_code ec, std::optional<io::mcbp_message>&& msg = {})
     {
         retry_backoff.cancel();
         deadline.cancel();
@@ -134,42 +139,45 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
         protocol::client_request<protocol::get_collection_id_request_body> req;
         req.opaque(session_->next_opaque());
         req.body().collection_path(request.id.collection_path());
-        session_->write_and_subscribe(
-          req.opaque(),
-          req.data(session_->supports_feature(protocol::hello_feature::snappy)),
-          [self = this->shared_from_this()](std::error_code ec, retry_reason /* reason */, io::mcbp_message&& msg) mutable {
-              if (ec == asio::error::operation_aborted) {
-                  return self->invoke_handler(errc::common::ambiguous_timeout);
-              }
-              if (ec == errc::common::collection_not_found) {
-                  if (self->request.id.is_collection_resolved()) {
-                      return self->invoke_handler(ec);
-                  }
-                  return self->handle_unknown_collection();
-              }
-              if (ec) {
-                  return self->invoke_handler(ec);
-              }
-              protocol::client_response<protocol::get_collection_id_response_body> resp(std::move(msg));
-              self->session_->update_collection_uid(self->request.id.collection_path(), resp.body().collection_uid());
-              self->request.id.collection_uid(resp.body().collection_uid());
-              return self->send();
-          });
+        session_->write_and_subscribe(req.opaque(),
+                                      req.data(session_->supports_feature(protocol::hello_feature::snappy)),
+                                      [self = this->shared_from_this()](std::error_code ec,
+                                                                        retry_reason /* reason */,
+                                                                        io::mcbp_message&& msg,
+                                                                        std::optional<key_value_error_map_info> /* error_info */) mutable {
+                                          if (ec == asio::error::operation_aborted) {
+                                              return self->invoke_handler(errc::common::ambiguous_timeout);
+                                          }
+                                          if (ec == errc::common::collection_not_found) {
+                                              if (self->request.id.is_collection_resolved()) {
+                                                  return self->invoke_handler(ec);
+                                              }
+                                              return self->handle_unknown_collection();
+                                          }
+                                          if (ec) {
+                                              return self->invoke_handler(ec);
+                                          }
+                                          protocol::client_response<protocol::get_collection_id_response_body> resp(std::move(msg));
+                                          self->session_->update_collection_uid(self->request.id.collection_path(),
+                                                                                resp.body().collection_uid());
+                                          self->request.id.collection_uid(resp.body().collection_uid());
+                                          return self->send();
+                                      });
     }
 
     void handle_unknown_collection()
     {
         auto backoff = std::chrono::milliseconds(500);
         auto time_left = deadline.expiry() - std::chrono::steady_clock::now();
-        LOG_DEBUG(R"({} unknown collection response for "{}", time_left={}ms, id="{}")",
-                  session_->log_prefix(),
-                  request.id,
-                  std::chrono::duration_cast<std::chrono::milliseconds>(time_left).count(),
-                  id_);
-        request.retries.reasons.insert(retry_reason::kv_collection_outdated);
+        CB_LOG_DEBUG(R"({} unknown collection response for "{}", time_left={}ms, id="{}")",
+                     session_->log_prefix(),
+                     request.id,
+                     std::chrono::duration_cast<std::chrono::milliseconds>(time_left).count(),
+                     id_);
+        request.retries.add_reason(retry_reason::key_value_collection_outdated);
         if (time_left < backoff) {
             return invoke_handler(
-              make_error_code(request.retries.idempotent ? errc::common::unambiguous_timeout : errc::common::ambiguous_timeout));
+              make_error_code(request.retries.idempotent() ? errc::common::unambiguous_timeout : errc::common::ambiguous_timeout));
         }
         retry_backoff.expires_after(backoff);
         retry_backoff.async_wait([self = this->shared_from_this()](std::error_code ec) mutable {
@@ -191,11 +199,11 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
                 if (collection_id) {
                     request.id.collection_uid(collection_id.value());
                 } else {
-                    LOG_DEBUG(R"({} no cache entry for collection, resolve collection id for "{}", timeout={}ms, id="{}")",
-                              session_->log_prefix(),
-                              request.id,
-                              timeout_.count(),
-                              id_);
+                    CB_LOG_DEBUG(R"({} no cache entry for collection, resolve collection id for "{}", timeout={}ms, id="{}")",
+                                 session_->log_prefix(),
+                                 request.id,
+                                 timeout_.count(),
+                                 id_);
                     return request_collection_id();
                 }
             } else {
@@ -219,7 +227,10 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
           request.opaque,
           encoded.data(session_->supports_feature(protocol::hello_feature::snappy)),
           [self = this->shared_from_this(),
-           start = std::chrono::steady_clock::now()](std::error_code ec, retry_reason reason, io::mcbp_message&& msg) mutable {
+           start = std::chrono::steady_clock::now()](std::error_code ec,
+                                                     retry_reason reason,
+                                                     io::mcbp_message&& msg,
+                                                     std::optional<key_value_error_map_info> /* error_info */) mutable {
               static std::string meter_name = "db.couchbase.operations";
               static std::map<std::string, std::string> tags = {
                   { "db.couchbase.service", "kv" },
@@ -232,8 +243,8 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
               self->retry_backoff.cancel();
               if (ec == asio::error::operation_aborted) {
                   self->span_->add_tag(tracing::attributes::orphan, "aborted");
-                  return self->invoke_handler(make_error_code(self->request.retries.idempotent ? errc::common::unambiguous_timeout
-                                                                                               : errc::common::ambiguous_timeout));
+                  return self->invoke_handler(make_error_code(self->request.retries.idempotent() ? errc::common::unambiguous_timeout
+                                                                                                 : errc::common::ambiguous_timeout));
               }
               if (ec == errc::common::request_canceled) {
                   if (reason == retry_reason::do_not_retry) {
@@ -251,13 +262,13 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
               }
               if (status == key_value_status_code::not_my_vbucket) {
                   self->session_->handle_not_my_vbucket(msg);
-                  return io::retry_orchestrator::maybe_retry(self->manager_, self, retry_reason::kv_not_my_vbucket, ec);
+                  return io::retry_orchestrator::maybe_retry(self->manager_, self, retry_reason::key_value_not_my_vbucket, ec);
               }
               if (status == key_value_status_code::unknown_collection) {
                   return self->handle_unknown_collection();
               }
               if (error_code && error_code.value().has_retry_attribute()) {
-                  reason = retry_reason::kv_error_map_retry_indicated;
+                  reason = retry_reason::key_value_error_map_retry_indicated;
               } else {
                   switch (status) {
                       case key_value_status_code::locked:
@@ -266,31 +277,31 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
                                * special case for unlock command, when it should not be retried, because it does not make sense
                                * (someone else unlocked the document)
                                */
-                              reason = retry_reason::kv_locked;
+                              reason = retry_reason::key_value_locked;
                           }
                           break;
                       case key_value_status_code::temporary_failure:
-                          reason = retry_reason::kv_temporary_failure;
+                          reason = retry_reason::key_value_temporary_failure;
                           break;
                       case key_value_status_code::sync_write_in_progress:
-                          reason = retry_reason::kv_sync_write_in_progress;
+                          reason = retry_reason::key_value_sync_write_in_progress;
                           break;
                       case key_value_status_code::sync_write_re_commit_in_progress:
-                          reason = retry_reason::kv_sync_write_re_commit_in_progress;
+                          reason = retry_reason::key_value_sync_write_re_commit_in_progress;
                           break;
                       default:
                           break;
                   }
               }
               if (reason == retry_reason::do_not_retry) {
-                  self->invoke_handler(ec, msg);
+                  self->invoke_handler(ec, std::move(msg));
               } else {
                   io::retry_orchestrator::maybe_retry(self->manager_, self, reason, ec);
               }
           });
     }
 
-    void send_to(std::shared_ptr<io::mcbp_session> session)
+    void send_to(io::mcbp_session session)
     {
         if (!handler_ || !span_) {
             return;

package/deps/couchbase-cxx-client/core/io/mcbp_context.hxx

@@ -21,6 +21,7 @@
 #include "core/topology/configuration.hxx"
 
 #include <algorithm>
+#include <optional>
 #include <vector>
 
 namespace couchbase::core

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

@@ -49,6 +49,11 @@ struct mcbp_message {
     binary_header header;
     std::vector<std::byte> body;
 
+    mcbp_message(const mcbp_message& other) = delete;
+    mcbp_message& operator=(const mcbp_message& other) = delete;
+    mcbp_message(mcbp_message&& other) = default;
+    mcbp_message& operator=(mcbp_message&& other) = default;
+
     [[nodiscard]] protocol::header_buffer header_data() const;
 };
 } // namespace io

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

@@ -33,7 +33,7 @@ namespace couchbase::core::io
 mcbp_parser::result
 mcbp_parser::next(mcbp_message& msg)
 {
-    static const size_t header_size = 24;
+    static const std::size_t header_size = 24;
     if (buf.size() < header_size) {
         return result::need_data;
     }
@@ -47,40 +47,40 @@ mcbp_parser::next(mcbp_message& msg)
     std::uint32_t key_size = utils::byte_swap(msg.header.keylen);
     std::uint32_t prefix_size = static_cast<std::uint32_t>(msg.header.extlen) + key_size;
     if (msg.header.magic == static_cast<std::uint8_t>(protocol::magic::alt_client_response)) {
-        std::uint8_t framing_extras_size = msg.header.keylen & 0xfU;
-        key_size = (msg.header.keylen & 0xf0U) >> 8U;
+        std::uint8_t framing_extras_size = msg.header.keylen & 0xffU;
+        key_size = static_cast<std::uint32_t>(msg.header.keylen >> 8U);
         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));
+    msg.body.insert(msg.body.end(), buf.begin() + header_size, buf.begin() + header_size + prefix_size);
 
     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;
+        std::size_t offset = header_size + prefix_size;
         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);
-            });
+            msg.body.insert(msg.body.end(),
+                            reinterpret_cast<std::byte*>(&uncompressed.data()[0]),
+                            reinterpret_cast<std::byte*>(&uncompressed.data()[uncompressed.size()]));
             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()));
         }
     }
     if (use_raw_value) {
-        std::copy(buf.begin() + header_size + prefix_size, buf.begin() + header_size + body_size, std::back_insert_iterator(msg.body));
+        msg.body.insert(msg.body.end(), buf.begin() + header_size + prefix_size, buf.begin() + header_size + body_size);
     }
     buf.erase(buf.begin(), buf.begin() + header_size + body_size);
     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,
-                    msg.header.opcode,
-                    msg.header.opaque,
-                    body_size,
-                    buf[0],
-                    buf.size(),
-                    spdlog::to_hex(buf));
+        CB_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,
+                       msg.header.opcode,
+                       msg.header.opaque,
+                       body_size,
+                       buf[0],
+                       buf.size(),
+                       spdlog::to_hex(buf));
         reset();
     }
     return result::ok;

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

@@ -30,7 +30,7 @@ struct mcbp_parser {
     void feed(Iterator begin, Iterator end)
     {
         buf.reserve(buf.size() + static_cast<std::size_t>(std::distance(begin, end)));
-        std::copy(begin, end, std::back_insert_iterator(buf));
+        buf.insert(buf.end(), begin, end);
     }
 
     void reset()