couchbase 3.8.1 → 3.9.0

data/ext/couchbase/core/analytics_stream_component.hxx

@@ -0,0 +1,67 @@
+/* -*- 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 "analytics_stream.hxx"
+#include "error_context/analytics.hxx"
+#include "operations/document_analytics.hxx"
+#include "utils/movable_function.hxx"
+
+#include <chrono>
+#include <memory>
+#include <system_error>
+
+namespace asio
+{
+class io_context;
+} // namespace asio
+
+namespace couchbase::core
+{
+class http_component;
+
+/**
+ * Dispatches an analytics query as a streaming HTTP request and resolves to an analytics_stream
+ * handle once the response preamble (signature + upfront errors) has been parsed.
+ *
+ * Unlike the buffered analytics path this never materialises the full response body; it performs no
+ * client-side retry.
+ */
+class analytics_stream_component
+{
+public:
+  // The context carries the error code (error_context::analytics::ec) alongside the diagnostics the
+  // buffered path reports — statement, parameters, the service's first error, HTTP status and body,
+  // and where the request was dispatched — so a streaming failure is as diagnosable as a buffered
+  // one. It is delivered on both outcomes: when the stream fails to start it describes that
+  // failure, and when it starts it describes the request and its dispatch, for the consumer to
+  // report a terminal error against later. Only `ec` differs between the two: falsy means the
+  // stream started.
+  using handler_type = utils::movable_function<void(analytics_stream, error_context::analytics)>;
+
+  analytics_stream_component(asio::io_context& io,
+                             http_component http,
+                             std::chrono::milliseconds default_timeout,
+                             row_streamer_options streaming_options = {});
+
+  void execute(operations::analytics_request request, handler_type&& handler) const;
+
+private:
+  std::shared_ptr<class analytics_stream_component_impl> impl_;
+};
+} // namespace couchbase::core

data/ext/couchbase/core/app_telemetry_meter.cxx

@@ -233,7 +233,7 @@ struct http_histogram {
       fmt::format_to(output, "{}_bucket{{le=\"30000\",{}}} {}\n", name, lbuf, le_30s.load());
       fmt::format_to(output, "{}_bucket{{le=\"75000\",{}}} {}\n", name, lbuf, le_75s.load());
       fmt::format_to(output, "{}_bucket{{le=\"+Inf\",{}}} {}\n", name, lbuf, inf.load());
-      fmt::format_to(output, "{}_sum{{{}}} {}\n", name, lbuf, sum.load() / 1000);
+      fmt::format_to(output, "{}_sum{{{}}} {}\n", name, lbuf, sum.load());
       fmt::format_to(output, "{}_count{{{}}} {}\n", name, lbuf, count.load());
     }
   }
@@ -599,7 +599,7 @@ public:
   auto value_recorder(const std::string& node_uuid, const std::string& bucket_name)
     -> std::shared_ptr<app_telemetry_value_recorder> override
   {
-    const std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
 
     if (auto node = recorders_.find(node_uuid); node != recorders_.end()) {
       if (auto bucket = node->second.find(bucket_name); bucket != node->second.end()) {
@@ -636,7 +636,7 @@ public:
 
   auto nothing_to_report() -> bool override
   {
-    const std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     return recorders_.empty();
   }
 
@@ -740,6 +740,15 @@ app_telemetry_meter::disable()
                tao::json::to_string(tao::json::value{
                  { "nothing_to_report", impl_->nothing_to_report() },
                }));
+  // Bump the generation before swapping impl_: a per-connection cache
+  // (app_telemetry_recorder_cache) reads the generation without this lock, so if the bump followed
+  // the swap there would be a window in which the cache still observes the old generation while the
+  // recorders have already been replaced, and it would keep recording into a now-retired recorder.
+  // Bumping first narrows that window but does not close it -- a lockless reader may still observe
+  // the old generation value for a bounded time after the bump -- so a brief race is tolerated by
+  // design: the cache re-reads the generation and drops any recorder it cached under a generation
+  // that has since moved.
+  generation_.fetch_add(1, std::memory_order_relaxed);
   impl_ = std::make_unique<null_app_telemetry_meter_impl>();
 }
 
@@ -751,6 +760,9 @@ app_telemetry_meter::enable()
     return;
   }
   CB_LOG_DEBUG("Enable app telemetry meter.");
+  // Bump the generation before swapping impl_ (see disable() for the tolerated race): keep the same
+  // bump-before-swap ordering so the cache's generation re-read reliably retires old recorders.
+  generation_.fetch_add(1, std::memory_order_relaxed);
   impl_ = std::make_unique<default_app_telemetry_meter_impl>();
 }
 
@@ -784,9 +796,19 @@ app_telemetry_meter::generate_report(std::vector<std::byte>& output_buffer)
   if (impl_->nothing_to_report()) {
     return;
   }
+  // Bump the generation before replacing impl_ (see disable() for the tolerated race): keep the
+  // same bump-before-swap ordering so the cache's generation re-read reliably retires old
+  // recorders.
+  generation_.fetch_add(1, std::memory_order_relaxed);
   const auto old_impl = std::move(impl_);
   impl_ = std::make_unique<default_app_telemetry_meter_impl>();
   impl_->set_node_labels_cache(old_impl->current_node_labels());
   old_impl->generate_to(output_buffer, agent_);
 }
