couchbase 3.7.0 → 3.8.0

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

@@ -17,14 +17,15 @@
 
 #include "core/cluster.hxx"
 
+#include "core/impl/error.hxx"
+#include "core/impl/observability_recorder.hxx"
+#include "core/logger/logger.hxx"
 #include "core/operations/management/query_index_build_deferred.hxx"
 #include "core/operations/management/query_index_create.hxx"
 #include "core/operations/management/query_index_drop.hxx"
 #include "core/operations/management/query_index_get_all.hxx"
-
-#include "core/impl/error.hxx"
-
-#include "core/logger/logger.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 
 #include <couchbase/collection_query_index_manager.hxx>
 #include <couchbase/query_index_manager.hxx>
@@ -34,6 +35,8 @@
 #include <algorithm>
 #include <utility>
 
+#include "couchbase/bucket.hxx"
+
 namespace couchbase
 {
 namespace
@@ -56,6 +59,9 @@ public:
     , scope_name_(std::move(scope_name))
     , collection_name_(std::move(collection_name))
     , handler_(std::move(handler))
+    , observability_recorder_(
+        create_observability_recorder(core::tracing::operation::mgr_query_watch_indexes,
+                                      options_.parent_span))
   {
   }
 
@@ -67,6 +73,7 @@ public:
     , scope_name_(std::move(other.scope_name_))
     , collection_name_(std::move(other.collection_name_))
     , handler_(std::move(other.handler_))
+    , observability_recorder_(std::move(other.observability_recorder_))
     , timer_(std::move(other.timer_))
     , start_time_(other.start_time_)
     , timeout_(other.timeout_)
@@ -81,16 +88,21 @@ public:
 
   void execute()
   {
+    auto get_all_obs_rec = create_suboperation_observability_recorder(
+      core::tracing::operation::mgr_query_get_all_indexes, observability_recorder_);
+    core::operations::management::query_index_get_all_request get_all_request{
+      bucket_name_,
+      scope_name_,
+      collection_name_,
+      {},
+      {},
+      remaining(),
+      get_all_obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::query_index_get_all_request{
-        bucket_name_,
-        scope_name_,
-        collection_name_,
-        {},
-        {},
-        remaining(),
-      },
-      [ctx = shared_from_this()](auto resp) {
+      std::move(get_all_request),
+      [ctx = shared_from_this(), get_all_obs_rec = std::move(get_all_obs_rec)](auto resp) {
+        get_all_obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         if (ctx->check(resp)) {
           ctx->finish(resp, {});
         } else if (ctx->remaining().count() <= 0) {
@@ -111,6 +123,7 @@ private:
       if (ec.has_value()) {
         resp.ctx.ec = ec.value();
       }
+      observability_recorder_->finish(resp.ctx.ec);
       handler(core::impl::make_error(resp.ctx));
       timer_.cancel();
     }
@@ -160,6 +173,37 @@ 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::query);
+    rec->with_bucket_name(bucket_name_);
+    if (!collection_name_.empty()) {
+      rec->with_scope_name(scope_name_);
+      rec->with_collection_name(collection_name_);
+    }
+    return rec;
+  }
+
+  [[nodiscard]] auto create_suboperation_observability_recorder(
+    const std::string& subop_name,
+    const std::unique_ptr<core::impl::observability_recorder>& parent_recorder) const
+    -> std::unique_ptr<core::impl::observability_recorder>
+  {
+    auto rec = parent_recorder->record_suboperation(subop_name);
+    rec->with_service(core::tracing::service::query);
+    rec->with_bucket_name(bucket_name_);
+    if (!collection_name_.empty()) {
+      rec->with_scope_name(scope_name_);
+      rec->with_collection_name(collection_name_);
+    }
+    return rec;
+  }
+
   couchbase::core::cluster core_;
   std::string bucket_name_;
   std::vector<std::string> index_names_;
@@ -167,6 +211,7 @@ private:
   std::string scope_name_;
   std::string collection_name_;
   watch_query_indexes_handler handler_;
+  std::unique_ptr<core::impl::observability_recorder> observability_recorder_;
   asio::steady_timer timer_{ core_.io_context() };
   std::chrono::steady_clock::time_point start_time_{ std::chrono::steady_clock::now() };
   std::chrono::milliseconds timeout_{ options_.timeout.value_or(
@@ -190,22 +235,25 @@ public:
                        const get_all_query_indexes_options::built& options,
                        get_all_query_indexes_handler&& handler) const
   {
-    return core_.execute(
-      core::operations::management::query_index_get_all_request{
-        bucket_name,
-        scope_name,
-        collection_name,
-        {},
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](
-        const core::operations::management::query_index_get_all_response& resp) {
-        if (resp.ctx.ec) {
-          return handler(core::impl::make_error(resp.ctx), {});
-        }
-        handler(core::impl::make_error(resp.ctx), resp.indexes);
-      });
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_query_get_all_indexes,
+                                    bucket_name,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+
+    core::operations::management::query_index_get_all_request request{
+      bucket_name, scope_name, collection_name, {}, {}, options.timeout, obs_rec->operation_span(),
+    };
+    return core_.execute(std::move(request),
+                         [obs_rec = std::move(obs_rec), handler = std::move(handler)](
+                           const core::operations::management::query_index_get_all_response& resp) {
+                           obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
+                           if (resp.ctx.ec) {
+                             return handler(core::impl::make_error(resp.ctx), {});
+                           }
+                           handler(core::impl::make_error(resp.ctx), resp.indexes);
+                         });
   }
 
   void create_index(const std::string& bucket_name,
@@ -216,23 +264,32 @@ public:
                     const create_query_index_options::built& options,
                     create_query_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_query_create_index,
+                                                 bucket_name,
+                                                 scope_name,
+                                                 collection_name,
+                                                 options.parent_span);
+
+    core::operations::management::query_index_create_request request{
+      bucket_name,
+      scope_name,
+      collection_name,
+      std::move(index_name),
+      std::move(keys),
+      {},
+      false /* is_primary */,
+      options.ignore_if_exists,
+      options.condition,
+      options.deferred,
+      options.num_replicas,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::query_index_create_request{
-        bucket_name,
-        scope_name,
-        collection_name,
-        std::move(index_name),
-        std::move(keys),
-        {},
-        false /* is_primary */,
-        options.ignore_if_exists,
-        options.condition,
-        options.deferred,
-        options.num_replicas,
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) {
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -243,23 +300,33 @@ public:
                             const create_primary_query_index_options::built& options,
                             create_primary_query_index_handler&& handler) const
   {
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_query_create_primary_index,
+                                    bucket_name,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+
+    core::operations::management::query_index_create_request request{
+      bucket_name,
+      scope_name,
+      collection_name,
+      options.index_name.value_or(""),
+      {},
+      {},
+      true /* is_primary */,
+      options.ignore_if_exists,
+      {},
+      options.deferred,
+      options.num_replicas,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::query_index_create_request{
-        bucket_name,
-        scope_name,
-        collection_name,
-        options.index_name.value_or(""),
-        {},
-        {},
-        true /* is_primary */,
-        options.ignore_if_exists,
-        {},
-        options.deferred,
-        options.num_replicas,
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) {
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -271,19 +338,28 @@ public:
                   const drop_query_index_options::built& options,
                   drop_query_index_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_query_drop_index,
+                                                 bucket_name,
+                                                 scope_name,
+                                                 collection_name,
+                                                 options.parent_span);
+
+    core::operations::management::query_index_drop_request request{
+      bucket_name,
+      scope_name,
+      collection_name,
+      std::move(index_name),
+      {},
+      false /* is_primary */,
+      options.ignore_if_not_exists,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::query_index_drop_request{
-        bucket_name,
-        scope_name,
-        collection_name,
-        std::move(index_name),
-        {},
-        false /* is_primary */,
-        options.ignore_if_not_exists,
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) {
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -294,22 +370,31 @@ public:
                           const drop_primary_query_index_options::built& options,
                           drop_primary_query_index_handler&& handler) const
   {
-    return core_.execute(
-      core::operations::management::query_index_drop_request{
-        bucket_name,
-        scope_name,
-        collection_name,
-        options.index_name.value_or(""),
-        {},
-        true,
-        options.ignore_if_not_exists,
-        {},
-        options.timeout,
-      },
-      [handler =
-         std::move(handler)](const core::operations::management::query_index_drop_response& resp) {
-        handler(core::impl::make_error(resp.ctx));
-      });
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_query_drop_primary_index,
+                                    bucket_name,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+
+    core::operations::management::query_index_drop_request request{
+      bucket_name,
+      scope_name,
+      collection_name,
+      options.index_name.value_or(""),
+      {},
+      true,
+      options.ignore_if_not_exists,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
+    return core_.execute(std::move(request),
+                         [obs_rec = std::move(obs_rec), handler = std::move(handler)](
+                           const core::operations::management::query_index_drop_response& resp) {
+                           obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
+                           handler(core::impl::make_error(resp.ctx));
+                         });
   }
 
   void build_deferred_indexes(const std::string& bucket_name,
@@ -319,32 +404,75 @@ public:
                               build_deferred_query_indexes_handler&& handler) const
   {
     auto timeout = options.timeout;
+
+    auto top_obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_query_build_deferred_indexes,
+                                    bucket_name,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+
+    auto get_all_deferred_obs_rec = create_suboperation_observability_recorder(
+      core::tracing::operation::mgr_query_get_all_deferred_indexes,
+      bucket_name,
+      scope_name,
+      collection_name,
+      top_obs_rec);
+
+    core::operations::management::query_index_get_all_deferred_request get_all_deferred_request{
+      bucket_name,
+      scope_name,
+      collection_name,
+      {},
+      {},
+      options.timeout,
+      get_all_deferred_obs_rec->operation_span(),
+    };
+
     return core_.execute(
-      core::operations::management::query_index_get_all_deferred_request{
-        bucket_name, scope_name, collection_name, {}, {}, timeout },
+      std::move(get_all_deferred_request),
       [self = shared_from_this(),
        bucket = bucket_name,
        scope = scope_name,
        collection = collection_name,
        timeout,
+       get_all_deferred_obs_rec = std::move(get_all_deferred_obs_rec),
+       top_obs_rec = std::move(top_obs_rec),
        handler = std::move(handler)](auto list_resp) mutable {
+        get_all_deferred_obs_rec->finish(list_resp.ctx.retry_attempts, list_resp.ctx.ec);
         if (list_resp.ctx.ec) {
+          top_obs_rec->finish(list_resp.ctx.ec);
           return handler(core::impl::make_error(list_resp.ctx));
         }
         if (list_resp.index_names.empty()) {
+          top_obs_rec->finish(list_resp.ctx.ec);
           return handler(core::impl::make_error(list_resp.ctx));
         }
-        self->core_.execute(
-          core::operations::management::query_index_build_request{ std::move(bucket),
-                                                                   scope,
-                                                                   collection,
-                                                                   {},
-                                                                   std::move(list_resp.index_names),
-                                                                   {},
-                                                                   timeout },
-          [handler = std::move(handler)](const auto& build_resp) {
-            return handler(core::impl::make_error(build_resp.ctx));
-          });
+        auto build_obs_rec = self->create_suboperation_observability_recorder(
+          core::tracing::operation::mgr_query_build_indexes,
+          bucket,
+          scope,
+          collection,
+          top_obs_rec);
+        core::operations::management::query_index_build_request build_request{
+          std::move(bucket),
+          scope,
+          collection,
+          {},
+          std::move(list_resp.index_names),
+          {},
+          timeout,
+          build_obs_rec->operation_span(),
+        };
+        self->core_.execute(std::move(build_request),
+                            [top_obs_rec = std::move(top_obs_rec),
+                             build_obs_rec = std::move(build_obs_rec),
+                             handler = std::move(handler)](const auto& build_resp) {
+                              build_obs_rec->finish(build_resp.ctx.retry_attempts,
+                                                    build_resp.ctx.ec);
+                              top_obs_rec->finish(build_resp.ctx.ec);
+                              return handler(core::impl::make_error(build_resp.ctx));
+                            });
       });
   }
 
@@ -366,6 +494,43 @@ public:
   }
 
 private:
+  [[nodiscard]] auto create_observability_recorder(
+    const std::string& operation_name,
+    const std::string& bucket_name,
+    const std::string& scope_name,
+    const std::string& collection_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::query);
+    rec->with_bucket_name(bucket_name);
+    if (!collection_name.empty()) {
+      rec->with_scope_name(scope_name);
+      rec->with_collection_name(collection_name);
+    }
+    return rec;
+  }
+
+  [[nodiscard]] auto create_suboperation_observability_recorder(
+    const std::string& subop_name,
+    const std::string& bucket_name,
+    const std::string& scope_name,
+    const std::string& collection_name,
+    const std::unique_ptr<core::impl::observability_recorder>& parent_recorder) const
+    -> std::unique_ptr<core::impl::observability_recorder>
+  {
+    auto rec = parent_recorder->record_suboperation(subop_name);
+    rec->with_service(core::tracing::service::query);
+    rec->with_bucket_name(bucket_name);
+    if (!collection_name.empty()) {
+      rec->with_scope_name(scope_name);
+      rec->with_collection_name(collection_name);
+    }
+    return rec;
+  }
+
   core::cluster core_;
 };
 

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

@@ -17,6 +17,8 @@
 
 #include "analytics.hxx"
 #include "core/cluster.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 #include "error.hxx"
 #include "internal_search_error_context.hxx"
 #include "internal_search_meta_data.hxx"
@@ -24,6 +26,7 @@
 #include "internal_search_row.hxx"
 #include "internal_search_row_location.hxx"
 #include "internal_search_row_locations.hxx"
+#include "observability_recorder.hxx"
 #include "query.hxx"
 #include "search.hxx"
 
@@ -75,9 +78,16 @@ public:
 
   void query(std::string statement, query_options::built options, query_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::query, core::service_type::query, options.parent_span);
+    obs_rec->with_query_statement(statement, options);
+
+    auto request = core::impl::build_query_request(
+      std::move(statement), query_context_, std::move(options), obs_rec->operation_span());
+
     return core_.execute(
-      core::impl::build_query_request(std::move(statement), query_context_, std::move(options)),
-      [handler = std::move(handler)](auto resp) {
+      std::move(request), [obs_rec = std::move(obs_rec), handler = std::move(handler)](auto resp) {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx), core::impl::build_result(resp));
       });
   }
@@ -86,12 +96,19 @@ public:
                        analytics_options::built options,
                        analytics_handler&& handler) const
   {
-    return core_.execute(core::impl::build_analytics_request(
-                           std::move(statement), std::move(options), bucket_name_, name_),
-                         [handler = std::move(handler)](auto resp) mutable {
-                           return handler(core::impl::make_error(resp.ctx),
-                                          core::impl::build_result(resp));
-                         });
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::analytics, core::service_type::analytics, options.parent_span);
+    obs_rec->with_query_statement(statement, options);
+
+    auto request = core::impl::build_analytics_request(
+      std::move(statement), std::move(options), bucket_name_, name_, obs_rec->operation_span());
+
+    return core_.execute(
+      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), core::impl::build_result(resp));
+      });
   }
 
   void search(std::string index_name,
@@ -99,16 +116,41 @@ public:
               search_options::built options,
               search_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::search, core::service_type::search, options.parent_span);
