couchbase 3.8.2 → 3.9.0

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

@@ -65,7 +65,7 @@ map_collection(std::string scope_name,
 }
 
 auto
-map_scope_specs(core::topology::collections_manifest& manifest)
+map_scope_specs(const core::topology::collections_manifest& manifest)
   -> std::vector<couchbase::management::bucket::scope_spec>
 {
   std::vector<couchbase::management::bucket::scope_spec> scope_specs{};

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

@@ -21,9 +21,9 @@
 #include "core/io/dns_client.hxx"
 #include "core/io/dns_config.hxx"
 #include "core/logger/logger.hxx"
+#include "core/logger/redaction.hxx"
 #include "core/origin.hxx"
 #include "core/topology/configuration.hxx"
-#include "core/utils/join_strings.hxx"
 #include "core/utils/movable_function.hxx"
 
 #include <couchbase/error_codes.hxx>
@@ -44,6 +44,27 @@
 
 namespace couchbase::core::impl
 {
+namespace
+{
+auto
+nameserver_address(const io::dns::dns_config& config) -> std::string
+{
+  return fmt::format(
+    "{}:{}", config.nameserver().empty() ? "(system)" : config.nameserver(), config.port());
+}
+
+auto
+node_addresses(const origin::node_list& nodes) -> std::vector<std::string>
+{
+  std::vector<std::string> addresses;
+  addresses.reserve(nodes.size());
+  for (const auto& [host, port] : nodes) {
+    addresses.emplace_back(fmt::format("{}:{}", host, port));
+  }
+  return addresses;
+}
+} // namespace
+
 dns_srv_tracker::dns_srv_tracker(asio::io_context& ctx,
                                  std::string address,
                                  io::dns::dns_config config,
@@ -61,26 +82,37 @@ void
 dns_srv_tracker::get_srv_nodes(
   utils::movable_function<void(origin::node_list, std::error_code)> callback)
 {
-  CB_LOG_DEBUG("Query DNS-SRV: address=\"{}\", service=\"{}\", nameserver=\"{}:{}\"",
-               address_,
+  CB_LOG_DEBUG("Query DNS-SRV: name=\"{}._tcp.{}\", nameserver=\"{}\"",
                service_,
-               config_.nameserver(),
-               config_.port());
+               logger::system_data(address_),
+               logger::system_data(nameserver_address(config_)));
   dns_client_.query_srv(address_,
                         service_,
                         config_,
                         [self = shared_from_this(), callback = std::move(callback)](
-                          couchbase::core::io::dns::dns_srv_response&& resp) mutable {
+                          couchbase::core::io::dns::dns_srv_response&& resp) mutable -> void {
                           origin::node_list nodes;
                           if (resp.ec) {
                             CB_LOG_WARNING("failed to fetch DNS SRV records for \"{}\" ({}), "
                                            "assuming that cluster is listening this address",
-                                           self->address_,
+                                           logger::system_data(self->address_),
                                            resp.ec.message());
                           } else if (resp.targets.empty() && self->address_ != "localhost") {
-                            CB_LOG_DEBUG("DNS SRV query returned 0 records for \"{}\", assuming "
-                                         "that cluster is listening this address",
-                                         self->address_);
+                            if (self->config_.nameserver().empty()) {
+                              CB_LOG_DEBUG("DNS SRV query returned 0 records for \"{}\", assuming "
+                                           "that cluster is listening this address",
+                                           logger::system_data(self->address_));
+                            } else {
+                              CB_LOG_WARNING(
+                                "DNS SRV query for \"{}._tcp.{}\" returned 0 records from "
+                                "nameserver \"{}\". The DNS server may not have SRV records "
+                                "for this hostname, or may not support SRV lookups. "
+                                "Falling back to direct connection to \"{}\".",
+                                self->service_,
+                                logger::system_data(self->address_),
+                                logger::system_data(nameserver_address(self->config_)),
+                                logger::system_data(self->address_));
+                            }
                           } else {
                             nodes.reserve(resp.targets.size());
                             for (const auto& address : resp.targets) {
@@ -115,14 +147,9 @@ dns_srv_tracker::do_dns_refresh()
 
       if (!listeners.empty()) {
         auto config = topology::make_blank_configuration(nodes, self->use_tls_, true);
-        std::vector<std::string> endpoints;
-        endpoints.reserve(nodes.size());
-        for (const auto& [host, port] : nodes) {
-          endpoints.emplace_back(fmt::format("\"{}:{}\"", host, port));
-        }
         CB_LOG_DEBUG("generated configuration from DNS-SRV response \"{}\": [{}]",
-                     self->address_,
-                     utils::join_strings(endpoints, ", "));
+                     logger::system_data(self->address_),
+                     logger::system_data_list(node_addresses(nodes), logger::list_entries::quoted));
         for (const auto& listener : listeners) {
           listener->update_config(config);
         }
@@ -152,7 +179,7 @@ dns_srv_tracker::report_bootstrap_error(const std::string& endpoint, std::error_
     CB_LOG_DEBUG(
       "all nodes failed to bootstrap, triggering DNS-SRV refresh, ec={}, last endpoint=\"{}\"",
       ec.message(),
-      endpoint);
+      logger::system_data(endpoint));
     return asio::post(asio::bind_executor(ctx_, [self = shared_from_this()]() mutable {
       self->do_dns_refresh();
     }));

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

@@ -86,6 +86,19 @@ error::error(std::error_code ec,
 {
 }
 
+error::error(std::error_code ec,
+             std::string message,
+             couchbase::error_context ctx,
+             couchbase::error cause,
+             couchbase::node_id node_id)
+  : ec_{ ec }
+  , message_{ std::move(message) }
+  , ctx_{ std::move(ctx) }
+  , cause_{ std::make_shared<error>(std::move(cause)) }
+  , node_id_{ std::move(node_id) }
+{
+}
+
 auto
 error::ec() const -> std::error_code
 {
@@ -120,7 +133,8 @@ error::node_id() const -> const couchbase::node_id&
   return node_id_;
 }
 
-error::operator bool() const
+error::
+operator bool() const
 {
   return ec_.value() != 0;
 }
@@ -222,11 +236,17 @@ make_error(const core::transactions::op_exception& exc) -> couchbase::error
   }
 
   if (cause.has_value()) {
+    // Propagate node_id from the inner cause to the outer error. Without
+    // this, a transaction-wrapped KV failure would have outer.node_id() ==
+    // {} while cause().value().node_id() carries the real attribution —
+    // surprising for callers reading error.node_id() at the top level.
+    auto node_id = cause->node_id();
     return couchbase::error{
       transaction_op_errc_from_external_exception(exc.cause()),
       exc.what(),
       {},
-      cause.value(),
+      std::move(*cause),
+      std::move(node_id),
     };
   }
 

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

@@ -0,0 +1,111 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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/analytics_meta_data.hxx>
+#include <couchbase/analytics_stream_result.hxx>
+#include <couchbase/error_codes.hxx>
+
+#include "core/analytics_stream.hxx"
+
+#include "core/error_context/analytics.hxx"
+#include <atomic>
+#include <future>
+
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <system_error>
+#include <utility>
+#include <vector>
+
+namespace couchbase::core::impl
+{
+class observability_recorder;
+} // namespace couchbase::core::impl
+
+namespace couchbase
+{
+class internal_analytics_stream_result
+  : public std::enable_shared_from_this<internal_analytics_stream_result>
+{
+public:
+  internal_analytics_stream_result(core::analytics_stream stream,
+                                   std::unique_ptr<core::impl::observability_recorder> obs_rec,
+                                   core::error_context::analytics ctx);
+  // Non-copyable and non-movable: holds a std::mutex and is only ever owned via shared_ptr.
+  internal_analytics_stream_result(const internal_analytics_stream_result&) = delete;
+  internal_analytics_stream_result(internal_analytics_stream_result&&) = delete;
+  auto operator=(const internal_analytics_stream_result&)
+    -> internal_analytics_stream_result& = delete;
+  auto operator=(internal_analytics_stream_result&&) -> internal_analytics_stream_result& = delete;
+
+  ~internal_analytics_stream_result();
+
+  void next(analytics_row_handler&& handler);
+  void cancel();
+
+  /**
+   * Returns the analytics signature captured from the response metadata.
+   */
+  [[nodiscard]] auto signature() const -> std::optional<codec::binary>;
+
+  /**
+   * Returns a future that resolves to analytics metadata once the stream reaches its terminal
+   * state (all rows consumed or an error). If the terminal has already been reached, returns a
+   * ready future built from the stored value.
+   */
+  auto meta_data() -> std::future<std::pair<error, analytics_meta_data>>;
+
+private:
+  /**
+   * Called when next_row reports the terminal condition (nullopt row).
+   * Resolves the meta_data promise from the core stream.
+   *
+   * @param ec error code from the terminal next_row call (falsy = clean end)
+   */
+  void resolve_meta_data(std::error_code ec);
+
+  core::analytics_stream stream_;
+
+  // The request's error context as of a successfully started stream (statement, parameters, HTTP
+  // status, endpoint). A terminal error is reported against a copy of this with the trailer's
+  // diagnostics stamped on, so a mid-stream failure is as diagnosable as one that failed to start.
+  core::error_context::analytics ctx_;
+
+  // Observability recorder for the whole streaming operation. Its operation span already parents
+  // the request; finish() is called exactly once from resolve_meta_data() (the single terminal
+  // hook, reached on drain/error/cancel/destruction), recording the operation latency metric and
+  // ending the span — the same instrumentation buffered analytics_query() emits via its recorder.
+  std::unique_ptr<core::impl::observability_recorder> obs_rec_;
+
+  // Guards the "only one outstanding next()" contract. Set while a pull is in flight and cleared
+  // when its handler runs; a concurrent/overlapping next() is rejected with invalid_argument
+  // rather than racing the single-consumer channel. Shared across handle copies (they alias one
+  // stream), so copies cannot smuggle in a second concurrent pull either.
+  std::atomic_bool pull_in_flight_{ false };
+
+  mutable std::mutex meta_mutex_{};
+  bool terminal_reached_{ false };
+  std::pair<error, analytics_meta_data> terminal_value_{};
+  // meta_data() may be called any number of times before the stream terminates; each call parks a
+  // promise here and they are all satisfied together at the terminal. (A single shared promise
+  // would throw future_already_retrieved on the second call.)
+  std::vector<std::promise<std::pair<error, analytics_meta_data>>> pending_meta_promises_{};
+};
+} // namespace couchbase

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

@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026. 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_codes.hxx>
+#include <couchbase/query_meta_data.hxx>
+#include <couchbase/query_stream_result.hxx>
+
+#include "core/query_stream.hxx"
+
+#include "core/error_context/query.hxx"
+#include <atomic>
+#include <future>
+
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <system_error>
+#include <utility>
+#include <vector>
+
+namespace couchbase::core::impl
+{
+class observability_recorder;
+} // namespace couchbase::core::impl
+
+namespace couchbase
+{
+class internal_query_stream_result
+  : public std::enable_shared_from_this<internal_query_stream_result>
+{
+public:
+  internal_query_stream_result(core::query_stream stream,
+                               std::unique_ptr<core::impl::observability_recorder> obs_rec,
+                               core::error_context::query ctx);
+  // Non-copyable and non-movable: holds a std::mutex and is only ever owned via shared_ptr.
+  internal_query_stream_result(const internal_query_stream_result&) = delete;
+  internal_query_stream_result(internal_query_stream_result&&) = delete;
+  auto operator=(const internal_query_stream_result&) -> internal_query_stream_result& = delete;
+  auto operator=(internal_query_stream_result&&) -> internal_query_stream_result& = delete;
+
+  ~internal_query_stream_result();
+
+  void next(query_row_handler&& handler);
+  void cancel();
+
+  /**
+   * Returns the query signature captured from the response metadata.
+   */
+  [[nodiscard]] auto signature() const -> std::optional<codec::binary>;
+
+  /**
+   * Returns a future that resolves to query metadata once the stream reaches its terminal state
+   * (all rows consumed or an error). If the terminal has already been reached, returns a
+   * ready future built from the stored value.
+   */
+  auto meta_data() -> std::future<std::pair<error, query_meta_data>>;
+
+private:
+  /**
+   * Called when next_row reports the terminal condition (nullopt row).
+   * Resolves the meta_data promise from the core stream.
+   *
+   * @param ec error code from the terminal next_row call (falsy = clean end)
+   */
+  void resolve_meta_data(std::error_code ec);
+
+  core::query_stream stream_;
+
+  // The request's error context as of a successfully started stream (statement, parameters, HTTP
+  // status, endpoint). A terminal error is reported against a copy of this with the trailer's
+  // diagnostics stamped on, so a mid-stream failure is as diagnosable as one that failed to start.
+  core::error_context::query ctx_;
+
+  // Observability recorder for the whole streaming operation. Its operation span already parents
+  // the request; finish() is called exactly once from resolve_meta_data() (the single terminal
+  // hook, reached on drain/error/cancel/destruction), recording the operation latency metric and
+  // ending the span — the same instrumentation the buffered query() emits via its recorder.
+  std::unique_ptr<core::impl::observability_recorder> obs_rec_;
+
+  // Guards the "only one outstanding next()" contract. Set while a pull is in flight and cleared
+  // when its handler runs; a concurrent/overlapping next() is rejected with invalid_argument
+  // rather than racing the single-consumer channel. Shared across handle copies (they alias one
+  // stream), so copies cannot smuggle in a second concurrent pull either.
+  std::atomic_bool pull_in_flight_{ false };
+
+  mutable std::mutex meta_mutex_{};
+  bool terminal_reached_{ false };
+  std::pair<error, query_meta_data> terminal_value_{};
+  // meta_data() may be called any number of times before the stream terminates; each call parks a
+  // promise here and they are all satisfied together at the terminal. (A single shared promise
+  // would throw future_already_retrieved on the second call.)
+  std::vector<std::promise<std::pair<error, query_meta_data>>> pending_meta_promises_{};
+};
+} // namespace couchbase

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

@@ -30,15 +30,23 @@ namespace couchbase::core::impl
  * 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.
+ * previous wrap_with_node_id helper.
+ *
+ * Parameters are taken by forwarding reference and perfect-forwarded to the
+ * invocation. Callers at the SDK boundary always pass rvalues (the result
+ * and error are constructed in-place at the response decoder), so this
+ * pattern eliminates the intermediate parameter-slot move and the
+ * @c invoke_with_node_id helper's overhead actually approaches zero — what
+ * the commit message claimed but the original (by-value) signatures did
+ * not quite deliver.
  */
-template<typename Handler, typename Result>
+template<typename Handler, typename Error, typename Result>
 void
-invoke_with_node_id(Handler&& handler, couchbase::error err, Result result)
+invoke_with_node_id(Handler&& handler, Error&& err, Result&& result)
 {
-  result.node_id(err.node_id());
-  std::forward<Handler>(handler)(std::move(err), std::move(result));
+  // Read node_id() BEFORE we move err, otherwise the read would see a
+  // moved-from string and yield a default node_id.
+  result.set_node_id_internal(err.node_id());
+  std::forward<Handler>(handler)(std::forward<Error>(err), std::forward<Result>(result));
 }
 } // namespace couchbase::core::impl

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

@@ -90,6 +90,12 @@ struct key_value_error_category : std::error_category {
         return "mutation_token_outdated (133)";
       case errc::key_value::range_scan_completed:
         return "range_scan_completed (134)";
+      case errc::key_value::document_not_found_on_replica:
+        return "document_not_found_on_replica (135)";
+      case errc::key_value::replica_index_out_of_bounds:
+        return "replica_index_out_of_bounds (136)";
+      case errc::key_value::replica_index_currently_unavailable:
+        return "replica_index_currently_unavailable (137)";
     }
     return "FIXME: unknown error code (recompile with newer library): couchbase.key_value." +
            std::to_string(ev);

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

@@ -59,7 +59,6 @@ lookup_in_replica_request::make_response(key_value_error_context&& ctx,
   bool deleted = false;
   couchbase::cas cas{};
   std::vector<lookup_in_replica_response::entry> fields{};
-  std::error_code ec = ctx.ec();
   std::optional<std::size_t> first_error_index{};
   std::optional<std::string> first_error_path{};
 
@@ -83,13 +82,14 @@ lookup_in_replica_request::make_response(key_value_error_context&& ctx,
                                                static_cast<std::uint16_t>(res_entry.status));
       if (fields[i].opcode == protocol::subdoc_opcode::exists &&
           fields[i].ec == errc::key_value::path_not_found) {
+        // exists treats path_not_found as success ("false"); suppress the error so the
+        // exists flag below carries the result instead.
         fields[i].ec.clear();
       }
-      if (!fields[i].ec && !ctx.ec()) {
-        ec = fields[i].ec;
-      }
-      if (!first_error_index && !fields[i].ec) {
-        first_error_index = i;
+      // Use original_index, not wire-order i: XATTR specs are reordered during encode_to(),
+      // so i != original_index (was the CXXCBC-788 bug).
+      if (!first_error_index && fields[i].ec) {
+        first_error_index = fields[i].original_index;
         first_error_path = fields[i].path;
       }
       fields[i].exists = res_entry.status == key_value_status_code::success ||
@@ -100,16 +100,16 @@ lookup_in_replica_request::make_response(key_value_error_context&& ctx,
         fields[i].value = utils::to_binary(res_entry.value);
       }
     }
-    if (!ec) {
-      cas = encoded.cas();
-    }
+    // Always assign CAS; previously guarded by a local ec that was polluted by per-path
+    // errors, zeroing CAS whenever any path failed (CXXCBC-788).
+    cas = encoded.cas();
     std::sort(fields.begin(), fields.end(), [](const auto& lhs, const auto& rhs) {
       return lhs.original_index < rhs.original_index;
     });
   }
 
   return lookup_in_replica_response{
-    make_subdocument_error_context(ctx, ec, first_error_path, first_error_index, deleted),
+    make_subdocument_error_context(ctx, ctx.ec(), first_error_path, first_error_index, deleted),
     cas,
     std::move(fields),
     deleted,

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

@@ -35,10 +35,10 @@ struct lookup_in_replica_response {
   struct entry {
     std::string path;
     couchbase::codec::binary value;
-    std::size_t original_index;
-    bool exists;
-    protocol::subdoc_opcode opcode;
-    key_value_status_code status;
+    std::size_t original_index{};
+    bool exists{};
+    protocol::subdoc_opcode opcode{};
+    key_value_status_code status{};
     std::error_code ec{};
   };
   subdocument_error_context ctx{};

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

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2024-Present Couchbase, Inc.
+ *   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.
@@ -19,10 +19,10 @@
 
 #include "core/utils/crc32.hxx"
 
-#include <spdlog/fmt/bundled/core.h>
-
+#include <array>
 #include <cstdint>
 #include <string>
+#include <utility>
 
 namespace couchbase
 {
@@ -39,9 +39,19 @@ namespace
 auto
 derive_fallback_id(const std::string& hostname, std::uint16_t port) -> std::string
 {
-  auto input = fmt::format("{}:{}", hostname, port);
+  auto input = hostname + ':' + std::to_string(port);
   auto crc = core::utils::hash_crc32(input.data(), input.size());
-  return fmt::format("{:08x}", crc);
+
+  // Format as 8 lowercase hex chars, zero-padded — avoids a heavy fmt include
+  // for what amounts to a two-line hex conversion.
+  static constexpr std::array<char, 16> hex_digits{ '0', '1', '2', '3', '4', '5', '6', '7',
+                                                    '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+  std::string out;
+  out.reserve(8);
+  for (int shift = 28; shift >= 0; shift -= 4) {
+    out.push_back(hex_digits[(crc >> shift) & 0xFU]);
+  }
+  return out;
 }
 } // namespace
 
@@ -54,56 +64,82 @@ node_id::node_id(std::string node_uuid, std::string hostname, std::uint16_t port
 }
 
 auto
-node_id::id() const -> const std::string&
+node_id::id() const noexcept -> const std::string&
 {
   return id_;
 }
 
 auto
-node_id::node_uuid() const -> const std::string&
+node_id::node_uuid() const noexcept -> const std::string&
 {
   return node_uuid_;
 }
 
 auto
-node_id::hostname() const -> const std::string&
+node_id::hostname() const noexcept -> const std::string&
 {
   return hostname_;
 }
 
 auto
-node_id::port() const -> std::uint16_t
+node_id::port() const noexcept -> std::uint16_t
 {
   return port_;
 }
 
 node_id::
-operator bool() const
+operator bool() const noexcept
 {
   return !id_.empty();
 }
 
 auto
-node_id::operator==(const node_id& other) const -> bool
+node_id::operator==(const node_id& other) const noexcept -> bool
 {
   return id_ == other.id_;
 }
 
 auto
-node_id::operator!=(const node_id& other) const -> bool
+node_id::operator!=(const node_id& other) const noexcept -> bool
 {
   return !(*this == other);
 }
 
 auto
-node_id::operator<(const node_id& other) const -> bool
+node_id::operator<(const node_id& other) const noexcept -> bool
 {
   return id_ < other.id_;
 }
 
+auto
+node_id::operator<=(const node_id& other) const noexcept -> bool
+{
+  return !(other < *this);
+}
+
+auto
+node_id::operator>(const node_id& other) const noexcept -> bool
+{
+  return other < *this;
+}
+
+auto
+node_id::operator>=(const node_id& other) const noexcept -> bool
+{
+  return !(*this < other);
+}
+
 auto
 internal_node_id::build(std::string node_uuid, std::string hostname, std::uint16_t port) -> node_id
 {
+  // Preserve the "falsy = unknown" contract: a node that has neither a
+  // server-assigned UUID nor a usable hostname+port pair cannot be uniquely
+  // identified. Returning a default-constructed node_id keeps such an input
+  // falsy so request- and response-side identity construction agree on the
+  // same "empty" answer for not-yet-bound or KV-less topology entries.
+  if (node_uuid.empty() && (hostname.empty() || port == 0)) {
+    return {};
+  }
   return { std::move(node_uuid), std::move(hostname), port };
 }
 

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

@@ -45,8 +45,18 @@ observability_recorder::operation_span() -> const std::shared_ptr<couchbase::tra
 void
 observability_recorder::finish(const std::error_code ec)
 {
-  metric_attributes_.ec = ec;
-  meter_.lock()->record_value(std::move(metric_attributes_), start_time_);
+  // Precompute the standardized error type once here, so the recorder-cache lookup keyed on it does
+  // not build a string per comparison.
+  metric_attributes_.error_type = metrics::standardized_error_type(ec);
+  // meter_ is a weak_ptr. On the buffered path finish() always runs inside the io-thread execute
+  // completion, so the meter (owned by the cluster) is alive. The streaming path defers finish() to
+  // a user-controlled terminal — a stream handle dropped via its destructor/cancel() — which may
+  // run after the owning cluster, and its meter, is gone. Guard the lock so a late finish records
+  // nothing instead of dereferencing an expired weak_ptr. span_ holds a strong ref, so ending it is
+  // always safe.
+  if (const auto meter = meter_.lock()) {
+    meter->record_value(std::move(metric_attributes_), start_time_);
+  }
   span_->end();
 }