+
+auto
+app_telemetry_meter::generation() const noexcept -> std::uint64_t
+{
+  return generation_.load(std::memory_order_relaxed);
+}
 } // namespace couchbase::core

data/ext/couchbase/core/app_telemetry_meter.hxx

@@ -17,6 +17,7 @@
 
 #include "service_type.hxx"
 
+#include <atomic>
 #include <chrono>
 #include <cstdint>
 #include <memory>
@@ -191,10 +192,86 @@ public:
     -> std::shared_ptr<app_telemetry_value_recorder>;
   void generate_report(std::vector<std::byte>& output_buffer);
 
+  /**
+   * A monotonically increasing counter that changes whenever the underlying recorders are replaced
+   * (enable/disable/generate_report). Callers that cache a recorder must re-resolve it when the
+   * generation changes, otherwise they would keep writing to a recorder that is no longer reported.
+   */
+  [[nodiscard]] auto generation() const noexcept -> std::uint64_t;
+
 private:
   std::string agent_;
   std::unique_ptr<app_telemetry_meter_impl> impl_;
   std::shared_mutex impl_mutex_{};
+  std::atomic<std::uint64_t> generation_{ 0 };
+};
+
+/**
+ * A single-slot, generation-aware cache of an app_telemetry recorder, held per connection. It keeps
+ * the per-operation recorder lookup — two locks and nested string-map traversals inside the meter —
+ * off the hot path by resolving once and re-resolving only when the key or the meter's generation
+ * changes.
+ *
+ * The cache's own fields are non-atomic and unsynchronized: correctness relies on the cache being
+ * accessed from a single executor only (the connection's IO thread). The meter's generation, by
+ * contrast, is atomic and may be bumped from another executor — enable/disable/generate_report can
+ * run on unrelated Asio handlers — so the cache reads it through an atomic load and re-resolves
+ * whenever the observed generation differs from the one it cached; the resolution itself re-checks
+ * the generation and retries, so the cached (recorder, generation) pair is always coherent.
+ *
+ * Because the read and the subsequent record happen without a lock, there remains a narrow, benign
+ * window: if the meter is swapped immediately after value_recorder() returns, that operation's
+ * sample can land in a just-retired recorder and be missed by the in-flight report. This is bounded
+ * to a single operation around an enable/disable/report transition, is not a memory-safety issue
+ * (the recorder is a shared_ptr and stays alive), and self-corrects on the next operation once the
+ * new generation is observed. Eliminating it entirely would require holding a lock across every
+ * operation, defeating the purpose of the cache. It also assumes a stable meter — the same meter
+ * instance is passed for the life of the cache — since the key does not include the meter's
+ * identity.
+ */
+class app_telemetry_recorder_cache
+{
+public:
+  [[nodiscard]] auto is_valid_for(std::uint64_t generation,
+                                  const std::string& node_uuid,
+                                  const std::string& bucket_name) const -> bool
+  {
+    return recorder_ != nullptr && generation_ == generation && node_uuid_ == node_uuid &&
+           bucket_name_ == bucket_name;
+  }
+
+  // Returns by value rather than by const reference: the cached recorder can be replaced on the
+  // next call (a key or generation change), so handing out a reference into the cache would be a
+  // dangling/aliasing hazard. The caller takes a shared_ptr by value anyway, so this only makes the
+  // (cheap) refcount bump explicit here.
+  auto value_recorder(app_telemetry_meter& meter,
+                      const std::string& node_uuid,
+                      const std::string& bucket_name)
+    -> std::shared_ptr<app_telemetry_value_recorder>
+  {
+    auto generation = meter.generation();
+    while (!is_valid_for(generation, node_uuid, bucket_name)) {
+      auto recorder = meter.value_recorder(node_uuid, bucket_name);
+      // Re-read the generation: if the meter was swapped while we resolved, the recorder we just
+      // fetched may already be retired. Retry with the new generation so we never cache a recorder
+      // under a generation that has already moved.
+      if (const auto latest = meter.generation(); latest != generation) {
+        generation = latest;
+        continue;
+      }
+      recorder_ = std::move(recorder);
+      generation_ = generation;
+      node_uuid_ = node_uuid;
+      bucket_name_ = bucket_name;
+    }
+    return recorder_;
+  }
+
+private:
+  std::shared_ptr<app_telemetry_value_recorder> recorder_{};
+  std::uint64_t generation_{ 0 };
+  std::string node_uuid_{};
+  std::string bucket_name_{};
 };
 
 } // namespace couchbase::core

data/ext/couchbase/core/app_telemetry_reporter.cxx

@@ -181,12 +181,13 @@ private:
     } else {
       stream_ = std::make_unique<io::plain_stream_impl>(ctx_);
     }
-    stream_->async_connect(endpoint->endpoint(), [self = shared_from_this()](auto ec) {
-      if (ec) {
-        return self->reconnect_socket(ec, "connection failure");
-      }
-      self->complete_with_success();
-    });
+    stream_->async_connect(
+      endpoint->endpoint(), address_.hostname, [self = shared_from_this()](auto ec) {
+        if (ec) {
+          return self->reconnect_socket(ec, "connection failure");
+        }
+        self->complete_with_success();
+      });
   }
 
   void resolve_address()