couchbase 3.0.0.alpha.4-universal-darwin-19 → 3.0.0.alpha.5-universal-darwin-19

data/ext/couchbase/io/dns_message.hxx

@@ -313,12 +313,9 @@ struct dns_header {
 
         [[nodiscard]] std::uint16_t encode() const
         {
-            return std::uint16_t((static_cast<std::uint32_t>(qr) & 1U) << 15U |
-                                 (static_cast<std::uint32_t>(opcode) & 15U) << 11U |
-                                 (static_cast<std::uint32_t>(aa) & 1U) << 10U |
-                                 (static_cast<std::uint32_t>(tc) & 1U) << 9U |
-                                 (static_cast<std::uint32_t>(rd) & 1U) << 8U |
-                                 (static_cast<std::uint32_t>(ra) & 1U) << 7U |
+            return std::uint16_t((static_cast<std::uint32_t>(qr) & 1U) << 15U | (static_cast<std::uint32_t>(opcode) & 15U) << 11U |
+                                 (static_cast<std::uint32_t>(aa) & 1U) << 10U | (static_cast<std::uint32_t>(tc) & 1U) << 9U |
+                                 (static_cast<std::uint32_t>(rd) & 1U) << 8U | (static_cast<std::uint32_t>(ra) & 1U) << 7U |
                                  (static_cast<std::uint32_t>(rcode) & 15U));
         }
 

data/ext/couchbase/io/http_session.hxx

@@ -41,14 +41,14 @@ namespace couchbase::io
 class http_session : public std::enable_shared_from_this<http_session>
 {
   public:
-    http_session(uuid::uuid_t client_id,
+    http_session(const std::string& client_id,
                  asio::io_context& ctx,
                  const std::string& username,
                  const std::string& password,
                  const std::string& hostname,
                  const std::string& service)
       : client_id_(client_id)
-      , id_(uuid::random())
+      , id_(uuid::to_string(uuid::random()))
       , ctx_(ctx)
       , resolver_(ctx_)
       , strand_(asio::make_strand(ctx_))
@@ -58,13 +58,16 @@ class http_session : public std::enable_shared_from_this
       , password_(password)
       , hostname_(hostname)
       , service_(service)
-      , user_agent_(fmt::format("ruby_sdk/{}.{}.{}; client/{}; session/{}",
+      , user_agent_(fmt::format("ruby/{}.{}.{}/{}; client/{}; session/{}; {}",
                                 BACKEND_VERSION_MAJOR,
                                 BACKEND_VERSION_MINOR,
                                 BACKEND_VERSION_PATCH,
-                                uuid::to_string(client_id_),
-                                uuid::to_string(id_)))
+                                BACKEND_GIT_REVISION,
+                                client_id_,
+                                id_,
+                                BACKEND_SYSTEM))
     {
+        log_prefix_ = fmt::format("[{}/{}]", client_id_, id_);
         resolver_.async_resolve(
           hostname, service, std::bind(&http_session::on_resolve, this, std::placeholders::_1, std::placeholders::_2));
     }
@@ -74,11 +77,21 @@ class http_session : public std::enable_shared_from_this
         stop();
     }
 
-    [[nodiscard]] uuid::uuid_t id()
+    [[nodiscard]] const std::string& log_prefix() const
+    {
+        return log_prefix_;
+    }
+
+    [[nodiscard]] const std::string& id() const
     {
         return id_;
     }
 
+    [[nodiscard]] const asio::ip::tcp::endpoint& endpoint() const
+    {
+        return endpoint_;
+    }
+
     void on_stop(std::function<void()> handler)
     {
         on_stop_handler_ = std::move(handler);
@@ -159,7 +172,7 @@ class http_session : public std::enable_shared_from_this
     void on_resolve(std::error_code ec, const asio::ip::tcp::resolver::results_type& endpoints)
     {
         if (ec) {
-            spdlog::error("error on resolve: {}", ec.message());
+            spdlog::error("{} error on resolve: {}", log_prefix_, ec.message());
             return;
         }
         endpoints_ = endpoints;
@@ -170,11 +183,11 @@ class http_session : public std::enable_shared_from_this
     void do_connect(asio::ip::tcp::resolver::results_type::iterator it)
     {
         if (it != endpoints_.end()) {
-            spdlog::trace("connecting to {}:{}", it->endpoint().address().to_string(), it->endpoint().port());
+            spdlog::debug("{} connecting to {}:{}", log_prefix_, it->endpoint().address().to_string(), it->endpoint().port());
             deadline_timer_.expires_after(timeout_defaults::connect_timeout);
             socket_.async_connect(it->endpoint(), std::bind(&http_session::on_connect, this, std::placeholders::_1, it));
         } else {
-            spdlog::error("no more endpoints left to connect");
+            spdlog::error("{} no more endpoints left to connect", log_prefix_);
             stop();
         }
     }
@@ -189,7 +202,8 @@ class http_session : public std::enable_shared_from_this
         } else {
             connected_ = true;
             endpoint_ = it->endpoint();
-            spdlog::trace("connected to {}:{}", it->endpoint().address().to_string(), it->endpoint().port());
+            spdlog::debug("{} connected to {}:{}", log_prefix_, it->endpoint().address().to_string(), it->endpoint().port());
+            log_prefix_ = fmt::format("[{}/{}] <{}:{}>", client_id_, id_, endpoint_.address().to_string(), endpoint_.port());
             deadline_timer_.expires_at(asio::steady_timer::time_point::max());
             deadline_timer_.cancel();
             flush();
@@ -222,11 +236,7 @@ class http_session : public std::enable_shared_from_this
                   return;
               }
               if (ec && ec != asio::error::operation_aborted) {
-                  spdlog::error("[{}] [{}:{}] IO error while reading from the socket: {}",
-                                uuid::to_string(self->id_),
-                                self->endpoint_.address().to_string(),
-                                self->endpoint_.port(),
-                                ec.message());
+                  spdlog::error("{} IO error while reading from the socket: {}", self->log_prefix_, ec.message());
                   return self->stop();
               }
 
@@ -243,10 +253,7 @@ class http_session : public std::enable_shared_from_this
                       }
                       return self->do_read();
                   case http_parser::status::failure:
-                      spdlog::error("[{}] [{}:{}] failed to parse HTTP response",
-                                    uuid::to_string(self->id_),
-                                    self->endpoint_.address().to_string(),
-                                    self->endpoint_.port());
+                      spdlog::error("{} failed to parse HTTP response", self->log_prefix_);
                       return self->stop();
               }
           });
