couchbase 3.8.0 → 3.8.1

data/ext/couchbase/core/impl/error.cxx

@@ -75,6 +75,17 @@ error::error(std::error_code ec,
 {
 }
 
+error::error(std::error_code ec,
+             std::string message,
+             couchbase::error_context ctx,
+             couchbase::node_id node_id)
+  : ec_{ ec }
+  , message_{ std::move(message) }
+  , ctx_{ std::move(ctx) }
+  , node_id_{ std::move(node_id) }
+{
+}
+
 auto
 error::ec() const -> std::error_code
 {
@@ -103,6 +114,12 @@ error::cause() const -> std::optional<error>
   return *cause_;
 }
 
+auto
+error::node_id() const -> const couchbase::node_id&
+{
+  return node_id_;
+}
+
 error::operator bool() const
 {
   return ec_.value() != 0;
@@ -164,19 +181,27 @@ make_error(const core::error_context::http& core_ctx) -> couchbase::error
 auto
 make_error(const couchbase::core::key_value_error_context& core_ctx) -> couchbase::error
 {
+  // Always preserve the node_id so that callers on both success and error
+  // paths can identify which node handled the request.
   if (!core_ctx.ec()) {
-    return {};
+    return { {}, {}, {}, core_ctx.last_dispatched_to_node_id() };
   }
-  return { core_ctx.ec(), {}, internal_error_context::build_error_context(core_ctx) };
+  return { core_ctx.ec(),
+           {},
+           internal_error_context::build_error_context(core_ctx),
+           core_ctx.last_dispatched_to_node_id() };
 }
 
 auto
 make_error(const couchbase::core::subdocument_error_context& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec()) {
-    return {};
+    return { {}, {}, {}, core_ctx.last_dispatched_to_node_id() };
   }
-  return { core_ctx.ec(), {}, internal_error_context::build_error_context(core_ctx) };
+  return { core_ctx.ec(),
+           {},
+           internal_error_context::build_error_context(core_ctx),
+           core_ctx.last_dispatched_to_node_id() };
 }
 
 auto

data/ext/couchbase/core/impl/invoke_with_node_id.hxx

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <couchbase/error.hxx>
+
+#include <utility>
+
+namespace couchbase::core::impl
+{
+/**
+ * Forwards (err, result) to the caller's handler, propagating the node_id
+ * carried by the error (which make_error populates for KV contexts) onto
+ * the result. Using a plain function template avoids the extra std::function
+ * allocation a type-erasing wrapper would introduce for the sole purpose of
+ * setting node_id - that extra allocation was the source of the 18
+ * "Potential memory leak" reports clang-static-analyzer flagged against the
+ * previous wrap_with_node_id helper. The handler is taken by forwarding
+ * reference and perfect-forwarded to the invocation so that callers moving
+ * an rvalue handler consume it without an intermediate copy.
+ */
+template<typename Handler, typename Result>
+void
+invoke_with_node_id(Handler&& handler, couchbase::error err, Result result)
+{
+  result.node_id(err.node_id());
+  std::forward<Handler>(handler)(std::move(err), std::move(result));
+}
+} // namespace couchbase::core::impl

data/ext/couchbase/core/impl/node_id.cxx

@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "node_id.hxx"
+
+#include "core/utils/crc32.hxx"
+
+#include <spdlog/fmt/bundled/core.h>
+
+#include <cstdint>
+#include <string>
+
+namespace couchbase
+{
+
+namespace
+{
+/**
+ * Produces a stable, opaque hex string from hostname + KV port.
+ *
+ * Uses CRC32 (already in-tree for vBucket mapping) rather than a
+ * cryptographic hash — collision resistance across a handful of cluster
+ * nodes is more than sufficient, and this avoids pulling in OpenSSL headers.
+ */
+auto
+derive_fallback_id(const std::string& hostname, std::uint16_t port) -> std::string
+{
+  auto input = fmt::format("{}:{}", hostname, port);
+  auto crc = core::utils::hash_crc32(input.data(), input.size());
+  return fmt::format("{:08x}", crc);
+}
+} // namespace
+
+node_id::node_id(std::string node_uuid, std::string hostname, std::uint16_t port)
+  : node_uuid_{ std::move(node_uuid) }
+  , hostname_{ std::move(hostname) }
+  , port_{ port }
+  , id_{ node_uuid_.empty() ? derive_fallback_id(hostname_, port_) : node_uuid_ }
+{
+}
+
+auto
+node_id::id() const -> const std::string&
+{
+  return id_;
+}
+
+auto
+node_id::node_uuid() const -> const std::string&
+{
+  return node_uuid_;
+}
+
+auto
+node_id::hostname() const -> const std::string&
+{
+  return hostname_;
+}
+
+auto
+node_id::port() const -> std::uint16_t
+{
+  return port_;
+}
+
+node_id::
+operator bool() const
+{
+  return !id_.empty();
+}
+
+auto
+node_id::operator==(const node_id& other) const -> bool
+{
+  return id_ == other.id_;
+}
+
+auto
+node_id::operator!=(const node_id& other) const -> bool
+{
+  return !(*this == other);
+}
+
+auto
+node_id::operator<(const node_id& other) const -> bool
+{
+  return id_ < other.id_;
+}
+
+auto
+internal_node_id::build(std::string node_uuid, std::string hostname, std::uint16_t port) -> node_id
+{
+  return { std::move(node_uuid), std::move(hostname), port };
+}
+
+} // namespace couchbase

data/ext/couchbase/core/impl/node_id.hxx

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <couchbase/node_id.hxx>
+
+#include <cstdint>
+#include <string>
+
+namespace couchbase
+{
+
+/**
+ * Internal factory for constructing node_id instances from core-level data.
+ *
+ * This class is a friend of node_id and provides the only way to construct
+ * a non-default node_id outside the couchbase namespace.
+ */
+class internal_node_id
+{
+public:
+  static auto build(std::string node_uuid, std::string hostname, std::uint16_t port) -> node_id;
+};
+
+} // namespace couchbase

data/ext/couchbase/core/io/http_session_manager.hxx

@@ -251,45 +251,45 @@ public:
             app_telemetry_meter_,
             options_.default_timeout_for(request.type));
 #endif
