couchbase 3.7.0 → 3.8.0

data/ext/couchbase/core/impl/search_index_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/search_index_analyze_document.hxx"
 #include "core/operations/management/search_index_control_ingest.hxx"
 #include "core/operations/management/search_index_control_plan_freeze.hxx"
@@ -27,6 +28,8 @@
 #include "core/operations/management/search_index_get_all.hxx"
 #include "core/operations/management/search_index_get_documents_count.hxx"
 #include "core/operations/management/search_index_upsert.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 #include "core/utils/json.hxx"
 
 #include <couchbase/scope_search_index_manager.hxx>
@@ -147,10 +150,17 @@ public:
                  const couchbase::get_search_index_options::built& options,
                  get_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_search_get_index,
+                                                 options.parent_span);
+
+    core::operations::management::search_index_get_request request{
+      std::move(index_name),     bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_get_request{
-        std::move(index_name), bucket_name_, 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), map_search_index(resp.index));
       });
   }
@@ -158,10 +168,15 @@ public:
   void get_all_indexes(const get_all_search_indexes_options::built& options,
                        get_all_search_indexes_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_search_get_all_indexes, options.parent_span);
+    core::operations::management::search_index_get_all_request request{
+      bucket_name_, scope_name_, {}, options.timeout, obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_get_all_request{
-        bucket_name_, 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), map_all_search_indexes(resp.indexes));
       });
   }
@@ -170,10 +185,16 @@ public:
                     const upsert_search_index_options::built& options,
                     upsert_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_search_upsert_index,
+                                                 options.parent_span);
+    core::operations::management::search_index_upsert_request request{
+      map_search_index(search_index), bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_upsert_request{
-        map_search_index(search_index), bucket_name_, 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,10 +203,16 @@ public:
                   const drop_search_index_options::built& options,
                   drop_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_search_drop_index,
+                                                 options.parent_span);
+    core::operations::management::search_index_drop_request request{
+      std::move(index_name),     bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_drop_request{
-        std::move(index_name), bucket_name_, 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));
       });
   }
@@ -194,10 +221,16 @@ public:
                                    const get_indexed_search_index_options::built& options,
                                    get_indexed_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_search_get_indexed_documents_count, options.parent_span);
+    core::operations::management::search_index_get_documents_count_request request{
+      std::move(index_name),     bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_get_documents_count_request{
-        std::move(index_name), bucket_name_, 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), resp.count);
       });
   }
@@ -206,10 +239,16 @@ public:
                     const pause_ingest_search_index_options::built& options,
                     pause_ingest_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_search_pause_ingest,
+                                                 options.parent_span);
+    core::operations::management::search_index_control_ingest_request request{
+      std::move(index_name),     true, bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_control_ingest_request{
-        std::move(index_name), true, bucket_name_, 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));
       });
   }
@@ -218,10 +257,16 @@ public:
                      const resume_ingest_search_index_options::built& options,
                      resume_ingest_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_search_resume_ingest,
+                                                 options.parent_span);
+    core::operations::management::search_index_control_ingest_request request{
+      std::move(index_name),     false, bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_control_ingest_request{
-        std::move(index_name), false, bucket_name_, 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));
       });
   }
@@ -230,10 +275,16 @@ public:
                       const allow_querying_search_index_options::built& options,
                       allow_querying_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_search_allow_querying, options.parent_span);
+    core::operations::management::search_index_control_query_request request{
+      std::move(index_name),     true, bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_control_query_request{
-        std::move(index_name), true, bucket_name_, 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));
       });
   }
@@ -242,10 +293,16 @@ public:
                          const disallow_querying_search_index_options::built& options,
                          disallow_querying_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_search_disallow_querying, options.parent_span);
+    core::operations::management::search_index_control_query_request request{
+      std::move(index_name),     false, bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_control_query_request{
-        std::move(index_name), false, bucket_name_, 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));
       });
   }
@@ -254,10 +311,16 @@ public:
                    const freeze_plan_search_index_options::built& options,
                    freeze_plan_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_search_freeze_plan,
+                                                 options.parent_span);
+    core::operations::management::search_index_control_plan_freeze_request request{
+      std::move(index_name),     true, bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_control_plan_freeze_request{
-        std::move(index_name), true, bucket_name_, 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));
       });
   }
@@ -266,10 +329,16 @@ public:
                      const unfreeze_plan_search_index_options::built& options,
                      unfreeze_plan_search_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_search_unfreeze_plan,
+                                                 options.parent_span);
+    core::operations::management::search_index_control_plan_freeze_request request{
+      std::move(index_name),     false, bucket_name_, scope_name_, {}, options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_control_plan_freeze_request{
-        std::move(index_name), false, bucket_name_, 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));
       });
   }
@@ -279,19 +348,40 @@ public:
                         const analyze_document_options::built& options,
                         analyze_document_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_search_analyze_document, options.parent_span);
+    core::operations::management::search_index_analyze_document_request request{
+      std::move(index_name), std::move(document),       bucket_name_, scope_name_, {},
+      options.timeout,       obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::search_index_analyze_document_request{ std::move(index_name),
-                                                                           std::move(document),
-                                                                           bucket_name_,
-                                                                           scope_name_,
-                                                                           {},
-                                                                           options.timeout },
-      [handler = std::move(handler)](const auto& resp) mutable {
-        return handler(core::impl::make_error(resp.ctx), convert_analysis(resp.analysis));
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        auto analysis = convert_analysis(resp.analysis);
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
+        return handler(core::impl::make_error(resp.ctx), std::move(analysis));
       });
   }
 
 private:
