couchbase 4.6.1 → 4.7.0

package/deps/couchbase-cxx-client/core/impl/analytics_index_manager.cxx

@@ -17,8 +17,8 @@
 
 #include "core/cluster.hxx"
 #include "core/impl/error.hxx"
+#include "core/impl/observability_recorder.hxx"
 #include "core/logger/logger.hxx"
-
 #include "core/management/analytics_link_azure_blob_external.hxx"
 #include "core/management/analytics_link_couchbase_remote.hxx"
 #include "core/management/analytics_link_s3_external.hxx"
@@ -37,6 +37,8 @@
 #include "core/operations/management/analytics_link_drop.hxx"
 #include "core/operations/management/analytics_link_get_all.hxx"
 #include "core/operations/management/analytics_link_replace.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 
 #include <couchbase/analytics_index_manager.hxx>
 #include <couchbase/connect_link_analytics_options.hxx>
@@ -152,32 +154,35 @@ public:
                         const create_dataverse_analytics_options::built& options,
                         create_dataverse_analytics_handler&& handler) const
   {
-    return core_.execute(
-      core::operations::management::analytics_dataverse_create_request{
-        dataverse_name,
-        options.ignore_if_exists,
-        {},
-        options.timeout,
-      },
-      [dataverse_name, handler = std::move(handler)](const auto& resp) {
-        CB_LOG_DEBUG(
-          "Dataverse create for {} error code = {}", dataverse_name, resp.ctx.ec.value());
-        handler(core::impl::make_error(resp.ctx));
-      });
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_create_dataverse, options.parent_span);
+
+    core::operations::management::analytics_dataverse_create_request request{
+      dataverse_name, options.ignore_if_exists, {}, options.timeout, obs_rec->operation_span(),
+    };
+    return core_.execute(std::move(request),
+                         [dataverse_name,
+                          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));
+                         });
   }
 
   void drop_dataverse(const std::string& dataverse_name,
                       const drop_dataverse_analytics_options::built& options,
                       drop_dataverse_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_drop_dataverse, options.parent_span);
+
+    core::operations::management::analytics_dataverse_drop_request request{
+      dataverse_name, options.ignore_if_not_exists, {}, options.timeout, obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_dataverse_drop_request{
-        dataverse_name,
-        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));
       });
   }
@@ -187,17 +192,23 @@ public:
                       const create_dataset_analytics_options::built& options,
                       create_dataset_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_create_dataset, options.parent_span);
+
+    core::operations::management::analytics_dataset_create_request request{
+      options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
+      dataset_name,
+      bucket_name,
+      options.condition,
+      {},
+      options.timeout,
+      options.ignore_if_exists,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_dataset_create_request{
-        options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
-        dataset_name,
-        bucket_name,
-        options.condition,
-        {},
-        options.timeout,
-        options.ignore_if_exists,
-      },
-      [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));
       });
   }
@@ -206,15 +217,21 @@ public:
                     const drop_dataset_analytics_options::built& options,
                     drop_dataset_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_drop_dataset, options.parent_span);
+
+    core::operations::management::analytics_dataset_drop_request request{
+      options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
+      dataset_name,
+      options.ignore_if_not_exists,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_dataset_drop_request{
-        options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
-        dataset_name,
-        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));
       });
   }
@@ -222,14 +239,20 @@ public:
   void get_all_datasets(const get_all_datasets_analytics_options::built& options,
                         get_all_datasets_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_get_all_datasets, options.parent_span);
+
+    core::operations::management::analytics_dataset_get_all_request request{
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_dataset_get_all_request{
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](
         const core::operations::management::analytics_dataset_get_all_response& resp) {
         if (resp.ctx.ec) {
+          obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
           return handler(core::impl::make_error(resp.ctx), {});
         }
         std::vector<management::analytics_dataset> datasets{};
@@ -242,6 +265,7 @@ public:
             d.bucket_name,
           });
         }
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         handler(core::impl::make_error(resp.ctx), datasets);
       });
   }
@@ -252,17 +276,23 @@ public:
                     const create_index_analytics_options::built& options,
                     create_index_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_create_index, options.parent_span);