-          cmd->start([start = std::chrono::steady_clock::now(),
-                      self = shared_from_this(),
-                      type,
-                      cmd,
-                      handler =
-                        collector->build_reporter()](operations::http_noop_response&& resp) {
-            diag::ping_state state = diag::ping_state::ok;
-            std::optional<std::string> error{};
-            if (auto ec = resp.ctx.ec; ec) {
-              if (ec == errc::common::unambiguous_timeout ||
-                  ec == errc::common::ambiguous_timeout) {
-                state = diag::ping_state::timeout;
-              } else {
-                state = diag::ping_state::error;
+          cmd->start(
+            [start = std::chrono::steady_clock::now(),
+             self = shared_from_this(),
+             type,
+             cmd,
+             handler = collector->build_reporter()](operations::http_noop_response&& resp) {
+              diag::ping_state state = diag::ping_state::ok;
+              std::optional<std::string> error{};
+              if (auto ec = resp.ctx.ec; ec) {
+                if (ec == errc::common::unambiguous_timeout ||
+                    ec == errc::common::ambiguous_timeout) {
+                  state = diag::ping_state::timeout;
+                } else {
+                  state = diag::ping_state::error;
+                }
+                error.emplace(fmt::format("code={}, message={}, http_code={}",
+                                          ec.value(),
+                                          ec.message(),
+                                          resp.ctx.http_status));
               }
-              error.emplace(fmt::format("code={}, message={}, http_code={}",
-                                        ec.value(),
-                                        ec.message(),
-                                        resp.ctx.http_status));
-            }
-            auto remote_address = cmd->session_->remote_address();
-            // If not connected, the remote address will be empty.  Better to
-            // give the user some context on the "attempted" remote address.
-            if (remote_address.empty()) {
-              remote_address =
-                fmt::format("{}:{}", cmd->session_->hostname(), cmd->session_->port());
-            }
-            handler->report(
-              diag::endpoint_ping_info{ type,
-                                        cmd->session_->id(),
-                                        std::chrono::duration_cast<std::chrono::microseconds>(
-                                          std::chrono::steady_clock::now() - start),
-                                        remote_address,
-                                        cmd->session_->local_address(),
-                                        state,
-                                        {},
-                                        error });
-            self->check_in(type, cmd->session_);
-          });
+              auto remote_address = cmd->session_->remote_address();
+              // If not connected, the remote address will be empty.  Better to
+              // give the user some context on the "attempted" remote address.
+              if (remote_address.empty()) {
+                remote_address =
+                  fmt::format("{}:{}", cmd->session_->hostname(), cmd->session_->port());
+              }
+              handler->report(
+                diag::endpoint_ping_info{ type,
+                                          cmd->session_->id(),
+                                          std::chrono::duration_cast<std::chrono::microseconds>(
+                                            std::chrono::steady_clock::now() - start),
+                                          remote_address,
+                                          cmd->session_->local_address(),
+                                          state,
+                                          {},
+                                          error });
+              self->check_in(type, cmd->session_);
+            });
 
           cmd->set_command_session(session);
           if (!session->is_connected()) {
@@ -402,9 +402,20 @@ public:
       return;
     }
     if (!session->is_connected()) {
-      CB_LOG_DEBUG("{} HTTP session never connected.  Skipping check-in", session->log_prefix());
-      return session.reset();
+      {
+        std::scoped_lock lock(sessions_mutex_);
+        if (auto pend_it = pending_sessions_.find(type); pend_it != pending_sessions_.end()) {
+          pend_it->second.remove_if([id = session->id()](const auto& s) {
+            return !s || s->id() == id;
+          });
+        }
+      }
+      CB_LOG_DEBUG("{} HTTP session never connected.  Ensured session is not in pending.",
+                   session->log_prefix());
+      return;
     }
+    bool should_stop = false;
+    std::chrono::milliseconds idle_timeout{};
     {
       std::scoped_lock lock(config_mutex_);
       if (!session->keep_alive() || !config_.has_node(options_.network,
@@ -412,22 +423,34 @@ public:
                                                       options_.enable_tls,
                                                       session->hostname(),
                                                       session->port())) {
-        return asio::post(session->get_executor(), [session]() {
-          session->stop();
-        });
+        should_stop = true;
+      } else {
+        idle_timeout = options_.idle_http_connection_timeout;
       }
     }
+    if (should_stop) {
+      return asio::post(session->get_executor(), [session]() {
+        session->stop();
+      });
+    }
     if (!session->is_stopped()) {
-      session->set_idle(options_.idle_http_connection_timeout);
+      // set_idle() arms the idle timer via async_wait — it never calls stop() inline,
+      // so on_stop cannot re-enter sessions_mutex_ here. It must precede publication to
+      // idle_sessions_ so a concurrent check_out's reset_idle() finds a pending timer.
+      session->set_idle(idle_timeout);
       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;
-      });
-      pending_sessions_[type].remove_if([id = session->id()](const auto& s) -> bool {
-        return !s || s->id() == id;
-      });
+      if (auto busy_it = busy_sessions_.find(type); busy_it != busy_sessions_.end()) {
+        busy_it->second.remove_if([id = session->id()](const auto& s) -> bool {
+          return !s || s->id() == id;
+        });
+      }
+      if (auto pend_it = pending_sessions_.find(type); pend_it != pending_sessions_.end()) {
+        pend_it->second.remove_if([id = session->id()](const auto& s) -> bool {
+          return !s || s->id() == id;
+        });
+      }
     }
   }
 