+  [[nodiscard]] auto create_observability_recorder(
+    const std::string& operation_name,
+    const std::shared_ptr<tracing::request_span>& parent_span) const
+    -> std::unique_ptr<core::impl::observability_recorder>
+  {
+    auto rec = core::impl::observability_recorder::create(
+      operation_name, parent_span, core_.tracer(), core_.meter());
+
+    rec->with_service(core::tracing::service::search);
+    if (bucket_name_.has_value()) {
+      rec->with_bucket_name(bucket_name_.value());
+    }
+    if (scope_name_.has_value()) {
+      rec->with_scope_name(scope_name_.value());
+    }
+    return rec;
+  }
+
   core::cluster core_;
   std::optional<std::string> bucket_name_{};
   std::optional<std::string> scope_name_{};

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

@@ -0,0 +1,75 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025 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 "core/impl/get_replica.hxx"
+#include "core/impl/lookup_in_replica.hxx"
+#include "core/operations/document_get.hxx"
+#include "core/operations/document_lookup_in.hxx"
+#include "core/operations/operation_traits.hxx"
+#include "core/utils/movable_function.hxx"
+
+#include <mutex>
+
+namespace couchbase::core
+{
+namespace impl
+{
+class cancellation_token
+{
+public:
+  void setup(utils::movable_function<void()> cancel_fn)
+  {
+    const std::lock_guard lock(mutex_);
+    if (cancelled_) {
+      cancel_fn();
+      return;
+    }
+    cancel_fn_ = std::move(cancel_fn);
+  }
+
+  void cancel()
+  {
+    utils::movable_function<void()> fn{};
+    {
+      const std::lock_guard lock(mutex_);
+      cancelled_ = true;
+      fn = std::move(cancel_fn_);
+    }
+    if (fn) {
+      fn();
+    }
+  }
+
+private:
+  std::mutex mutex_{};
+  utils::movable_function<void()> cancel_fn_{};
+  bool cancelled_{ false };
+};
+
+template<typename kv_operation>
+struct with_cancellation : public kv_operation {
+  const std::shared_ptr<cancellation_token> cancel_token{ std::make_shared<cancellation_token>() };
+};
+} // namespace impl
+
+template<typename kv_operation>
+struct operations::is_cancellable_operation<impl::with_cancellation<kv_operation>>
+  : public std::true_type {
+};
+} // namespace couchbase::core

data/ext/couchbase/core/io/config_tracker.cxx

@@ -50,7 +50,7 @@ public:
   cluster_config_tracker_impl(std::string client_id,
                               couchbase::core::origin origin,
                               asio::io_context& ctx,
-                              asio::ssl::context& tls,
+                              tls_context_provider& tls,
                               std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                               std::vector<protocol::hello_feature> supported_features = {})
     : client_id_{ std::move(client_id) }
@@ -286,9 +286,9 @@ private:
       const std::scoped_lock lock(sessions_mutex_);
 
       if (sessions_.empty()) {
-        CB_LOG_WARNING(R"({} unable to find connected session (sessions_ is empty), retry in {})",
-                       log_prefix_,
-                       heartbeat_interval_);
+        CB_LOG_DEBUG(R"({} unable to find connected session (sessions_ is empty), retry in {})",
+                     log_prefix_,
+                     heartbeat_interval_);
         return;
       }
 
@@ -307,9 +307,9 @@ private:
       req.opaque(session->next_opaque());
       session->write_and_flush(req.data());
     } else {
-      CB_LOG_WARNING(R"({} unable to find connected session with GCCCP support, retry in {})",
-                     log_prefix_,
-                     heartbeat_interval_);
+      CB_LOG_DEBUG(R"({} unable to find connected session with GCCCP support, retry in {})",
+                   log_prefix_,
+                   heartbeat_interval_);
     }
   }
 
@@ -559,7 +559,7 @@ private:
   couchbase::core::origin origin_{};
   std::string log_prefix_{};
   asio::io_context& ctx_;
-  asio::ssl::context& tls_;
+  tls_context_provider& tls_;
 
   asio::steady_timer heartbeat_timer_;
   std::chrono::milliseconds heartbeat_interval_;
@@ -591,7 +591,7 @@ cluster_config_tracker::cluster_config_tracker(
   std::string client_id,
   couchbase::core::origin origin,
   asio::io_context& ctx,
-  asio::ssl::context& tls,
+  tls_context_provider& tls,
   std::shared_ptr<impl::bootstrap_state_listener> state_listener)
   : impl_{ std::make_shared<cluster_config_tracker_impl>(std::move(client_id),
                                                          std::move(origin),

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

@@ -23,6 +23,7 @@
 #endif
 #include "core/config_listener.hxx"
 #include "core/protocol/hello_feature.hxx"
+#include "core/tls_context_provider.hxx"
 #include "core/utils/movable_function.hxx"
 
 #include <mutex>
@@ -90,7 +91,7 @@ public:
   cluster_config_tracker(std::string client_id,
                          couchbase::core::origin origin,
                          asio::io_context& ctx,
-                         asio::ssl::context& tls,
+                         tls_context_provider& tls,
                          std::shared_ptr<impl::bootstrap_state_listener> state_listener);
   ~cluster_config_tracker() override;