@@ -271,11 +278,7 @@ class http_session : public std::enable_shared_from_this
                 return;
             }
             if (ec) {
-                spdlog::error("[{}] [{}:{}] IO error while writing to the socket: {}",
-                              uuid::to_string(self->id_),
-                              self->endpoint_.address().to_string(),
-                              self->endpoint_.port(),
-                              ec.message());
+                spdlog::error("{} IO error while writing to the socket: {}", self->log_prefix_, ec.message());
                 return self->stop();
             }
             self->writing_buffer_.clear();
@@ -286,8 +289,8 @@ class http_session : public std::enable_shared_from_this
         });
     }
 
-    uuid::uuid_t client_id_;
-    uuid::uuid_t id_;
+    std::string client_id_;
+    std::string id_;
     asio::io_context& ctx_;
     asio::ip::tcp::resolver resolver_;
     asio::strand<asio::io_context::executor_type> strand_;
@@ -312,5 +315,7 @@ class http_session : public std::enable_shared_from_this
     std::vector<std::vector<std::uint8_t>> writing_buffer_{};
     asio::ip::tcp::endpoint endpoint_{}; // connected endpoint
     asio::ip::tcp::resolver::results_type endpoints_;
+
+    std::string log_prefix_{};
 };
 } // namespace couchbase::io

data/ext/couchbase/io/{session_manager.hxx → http_session_manager.hxx}