@@ -741,13 +764,30 @@ private:
     }
 
     session->on_stop([type, id = session->id(), self = this->shared_from_this()]() {
-      const std::scoped_lock inner_lock(self->sessions_mutex_);
-      self->busy_sessions_[type].remove_if([&id](const auto& s) {
-        return !s || s->id() == id;
-      });
-      self->idle_sessions_[type].remove_if([&id](const auto& s) {
-        return !s || s->id() == id;
-      });
+      // Declared outside the lock so destructors run after sessions_mutex_ is released.
+      // cppcheck-suppress variableScope
+      std::vector<std::shared_ptr<http_session>> dropped;
+      {
+        const std::scoped_lock inner_lock(self->sessions_mutex_);
+        for (auto* map :
+             { &self->busy_sessions_, &self->idle_sessions_, &self->pending_sessions_ }) {
+          auto map_it = map->find(type);
+          if (map_it == map->end()) {
+            continue;
+          }
+          auto& list = map_it->second;
+          for (auto it = list.begin(); it != list.end();) {
+            if (!*it || (*it)->id() == id) {
+              if (*it) {
+                dropped.push_back(std::move(*it));
+              }
+              it = list.erase(it);
+            } else {
+              ++it;
+            }
+          }
+        }
+      }
     });
     return session;
   }

