couchbase 3.7.0 → 3.8.1

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

@@ -19,6 +19,8 @@
 
 #include "core/cluster.hxx"
 #include "core/impl/error.hxx"
+#include "core/impl/invoke_with_node_id.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 +30,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>
@@ -49,6 +54,8 @@
 
 namespace couchbase
 {
+using core::impl::invoke_with_node_id;
+
 class binary_collection_impl : public std::enable_shared_from_this<binary_collection_impl>
 {
 public:
@@ -83,6 +90,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,23 +100,29 @@ 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{});
+            invoke_with_node_id(
+              std::move(handler), core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+            return;
           }
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         mutation_result{ resp.cas, std::move(resp.token) });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              mutation_result{ resp.cas, std::move(resp.token) });
         });
     }
 
@@ -119,34 +135,46 @@ 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 {
-                           if (resp.ctx.ec()) {
-                             return handler(core::impl::make_error(std::move(resp.ctx)),
-                                            mutation_result{ resp.cas, std::move(resp.token) });
-                           }
-
-                           auto token = resp.token;
-                           core::impl::initiate_observe_poll(
-                             core,
-                             std::move(id),
-                             token,
-                             options.timeout,
-                             options.persist_to,
-                             options.replicate_to,
-                             [resp = std::forward<decltype(resp)>(resp),
-                              handler = std::move(handler)](std::error_code ec) mutable {
-                               if (ec) {
-                                 resp.ctx.override_ec(ec);
-                                 return handler(core::impl::make_error(std::move(resp.ctx)),
-                                                mutation_result{});
-                               }
-                               return handler(core::impl::make_error(std::move(resp.ctx)),
-                                              mutation_result{ resp.cas, std::move(resp.token) });
-                             });
-                         });
+    return core_.execute(
+      std::move(request),
+      [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());
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              mutation_result{ resp.cas, std::move(resp.token) });
+          return;
+        }
+
+        auto token = resp.token;
+        core::impl::initiate_observe_poll(
+          core,
+          std::move(id),
+          token,
+          options.timeout,
+          options.persist_to,
+          options.replicate_to,
+          [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);
+              invoke_with_node_id(
+                std::move(handler), core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+              return;
+            }
+            invoke_with_node_id(std::move(handler),
+                                core::impl::make_error(std::move(resp.ctx)),
+                                mutation_result{ resp.cas, std::move(resp.token) });
+          });
+      });
   }
 
   void prepend(std::string document_key,
@@ -154,6 +182,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,23 +192,29 @@ 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{});
+            invoke_with_node_id(
+              std::move(handler), core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+            return;
           }
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         mutation_result{ resp.cas, std::move(resp.token) });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              mutation_result{ resp.cas, std::move(resp.token) });
         });
     }
 
@@ -190,40 +227,55 @@ 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 {
-                           if (resp.ctx.ec()) {
-                             return handler(core::impl::make_error(std::move(resp.ctx)),
-                                            mutation_result{ resp.cas, std::move(resp.token) });
-                           }
-
-                           auto token = resp.token;
-                           core::impl::initiate_observe_poll(
-                             core,
-                             std::move(id),
-                             token,
-                             options.timeout,
-                             options.persist_to,
-                             options.replicate_to,
-                             [resp = std::forward<decltype(resp)>(resp),
-                              handler = std::move(handler)](std::error_code ec) mutable {
-                               if (ec) {
-                                 resp.ctx.override_ec(ec);
-                                 return handler(core::impl::make_error(std::move(resp.ctx)),
-                                                mutation_result{});
-                               }
-                               return handler(core::impl::make_error(std::move(resp.ctx)),
-                                              mutation_result{ resp.cas, std::move(resp.token) });
-                             });
-                         });
+    return core_.execute(
+      std::move(request),
+      [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());
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              mutation_result{ resp.cas, std::move(resp.token) });
+          return;
+        }
+
+        auto token = resp.token;
+        core::impl::initiate_observe_poll(
+          core,
+          std::move(id),
+          token,
+          options.timeout,
+          options.persist_to,
+          options.replicate_to,
+          [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);
+              invoke_with_node_id(
+                std::move(handler), core::impl::make_error(std::move(resp.ctx)), mutation_result{});
+              return;
+            }
+            invoke_with_node_id(std::move(handler),
+                                core::impl::make_error(std::move(resp.ctx)),
+                                mutation_result{ resp.cas, std::move(resp.token) });
+          });
+      });
   }
 
   void decrement(std::string document_key,
                  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,24 +283,31 @@ 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{});
+            invoke_with_node_id(
+              std::move(handler), core::impl::make_error(std::move(resp.ctx)), counter_result{});
+            return;
           }
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         counter_result{ resp.cas, std::move(resp.token), resp.content });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              counter_result{ resp.cas, std::move(resp.token), resp.content });
         });
     }
 
@@ -262,14 +321,21 @@ 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()) {
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         counter_result{ resp.cas, std::move(resp.token), resp.content });
+          obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              counter_result{ resp.cas, std::move(resp.token), resp.content });
+          return;
         }
 
         auto token = resp.token;
@@ -280,14 +346,19 @@ 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{});
+              invoke_with_node_id(
+                std::move(handler), core::impl::make_error(std::move(resp.ctx)), counter_result{});
+              return;
             }
-            return handler(core::impl::make_error(std::move(resp.ctx)),
-                           counter_result{ resp.cas, std::move(resp.token), resp.content });
+            invoke_with_node_id(std::move(handler),
+                                core::impl::make_error(std::move(resp.ctx)),
+                                counter_result{ resp.cas, std::move(resp.token), resp.content });
           });
       });
   }
@@ -296,6 +367,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,24 +377,30 @@ 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{});
+            invoke_with_node_id(
+              std::move(handler), core::impl::make_error(std::move(resp.ctx)), counter_result{});
+            return;
           }
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         counter_result{ resp.cas, std::move(resp.token), resp.content });
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              counter_result{ resp.cas, std::move(resp.token), resp.content });
         });
     }
 
@@ -334,14 +414,21 @@ 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()) {
-          return handler(core::impl::make_error(std::move(resp.ctx)),
-                         counter_result{ resp.cas, std::move(resp.token), resp.content });
+          obs_rec->finish(resp.ctx.retry_attempts(), resp.ctx.ec());
+          invoke_with_node_id(std::move(handler),
+                              core::impl::make_error(std::move(resp.ctx)),
+                              counter_result{ resp.cas, std::move(resp.token), resp.content });
+          return;
         }
 
         auto token = resp.token;
@@ -352,19 +439,43 @@ 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{});
+              invoke_with_node_id(
+                std::move(handler), core::impl::make_error(std::move(resp.ctx)), counter_result{});
+              return;
             }
-            return handler(core::impl::make_error(std::move(resp.ctx)),
-                           counter_result{ resp.cas, std::move(resp.token), resp.content });
+            invoke_with_node_id(std::move(handler),
+                                core::impl::make_error(std::move(resp.ctx)),
+                                counter_result{ resp.cas, std::move(resp.token), resp.content });
           });
       });
   }
 
 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_;