@@ -25,10 +25,10 @@
 namespace couchbase::io
 {
 
-class session_manager : public std::enable_shared_from_this<session_manager>
+class http_session_manager : public std::enable_shared_from_this<http_session_manager>
 {
   public:
-    session_manager(uuid::uuid_t client_id, asio::io_context& ctx)
+    http_session_manager(const std::string& client_id, asio::io_context& ctx)
       : client_id_(client_id)
       , ctx_(ctx)
     {
@@ -116,7 +116,7 @@ class session_manager : public std::enable_shared_from_this
         return { "", 0 };
     }
 
-    uuid::uuid_t client_id_;
+    std::string client_id_;
     asio::io_context& ctx_;
 
     configuration config_{};

data/ext/couchbase/io/mcbp_message.hxx

@@ -19,8 +19,17 @@
 
 #include <cstdint>
 #include <vector>
+#include <array>
 
-namespace couchbase::io
+namespace couchbase
+{
+namespace protocol
+{
+static const size_t header_size = 24;
+using header_buffer = std::array<std::uint8_t, header_size>;
+} // namespace protocol
+
+namespace io
 {
 struct binary_header {
     std::uint8_t magic;
@@ -37,5 +46,13 @@ struct binary_header {
 struct mcbp_message {
     binary_header header;
     std::vector<std::uint8_t> body;
+
+    protocol::header_buffer header_data()
+    {
+        protocol::header_buffer buf;
+        std::memcpy(buf.data(), &header, sizeof(header));
+        return buf;
+    }
 };
-} // namespace couchbase::io
+} // namespace io
+} // namespace couchbase

data/ext/couchbase/io/mcbp_session.hxx

@@ -123,12 +123,18 @@ class mcbp_session : public std::enable_shared_from_this
                   { "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1", "PLAIN" })
         {
             tao::json::value user_agent{
-                { "a", fmt::format("ruby_sdk/{}.{}.{}", BACKEND_VERSION_MAJOR, BACKEND_VERSION_MINOR, BACKEND_VERSION_PATCH) },
-                { "i", fmt::format("{}/{}", uuid::to_string(session_->client_id_), uuid::to_string(session_->id_)) }
+                { "a",
+                  fmt::format(
+                    "ruby/{}.{}.{}/{}", BACKEND_VERSION_MAJOR, BACKEND_VERSION_MINOR, BACKEND_VERSION_PATCH, BACKEND_GIT_REVISION) },
+                { "i", fmt::format("{}/{}", session_->client_id_, session_->id_) }
             };
             protocol::client_request<protocol::hello_request_body> hello_req;
             hello_req.opaque(session_->next_opaque());
             hello_req.body().user_agent(tao::json::to_string(user_agent));
+            spdlog::debug("{} user_agent={}, requested_features=[{}]",
+                          session_->log_prefix_,
+                          hello_req.body().user_agent(),
+                          fmt::join(hello_req.body().features(), ", "));
             session_->write(hello_req.data());
 
             protocol::client_request<protocol::sasl_list_mechs_request_body> list_req;
@@ -187,15 +193,16 @@ class mcbp_session : public std::enable_shared_from_this
                     protocol::client_response<protocol::hello_response_body> resp(msg);
                     if (resp.status() == protocol::status::success) {
                         session_->supported_features_ = resp.body().supported_features();
+                        spdlog::debug("{} supported_features=[{}]", session_->log_prefix_, fmt::join(session_->supported_features_, ", "));
                     } else {
-                        spdlog::warn("unexpected message status during bootstrap: {}", resp.error_message());
+                        spdlog::warn("{} unexpected message status during bootstrap: {}", session_->log_prefix_, resp.error_message());
                         return complete(std::make_error_code(error::network_errc::handshake_failure));
                     }
                 } break;
                 case protocol::client_opcode::sasl_list_mechs: {
                     protocol::client_response<protocol::sasl_list_mechs_response_body> resp(msg);
                     if (resp.status() != protocol::status::success) {
-                        spdlog::warn("unexpected message status during bootstrap: {}", resp.error_message());
+                        spdlog::warn("{} unexpected message status during bootstrap: {}", session_->log_prefix_, resp.error_message());
                         return complete(std::make_error_code(error::common_errc::authentication_failure));
                     }
                 } break;
@@ -218,11 +225,14 @@ class mcbp_session : public std::enable_shared_from_this
                             req.body().sasl_data(sasl_payload);
                             session_->write_and_flush(req.data());
                         } else {
-                            spdlog::error("unable to authenticate: sasl_code={}", sasl_code);
+                            spdlog::error("{} unable to authenticate: sasl_code={}", session_->log_prefix_, sasl_code);
                             return complete(std::make_error_code(error::common_errc::authentication_failure));
                         }
                     } else {
-                        spdlog::warn("unexpected message status during bootstrap: {} (opcode={})", resp.error_message(), opcode);
+                        spdlog::warn("{} unexpected message status during bootstrap: {} (opcode={})",
+                                     session_->log_prefix_,
+                                     resp.error_message(),
+                                     opcode);
                         return complete(std::make_error_code(error::common_errc::authentication_failure));
                     }
                 } break;