+
+    core::operations::management::analytics_index_create_request request{
+      options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
+      dataset_name,
+      index_name,
+      fields,
+      options.ignore_if_exists,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_index_create_request{
-        options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
-        dataset_name,
-        index_name,
-        fields,
-        options.ignore_if_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));
       });
   }
@@ -272,16 +302,22 @@ public:
                   const drop_index_analytics_options::built& options,
                   drop_index_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_analytics_drop_index,
+                                                 options.parent_span);
+
+    core::operations::management::analytics_index_drop_request request{
+      options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
+      dataset_name,
+      index_name,
+      options.ignore_if_not_exists,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_index_drop_request{
-        options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
-        dataset_name,
-        index_name,
-        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));
       });
   }
@@ -289,14 +325,20 @@ public:
   void get_all_indexes(const get_all_indexes_analytics_options::built& options,
                        get_all_indexes_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_get_all_indexes, options.parent_span);
+
+    core::operations::management::analytics_index_get_all_request request{
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_index_get_all_request{
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](
         const core::operations::management::analytics_index_get_all_response& resp) {
         if (resp.ctx.ec) {
+          obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
           return handler(core::impl::make_error(resp.ctx), {});
         }
         std::vector<management::analytics_index> indexes{};
@@ -309,6 +351,7 @@ public:
             idx.is_primary,
           });
         }
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         handler(core::impl::make_error(resp.ctx), indexes);
       });
   }
@@ -316,15 +359,21 @@ public:
   void connect_link(const connect_link_analytics_options::built& options,
                     connect_link_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_connect_link, options.parent_span);
+
+    core::operations::management::analytics_link_connect_request request{
+      options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
+      options.link_name.value_or(DEFAULT_LINK_NAME),
+      options.force,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_link_connect_request{
-        options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
-        options.link_name.value_or(DEFAULT_LINK_NAME),
-        options.force,
-        {},
-        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));
       });
   }
@@ -332,14 +381,20 @@ public:
   void disconnect_link(const disconnect_link_analytics_options::built& options,
                        disconnect_link_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_disconnect_link, options.parent_span);
+
+    core::operations::management::analytics_link_disconnect_request request{
+      options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
+      options.link_name.value_or(DEFAULT_LINK_NAME),
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_link_disconnect_request{
-        options.dataverse_name.value_or(DEFAULT_DATAVERSE_NAME),
-        options.link_name.value_or(DEFAULT_LINK_NAME),
-        {},
-        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));
       });
   }
@@ -347,14 +402,20 @@ public:
   void get_pending_mutations(const get_pending_mutations_analytics_options::built& options,
                              get_pending_mutations_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_get_pending_mutations, options.parent_span);
+
+    core::operations::management::analytics_get_pending_mutations_request request{
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_get_pending_mutations_request{
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](
         const core::operations::management::analytics_get_pending_mutations_response& resp) {
         if (resp.ctx.ec) {
+          obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
           return handler(core::impl::make_error(resp.ctx), {});
         }
         std::map<std::string, std::map<std::string, std::int64_t>> pending_mutations{};
@@ -369,6 +430,7 @@ public:
           }
           pending_mutations.at(dataverse_name).insert({ dataset_name, mutation_count });
         }
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         handler(core::impl::make_error(resp.ctx), pending_mutations);
       });
   }
@@ -377,42 +439,58 @@ public:
                    const create_link_analytics_options::built& options,
                    create_link_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_create_link, options.parent_span);
+
     switch (link.link_type()) {
-      case management::s3_external:
-        return core_.execute(
-          core::operations::management::analytics_link_create_request<
-            core::management::analytics::s3_external_link>{
+      case management::s3_external: {
+        core::operations::management::analytics_link_create_request<
+          core::management::analytics::s3_external_link>
+          request{
             to_core_s3_external_link(link),
             {},
             options.timeout,
-          },
-          [handler = std::move(handler)](const auto& resp) {
+            obs_rec->operation_span(),
+          };
+        return core_.execute(
+          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));
           });
-
-      case management::azure_external:
-        return core_.execute(
-          core::operations::management::analytics_link_create_request<
-            core::management::analytics::azure_blob_external_link>{
+      }
+      case management::azure_external: {
+        core::operations::management::analytics_link_create_request<
+          core::management::analytics::azure_blob_external_link>
+          request{
             to_core_azure_blob_external_link(link),
             {},
             options.timeout,
-          },
-          [handler = std::move(handler)](const auto& resp) {
+            obs_rec->operation_span(),
+          };
+        return core_.execute(
+          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));
           });
