couchbase 4.4.2 → 4.4.4

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/metrics/meter_wrapper.cxx

@@ -0,0 +1,188 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "meter_wrapper.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <mutex>
+#include <system_error>
+
+namespace couchbase::core::metrics
+{
+namespace
+{
+auto
+snake_case_to_camel_case(const std::string& s) -> std::string
+{
+  std::string res{};
+  bool capitalize{ true }; // First letter should be capitalized
+  for (const char c : s) {
+    if (c == '_') {
+      capitalize = true; // Next letter should be capitalized
+      continue;
+    }
+    if (capitalize) {
+      res += static_cast<char>(std::toupper(c));
+      capitalize = false;
+    } else {
+      res += c;
+    }
+  }
+  return res;
+}
+
+auto
+extract_error_name(std::error_code ec) -> std::string
+{
+  const std::string::size_type pos = ec.message().find(' ');
+  if (pos != std::string::npos) {
+    return ec.message().substr(0, pos);
+  }
+  return ec.message();
+}
+
+auto
+service_to_string(service_type s) -> std::string
+{
+  switch (s) {
+    case service_type::analytics:
+      return "analytics";
+    case service_type::search:
+      return "search";
+    case service_type::key_value:
+      return "kv";
+    case service_type::management:
+      return "management";
+    case service_type::eventing:
+      return "eventing";
+    case service_type::query:
+      return "query";
+    case service_type::view:
+      return "views";
+  }
+  return {};
+}
+
+auto
+get_standardized_outcome(std::error_code ec) -> std::string
+{
+  if (!ec) {
+    return "Success";
+  }
+
+  // SDK-specific errors
+  if (ec.value() >= 1000) {
+    return "CouchbaseError";
+  }
+
+  // Errors where message and RFC-message don't match
+  if (ec == errc::field_level_encryption::generic_cryptography_failure) {
+    return "CryptoError";
+  }
+
+  return snake_case_to_camel_case(extract_error_name(ec));
+}
+} // namespace
+
+auto
+metric_attributes::encode() const -> std::map<std::string, std::string>
+{
+  std::map<std::string, std::string> tags = { { "db.couchbase.service",
+                                                service_to_string(service) },
+                                              { "db.operation", operation },
+                                              { "outcome", get_standardized_outcome(ec) } };
+
+  if (internal.cluster_name.has_value()) {
+    tags.emplace("db.couchbase.cluster_name", internal.cluster_name.value());
+  }
+  if (internal.cluster_uuid.has_value()) {
+    tags.emplace("db.couchbase.cluster_uuid", internal.cluster_uuid.value());
+  }
+  if (bucket_name) {
+    tags.emplace("db.name", bucket_name.value());
+  }
+  if (scope_name) {
+    tags.emplace("db.couchbase.scope", scope_name.value());
+  }
+  if (collection_name) {
+    tags.emplace("db.couchbase.collection", collection_name.value());
+  }
+
+  return tags;
+}
+
+meter_wrapper::meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter)
+  : meter_{ std::move(meter) }
+{
+}
+
+void
+meter_wrapper::start()
+{
+  meter_->start();
+}
+
+void
+meter_wrapper::stop()
+{
+  meter_->stop();
+}
+
+void
+meter_wrapper::record_value(metric_attributes attrs,
+                            std::chrono::steady_clock::time_point start_time)
+{
+  static const std::string meter_name{ "db.couchbase.operations" };
+
+  {
+    const std::shared_lock lock{ cluster_labels_mutex_ };
+
+    if (cluster_name_) {
+      attrs.internal.cluster_name = cluster_name_;
+    }
+    if (cluster_uuid_) {
+      attrs.internal.cluster_uuid = cluster_uuid_;
+    }
+  }
+
+  auto tags = attrs.encode();
+  meter_->get_value_recorder(meter_name, tags)
+    ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(
+                     std::chrono::steady_clock::now() - start_time)
+                     .count());
+}
+
+void
+meter_wrapper::update_config(topology::configuration config)
+{
+  const std::scoped_lock<std::shared_mutex> lock{ cluster_labels_mutex_ };
+  if (config.cluster_uuid.has_value()) {
+    cluster_uuid_ = config.cluster_uuid;
+  }
+  if (config.cluster_name.has_value()) {
+    cluster_name_ = config.cluster_name;
+  }
+}
+
+auto
+meter_wrapper::create(std::shared_ptr<couchbase::metrics::meter> meter)
+  -> std::shared_ptr<meter_wrapper>
+{
+  return std::make_shared<meter_wrapper>(std::move(meter));
+}
+} // namespace couchbase::core::metrics

package/deps/couchbase-cxx-client/core/metrics/meter_wrapper.hxx

@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "core/config_listener.hxx"
+#include "core/service_type.hxx"
+#include "core/topology/configuration.hxx"
+
+#include <couchbase/metrics/meter.hxx>
+
+#include <chrono>
+#include <map>
+#include <optional>
+#include <shared_mutex>
+#include <string>
+#include <system_error>
+
+namespace couchbase::core::metrics
+{
+struct metric_attributes {
+  couchbase::core::service_type service;
+  std::string operation;
+  std::error_code ec;
+  std::optional<std::string> bucket_name{};
+  std::optional<std::string> scope_name{};
+  std::optional<std::string> collection_name{};
+
+  struct {
+    std::optional<std::string> cluster_name{};
+    std::optional<std::string> cluster_uuid{};
+  } internal{};
+
+  [[nodiscard]] auto encode() const -> std::map<std::string, std::string>;
+};
+
+class meter_wrapper : public config_listener
+{
+public:
+  explicit meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter);
+
+  void start();
+  void stop();
+
+  void record_value(metric_attributes attrs, std::chrono::steady_clock::time_point start_time);
+
+  void update_config(topology::configuration config) override;
+
+  [[nodiscard]] static auto create(std::shared_ptr<couchbase::metrics::meter> meter)
+    -> std::shared_ptr<meter_wrapper>;
+
+private:
+  std::shared_ptr<couchbase::metrics::meter> meter_;
+
+  std::optional<std::string> cluster_name_{};
+  std::optional<std::string> cluster_uuid_{};
+  std::shared_mutex cluster_labels_mutex_{};
+};
+} // namespace couchbase::core::metrics

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;