@@ -238,22 +248,26 @@ class mcbp_session : public std::enable_shared_from_this
                     if (resp.status() == protocol::status::success) {
                         session_->errmap_.emplace(resp.body().errmap());
                     } else {
-                        spdlog::warn("unexpected message status during bootstrap: {} (opcode={})", resp.error_message(), opcode);
+                        spdlog::warn("{} unexpected message status during bootstrap: {} (opcode={})",
+                                     session_->log_prefix_,
+                                     resp.error_message(),
+                                     opcode);
                         return complete(std::make_error_code(error::network_errc::protocol_error));
                     }
                 } break;
                 case protocol::client_opcode::select_bucket: {
                     protocol::client_response<protocol::select_bucket_response_body> resp(msg);
                     if (resp.status() == protocol::status::success) {
-                        spdlog::trace("selected bucket: {}", session_->bucket_name_.value_or(""));
+                        spdlog::debug("{} selected bucket: {}", session_->log_prefix_, session_->bucket_name_.value_or(""));
                         session_->bucket_selected_ = true;
                     } else if (resp.status() == protocol::status::no_access) {
-                        spdlog::trace("unable to select bucket: {}, probably the bucket does not exist",
+                        spdlog::debug("{} unable to select bucket: {}, probably the bucket does not exist",
+                                      session_->log_prefix_,
                                       session_->bucket_name_.value_or(""));
                         session_->bucket_selected_ = false;
                         return complete(std::make_error_code(error::common_errc::bucket_not_found));
                     } else {
-                        spdlog::warn("unexpected message status during bootstrap: {}", resp.error_message());
+                        spdlog::warn("{} unexpected message status during bootstrap: {}", session_->log_prefix_, resp.error_message());
                         return complete(std::make_error_code(error::common_errc::bucket_not_found));
                     }
                 } break;
@@ -265,17 +279,21 @@ class mcbp_session : public std::enable_shared_from_this
                     } else if (resp.status() == protocol::status::no_bucket && !session_->bucket_name_) {
                         // bucket-less session, but the server wants bucket
                         session_->supports_gcccp_ = false;
-                        spdlog::warn("this server does not support GCCCP, open bucket before making any cluster-level command");
+                        spdlog::warn("{} this server does not support GCCCP, open bucket before making any cluster-level command",
+                                     session_->log_prefix_);
                         session_->update_configuration(
                           make_blank_configuration(session_->endpoint_.address().to_string(), session_->endpoint_.port(), 0));
                         complete({});
                     } else {
-                        spdlog::warn("unexpected message status during bootstrap: {} (opcode={})", resp.error_message(), opcode);
+                        spdlog::warn("{} unexpected message status during bootstrap: {} (opcode={})",
+                                     session_->log_prefix_,
+                                     resp.error_message(),
+                                     opcode);
                         return complete(std::make_error_code(error::network_errc::protocol_error));
                     }
                 } break;
                 default:
-                    spdlog::warn("unexpected message during bootstrap: {}", opcode);
+                    spdlog::warn("{} unexpected message during bootstrap: {}", session_->log_prefix_, opcode);
                     return complete(std::make_error_code(error::network_errc::protocol_error));
             }
         }
