couchbase 3.7.0 → 3.8.0

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

@@ -19,6 +19,7 @@
 
 #include "core/cluster.hxx"
 #include "core/impl/error.hxx"
+#include "core/impl/observability_recorder.hxx"
 #include "core/operations/document_append.hxx"
 #include "core/operations/document_decrement.hxx"
 #include "core/operations/document_increment.hxx"
@@ -28,6 +29,9 @@
 #include "core/operations/document_remove.hxx"
 #include "core/operations/document_replace.hxx"
 #include "core/operations/document_upsert.hxx"
+#include "core/tracing/attribute_helpers.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 #include "observe_poll.hxx"
 
 #include <couchbase/append_options.hxx>
@@ -83,6 +87,9 @@ public:
               append_options::built options,
               append_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mcbp_append, options.parent_span, options.durability_level);
+
     auto id = core::document_id{
       bucket_name_,
       scope_name_,
@@ -90,18 +97,21 @@ public:
       std::move(document_key),
     };
     if (options.persist_to == persist_to::none && options.replicate_to == replicate_to::none) {
+      core::operations::append_request request{
+        std::move(id),
+        std::move(data),
+        {},
+        {},
+        options.cas,
+        options.durability_level,
+        options.timeout,
+        { options.retry_strategy },
+        obs_rec->operation_span(),
+      };
       return core_.execute(
-        core::operations::append_request{
-          std::move(id),
-          std::move(data),
-          {},
-          {},
-          options.cas,
-          options.durability_level,
-          options.timeout,
-          { options.retry_strategy },
-        },
-        [handler = std::move(handler)](auto&& resp) mutable {
+        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());
           if (resp.ctx.ec()) {
             return handler(core::impl::make_error(std::move(resp.ctx)), mutation_result{});
           }
@@ -119,11 +129,16 @@ public:
       durability_level::none,
       options.timeout,
       { options.retry_strategy },
+      obs_rec->operation_span(),
     };
     return core_.execute(std::move(request),
-                         [core = core_, id = std::move(id), options, handler = std::move(handler)](
-                           auto&& resp) mutable {
+                         [core = core_,
+                          id = std::move(id),
+                          options,
+                          obs_rec = std::move(obs_rec),
+                          handler = std::move(handler)](auto&& resp) mutable {
                            if (resp.ctx.ec()) {
+                             obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
                              return handler(core::impl::make_error(std::move(resp.ctx)),
                                             mutation_result{ resp.cas, std::move(resp.token) });
                            }
@@ -136,8 +151,10 @@ public:
                              options.timeout,
                              options.persist_to,
                              options.replicate_to,
-                             [resp = std::forward<decltype(resp)>(resp),
+                             [obs_rec = std::move(obs_rec),
+                              resp = std::forward<decltype(resp)>(resp),
                               handler = std::move(handler)](std::error_code ec) mutable {
+                               obs_rec->finish(resp.ctx.retry_attempts(), ec);
                                if (ec) {
                                  resp.ctx.override_ec(ec);
                                  return handler(core::impl::make_error(std::move(resp.ctx)),
@@ -154,6 +171,9 @@ public:
                prepend_options::built options,
                prepend_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mcbp_prepend, options.parent_span, options.durability_level);
+
     auto id = core::document_id{
       bucket_name_,
       scope_name_,
@@ -161,18 +181,21 @@ public:
       std::move(document_key),
     };
     if (options.persist_to == persist_to::none && options.replicate_to == replicate_to::none) {
+      core::operations::prepend_request request{
+        std::move(id),
+        std::move(data),
+        {},
+        {},
+        options.cas,
+        options.durability_level,
+        options.timeout,
+        { options.retry_strategy },
+        obs_rec->operation_span(),
+      };
       return core_.execute(
-        core::operations::prepend_request{
-          std::move(id),
-          std::move(data),
-          {},
-          {},
-          options.cas,
-          options.durability_level,
-          options.timeout,
-          { options.retry_strategy },
-        },
-        [handler = std::move(handler)](auto&& resp) mutable {
+        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());
           if (resp.ctx.ec()) {
             return handler(core::impl::make_error(std::move(resp.ctx)), mutation_result{});
           }
@@ -190,11 +213,16 @@ public:
       durability_level::none,
       options.timeout,
       { options.retry_strategy },
+      obs_rec->operation_span(),
     };
     return core_.execute(std::move(request),
-                         [core = core_, id = std::move(id), options, handler = std::move(handler)](
-                           auto&& resp) mutable {
+                         [obs_rec = std::move(obs_rec),
+                          core = core_,
+                          id = std::move(id),
+                          options,
+                          handler = std::move(handler)](auto&& resp) mutable {
                            if (resp.ctx.ec()) {
+                             obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
                              return handler(core::impl::make_error(std::move(resp.ctx)),
                                             mutation_result{ resp.cas, std::move(resp.token) });
                            }
@@ -207,8 +235,10 @@ public:
                              options.timeout,
                              options.persist_to,
                              options.replicate_to,
-                             [resp = std::forward<decltype(resp)>(resp),
+                             [obs_rec = std::move(obs_rec),
+                              resp = std::forward<decltype(resp)>(resp),
                               handler = std::move(handler)](std::error_code ec) mutable {
+                               obs_rec->finish(resp.ctx.retry_attempts(), ec);
                                if (ec) {
                                  resp.ctx.override_ec(ec);
                                  return handler(core::impl::make_error(std::move(resp.ctx)),
@@ -224,6 +254,9 @@ public:
                  decrement_options::built options,
                  decrement_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mcbp_decrement, options.parent_span, options.durability_level);
+
     auto id = core::document_id{
       bucket_name_,
       scope_name_,
@@ -231,19 +264,23 @@ public:
       std::move(document_key),
     };
     if (options.persist_to == persist_to::none && options.replicate_to == replicate_to::none) {
+      core::operations::decrement_request request{
+        std::move(id),
+        {},
+        {},
+        options.expiry,
+        options.delta,
+        options.initial_value,
+        options.durability_level,
+        options.timeout,
+        { options.retry_strategy },
+        obs_rec->operation_span(),
+      };
       return core_.execute(
-        core::operations::decrement_request{
-          std::move(id),
-          {},
-          {},
-          options.expiry,
-          options.delta,
-          options.initial_value,
-          options.durability_level,
-          options.timeout,
-          { options.retry_strategy },
-        },
-        [handler = std::move(handler)](auto&& resp) mutable {
+        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());
+
           if (resp.ctx.ec()) {
             return handler(core::impl::make_error(std::move(resp.ctx)), counter_result{});
           }
@@ -262,12 +299,17 @@ public:
       durability_level::none,
       options.timeout,
       { options.retry_strategy },
+      obs_rec->operation_span(),
     };
     return core_.execute(
       std::move(request),
-      [core = core_, id = std::move(id), options, handler = std::move(handler)](
-        auto&& resp) mutable {
+      [obs_rec = std::move(obs_rec),
+       core = core_,
+       id = std::move(id),
+       options,
+       handler = std::move(handler)](auto&& resp) mutable {
         if (resp.ctx.ec()) {
+          obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
           return handler(core::impl::make_error(std::move(resp.ctx)),
                          counter_result{ resp.cas, std::move(resp.token), resp.content });
         }
@@ -280,8 +322,10 @@ public:
           options.timeout,
           options.persist_to,
           options.replicate_to,
-          [resp = std::forward<decltype(resp)>(resp),
+          [obs_rec = std::move(obs_rec),
+           resp = std::forward<decltype(resp)>(resp),
            handler = std::move(handler)](std::error_code ec) mutable {
+            obs_rec->finish(resp.ctx.retry_attempts(), ec);
             if (ec) {
               resp.ctx.override_ec(ec);
               return handler(core::impl::make_error(std::move(resp.ctx)), counter_result{});
@@ -296,6 +340,9 @@ public:
                  increment_options::built options,
                  increment_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mcbp_increment, options.parent_span, options.durability_level);
+
     auto id = core::document_id{
       bucket_name_,
       scope_name_,
@@ -303,19 +350,22 @@ public:
       std::move(document_key),
     };
     if (options.persist_to == persist_to::none && options.replicate_to == replicate_to::none) {
+      core::operations::increment_request request{
+        std::move(id),
+        {},
+        {},
+        options.expiry,
+        options.delta,
+        options.initial_value,
+        options.durability_level,
+        options.timeout,
+        { options.retry_strategy },
+        obs_rec->operation_span(),
+      };
       return core_.execute(
-        core::operations::increment_request{
-          std::move(id),
-          {},
-          {},
-          options.expiry,
-          options.delta,
-          options.initial_value,
-          options.durability_level,
-          options.timeout,
-          { options.retry_strategy },
-        },
-        [handler = std::move(handler)](auto&& resp) mutable {
+        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());
           if (resp.ctx.ec()) {
             return handler(core::impl::make_error(std::move(resp.ctx)), counter_result{});
           }
@@ -334,12 +384,17 @@ public:
       durability_level::none,
       options.timeout,
       { options.retry_strategy },
+      obs_rec->operation_span(),
     };
     return core_.execute(
       std::move(request),
-      [core = core_, id = std::move(id), options, handler = std::move(handler)](
-        auto&& resp) mutable {
+      [obs_rec = std::move(obs_rec),
+       core = core_,
+       id = std::move(id),
+       options,
+       handler = std::move(handler)](auto&& resp) mutable {
         if (resp.ctx.ec()) {
+          obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
           return handler(core::impl::make_error(std::move(resp.ctx)),
                          counter_result{ resp.cas, std::move(resp.token), resp.content });
         }
@@ -352,8 +407,10 @@ public:
           options.timeout,
           options.persist_to,
           options.replicate_to,
-          [resp = std::forward<decltype(resp)>(resp),
+          [obs_rec = std::move(obs_rec),
+           resp = std::forward<decltype(resp)>(resp),
            handler = std::move(handler)](std::error_code ec) mutable {
+            obs_rec->finish(resp.ctx.retry_attempts(), ec);
             if (ec) {
               resp.ctx.override_ec(ec);
               return handler(core::impl::make_error(std::move(resp.ctx)), counter_result{});
@@ -365,6 +422,25 @@ public:
   }
 
 private:
+  auto create_observability_recorder(const std::string& operation_name,
+                                     const std::shared_ptr<tracing::request_span>& parent_span,
+                                     const std::optional<durability_level> durability = {}) 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::key_value);
+    rec->with_bucket_name(bucket_name_);
+    rec->with_scope_name(scope_name_);
+    rec->with_collection_name(name_);
+    if (durability.has_value()) {
+      rec->with_durability(durability.value());
+    }
+
+    return rec;
+  }
+
   core::cluster core_;
   std::string bucket_name_;
   std::string scope_name_;

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_;
 };