data/ext/couchbase/core/operations/document_get_all_replicas.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/error_codes.hxx>
+#include <couchbase/node_id.hxx>
 
 #include "core/error_context/key_value.hxx"
 #include "core/impl/get_replica.hxx"
@@ -40,6 +41,7 @@ struct get_all_replicas_response {
     couchbase::cas cas{};
     std::uint32_t flags{};
     bool replica{ true };
+    couchbase::node_id dispatched_to_node_id{};
   };
   key_value_error_context ctx{};
   std::vector<entry> entries{};
@@ -156,8 +158,12 @@ struct get_all_replicas_request {
                       return;
                     }
                   } else {
-                    ctx->result_.emplace_back(get_all_replicas_response::entry{
-                      std::move(resp.value), resp.cas, resp.flags, true /* replica */ });
+                    ctx->result_.emplace_back(
+                      get_all_replicas_response::entry{ std::move(resp.value),
+                                                        resp.cas,
+                                                        resp.flags,
+                                                        true /* replica */,
+                                                        resp.ctx.last_dispatched_to_node_id() });
                   }
                   if (ctx->expected_responses_ == 0) {
                     ctx->done_ = true;
@@ -203,8 +209,12 @@ struct get_all_replicas_request {
                       return;
                     }
                   } else {
-                    ctx->result_.emplace_back(get_all_replicas_response::entry{
-                      std::move(resp.value), resp.cas, resp.flags, false /* active */ });
+                    ctx->result_.emplace_back(
+                      get_all_replicas_response::entry{ std::move(resp.value),
+                                                        resp.cas,
+                                                        resp.flags,
+                                                        false /* active */,
+                                                        resp.ctx.last_dispatched_to_node_id() });
                   }
                   if (ctx->expected_responses_ == 0) {
                     ctx->done_ = true;

data/ext/couchbase/core/operations/document_get_projected.cxx

@@ -210,14 +210,13 @@ get_projected_request::make_response(key_value_error_context&& ctx,
           response.ctx.override_ec(errc::common::parsing_failure);
           return response;
         }
-        tao::json::value new_doc;
+        tao::json::value new_doc = tao::json::empty_object;
         for (const auto& projection : projections) {
           if (auto value_to_apply = subdoc_lookup(full_doc, projection)) {
             subdoc_apply_projection(new_doc, projection, *value_to_apply, preserve_array_indexes);
-          } else {
-            response.ctx.override_ec(errc::key_value::path_not_found);
-            return response;
           }
+          // We ignore paths that were not found, similar to how we ignore them in the subdoc
+          // multi-lookup below.
         }
         response.value = utils::json::generate_binary(new_doc);
       }

data/ext/couchbase/core/operations/document_lookup_in_all_replicas.hxx

@@ -28,6 +28,7 @@
 
 #include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/error_codes.hxx>
+#include <couchbase/node_id.hxx>
 
 #include <functional>
 #include <memory>
@@ -50,6 +51,7 @@ struct lookup_in_all_replicas_response {
     couchbase::cas cas{};
     bool deleted{ false };
     bool is_replica{ true };
+    couchbase::node_id dispatched_to_node_id{};
   };
   subdocument_error_context ctx{};
   std::vector<entry> entries{};