@@ -328,7 +346,7 @@ class mcbp_session : public std::enable_shared_from_this
                                     session_->update_configuration(resp.body().config());
                                 }
                             } else {
-                                spdlog::warn("unexpected message status: {}", resp.error_message());
+                                spdlog::warn("{} unexpected message status: {}", session_->log_prefix_, resp.error_message());
                             }
                         } break;
                         case protocol::client_opcode::get_collection_id:
@@ -350,14 +368,23 @@ class mcbp_session : public std::enable_shared_from_this
                             std::uint16_t status = ntohs(msg.header.specific);
                             auto handler = session_->command_handlers_.find(opaque);
                             if (handler != session_->command_handlers_.end()) {
-                                handler->second(session_->map_status_code(opcode, status), std::move(msg));
+                                auto ec = session_->map_status_code(opcode, status);
+                                spdlog::debug("{} MCBP invoke operation handler, opaque={}, status={}, ec={}",
+                                              session_->log_prefix_,
+                                              opaque,
+                                              status,
+                                              ec.message());
+                                handler->second(ec, std::move(msg));
                                 session_->command_handlers_.erase(handler);
                             } else {
-                                spdlog::debug("unexpected orphan response opcode={}, opaque={}", msg.header.opcode, msg.header.opaque);
+                                spdlog::debug("{} unexpected orphan response opcode={}, opaque={}",
+                                              session_->log_prefix_,
+                                              msg.header.opcode,
+                                              msg.header.opaque);
                             }
                         } break;
                         default:
-                            spdlog::warn("unexpected client response: {}", opcode);
+                            spdlog::warn("{} unexpected client response: {}", session_->log_prefix_, opcode);
                     }
                     break;
                 case protocol::magic::server_request:
@@ -374,13 +401,14 @@ class mcbp_session : public std::enable_shared_from_this
                             }
                         } break;
                         default:
-                            spdlog::warn("unexpected server request: {}", opcode);
+                            spdlog::warn("{} unexpected server request: {}", session_->log_prefix_, opcode);
                     }
                     break;
                 case protocol::magic::client_request:
                 case protocol::magic::alt_client_request:
                 case protocol::magic::server_response:
-                    spdlog::warn("unexpected magic: {}, opcode={}, opaque={}", magic, msg.header.opcode, msg.header.opaque);
+                    spdlog::warn(
+                      "{} unexpected magic: {}, opcode={}, opaque={}", session_->log_prefix_, magic, msg.header.opcode, msg.header.opaque);
                     break;
             }
         }
@@ -402,16 +430,21 @@ class mcbp_session : public std::enable_shared_from_this
     };
 
   public:
-    mcbp_session(uuid::uuid_t client_id, asio::io_context& ctx, std::optional<std::string> bucket_name = {})
+    mcbp_session(const std::string& client_id,
+                 asio::io_context& ctx,
+                 std::optional<std::string> bucket_name = {},
+                 std::vector<protocol::hello_feature> known_features = {})
       : client_id_(client_id)
-      , id_(uuid::random())
+      , id_(uuid::to_string(uuid::random()))
       , ctx_(ctx)
       , resolver_(ctx_)
       , strand_(asio::make_strand(ctx_))
       , socket_(strand_)
       , deadline_timer_(ctx_)
       , bucket_name_(std::move(bucket_name))
+      , supported_features_(known_features)
     {
+        log_prefix_ = fmt::format("[{}/{}/{}]", client_id_, id_, bucket_name_.value_or("-"));
     }
 
     ~mcbp_session()
@@ -432,9 +465,9 @@ class mcbp_session : public std::enable_shared_from_this
           hostname, service, std::bind(&mcbp_session::on_resolve, this, std::placeholders::_1, std::placeholders::_2));
     }
 
-    [[nodiscard]] std::string id()
+    [[nodiscard]] const std::string& id() const
     {
-        return uuid::to_string(id_);
+        return id_;
     }
 
     void stop()
@@ -485,6 +518,8 @@ class mcbp_session : public std::enable_shared_from_this
         if (stopped_) {
             return;
         }