+
+    auto core_req = core::impl::build_search_request(std::move(index_name),
+                                                     std::move(request),
+                                                     std::move(options),
+                                                     bucket_name_,
+                                                     name_,
+                                                     obs_rec->operation_span());
     return core_.execute(
-      core::impl::build_search_request(
-        std::move(index_name), std::move(request), std::move(options), bucket_name_, name_),
-      [handler = std::move(handler)](auto&& resp) mutable {
+      std::move(core_req),
+      [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),
                        search_result{ internal_search_result{ resp } });
       });
   }
 
 private:
+  [[nodiscard]] auto create_observability_recorder(
+    const std::string& operation_name,
+    const core::service_type service,
+    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_name_for_http_service(service));
+    rec->with_bucket_name(bucket_name_);
+    rec->with_scope_name(name_);
+
+    return rec;
+  }
+
   core::cluster core_;
   std::string bucket_name_;
   std::string name_;

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

@@ -132,7 +132,9 @@ build_search_request(std::string index_name,
                      const search_query& query,
                      search_options::built options,
                      std::optional<std::string> bucket_name,
-                     std::optional<std::string> scope_name) -> core::operations::search_request
+                     std::optional<std::string> scope_name,
+                     std::shared_ptr<couchbase::tracing::request_span> op_span)
+  -> core::operations::search_request
 {
   auto encoded = query.encode();
   if (encoded.ec) {
@@ -165,7 +167,7 @@ build_search_request(std::string index_name,
     options.client_context_id,
     options.timeout,
   };
-  request.parent_span = options.parent_span;
+  request.parent_span = std::move(op_span);
   return request;
 }
 
@@ -174,7 +176,9 @@ build_search_request(std::string index_name,
                      couchbase::search_request request,
                      search_options::built options,
                      std::optional<std::string> bucket_name,
-                     std::optional<std::string> scope_name) -> core::operations::search_request
+                     std::optional<std::string> scope_name,
+                     std::shared_ptr<couchbase::tracing::request_span> op_span)
+  -> core::operations::search_request
 {
   if (!request.search_query().has_value()) {
     request.search_query(couchbase::match_none_query{});
@@ -208,7 +212,7 @@ build_search_request(std::string index_name,
     options.client_context_id,
     options.timeout,
   };
-  core_request.parent_span = options.parent_span;
+  core_request.parent_span = std::move(op_span);
 
   if (auto vector_search = request.vector_search(); vector_search.has_value()) {
     core_request.vector_search = core::utils::json::generate_binary(vector_search->query);

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

@@ -33,13 +33,17 @@ build_search_request(std::string index_name,
                      const search_query& query,
                      search_options::built options,
                      std::optional<std::string> bucket_name,
-                     std::optional<std::string> scope_name) -> core::operations::search_request;
+                     std::optional<std::string> scope_name,
+                     std::shared_ptr<couchbase::tracing::request_span> op_span)
+  -> core::operations::search_request;
 
 auto
 build_search_request(std::string index_name,
                      search_request request,
                      search_options::built options,
                      std::optional<std::string> bucket_name,
-                     std::optional<std::string> scope_name) -> core::operations::search_request;
+                     std::optional<std::string> scope_name,
+                     std::shared_ptr<couchbase::tracing::request_span> op_span)
+  -> core::operations::search_request;
 
 } // namespace couchbase::core::impl