-
-      case management::couchbase_remote:
-        return core_.execute(
-          core::operations::management::analytics_link_create_request<
-            core::management::analytics::couchbase_remote_link>{
+      }
+      case management::couchbase_remote: {
+        core::operations::management::analytics_link_create_request<
+          core::management::analytics::couchbase_remote_link>
+          request{
             to_core_couchbase_remote_link(link),
             {},
             options.timeout,
-          },
-          [handler = std::move(handler)](const auto& resp) {
+            obs_rec->operation_span(),
+          };
+        return core_.execute(
+          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));
           });
+      }
     }
   }
 
@@ -420,42 +498,58 @@ public:
                     const replace_link_analytics_options::built& options,
                     replace_link_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_analytics_replace_link, options.parent_span);
+
     switch (link.link_type()) {
-      case management::s3_external:
-        return core_.execute(
-          core::operations::management::analytics_link_replace_request<
-            core::management::analytics::s3_external_link>{
+      case management::s3_external: {
+        core::operations::management::analytics_link_replace_request<
+          core::management::analytics::s3_external_link>
+          request{
             to_core_s3_external_link(link),
             {},
             options.timeout,
-          },
-          [handler = std::move(handler)](const auto& resp) {
+            obs_rec->operation_span(),
+          };
+        return core_.execute(
+          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));
           });
-
-      case management::azure_external:
-        return core_.execute(
-          core::operations::management::analytics_link_replace_request<
-            core::management::analytics::azure_blob_external_link>{
+      }
+      case management::azure_external: {
+        core::operations::management::analytics_link_replace_request<
+          core::management::analytics::azure_blob_external_link>
+          request{
             to_core_azure_blob_external_link(link),
             {},
             options.timeout,
-          },
-          [handler = std::move(handler)](const auto& resp) {
+            obs_rec->operation_span(),
+          };
+        return core_.execute(
+          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));
           });
-
-      case management::couchbase_remote:
-        return core_.execute(
-          core::operations::management::analytics_link_replace_request<
-            core::management::analytics::couchbase_remote_link>{
+      }
+      case management::couchbase_remote: {
+        core::operations::management::analytics_link_replace_request<
+          core::management::analytics::couchbase_remote_link>
+          request{
             to_core_couchbase_remote_link(link),
             {},
             options.timeout,
-          },
-          [handler = std::move(handler)](const auto& resp) {
+            obs_rec->operation_span(),
+          };
+        return core_.execute(
+          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));
           });
+      }
     }
   }
 
@@ -464,14 +558,16 @@ public:
                  const drop_link_analytics_options::built& options,
                  drop_link_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_analytics_drop_link,
+                                                 options.parent_span);
+
+    core::operations::management::analytics_link_drop_request request{
+      link_name, dataverse_name, {}, options.timeout, obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::analytics_link_drop_request{
-        link_name,
-        dataverse_name,
-        {},
-        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));
       });
   }
@@ -479,8 +575,11 @@ public:
   void get_links(const get_links_analytics_options::built& options,
                  get_links_analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(core::tracing::operation::mgr_analytics_get_links,
+                                                 options.parent_span);
+
     core::operations::management::analytics_link_get_all_request req{
-      {}, {}, {}, {}, options.timeout,
+      {}, {}, {}, {}, options.timeout, obs_rec->operation_span(),
     };
     if (options.name.has_value()) {
       req.link_name = options.name.value();
@@ -502,10 +601,11 @@ public:
       }
     }
     return core_.execute(
-      req,
-      [handler = std::move(handler)](
+      std::move(req),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](
         const core::operations::management::analytics_link_get_all_response& resp) {
         if (resp.ctx.ec) {
+          obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
           return handler(core::impl::make_error(resp.ctx), {});
         }
         std::vector<std::unique_ptr<management::analytics_link>> links{};
@@ -552,11 +652,23 @@ public:
           links.push_back(std::move(azure_link));
         }
 
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         handler(core::impl::make_error(resp.ctx), std::move(links));
       });
   }
 
 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::analytics);
+    return rec;
+  }
+
   core::cluster core_;
 };