couchbase 3.7.0 → 3.8.1

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

@@ -18,6 +18,7 @@
 #include "core/cluster.hxx"
 
 #include "core/impl/error.hxx"
+#include "core/impl/observability_recorder.hxx"
 #include "core/operations/management/collection_create.hxx"
 #include "core/operations/management/collection_drop.hxx"
 #include "core/operations/management/collection_update.hxx"
@@ -25,6 +26,8 @@
 #include "core/operations/management/scope_drop.hxx"
 #include "core/operations/management/scope_get_all.hxx"
 #include "core/topology/collections_manifest.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 
 #include <couchbase/collection_manager.hxx>
 #include <couchbase/create_collection_options.hxx>
@@ -93,15 +96,19 @@ public:
                        const couchbase::drop_collection_options::built& options,
                        couchbase::drop_collection_handler&& handler) const
   {
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_collections_drop_collection,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+    core::operations::management::collection_drop_request request{
+      bucket_name_, std::move(scope_name), std::move(collection_name),
+      {},           options.timeout,       obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::collection_drop_request{
-        bucket_name_,
-        std::move(scope_name),
-        std::move(collection_name),
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -112,17 +119,20 @@ public:
                          const couchbase::update_collection_options::built& options,
                          couchbase::update_collection_handler&& handler) const
   {
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_collections_update_collection,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+    core::operations::management::collection_update_request request{
+      bucket_name_,        std::move(scope_name),     std::move(collection_name),
+      settings.max_expiry, settings.history,          {},
+      options.timeout,     obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::collection_update_request{
-        bucket_name_,
-        std::move(scope_name),
-        std::move(collection_name),
-        settings.max_expiry,
-        settings.history,
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -133,17 +143,20 @@ public:
                          const couchbase::create_collection_options::built& options,
                          couchbase::update_collection_handler&& handler) const
   {
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_collections_create_collection,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+    core::operations::management::collection_create_request request{
+      bucket_name_,        std::move(scope_name),     std::move(collection_name),
+      settings.max_expiry, settings.history,          {},
+      options.timeout,     obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::collection_create_request{
-        bucket_name_,
-        std::move(scope_name),
-        std::move(collection_name),
-        settings.max_expiry,
-        settings.history,
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -151,13 +164,18 @@ public:
   void get_all_scopes(const get_all_scopes_options::built& options,
                       get_all_scopes_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_collections_get_all_scopes, {}, {}, options.parent_span);
+    core::operations::management::scope_get_all_request request{
+      bucket_name_,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::scope_get_all_request{
-        bucket_name_,
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](auto resp) mutable {
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](auto resp) mutable {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx), map_scope_specs(resp.manifest));
       });
   }
@@ -166,14 +184,15 @@ public:
                     const couchbase::create_scope_options::built& options,
                     couchbase::create_scope_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_collections_create_scope, scope_name, {}, options.parent_span);
+    core::operations::management::scope_create_request request{
+      bucket_name_, std::move(scope_name), {}, options.timeout, obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::scope_create_request{
-        bucket_name_,
-        std::move(scope_name),
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -182,19 +201,40 @@ public:
                   const couchbase::drop_scope_options::built& options,
                   couchbase::drop_scope_handler&& handler) const
   {
-    core_.execute(
-      core::operations::management::scope_drop_request{
-        bucket_name_,
-        std::move(scope_name),
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_collections_drop_scope, scope_name, {}, options.parent_span);
+    core::operations::management::scope_drop_request request{
+      bucket_name_, std::move(scope_name), {}, options.timeout, obs_rec->operation_span(),
+    };
+    return core_.execute(
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx));
       });
   }
 
 private:
+  [[nodiscard]] auto create_observability_recorder(
+    const std::string& operation_name,
+    const std::optional<std::string>& scope_name,
+    const std::optional<std::string>& collection_name,
+    const std::shared_ptr<tracing::request_span>& parent_span) const
+    -> std::unique_ptr<core::impl::observability_recorder>
+  {
+    auto obs_rec = core::impl::observability_recorder::create(
+      operation_name, parent_span, core_.tracer(), core_.meter());
+    obs_rec->with_service(core::tracing::service::management);
+    obs_rec->with_bucket_name(bucket_name_);
+    if (scope_name.has_value()) {
+      obs_rec->with_scope_name(scope_name.value());
+    }
+    if (collection_name.has_value()) {
+      obs_rec->with_collection_name(collection_name.value());
+    }
+    return obs_rec;
+  }
+
   core::cluster core_;
   std::string bucket_name_;
 };

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

@@ -78,9 +78,9 @@ dns_srv_tracker::get_srv_nodes(
                                            self->address_,
                                            resp.ec.message());
                           } else if (resp.targets.empty() && self->address_ != "localhost") {
-                            CB_LOG_WARNING("DNS SRV query returned 0 records for \"{}\", assuming "
-                                           "that cluster is listening this address",
-                                           self->address_);
+                            CB_LOG_DEBUG("DNS SRV query returned 0 records for \"{}\", assuming "
+                                         "that cluster is listening this address",
+                                         self->address_);
                           } else {
                             nodes.reserve(resp.targets.size());
                             for (const auto& address : resp.targets) {
@@ -136,7 +136,7 @@ dns_srv_tracker::report_bootstrap_error(const std::string& endpoint, std::error_
 {
   bool trigger_dns_srv_refresh = false;
 
-  if (ec && ec != errc::common::request_canceled) {
+  if (ec && ec != errc::common::request_canceled && ec != errc::common::bucket_not_found) {
     const std::scoped_lock lock(known_endpoints_mutex_);
     known_endpoints_.erase(endpoint);
     if (known_endpoints_.empty()) {

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

@@ -17,6 +17,7 @@
 
 #include "error.hxx"
 
+#include "core/error.hxx"
 #include "core/error_context/analytics.hxx"
 #include "core/error_context/analytics_json.hxx"
 #include "core/error_context/http.hxx"
@@ -74,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
 {
@@ -102,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;
@@ -116,7 +134,7 @@ error::operator==(const couchbase::error& other) const -> bool
 namespace core::impl
 {
 auto
-make_error(const core::error_context::query& core_ctx) -> error
+make_error(const core::error_context::query& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec) {
     return {};
@@ -125,7 +143,7 @@ make_error(const core::error_context::query& core_ctx) -> error
 }
 
 auto
-make_error(const query_error_context& core_ctx) -> error
+make_error(const query_error_context& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec()) {
     return {};
@@ -134,7 +152,7 @@ make_error(const query_error_context& core_ctx) -> error
 }
 
 auto
-make_error(const core::error_context::search& core_ctx) -> error
+make_error(const core::error_context::search& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec) {
     return {};
@@ -143,7 +161,7 @@ make_error(const core::error_context::search& core_ctx) -> error
 }
 
 auto
-make_error(const core::error_context::analytics& core_ctx) -> error
+make_error(const core::error_context::analytics& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec) {
     return {};
@@ -152,7 +170,7 @@ make_error(const core::error_context::analytics& core_ctx) -> error
 }
 
 auto
-make_error(const core::error_context::http& core_ctx) -> error
+make_error(const core::error_context::http& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec) {
     return {};
@@ -161,33 +179,41 @@ make_error(const core::error_context::http& core_ctx) -> error
 }
 
 auto
-make_error(const couchbase::core::key_value_error_context& core_ctx) -> error
+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) -> error
+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
-make_error(const couchbase::core::transaction_error_context& ctx) -> error
+make_error(const couchbase::core::transaction_error_context& ctx) -> couchbase::error
 {
   return { ctx.ec(), {}, {}, { ctx.cause() } };
 }
 
 auto
-make_error(const core::transactions::op_exception& exc) -> error
+make_error(const core::transactions::op_exception& exc) -> couchbase::error
 {
-  std::optional<error> cause;
+  std::optional<couchbase::error> cause;
   if (std::holds_alternative<key_value_error_context>(exc.ctx().cause())) {
     cause = make_error(std::get<key_value_error_context>(exc.ctx().cause()));
   }
@@ -196,7 +222,7 @@ make_error(const core::transactions::op_exception& exc) -> error
   }
 
   if (cause.has_value()) {
-    return error{
+    return couchbase::error{
       transaction_op_errc_from_external_exception(exc.cause()),
       exc.what(),
       {},
@@ -204,7 +230,7 @@ make_error(const core::transactions::op_exception& exc) -> error
     };
   }
 
-  return error{
+  return couchbase::error{
     transaction_op_errc_from_external_exception(exc.cause()),
     exc.what(),
     {},
@@ -218,7 +244,13 @@ make_error(const couchbase::core::transactions::transaction_operation_failed& co
   return { couchbase::errc::transaction_op::transaction_op_failed,
            core_tof.what(),
            internal_error_context::build_error_context(tao::json::empty_object, core_tof),
-           error(transaction_op_errc_from_external_exception(core_tof.cause())) };
+           couchbase::error(transaction_op_errc_from_external_exception(core_tof.cause())) };
+}
+
+auto
+make_error(const core::error& err) -> couchbase::error
+{
+  return { err.ec, err.message };
 }
 } // namespace core::impl
 } // namespace couchbase

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

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "core/error.hxx"
 #include "core/error_context/key_value_error_context.hxx"
 #include "core/error_context/query_error_context.hxx"
 #include "core/error_context/subdocument_error_context.hxx"
@@ -33,32 +34,36 @@
 namespace couchbase::core::impl
 {
 auto
-make_error(const core::error_context::query& core_ctx) -> error;
+make_error(const core::error_context::query& core_ctx) -> couchbase::error;
 
 auto
-make_error(const core::error_context::search& core_ctx) -> error;
+make_error(const core::error_context::search& core_ctx) -> couchbase::error;
 
 auto
-make_error(const core::error_context::analytics& core_ctx) -> error;
+make_error(const core::error_context::analytics& core_ctx) -> couchbase::error;
 
 auto
-make_error(const core::error_context::http& core_ctx) -> error;
+make_error(const core::error_context::http& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::key_value_error_context& core_ctx) -> error;
+make_error(const couchbase::core::key_value_error_context& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::subdocument_error_context& core_ctx) -> error;
+make_error(const couchbase::core::subdocument_error_context& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::query_error_context& core_ctx) -> error;
+make_error(const couchbase::core::query_error_context& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::transaction_error_context& core_ctx) -> error;
+make_error(const couchbase::core::transaction_error_context& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::transactions::op_exception& exc) -> error;
+make_error(const couchbase::core::transactions::op_exception& exc) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::transactions::transaction_operation_failed& core_tof) -> error;
+make_error(const couchbase::core::transactions::transaction_operation_failed& core_tof)
+  -> couchbase::error;
+
+auto
+make_error(const core::error& err) -> couchbase::error;
 } // namespace couchbase::core::impl

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

@@ -70,7 +70,7 @@ private:
 };
 
 using movable_get_all_replicas_handler =
-  utils::movable_function<void(error, get_all_replicas_result)>;
+  utils::movable_function<void(couchbase::error, get_all_replicas_result)>;
 
 void
 initiate_get_all_replicas_operation(std::shared_ptr<cluster> core,

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

@@ -65,7 +65,8 @@ private:
   std::optional<std::chrono::milliseconds> timeout_{};
 };
 
-using movable_get_any_replica_handler = utils::movable_function<void(error, get_replica_result)>;
+using movable_get_any_replica_handler =
+  utils::movable_function<void(couchbase::error, get_replica_result)>;
 
 void
 initiate_get_any_replica_operation(std::shared_ptr<cluster> core,

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

@@ -23,6 +23,7 @@
 #include "core/io/retry_context.hxx"
 #include "core/protocol/client_request.hxx"
 #include "core/protocol/cmd_get_replica.hxx"
+#include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::impl
@@ -48,6 +49,7 @@ struct get_replica_request {
   std::uint16_t partition{};
   std::uint32_t opaque{};
   io::retry_context<true> retries{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
   [[nodiscard]] auto encode_to(encoded_request_type& encoded,
                                core::mcbp_context&& context) const -> std::error_code;

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/lookup_in_replica.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include "core/error_context/key_value.hxx"
+#include "core/error_context/subdocument_error_context.hxx"
 #include "core/impl/subdoc/command.hxx"
 #include "core/io/mcbp_context.hxx"
 #include "core/io/retry_context.hxx"
@@ -26,7 +27,6 @@
 #include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
-#include "core/error_context/subdocument_error_context.hxx"
 #include <couchbase/lookup_in_result.hxx>
 
 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