+        spdlog::trace(
+          "{} MCBP send, opaque={}{:a}", log_prefix_, endpoint_.address().to_string(), endpoint_.port(), opaque, spdlog::to_hex(data));
         command_handlers_.emplace(opaque, std::move(handler));
         if (bootstrapped_ && socket_.is_open()) {
             write_and_flush(data);
@@ -500,17 +535,23 @@ class mcbp_session : public std::enable_shared_from_this
         }
         auto handler = command_handlers_.find(opaque);
         if (handler != command_handlers_.end()) {
+            spdlog::debug("{} MCBP cancel operation, opaque={}, ec={}", log_prefix_, opaque, ec.message());
             handler->second(ec, {});
             command_handlers_.erase(handler);
         }
     }
 
-    bool supports_feature(protocol::hello_feature feature)
+    [[nodiscard]] bool supports_feature(protocol::hello_feature feature)
     {
         return std::find(supported_features_.begin(), supported_features_.end(), feature) != supported_features_.end();
     }
 
-    bool supports_gcccp()
+    [[nodiscard]] std::vector<protocol::hello_feature> supported_features() const
+    {
+        return supported_features_;
+    }
+
+    [[nodiscard]] bool supports_gcccp()
     {
         return supports_gcccp_;
     }
@@ -550,16 +591,17 @@ class mcbp_session : public std::enable_shared_from_this
                 return std::make_error_code(error::key_value_errc::document_not_found);
 
             case protocol::status::exists:
-                if (opcode == protocol::client_opcode::replace || opcode == protocol::client_opcode::remove) {
-                    return std::make_error_code(error::common_errc::cas_mismatch);
+                if (opcode == protocol::client_opcode::insert) {
+                    return std::make_error_code(error::key_value_errc::document_exists);
                 }
-                return std::make_error_code(error::key_value_errc::document_exists);
+                return std::make_error_code(error::common_errc::cas_mismatch);
 
             case protocol::status::too_big:
                 return std::make_error_code(error::key_value_errc::value_too_large);
 
             case protocol::status::invalid:
             case protocol::status::xattr_invalid:
+            case protocol::status::subdoc_invalid_combo:
                 return std::make_error_code(error::common_errc::invalid_argument);
 
             case protocol::status::delta_bad_value:
@@ -643,7 +685,6 @@ class mcbp_session : public std::enable_shared_from_this
             case protocol::status::subdoc_value_too_deep:
                 return std::make_error_code(error::key_value_errc::value_too_deep);
 
-            case protocol::status::subdoc_invalid_combo:
             case protocol::status::subdoc_xattr_invalid_flag_combo:
             case protocol::status::subdoc_xattr_invalid_key_combo:
                 return std::make_error_code(error::key_value_errc::xattr_invalid_key_combo);
@@ -670,7 +711,7 @@ class mcbp_session : public std::enable_shared_from_this
                 break;
         }
         // FIXME: use error map here
-        spdlog::warn("unknown status code: {} (opcode={})", status, opcode);
+        spdlog::warn("{} unknown status code: {} (opcode={})", log_prefix_, status, opcode);
         return std::make_error_code(error::network_errc::protocol_error);
     }
 
@@ -678,7 +719,7 @@ class mcbp_session : public std::enable_shared_from_this
     {
         if (!config_ || config.rev > config_->rev) {
             config_.emplace(config);
-            spdlog::trace("received new configuration: {}", config_.value());
+            spdlog::debug("{} received new configuration: {}", log_prefix_, config_.value());
         }
     }
 
@@ -718,7 +759,7 @@ class mcbp_session : public std::enable_shared_from_this
             return;
         }
         if (ec) {
-            spdlog::error("error on resolve: {}", ec.message());
+            spdlog::error("{} error on resolve: {}", log_prefix_, ec.message());
             return invoke_bootstrap_handler(std::make_error_code(error::network_errc::resolve_failure));
         }
         endpoints_ = endpoints;
