couchbase 3.7.0 → 3.8.1

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

@@ -19,6 +19,7 @@
 
 #include "core/cluster.hxx"
 #include "core/impl/error.hxx"
+#include "core/impl/observability_recorder.hxx"
 #include "core/management/bucket_settings.hxx"
 #include "core/operations/management/bucket_create.hxx"
 #include "core/operations/management/bucket_drop.hxx"
@@ -26,6 +27,8 @@
 #include "core/operations/management/bucket_get.hxx"
 #include "core/operations/management/bucket_get_all.hxx"
 #include "core/operations/management/bucket_update.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 
 #include <couchbase/create_bucket_options.hxx>
 #include <couchbase/drop_bucket_options.hxx>
@@ -265,13 +268,18 @@ public:
                   const get_bucket_options::built& options,
                   get_bucket_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_buckets_get_bucket, bucket_name, options.parent_span);
+    core::operations::management::bucket_get_request request{
+      std::move(bucket_name),
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::bucket_get_request{
-        std::move(bucket_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_bucket_settings(resp.bucket));
       });
   }
@@ -279,12 +287,17 @@ public:
   void get_all_buckets(const get_all_buckets_options::built& options,
                        get_all_buckets_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_buckets_get_all_buckets, std::nullopt, options.parent_span);
+    core::operations::management::bucket_get_all_request request{
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::bucket_get_all_request{
-        {},
-        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_bucket_settings(resp.buckets));
       });
   }
@@ -293,13 +306,20 @@ public:
                      const create_bucket_options::built& options,
                      create_bucket_handler&& handler) const
   {
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_buckets_create_bucket,
+                                    bucket_settings.name,
+                                    options.parent_span);
+    core::operations::management::bucket_create_request request{
+      map_bucket_settings(bucket_settings),
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::bucket_create_request{
-        map_bucket_settings(bucket_settings),
-        {},
-        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));
       });
   }
@@ -308,13 +328,20 @@ public:
                      const update_bucket_options::built& options,
                      update_bucket_handler&& handler) const
   {
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_buckets_update_bucket,
+                                    bucket_settings.name,
+                                    options.parent_span);
+    core::operations::management::bucket_update_request request{
+      map_bucket_settings(bucket_settings),
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::bucket_update_request{
-        map_bucket_settings(bucket_settings),
-        {},
-        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));
       });
   }
@@ -323,13 +350,18 @@ public:
                    const drop_bucket_options::built& options,
                    drop_bucket_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_buckets_drop_bucket, bucket_name, options.parent_span);
+    core::operations::management::bucket_drop_request request{
+      std::move(bucket_name),
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::bucket_drop_request{
-        std::move(bucket_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));
       });
   }
@@ -338,18 +370,38 @@ public:
                     const flush_bucket_options::built& options,
                     flush_bucket_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_buckets_flush_bucket, bucket_name, options.parent_span);
+    core::operations::management::bucket_flush_request request{
+      std::move(bucket_name),
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     core_.execute(
-      core::operations::management::bucket_flush_request{
-        std::move(bucket_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));
       });
   }
 
 private:
+  [[nodiscard]] auto create_observability_recorder(
+    const std::string& operation_name,
+    const std::optional<std::string>& bucket_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::management);
+    if (bucket_name.has_value()) {
+      rec->with_bucket_name(bucket_name.value());
+    }
+    return rec;
+  }
+
   core::cluster core_;
 };