couchbase 4.4.3 → 4.4.4

package/deps/couchbase-cxx-client/core/impl/get_replica.hxx

@@ -41,6 +41,8 @@ struct get_replica_request {
   using encoded_response_type =
     core::protocol::client_response<core::protocol::get_replica_response_body>;
 
+  static const inline std::string observability_identifier = "get_replica";
+
   core::document_id id;
   std::optional<std::chrono::milliseconds> timeout{};
   std::uint16_t partition{};

package/deps/couchbase-cxx-client/core/impl/lookup_in_replica.hxx

@@ -53,6 +53,8 @@ struct lookup_in_replica_request {
   using encoded_response_type =
     protocol::client_response<protocol::lookup_in_replica_response_body>;
 
+  static const inline std::string observability_identifier = "lookup_in_replica";
+
   document_id id;
   std::vector<couchbase::core::impl::subdoc::command> specs{};
   std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/core/impl/observe_seqno.hxx

@@ -50,6 +50,8 @@ struct observe_seqno_request {
   using encoded_response_type =
     core::protocol::client_response<core::protocol::observe_seqno_response_body>;
 
+  static const inline std::string observability_identifier = "observe_seqno";
+
   core::document_id id;
   bool active{};
   std::uint64_t partition_uuid{};

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

@@ -180,6 +180,7 @@ build_query_request(std::string statement,
     std::move(query_context), std::move(options.client_context_id),
     options.timeout,          options.profile,
   };
+  request.parent_span = options.parent_span;
   if (!options.raw.empty()) {
     for (auto& [name, value] : options.raw) {
       request.raw[name] = std::move(value);

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

@@ -165,6 +165,7 @@ build_search_request(std::string index_name,
     options.client_context_id,
     options.timeout,
   };
+  request.parent_span = options.parent_span;
   return request;
 }
 
@@ -207,6 +208,7 @@ build_search_request(std::string index_name,
     options.client_context_id,
     options.timeout,
   };
+  core_request.parent_span = options.parent_span;
 
   if (auto vector_search = request.vector_search(); vector_search.has_value()) {
     core_request.vector_search = core::utils::json::generate_binary(vector_search->query);

package/deps/couchbase-cxx-client/core/io/http_command.hxx

@@ -246,8 +246,8 @@ private:
         }
         if (self->meter_) {
           metrics::metric_attributes attrs{
-            service_type::key_value,
-            fmt::format("{}", self->encoded.path),
+            self->request.type,
+            self->request.observability_identifier,
             ec,
           };
           self->meter_->record_value(std::move(attrs), start);

package/deps/couchbase-cxx-client/core/io/mcbp_command.hxx

@@ -269,7 +269,7 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
         std::optional<key_value_error_map_info> /* error_info */) mutable {
         metrics::metric_attributes attrs{
           service_type::key_value,
-          fmt::format("{}", encoded_request_type::body_type::opcode),
+          self->request.observability_identifier,
           ec,
           self->request.id.bucket(),
           self->request.id.scope(),

package/deps/couchbase-cxx-client/core/meta/features.hxx

@@ -195,3 +195,14 @@
  * encode document content or decode results.
  */
 #define COUCHBASE_CXX_CLIENT_PUBLIC_API_USES_TAO_JSON_ONLY_FOR_CONTENT
+
+/**
+ * couchbase::metrics::otel_meter uses the GA version of the OpenTelemetry Metrics API.
+ * The Metrics API for OpenTelemetry was GA'd in version 1.7.0.
+ */
+#define COUCHBASE_CXX_CLIENT_OTEL_METER_USES_GA_METRICS_API 1
+
+/**
+ * All options classes in the Public API expose the parent_span option.
+ */
+#define COUCHBASE_CXX_CLIENT_PUBLIC_API_PARENT_SPAN 1

package/deps/couchbase-cxx-client/core/meta/version.cxx

@@ -316,6 +316,28 @@ os() -> const std::string&
   return system;
 }
 
+namespace
+{
+constexpr auto
+has_wrapper_sdk_id() -> bool
+{
+  return COUCHBASE_CXX_CLIENT_WRAPPER_UNIFIED_ID != nullptr &&
+         COUCHBASE_CXX_CLIENT_WRAPPER_UNIFIED_ID[0] != '\0';
+}
+
+auto
+wrapper_sdk_id() -> std::string
+{
+  return COUCHBASE_CXX_CLIENT_WRAPPER_UNIFIED_ID;
+}
+
+auto
+cxx_sdk_id() -> std::string
+{
+  return fmt::format("cxx/{}", sdk_semver());
+}
+} // namespace
+
 constexpr const char* ssl_lib_id =
 #if defined(COUCHBASE_CXX_CLIENT_STATIC_BORINGSSL)
   "bssl"
@@ -329,16 +351,24 @@ user_agent_for_http(const std::string& client_id,
                     const std::string& session_id,
                     const std::string& extra) -> std::string
 {
-  auto user_agent = fmt::format("{};{}/0x{:x};client/{};session/{};{}",
-                                couchbase::core::meta::sdk_id(),
+  std::string user_agent{ has_wrapper_sdk_id() ? wrapper_sdk_id() : cxx_sdk_id() };
+  user_agent.append(" (");
+  if (has_wrapper_sdk_id()) {
+    user_agent.append(cxx_sdk_id()).append(";");
+  }
+
+  user_agent.append(fmt::format("{}/{};{}/0x{:x};client/{};session/{};{}",
+                                COUCHBASE_CXX_CLIENT_SYSTEM_NAME,
+                                COUCHBASE_CXX_CLIENT_SYSTEM_PROCESSOR,
                                 ssl_lib_id,
                                 OpenSSL_version_num(),
                                 client_id,
                                 session_id,
-                                couchbase::core::meta::os());
+                                couchbase::core::meta::os()));
   if (!extra.empty()) {
     user_agent.append(";").append(extra);
   }
+  user_agent.append(")");
   for (auto& ch : user_agent) {
     if (ch == '\n' || ch == '\r') {
       ch = ' ';
@@ -356,12 +386,22 @@ user_agent_for_mcbp(const std::string& client_id,
   tao::json::value user_agent{
     { "i", fmt::format("{}/{}", client_id, session_id) },
   };
-  const std::string core_id =
-    fmt::format("{};{}/0x{:x}", couchbase::core::meta::sdk_id(), ssl_lib_id, OpenSSL_version_num());
+  std::string core_id{ has_wrapper_sdk_id() ? wrapper_sdk_id() : cxx_sdk_id() };
+  core_id.append(" (");
+  if (has_wrapper_sdk_id()) {
+    core_id.append(cxx_sdk_id()).append(";");
+  }
+  core_id.append(fmt::format("{}/{};{}/0x{:x}",
+                             COUCHBASE_CXX_CLIENT_SYSTEM_NAME,
+                             COUCHBASE_CXX_CLIENT_SYSTEM_PROCESSOR,
+                             ssl_lib_id,
+                             OpenSSL_version_num()));
   std::string sdk_id = core_id;
+  core_id.append(")");
   if (!extra.empty()) {
     sdk_id.append(";").append(extra);
   }
+  sdk_id.append(")");
   if (max_length > 0) {
     auto current_length = utils::json::generate(user_agent).size();
     auto allowed_length = max_length - current_length;
@@ -373,7 +413,8 @@ user_agent_for_mcbp(const std::string& client_id,
         /* user-provided string is too weird, lets just fall back to just core */
         sdk_id = core_id;
       } else {
-        sdk_id.erase(allowed_length - escaped_characters);
+        sdk_id.erase(allowed_length - escaped_characters - 1);
+        sdk_id.append(")");
       }
     }
   }

package/deps/couchbase-cxx-client/core/operations/document_analytics.cxx

@@ -116,12 +116,16 @@ analytics_request::make_response(error_context::analytics&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    response.meta.request_id = payload.at("requestID").get_string();
-    response.meta.client_context_id = payload.at("clientContextID").get_string();
-    if (response.ctx.client_context_id != response.meta.client_context_id) {
-      CB_LOG_WARNING(R"(unexpected clientContextID returned by service: "{}", expected "{}")",
-                     response.meta.client_context_id,
-                     response.ctx.client_context_id);
+    if (const auto* i = payload.find("requestID"); i != nullptr) {
+      response.meta.request_id = i->get_string();
+    }
+    if (const auto* i = payload.find("clientContextID"); i != nullptr) {
+      response.meta.client_context_id = i->get_string();
+      if (response.ctx.client_context_id != response.meta.client_context_id) {
+        CB_LOG_WARNING(R"(unexpected clientContextID returned by service: "{}", expected "{}")",
+                       response.meta.client_context_id,
+                       response.ctx.client_context_id);
+      }
     }
     if (auto& status_prop = payload.at("status"); status_prop.is_string()) {
       const auto& status = status_prop.get_string();
@@ -154,17 +158,19 @@ analytics_request::make_response(error_context::analytics&& ctx,
       response.meta.signature = couchbase::core::utils::json::generate(*s);
     }
 
-    const tao::json::value& metrics = payload.at("metrics");
-    response.meta.metrics.result_count = metrics.at("resultCount").get_unsigned();
-    response.meta.metrics.result_size = metrics.at("resultSize").get_unsigned();
-    response.meta.metrics.elapsed_time =
-      utils::parse_duration(metrics.at("elapsedTime").get_string());
-    response.meta.metrics.execution_time =
-      utils::parse_duration(metrics.at("executionTime").get_string());
-    response.meta.metrics.processed_objects = metrics.at("processedObjects").get_unsigned();
-    response.meta.metrics.error_count = metrics.optional<std::uint64_t>("errorCount").value_or(0);
-    response.meta.metrics.warning_count =
-      metrics.optional<std::uint64_t>("warningCount").value_or(0);
+    if (const auto* metrics = payload.find("metrics"); metrics != nullptr) {
+      response.meta.metrics.result_count = metrics->at("resultCount").get_unsigned();
+      response.meta.metrics.result_size = metrics->at("resultSize").get_unsigned();
+      response.meta.metrics.elapsed_time =
+        utils::parse_duration(metrics->at("elapsedTime").get_string());
+      response.meta.metrics.execution_time =
+        utils::parse_duration(metrics->at("executionTime").get_string());
+      response.meta.metrics.processed_objects = metrics->at("processedObjects").get_unsigned();
+      response.meta.metrics.error_count =
+        metrics->optional<std::uint64_t>("errorCount").value_or(0);
+      response.meta.metrics.warning_count =
+        metrics->optional<std::uint64_t>("warningCount").value_or(0);
+    }
 
     if (const auto* e = payload.find("errors"); e != nullptr) {
       for (const auto& err : e->get_array()) {

package/deps/couchbase-cxx-client/core/operations/document_analytics.hxx

@@ -80,6 +80,7 @@ struct analytics_request {
   using error_context_type = error_context::analytics;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "analytics";
 
   std::string statement;
 

package/deps/couchbase-cxx-client/core/operations/document_append.hxx

@@ -44,6 +44,8 @@ struct append_request {
   using encoded_request_type = protocol::client_request<protocol::append_request_body>;
   using encoded_response_type = protocol::client_response<protocol::append_response_body>;
 
+  static const inline std::string observability_identifier = "append";
+
   document_id id;
   std::vector<std::byte> value;
   std::uint16_t partition{};

package/deps/couchbase-cxx-client/core/operations/document_decrement.hxx

@@ -45,6 +45,8 @@ struct decrement_request {
   using encoded_request_type = protocol::client_request<protocol::decrement_request_body>;
   using encoded_response_type = protocol::client_response<protocol::decrement_response_body>;
 
+  static const inline std::string observability_identifier = "decrement";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_exists.hxx

@@ -50,6 +50,8 @@ struct exists_request {
   using encoded_request_type = protocol::client_request<protocol::get_meta_request_body>;
   using encoded_response_type = protocol::client_response<protocol::get_meta_response_body>;
 
+  static const inline std::string observability_identifier = "exists";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_get.hxx

@@ -41,6 +41,8 @@ struct get_request {
   using encoded_request_type = protocol::client_request<protocol::get_request_body>;
   using encoded_response_type = protocol::client_response<protocol::get_response_body>;
 
+  static const inline std::string observability_identifier = "get";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_get_all_replicas.hxx

@@ -50,6 +50,8 @@ struct get_all_replicas_request {
   using encoded_response_type =
     core::protocol::client_response<core::protocol::get_replica_response_body>;
 
+  static const inline std::string observability_identifier = "get_all_replicas";
+
   core::document_id id;
   std::optional<std::chrono::milliseconds> timeout{};
   couchbase::read_preference read_preference{ couchbase::read_preference::no_preference };

package/deps/couchbase-cxx-client/core/operations/document_get_and_lock.hxx

@@ -41,6 +41,8 @@ struct get_and_lock_request {
   using encoded_request_type = protocol::client_request<protocol::get_and_lock_request_body>;
   using encoded_response_type = protocol::client_response<protocol::get_and_lock_response_body>;
 
+  static const inline std::string observability_identifier = "get_and_lock";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_get_and_touch.hxx

@@ -42,6 +42,8 @@ struct get_and_touch_request {
   using encoded_request_type = protocol::client_request<protocol::get_and_touch_request_body>;
   using encoded_response_type = protocol::client_response<protocol::get_and_touch_response_body>;
 
+  static const inline std::string observability_identifier = "get_and_touch";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_get_any_replica.hxx

@@ -46,6 +46,8 @@ struct get_any_replica_request {
   using encoded_response_type =
     core::protocol::client_response<core::protocol::get_replica_response_body>;
 
+  static const inline std::string observability_identifier = "get_any_replica";
+
   core::document_id id;
   std::optional<std::chrono::milliseconds> timeout{};
   couchbase::read_preference read_preference{ couchbase::read_preference::no_preference };

package/deps/couchbase-cxx-client/core/operations/document_get_projected.hxx

@@ -42,6 +42,8 @@ struct get_projected_request {
   using encoded_request_type = protocol::client_request<protocol::lookup_in_request_body>;
   using encoded_response_type = protocol::client_response<protocol::lookup_in_response_body>;
 
+  static const inline std::string observability_identifier = "get";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_increment.hxx

@@ -45,6 +45,8 @@ struct increment_request {
   using encoded_request_type = protocol::client_request<protocol::increment_request_body>;
   using encoded_response_type = protocol::client_response<protocol::increment_response_body>;
 
+  static const inline std::string observability_identifier = "increment";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_insert.hxx

@@ -44,6 +44,8 @@ struct insert_request {
   using encoded_request_type = protocol::client_request<protocol::insert_request_body>;
   using encoded_response_type = protocol::client_response<protocol::insert_response_body>;
 
+  static const inline std::string observability_identifier = "insert";
+
   document_id id;
   std::vector<std::byte> value;
   std::uint16_t partition{};

package/deps/couchbase-cxx-client/core/operations/document_lookup_in.hxx

@@ -54,6 +54,8 @@ struct lookup_in_request {
   using encoded_request_type = protocol::client_request<protocol::lookup_in_request_body>;
   using encoded_response_type = protocol::client_response<protocol::lookup_in_response_body>;
 
+  static const inline std::string observability_identifier = "lookup_in";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_all_replicas.hxx

@@ -61,6 +61,8 @@ struct lookup_in_all_replicas_request {
   using encoded_response_type =
     core::protocol::client_response<core::protocol::lookup_in_replica_response_body>;
 
+  static const inline std::string observability_identifier = "lookup_in_all_replicas";
+
   core::document_id id;
   std::vector<couchbase::core::impl::subdoc::command> specs{};
   std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_any_replica.hxx

@@ -59,6 +59,8 @@ struct lookup_in_any_replica_request {
   using encoded_response_type =
     core::protocol::client_response<core::protocol::lookup_in_replica_response_body>;
 
+  static const inline std::string observability_identifier = "lookup_in_any_replica";
+
   core::document_id id;
   std::vector<couchbase::core::impl::subdoc::command> specs{};
   std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/core/operations/document_mutate_in.hxx

@@ -55,6 +55,8 @@ struct mutate_in_request {
   using encoded_request_type = protocol::client_request<protocol::mutate_in_request_body>;
   using encoded_response_type = protocol::client_response<protocol::mutate_in_response_body>;
 
+  static const inline std::string observability_identifier = "mutate_in";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_prepend.hxx

@@ -44,6 +44,8 @@ struct prepend_request {
   using encoded_request_type = protocol::client_request<protocol::prepend_request_body>;
   using encoded_response_type = protocol::client_response<protocol::prepend_response_body>;
 
+  static const inline std::string observability_identifier = "prepend";
+
   document_id id;
   std::vector<std::byte> value;
   std::uint16_t partition{};

package/deps/couchbase-cxx-client/core/operations/document_query.hxx

@@ -80,6 +80,7 @@ struct query_request {
   using error_context_type = error_context::query;
 
   static const inline service_type type = service_type::query;
+  static const inline std::string observability_identifier = "query";
 
   std::string statement;
 

package/deps/couchbase-cxx-client/core/operations/document_remove.hxx

@@ -44,6 +44,8 @@ struct remove_request {
   using encoded_request_type = protocol::client_request<protocol::remove_request_body>;
   using encoded_response_type = protocol::client_response<protocol::remove_response_body>;
 
+  static const inline std::string observability_identifier = "remove";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_replace.hxx

@@ -44,6 +44,8 @@ struct replace_request {
   using encoded_request_type = protocol::client_request<protocol::replace_request_body>;
   using encoded_response_type = protocol::client_response<protocol::replace_response_body>;
 
+  static const inline std::string observability_identifier = "replace";
+
   document_id id;
   std::vector<std::byte> value;
   std::uint16_t partition{};

package/deps/couchbase-cxx-client/core/operations/document_search.hxx

@@ -116,6 +116,7 @@ struct search_request {
   using error_context_type = error_context::search;
 
   static const inline service_type type = service_type::search;
+  static const inline std::string observability_identifier = "search";
 
   std::string index_name;
   couchbase::core::json_string query;

package/deps/couchbase-cxx-client/core/operations/document_touch.hxx

@@ -39,6 +39,8 @@ struct touch_request {
   using encoded_request_type = protocol::client_request<protocol::touch_request_body>;
   using encoded_response_type = protocol::client_response<protocol::touch_response_body>;
 
+  static const inline std::string observability_identifier = "touch";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_unlock.hxx

@@ -39,6 +39,8 @@ struct unlock_request {
   using encoded_request_type = protocol::client_request<protocol::unlock_request_body>;
   using encoded_response_type = protocol::client_response<protocol::unlock_response_body>;
 
+  static const inline std::string observability_identifier = "unlock";
+
   document_id id;
   std::uint16_t partition{};
   std::uint32_t opaque{};

package/deps/couchbase-cxx-client/core/operations/document_upsert.hxx

@@ -44,6 +44,8 @@ struct upsert_request {
   using encoded_request_type = protocol::client_request<protocol::upsert_request_body>;
   using encoded_response_type = protocol::client_response<protocol::upsert_response_body>;
 
+  static const inline std::string observability_identifier = "upsert";
+
   document_id id;
   std::vector<std::byte> value;
   std::uint16_t partition{};

package/deps/couchbase-cxx-client/core/operations/document_view.hxx

@@ -61,6 +61,7 @@ struct document_view_request {
   using error_context_type = error_context::view;
 
   static const inline service_type type = service_type::view;
+  static const inline std::string observability_identifier = "views";
 
   std::string bucket_name;
   std::string document_name;

package/deps/couchbase-cxx-client/core/operations/http_noop.hxx

@@ -35,6 +35,8 @@ struct http_noop_request {
   using encoded_response_type = io::http_response;
   using error_context_type = error_context::http;
 
+  static const inline std::string observability_identifier = "noop";
+
   service_type type{};
 
   std::optional<std::string> client_context_id{};

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataset_create.hxx

@@ -39,6 +39,7 @@ struct analytics_dataset_create_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_create_dataset";
 
   std::string dataverse_name{ "Default" };
   std::string dataset_name;

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataset_drop.hxx

@@ -39,6 +39,7 @@ struct analytics_dataset_drop_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_drop_dataset";
 
   std::string dataverse_name{ "Default" };
   std::string dataset_name;

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataset_get_all.hxx

@@ -41,6 +41,7 @@ struct analytics_dataset_get_all_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_get_all_datasets";
 
   std::optional<std::string> client_context_id{};
   std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataverse_create.hxx

@@ -39,6 +39,7 @@ struct analytics_dataverse_create_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_create_dataverse";
 
   std::string dataverse_name;
 

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataverse_drop.hxx

@@ -39,6 +39,7 @@ struct analytics_dataverse_drop_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_drop_dataverse";
 
   std::string dataverse_name;
 

package/deps/couchbase-cxx-client/core/operations/management/analytics_get_pending_mutations.hxx

@@ -40,6 +40,8 @@ struct analytics_get_pending_mutations_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier =
+    "manager_analytics_get_pending_mutations";
 
   std::optional<std::string> client_context_id{};
   std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/core/operations/management/analytics_index_create.hxx

@@ -39,6 +39,7 @@ struct analytics_index_create_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_create_index";
 
   std::string dataverse_name{ "Default" };
   std::string dataset_name;

package/deps/couchbase-cxx-client/core/operations/management/analytics_index_drop.hxx

@@ -39,6 +39,7 @@ struct analytics_index_drop_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_drop_index";
 
   std::string dataverse_name{ "Default" };
   std::string dataset_name;

package/deps/couchbase-cxx-client/core/operations/management/analytics_index_get_all.hxx

@@ -41,6 +41,7 @@ struct analytics_index_get_all_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_get_all_indexes";
 
   std::optional<std::string> client_context_id{};
   std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/core/operations/management/analytics_link_connect.hxx

@@ -43,6 +43,7 @@ struct analytics_link_connect_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_connect_link";
 
   std::string dataverse_name{ "Default" };
   std::string link_name{ "Local" };

package/deps/couchbase-cxx-client/core/operations/management/analytics_link_create.hxx

@@ -51,6 +51,7 @@ struct analytics_link_create_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_create_link";
 
   analytics_link_type link{};
   std::optional<std::string> client_context_id{};

package/deps/couchbase-cxx-client/core/operations/management/analytics_link_disconnect.hxx

@@ -43,6 +43,7 @@ struct analytics_link_disconnect_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_disconnect_link";
 
   std::string dataverse_name{ "Default" };
   std::string link_name{ "Local" };

package/deps/couchbase-cxx-client/core/operations/management/analytics_link_drop.hxx

@@ -43,6 +43,7 @@ struct analytics_link_drop_request {
   using error_context_type = error_context::http;
 
   static const inline service_type type = service_type::analytics;
+  static const inline std::string observability_identifier = "manager_analytics_drop_link";
 
   std::string link_name{};
   std::string dataverse_name{};