@@ -203,6 +205,7 @@ struct lookup_in_all_replicas_request {
                       top_entry.cas = resp.cas;
                       top_entry.deleted = resp.deleted;
                       top_entry.is_replica = true;
+                      top_entry.dispatched_to_node_id = resp.ctx.last_dispatched_to_node_id();
                       for (auto& field : resp.fields) {
                         lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
                         lookup_in_entry.path = field.path;
@@ -267,6 +270,7 @@ struct lookup_in_all_replicas_request {
                         top_entry.cas = resp.cas;
                         top_entry.deleted = resp.deleted;
                         top_entry.is_replica = false;
+                        top_entry.dispatched_to_node_id = resp.ctx.last_dispatched_to_node_id();
                         for (auto& field : resp.fields) {
                           lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
                           lookup_in_entry.path = field.path;

data/ext/couchbase/core/operations/document_query.cxx

@@ -20,6 +20,7 @@
 #include "core/cluster_options.hxx"
 #include "core/logger/logger.hxx"
 #include "core/operations/management/error_utils.hxx"
+#include "core/utils/contains_string.hxx"
 #include "core/utils/duration_parser.hxx"
 #include "core/utils/json.hxx"
 
@@ -28,13 +29,11 @@
 #include <gsl/assert>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations
 {
 auto
-query_request::encode_to(query_request::encoded_request_type& encoded,
-                         http_context& context) -> std::error_code
+query_request::encode_to(query_request::encoded_request_type& encoded, http_context& context)
+  -> std::error_code
 {
   ctx_.emplace(context);
   tao::json::value body{
@@ -209,8 +208,8 @@ query_request::encode_to(query_request::encoded_request_type& encoded,
 }
 
 auto
-query_request::make_response(error_context::query&& ctx,
-                             const encoded_response_type& encoded) -> query_response
+query_request::make_response(error_context::query&& ctx, const encoded_response_type& encoded)
+  -> query_response
 {
   query_response response{ std::move(ctx) };
   response.ctx.statement = statement;
@@ -374,13 +373,14 @@ query_request::make_response(error_context::query&& ctx,
             response.ctx.ec = errc::common::index_exists;
             break;
           case 5000: /* IKey: "Internal Error" */
-            if (std::regex_search(response.ctx.first_error_message,
-                                  std::regex{ ".*[iI]ndex .*already exist.*" })) {
+            if (utils::contains_string(response.ctx.first_error_message, "index", true) &&
+                utils::contains_string(response.ctx.first_error_message, "already exist", true)) {
               response.ctx.ec = errc::common::index_exists;
-            } else if (response.ctx.first_error_message.find("Index does not exist") !=
-                         std::string::npos ||
-                       std::regex_search(response.ctx.first_error_message,
-                                         std::regex{ ".*[iI]ndex .*[nN]ot [fF]ound.*" })) {
+            } else if (utils::contains_string(response.ctx.first_error_message,
+                                              "Index does not exist") ||
+                       (utils::contains_string(response.ctx.first_error_message, "index", true) &&
+                        utils::contains_string(
+                          response.ctx.first_error_message, "not found", true))) {
               response.ctx.ec = errc::common::index_not_found;
             } else if (response.ctx.first_error_message.find("Bucket Not Found") !=
                        std::string::npos) {

data/ext/couchbase/core/operations/management/collection_create.cxx

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-collection_create_request::encode_to(encoded_request_type& encoded,
-                                     http_context& /*context*/) const -> std::error_code
+collection_create_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
+  -> std::error_code
 {
   encoded.method = "POST";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections",
@@ -58,18 +56,20 @@ collection_create_request::make_response(error_context::http&& ctx,
 {
   collection_create_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400: {
-        const std::regex collection_exists("Collection with name .+ already exists");
-        if (std::regex_search(encoded.body.data(), collection_exists)) {
+        const auto prefix_pos = body.find("Collection with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" already exists", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::management::collection_exists;
         } else {
           response.ctx.ec = errc::common::invalid_argument;
         }
       } break;
       case 404: {
-        const std::regex scope_not_found("Scope with name .+ is not found");
-        if (std::regex_search(encoded.body.data(), scope_not_found)) {
+        const auto prefix_pos = body.find("Scope with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" is not found", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::scope_not_found;
         } else {
           response.ctx.ec = errc::common::bucket_not_found;
@@ -78,7 +78,7 @@ collection_create_request::make_response(error_context::http&& ctx,
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -86,7 +86,7 @@ collection_create_request::make_response(error_context::http&& ctx,
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }