couchbase 3.4.3 → 3.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 573df37049b91d6dc00b674904dbda7883a4a20e7078191fc01f3b29f139df13
-  data.tar.gz: ec07bdbe1a3cdd5caab78b7bc4af3e525d0dba25e54e8bfb13b5d07203c0361a
+  metadata.gz: b3c1e2edfe7f74eb3f3094dd526e7dc1896f3002caca935ddeb76923b593f341
+  data.tar.gz: b5409f7083156b38aee870037ce0c5d3a14dc7ffe3aa3ac64b5862245b47e4d5
 SHA512:
-  metadata.gz: 3b945f9a1942520c04fb22810049bda99e4daecccbadab60c9df474ec9d606a92f253f56e815739e3d64c927727d83d74265973fa72a6493ab38cc27df5f0913
-  data.tar.gz: 7cfa5628c2dc3a4c43741e139e064ac20f1085fd446f3b10cc480fc622464d0396cfa31d470cdca9c7c8323bb37d6b38ef1200c4b8d4b511fea0642a56f699d5
+  metadata.gz: 16705649dc3954db461a7f8a63ee1168a4b191cacb0744e4e5b5b7b110788491d42fab78611b4898078a0276bbe0d9930352e24b4f95db87ab79ed6b6e8f9101
+  data.tar.gz: 157af7be99dc745ef7d95ef45490c0025f16ead6abb2f75079188405e82fcec9a64abb681695720e9080fd36b3c17883a56f84bafd06062e56c22ad9286c7ed4

data/README.md

@@ -2,7 +2,7 @@
 
 [![license](https://img.shields.io/github/license/couchbase/couchbase-ruby-client?color=brightgreen)](https://opensource.org/licenses/Apache-2.0)
 [![gem](https://img.shields.io/gem/v/couchbase?color=brightgreen)](https://rubygems.org/gems/couchbase)
-[![commits](https://img.shields.io/github/commits-since/couchbase/couchbase-ruby-client/latest?color=brightgreen)](https://github.com/couchbase/couchbase-ruby-client/commits/master)
+[![commits](https://img.shields.io/github/commits-since/couchbase/couchbase-ruby-client/latest?color=brightgreen)](https://github.com/couchbase/couchbase-ruby-client/commits/main)
 [![linters](https://img.shields.io/github/actions/workflow/status/couchbase/couchbase-ruby-client/linters.yml?branch=main&label=linters)](https://github.com/couchbase/couchbase-ruby-client/actions?query=workflow%3Alinters)
 
 This repository contains the third generation of the official Couchbase SDK for Ruby (aka. SDKv3)
@@ -23,7 +23,7 @@ The library has been tested with MRI 3.0, 3.1 and 3.2. Supported platforms are L
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.4.3"
+gem "couchbase", "3.4.4"
 ```
 
 And then execute:

data/ext/couchbase/CMakeLists.txt

@@ -100,6 +100,7 @@ set(couchbase_cxx_client_FILES
         core/free_form_http_request.cxx
         core/key_value_config.cxx
         core/n1ql_query_options.cxx
+        core/origin.cxx
         core/range_scan_options.cxx
         core/range_scan_orchestrator.cxx
         core/retry_orchestrator.cxx
@@ -232,6 +233,7 @@ set(couchbase_cxx_client_FILES
         core/protocol/cmd_increment.cxx
         core/protocol/cmd_insert.cxx
         core/protocol/cmd_lookup_in.cxx
+        core/protocol/cmd_lookup_in_replica.cxx
         core/protocol/cmd_mutate_in.cxx
         core/protocol/cmd_noop.cxx
         core/protocol/cmd_observe_seqno.cxx
@@ -265,10 +267,10 @@ set(couchbase_cxx_client_FILES
         core/impl/boolean_query.cxx
         core/impl/build_deferred_query_indexes.cxx
         core/impl/cluster.cxx
-        core/impl/collection_query_index_manager.cxx
         core/impl/common_error_category.cxx
         core/impl/configuration_profiles_registry.cxx
         core/impl/conjunction_query.cxx
+        core/impl/create_bucket.cxx
         core/impl/create_query_index.cxx
         core/impl/date_range.cxx
         core/impl/date_range_facet.cxx
@@ -277,24 +279,29 @@ set(couchbase_cxx_client_FILES
         core/impl/decrement.cxx
         core/impl/disjunction_query.cxx
         core/impl/dns_srv_tracker.cxx
+        core/impl/drop_bucket.cxx
         core/impl/drop_query_index.cxx
         core/impl/exists.cxx
         core/impl/expiry.cxx
         core/impl/fail_fast_retry_strategy.cxx
         core/impl/field_level_encryption_error_category.cxx
+        core/impl/flush_bucket.cxx
         core/impl/geo_bounding_box_query.cxx
         core/impl/geo_distance_query.cxx
         core/impl/geo_polygon_query.cxx
         core/impl/get.cxx
+        core/impl/get_all_buckets.cxx
         core/impl/get_all_query_indexes.cxx
         core/impl/get_all_replicas.cxx
         core/impl/get_and_lock.cxx
         core/impl/get_and_touch.cxx
         core/impl/get_any_replica.cxx
+        core/impl/get_bucket.cxx
         core/impl/get_replica.cxx
         core/impl/increment.cxx
         core/impl/insert.cxx
         core/impl/internal_date_range_facet_result.cxx
+        core/impl/internal_manager_error_context.cxx
         core/impl/internal_numeric_range_facet_result.cxx
         core/impl/internal_search_error_context.cxx
         core/impl/internal_search_meta_data.cxx
@@ -303,8 +310,13 @@ set(couchbase_cxx_client_FILES
         core/impl/internal_search_row_locations.cxx
         core/impl/internal_term_facet_result.cxx
         core/impl/key_value_error_category.cxx
+        core/impl/key_value_error_context.cxx
         core/impl/lookup_in.cxx
+        core/impl/lookup_in_replica.cxx
+        core/impl/lookup_in_all_replicas.cxx
+        core/impl/lookup_in_any_replica.cxx
         core/impl/management_error_category.cxx
+        core/impl/manager_error_context.cxx
         core/impl/match_all_query.cxx
         core/impl/match_none_query.cxx
         core/impl/match_phrase_query.cxx
@@ -322,6 +334,7 @@ set(couchbase_cxx_client_FILES
         core/impl/prepend.cxx
         core/impl/query.cxx
         core/impl/query_error_category.cxx
+        core/impl/query_error_context.cxx
         core/impl/query_string_query.cxx
         core/impl/regexp_query.cxx
         core/impl/remove.cxx
@@ -366,6 +379,7 @@ set(couchbase_cxx_client_FILES
         core/impl/transaction_get_result.cxx
         core/impl/transaction_op_error_category.cxx
         core/impl/unlock.cxx
+        core/impl/update_bucket.cxx
         core/impl/upsert.cxx
         core/impl/view_error_category.cxx
         core/impl/watch_query_indexes.cxx

data/ext/couchbase/core/bucket.cxx

@@ -22,7 +22,6 @@
 #include "core/mcbp/codec.hxx"
 #include "dispatcher.hxx"
 #include "impl/bootstrap_state_listener.hxx"
-#include "mcbp/completion_token.hxx"
 #include "mcbp/operation_queue.hxx"
 #include "mcbp/queue_request.hxx"
 #include "mcbp/queue_response.hxx"
@@ -41,28 +40,6 @@
 
 namespace couchbase::core
 {
-/**
- * copies nodes from rhs that are not in lhs to output vector
- */
-static void
-diff_nodes(const std::vector<topology::configuration::node>& lhs,
-           const std::vector<topology::configuration::node>& rhs,
-           std::vector<topology::configuration::node>& output)
-{
-    for (const auto& re : rhs) {
-        bool known = false;
-        for (const auto& le : lhs) {
-            if (le.hostname == re.hostname && le.services_plain.management.value_or(0) == re.services_plain.management.value_or(0)) {
-                known = true;
-                break;
-            }
-        }
-        if (!known) {
-            output.push_back(re);
-        }
-    }
-}
-
 class bucket_impl
   : public std::enable_shared_from_this<bucket_impl>
   , public config_listener
@@ -303,82 +280,111 @@ class bucket_impl
         return config_->map_key(key, node_index);
     }
 
-    void restart_node(std::size_t index, const std::string& hostname, const std::string& port)
+    void restart_sessions()
     {
-        if (closed_) {
-            CB_LOG_DEBUG(R"({} requested to restart session, but the bucket has been closed already. idx={}, address="{}:{}")",
-                         log_prefix_,
-                         index,
-                         hostname,
-                         port);
+        const std::scoped_lock lock(config_mutex_, sessions_mutex_);
+        if (!config_.has_value()) {
             return;
         }
-        {
-            std::scoped_lock lock(config_mutex_);
-            if (!config_->has_node(origin_.options().network, service_type::key_value, origin_.options().enable_tls, hostname, port)) {
-                CB_LOG_TRACE(
-                  R"({} requested to restart session, but the node has been ejected from current configuration already. idx={}, network={}, address="{}:{}")",
-                  log_prefix_,
-                  index,
-                  origin_.options().network,
-                  hostname,
-                  port);
-                return;
-            }
-        }
-        couchbase::core::origin origin(origin_.credentials(), hostname, port, origin_.options());
 
-        io::mcbp_session session = origin_.options().enable_tls
-                                     ? io::mcbp_session(client_id_, ctx_, tls_, origin, state_listener_, name_, known_features_)
-                                     : io::mcbp_session(client_id_, ctx_, origin, state_listener_, name_, known_features_);
+        std::size_t kv_node_index{ 0 };
+        for (std::size_t index = 0; index < config_->nodes.size(); ++index) {
+            const auto& node = config_->nodes[index];
 
-        std::scoped_lock lock(sessions_mutex_);
-        if (auto ptr = sessions_.find(index); ptr == sessions_.end()) {
-            CB_LOG_DEBUG(R"({} requested to restart session idx={}, which does not exist yet, initiate new one id="{}", address="{}:{}")",
-                         log_prefix_,
-                         index,
-                         session.id(),
-                         hostname,
-                         port);
-        } else {
-            const auto& old_session = ptr->second;
-            auto old_id = old_session.id();
-            sessions_.erase(ptr);
-            Expects(sessions_.count(index) == 0);
-            CB_LOG_DEBUG(R"({} restarting session idx={}, id=("{}" -> "{}"), address="{}:{}")",
+            const auto& hostname = node.hostname_for(origin_.options().network);
+            auto port = node.port_or(origin_.options().network, service_type::key_value, origin_.options().enable_tls, 0);
+            if (port == 0) {
+                continue;
+            }
+
+            auto ptr = std::find_if(sessions_.begin(), sessions_.end(), [&hostname, &port](const auto& session) {
+                return session.second.bootstrap_hostname() == hostname && session.second.bootstrap_port_number() == port;
+            });
+            if (ptr != sessions_.end()) {
+
+                if (auto found_kv_node_index = ptr->first; found_kv_node_index != kv_node_index) {
+                    if (auto current = sessions_.find(kv_node_index); current == sessions_.end()) {
+                        CB_LOG_WARNING(R"({} KV node index mismatch: config rev={} states that address="{}:{}" should be at idx={}, )"
+                                       R"(but it is at idx={} ("{}"). Moving session to idx={}.)",
+                                       log_prefix_,
+                                       config_->rev_str(),
+                                       hostname,
+                                       port,
+                                       kv_node_index,
+                                       found_kv_node_index,
+                                       ptr->second.id(),
+                                       kv_node_index);
+                        sessions_.insert_or_assign(kv_node_index, std::move(ptr->second));
+                        sessions_.erase(ptr);
+                    } else {
+                        CB_LOG_WARNING(
+                          R"({} KV node index mismatch: config rev={} states that address="{}:{}" should be at idx={}, )"
+                          R"(but it is at idx={} ("{}"). Slot with idx={} is holds session with address="{}" ("{}"), swapping them.)",
+                          log_prefix_,
+                          config_->rev_str(),
+                          hostname,
+                          port,
+                          kv_node_index,
+                          found_kv_node_index,
+                          ptr->second.id(),
+                          kv_node_index,
+                          current->second.bootstrap_address(),
+                          current->second.id());
+                        std::swap(current->second, ptr->second);
+                    }
+                }
+                ++kv_node_index;
+                continue;
+            }
+            couchbase::core::origin origin(origin_.credentials(), hostname, port, origin_.options());
+            io::mcbp_session session = origin_.options().enable_tls
+                                         ? io::mcbp_session(client_id_, ctx_, tls_, origin, state_listener_, name_, known_features_)
+                                         : io::mcbp_session(client_id_, ctx_, origin, state_listener_, name_, known_features_);
+            CB_LOG_DEBUG(R"({} rev={}, restart idx={}, session="{}", address="{}:{}")",
                          log_prefix_,
-                         index,
-                         old_id,
+                         config_->rev_str(),
+                         node.index,
                          session.id(),
                          hostname,
                          port);
+            session.bootstrap(
+              [self = shared_from_this(), session](std::error_code err, topology::configuration cfg) mutable {
+                  if (err) {
+                      return self->remove_session(session.id());
+                  }
+                  self->update_config(std::move(cfg));
+                  session.on_configuration_update(self);
+                  session.on_stop([id = session.id(), self]() { self->remove_session(id); });
+                  self->drain_deferred_queue();
+              },
+              true);
+            sessions_.insert_or_assign(index, std::move(session));
+            ++kv_node_index;
         }
+    }
 
-        session.bootstrap(
-          [self = shared_from_this(), session, this_index = index, hostname, port](std::error_code ec,
-                                                                                   const topology::configuration& config) mutable {
-              if (self->closed_) {
-                  asio::post(asio::bind_executor(
-                    self->ctx_, [session = std::move(session)]() mutable { return session.stop(retry_reason::do_not_retry); }));
-                  return;
-              }
-              if (ec) {
-                  CB_LOG_WARNING(R"({} failed to restart session idx={}, ec={})", session.log_prefix(), this_index, ec.message());
-                  self->restart_node(this_index, hostname, port);
-                  return;
-              }
-              session.on_configuration_update(self);
-              session.on_stop([this_index, hostname, port, self](retry_reason reason) {
-                  if (reason == retry_reason::socket_closed_while_in_flight) {
-                      self->restart_node(this_index, hostname, port);
-                  }
-              });
+    void remove_session(const std::string& id)
+    {
+        bool found{ false };
+        const std::scoped_lock lock(sessions_mutex_);
+        for (auto ptr = sessions_.cbegin(); ptr != sessions_.cend();) {
+            if (ptr->second.id() == id) {
+                CB_LOG_DEBUG(R"({} removed session id="{}", address="{}", bootstrap_address="{}:{}")",
+                             log_prefix_,
+                             ptr->second.id(),
+                             ptr->second.remote_address(),
+                             ptr->second.bootstrap_hostname(),
+                             ptr->second.bootstrap_port());
+                ptr = sessions_.erase(ptr);
+                found = true;
+            } else {
+                ptr = std::next(ptr);
+            }
+        }
 
-              self->update_config(config);
-              self->drain_deferred_queue();
-          },
-          true);
-        sessions_.insert_or_assign(index, std::move(session));
+        if (found) {
+            asio::post(asio::bind_executor(ctx_, [self = shared_from_this()]() { return self->restart_sessions(); }));
+        }
     }
 
     void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler)
@@ -393,15 +399,11 @@ class bucket_impl
                                                                                                topology::configuration cfg) mutable {
             if (ec) {
                 CB_LOG_WARNING(R"({} failed to bootstrap session ec={}, bucket="{}")", new_session.log_prefix(), ec.message(), self->name_);
+                self->remove_session(new_session.id());
             } else {
                 const std::size_t this_index = new_session.index();
                 new_session.on_configuration_update(self);
-                new_session.on_stop([this_index, hostname = new_session.bootstrap_hostname(), port = new_session.bootstrap_port(), self](
-                                      retry_reason reason) {
-                    if (reason == retry_reason::socket_closed_while_in_flight) {
-                        self->restart_node(this_index, hostname, port);
-                    }
-                });
+                new_session.on_stop([id = new_session.id(), self]() { self->remove_session(id); });
 
                 {
                     std::scoped_lock lock(self->sessions_mutex_);
@@ -455,6 +457,9 @@ class bucket_impl
             std::scoped_lock lock(deferred_commands_mutex_);
             std::swap(deferred_commands_, commands);
         }
+        if (!commands.empty()) {
+            CB_LOG_TRACE(R"({} draining deferred operation queue, size={})", log_prefix_, commands.size());
+        }
         while (!commands.empty()) {
             commands.front()();
             commands.pop();
@@ -489,9 +494,33 @@ class bucket_impl
         }
     }
 
+    /**
+     * copies nodes from rhs that are not in lhs to output vector
+     */
+    void diff_nodes(const std::vector<topology::configuration::node>& lhs,
+                    const std::vector<topology::configuration::node>& rhs,
+                    std::vector<topology::configuration::node>& output)
+    {
+        for (const auto& re : rhs) {
+            bool known = false;
+            const auto& rhost = re.hostname_for(origin_.options().network);
+            const auto rport = re.port_or(origin_.options().network, service_type::key_value, origin_.options().enable_tls, 0);
+            for (const auto& le : lhs) {
+                const auto& lhost = le.hostname_for(origin_.options().network);
+                const auto lport = le.port_or(origin_.options().network, service_type::key_value, origin_.options().enable_tls, 0);
+                if (rhost == lhost && rport == lport) {
+                    known = true;
+                    break;
+                }
+            }
+            if (!known) {
+                output.push_back(re);
+            }
+        }
+    }
+
     void update_config(topology::configuration config) override
     {
-        bool forced_config = false;
         std::vector<topology::configuration::node> added{};
         std::vector<topology::configuration::node> removed{};
         {
@@ -500,7 +529,6 @@ class bucket_impl
                 CB_LOG_DEBUG("{} initialize configuration rev={}", log_prefix_, config.rev_str());
             } else if (config.force) {
                 CB_LOG_DEBUG("{} forced to accept configuration rev={}", log_prefix_, config.rev_str());
-                forced_config = true;
             } else if (!config.vbmap) {
                 CB_LOG_DEBUG("{} will not update the configuration old={} -> new={}, because new config does not have partition map",
                              log_prefix_,
@@ -533,78 +561,81 @@ class bucket_impl
             std::scoped_lock lock(sessions_mutex_);
             std::map<size_t, io::mcbp_session> new_sessions{};
 
-            for (auto& [index, session] : sessions_) {
-                std::size_t new_index = config.nodes.size() + 1;
-                for (const auto& node : config.nodes) {
-                    if (session.bootstrap_hostname() == node.hostname_for(origin_.options().network) &&
-                        session.bootstrap_port() ==
-                          std::to_string(
-                            node.port_or(origin_.options().network, service_type::key_value, origin_.options().enable_tls, 0))) {
-                        new_index = node.index;
-                        break;
-                    }
-                }
-                if (new_index < config.nodes.size()) {
-                    CB_LOG_DEBUG(R"({} rev={}, preserve session="{}", address="{}:{}", index={}->{})",
-                                 log_prefix_,
-                                 config.rev_str(),
-                                 session.id(),
-                                 session.bootstrap_hostname(),
-                                 session.bootstrap_port(),
-                                 index,
-                                 new_index);
-                    new_sessions.insert_or_assign(new_index, std::move(session));
-                } else {
-                    CB_LOG_DEBUG(R"({} rev={}, drop session="{}", address="{}:{}", index={})",
-                                 log_prefix_,
-                                 config.rev_str(),
-                                 session.id(),
-                                 session.bootstrap_hostname(),
-                                 session.bootstrap_port(),
-                                 index);
-                    asio::post(asio::bind_executor(
-                      ctx_, [session = std::move(session)]() mutable { return session.stop(retry_reason::do_not_retry); }));
-                }
-            }
-
+            std::size_t next_index{ 0 };
             for (const auto& node : config.nodes) {
-                if (new_sessions.find(node.index) != new_sessions.end()) {
-                    continue;
-                }
-
                 const auto& hostname = node.hostname_for(origin_.options().network);
                 auto port = node.port_or(origin_.options().network, service_type::key_value, origin_.options().enable_tls, 0);
                 if (port == 0) {
                     continue;
                 }
+
+                bool reused_session{ false };
+                for (auto it = sessions_.begin(); it != sessions_.end(); ++it) {
+                    if (it->second.bootstrap_hostname() == hostname && it->second.bootstrap_port_number() == port) {
+                        CB_LOG_DEBUG(R"({} rev={}, preserve session="{}", address="{}:{}", index={}->{})",
+                                     log_prefix_,
+                                     config.rev_str(),
+                                     it->second.id(),
+                                     it->second.bootstrap_hostname(),
+                                     it->second.bootstrap_port(),
+                                     it->first,
+                                     next_index);
+                        new_sessions.insert_or_assign(next_index, std::move(it->second));
+                        reused_session = true;
+                        ++next_index;
+                        sessions_.erase(it);
+                        break;
+                    }
+                }
+                if (reused_session) {
+                    continue;
+                }
+
                 couchbase::core::origin origin(origin_.credentials(), hostname, port, origin_.options());
                 io::mcbp_session session = origin_.options().enable_tls
                                              ? io::mcbp_session(client_id_, ctx_, tls_, origin, state_listener_, name_, known_features_)
                                              : io::mcbp_session(client_id_, ctx_, origin, state_listener_, name_, known_features_);
-                CB_LOG_DEBUG(
-                  R"({} rev={}, add session="{}", address="{}:{}")", log_prefix_, config.rev_str(), session.id(), hostname, port);
+                CB_LOG_DEBUG(R"({} rev={}, add session="{}", address="{}:{}", index={})",
+                             log_prefix_,
+                             config.rev_str(),
+                             session.id(),
+                             hostname,
+                             port,
+                             node.index);
                 session.bootstrap(
-                  [self = shared_from_this(), session, forced_config, idx = node.index](std::error_code err,
-                                                                                        topology::configuration cfg) mutable {
-                      if (!err) {
-                          self->update_config(std::move(cfg));
-                          session.on_configuration_update(self);
-                          session.on_stop(
-                            [index = session.index(), hostname = session.bootstrap_hostname(), port = session.bootstrap_port(), self](
-                              retry_reason reason) {
-                                if (reason == retry_reason::socket_closed_while_in_flight) {
-                                    self->restart_node(index, hostname, port);
-                                }
-                            });
-                          self->drain_deferred_queue();
-                      } else if (err == errc::common::unambiguous_timeout && forced_config) {
-                          self->restart_node(idx, session.bootstrap_hostname(), session.bootstrap_port());
+                  [self = shared_from_this(), session, idx = next_index](std::error_code err, topology::configuration cfg) mutable {
+                      if (err) {
+                          CB_LOG_WARNING(R"({} failed to bootstrap session="{}", address="{}:{}", index={}, ec={})",
+                                         session.log_prefix(),
+                                         session.id(),
+                                         session.bootstrap_hostname(),
+                                         session.bootstrap_port(),
+                                         idx,
+                                         err.message());
+                          return self->remove_session(session.id());
                       }
+                      self->update_config(std::move(cfg));
+                      session.on_configuration_update(self);
+                      session.on_stop([id = session.id(), self]() { self->remove_session(id); });
+                      self->drain_deferred_queue();
                   },
                   true);
-                new_sessions.insert_or_assign(node.index, std::move(session));
+                new_sessions.insert_or_assign(next_index, std::move(session));
+                ++next_index;
+            }
+            std::swap(sessions_, new_sessions);
+
+            for (auto it = new_sessions.begin(); it != new_sessions.end(); ++it) {
+                CB_LOG_DEBUG(R"({} rev={}, drop session="{}", address="{}:{}", index={})",
+                             log_prefix_,
+                             config.rev_str(),
+                             it->second.id(),
+                             it->second.bootstrap_hostname(),
+                             it->second.bootstrap_port(),
+                             it->first);
+                asio::post(asio::bind_executor(
+                  ctx_, [session = std::move(it->second)]() mutable { return session.stop(retry_reason::do_not_retry); }));
             }
-            sessions_ = new_sessions;
         }
     }
 

data/ext/couchbase/core/bucket.hxx

@@ -83,7 +83,7 @@ class bucket
         auto cmd = std::make_shared<operations::mcbp_command<bucket, Request>>(ctx_, shared_from_this(), request, default_timeout());
         cmd->start([cmd, handler = std::forward<Handler>(handler)](std::error_code ec, std::optional<io::mcbp_message>&& msg) mutable {
             using encoded_response_type = typename Request::encoded_response_type;
-            std::uint16_t status_code = msg ? msg->header.status() : 0U;
+            std::uint16_t status_code = msg ? msg->header.status() : 0xffffU;
             auto resp = msg ? encoded_response_type(std::move(*msg)) : encoded_response_type{};
             auto ctx = make_key_value_error_context(ec, status_code, cmd, resp);
             handler(cmd->request.make_response(std::move(ctx), std::move(resp)));
@@ -107,7 +107,7 @@ class bucket
             auto [partition, server] = map_id(cmd->request.id);
             if (!server.has_value()) {
                 CB_LOG_TRACE(
-                  R"({} unable to map key=\"{}\" to the node, id={}, partition={})", log_prefix(), cmd->request.id, cmd->id_, partition);
+                  R"({} unable to map key="{}" to the node, id={}, partition={})", log_prefix(), cmd->request.id, cmd->id_, partition);
                 return io::retry_orchestrator::maybe_retry(
                   cmd->manager_, cmd, retry_reason::node_not_available, errc::common::request_canceled);
             }
@@ -116,19 +116,32 @@ class bucket
         }
         auto session = find_session_by_index(index);
         if (!session || !session->has_config()) {
-            CB_LOG_TRACE(R"({} defer operation id={}, session={}, has_config={})",
+            CB_LOG_TRACE(R"({} defer operation id={}, key="{}", partition={}, index={}, session={}, address="{}", has_config={})",
                          log_prefix(),
                          cmd->id_,
+                         cmd->request.id,
+                         cmd->request.partition,
+                         index,
                          session.has_value(),
+                         session.has_value() ? session->bootstrap_address() : "",
                          session.has_value() && session->has_config());
             return defer_command([self = shared_from_this(), cmd]() { self->map_and_send(cmd); });
         }
         if (session->is_stopped()) {
             CB_LOG_TRACE(
-              R"({} the session has been found, but it is stopped, retrying id={}, session={})", log_prefix(), cmd->id_, session->id());
+              R"({} the session has been found for idx={}, but it is stopped, retrying id={}, key="{}", partition={}, session={}, address="{}")",
+              log_prefix(),
+              index,
+              cmd->id_,
+              cmd->request.id,
+              cmd->request.partition,
+              session->id(),
+              session->bootstrap_address());
             return io::retry_orchestrator::maybe_retry(
               cmd->manager_, cmd, retry_reason::node_not_available, errc::common::request_canceled);
         }
+        cmd->last_dispatched_from_ = session->local_address();
+        cmd->last_dispatched_to_ = session->bootstrap_address();
         cmd->send_to(session.value());
     }