@@ -732,11 +773,11 @@ class mcbp_session : public std::enable_shared_from_this
             return;
         }
         if (it != endpoints_.end()) {
-            spdlog::trace("connecting to {}:{}", it->endpoint().address().to_string(), it->endpoint().port());
+            spdlog::debug("{} connecting to {}:{}", log_prefix_, it->endpoint().address().to_string(), it->endpoint().port());
             deadline_timer_.expires_after(timeout_defaults::connect_timeout);
             socket_.async_connect(it->endpoint(), std::bind(&mcbp_session::on_connect, this, std::placeholders::_1, it));
         } else {
-            spdlog::error("no more endpoints left to connect");
+            spdlog::error("{} no more endpoints left to connect", log_prefix_);
             invoke_bootstrap_handler(std::make_error_code(error::network_errc::no_endpoints_left));
             stop();
         }
@@ -753,7 +794,9 @@ class mcbp_session : public std::enable_shared_from_this
             socket_.set_option(asio::ip::tcp::no_delay{ true });
             socket_.set_option(asio::socket_base::keep_alive{ true });
             endpoint_ = it->endpoint();
-            spdlog::trace("connected to {}:{}", endpoint_.address().to_string(), it->endpoint().port());
+            spdlog::debug("{} connected to {}:{}", log_prefix_, endpoint_.address().to_string(), it->endpoint().port());
+            log_prefix_ = fmt::format(
+              "[{}/{}/{}] <{}:{}>", client_id_, id_, bucket_name_.value_or("-"), endpoint_.address().to_string(), endpoint_.port());
             handler_ = std::make_unique<bootstrap_handler>(shared_from_this());
             deadline_timer_.expires_at(asio::steady_timer::time_point::max());
             deadline_timer_.cancel();
@@ -790,11 +833,7 @@ class mcbp_session : public std::enable_shared_from_this
                                         return;
                                     }
                                     if (ec) {
-                                        spdlog::error("[{}] [{}:{}] IO error while reading from the socket: {}",
-                                                      uuid::to_string(self->id_),
-                                                      self->endpoint_.address().to_string(),
-                                                      self->endpoint_.port(),
-                                                      ec.message());
+                                        spdlog::error("{} IO error while reading from the socket: {}", self->log_prefix_, ec.message());
                                         return self->stop();
                                     }
                                     self->parser_.feed(self->input_buffer_.data(), self->input_buffer_.data() + ssize_t(bytes_transferred));
@@ -803,13 +842,17 @@ class mcbp_session : public std::enable_shared_from_this
                                         mcbp_message msg{};
                                         switch (self->parser_.next(msg)) {
                                             case mcbp_parser::ok:
+                                                spdlog::trace("{} MCBP recv, opaque={}{:a}{:a}",
+                                                              self->log_prefix_,
+                                                              msg.header.opaque,
+                                                              spdlog::to_hex(msg.header_data()),
+                                                              spdlog::to_hex(msg.body));
                                                 self->handler_->handle(std::move(msg));
                                                 break;
                                             case mcbp_parser::need_data:
                                                 self->reading_ = false;
                                                 return self->do_read();
                                             case mcbp_parser::failure:
-                                                ec = std::make_error_code(error::common_errc::parsing_failure);
                                                 return self->stop();
                                         }
                                     }
@@ -835,10 +878,7 @@ class mcbp_session : public std::enable_shared_from_this
                 return;
             }
             if (ec) {
-                spdlog::error("[{}] [{}] IO error while writing to the socket: {}",
-                              uuid::to_string(self->id_),
-                              self->endpoint_.address().to_string(),
-                              ec.message());
+                spdlog::error("{} IO error while writing to the socket: {}", self->log_prefix_, ec.message());
                 return self->stop();
             }
             self->writing_buffer_.clear();
@@ -849,8 +889,8 @@ class mcbp_session : public std::enable_shared_from_this
         });
     }
 
-    uuid::uuid_t client_id_;
-    uuid::uuid_t id_;
+    std::string client_id_;
+    std::string id_;
     asio::io_context& ctx_;
     asio::ip::tcp::resolver resolver_;
     asio::strand<asio::io_context::executor_type> strand_;
@@ -885,5 +925,7 @@ class mcbp_session : public std::enable_shared_from_this
     collection_cache collection_cache_;
 
     std::atomic_bool reading_{ false };
+
+    std::string log_prefix_{};
 };
 } // namespace couchbase::io