couchbase 3.5.4 → 3.5.5

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

@@ -15,12 +15,13 @@
  *   limitations under the License.
  */
 
-#include <couchbase/fmt/retry_reason.hxx>
-
 #include "core/error_context/query_error_context.hxx"
 
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/to_string.hpp>
 
+#include <couchbase/fmt/retry_reason.hxx>
+
 namespace couchbase::core
 {
 auto

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

@@ -31,7 +31,7 @@
 #include <couchbase/collection.hxx>
 #include <couchbase/scope.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <memory>
 #include <utility>
@@ -136,8 +136,8 @@ scope::query(std::string statement, const query_options& options, query_handler&
 }
 
 auto
-scope::query(std::string statement,
-             const query_options& options) const -> std::future<std::pair<error, query_result>>
+scope::query(std::string statement, const query_options& options) const
+  -> std::future<std::pair<error, query_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, query_result>>>();
   auto future = barrier->get_future();
@@ -178,9 +178,8 @@ scope::search(std::string index_name,
 }
 
 auto
-scope::search(std::string index_name,
-              search_request request,
-              const search_options& options) const -> std::future<std::pair<error, search_result>>
+scope::search(std::string index_name, search_request request, const search_options& options) const
+  -> std::future<std::pair<error, search_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, search_result>>>();
   auto future = barrier->get_future();

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

@@ -29,7 +29,7 @@
 #include <couchbase/match_none_query.hxx>
 #include <utility>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 namespace couchbase::core::impl
 {
@@ -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);

data/ext/couchbase/core/io/config_tracker.cxx

@@ -29,7 +29,7 @@
 #include "mcbp_session.hxx"
 
 #include <asio/steady_timer.hpp>
-#include <fmt/chrono.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 namespace couchbase::core::io
 {

data/ext/couchbase/core/io/dns_client.cxx

@@ -27,10 +27,8 @@
 #include <asio/ip/tcp.hpp>
 #include <asio/read.hpp>
 #include <asio/write.hpp>
-
-#include <fmt/chrono.h>
-
 #include <spdlog/fmt/bin_to_hex.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 #include <chrono>
 #include <memory>
@@ -98,6 +96,9 @@ public:
                         bytes_transferred1);
         if (ec1) {
           self->udp_deadline_.cancel();
+          if (ec1 == asio::error::operation_aborted) {
+            return;
+          }
           CB_LOG_DEBUG(
             "DNS UDP write operation has got error, retrying with TCP, address=\"{}:{}\", ec={}",
             self->address_.to_string(),
@@ -121,6 +122,9 @@ public:
 
             self->udp_deadline_.cancel();
             if (ec2) {
+              if (ec2 == asio::error::operation_aborted) {
+                return;
+              }
               CB_LOG_DEBUG(
                 "DNS UDP read operation has got error, retrying with TCP, address=\"{}:{}\", ec={}",
                 self->address_.to_string(),
@@ -151,11 +155,12 @@ public:
       if (ec == asio::error::operation_aborted) {
         return;
       }
+      self->udp_.cancel();
       CB_LOG_DEBUG("DNS UDP deadline has been reached, cancelling UDP operation and fall back to "
                    "TCP, address=\"{}:{}\"",
                    self->address_.to_string(),
                    self->port_);
-      self->udp_.cancel();
+      return self->retry_with_tcp();
     });
 
     deadline_.expires_after(total_timeout);
@@ -172,6 +177,7 @@ public:
       if (self->tcp_.is_open()) {
         self->tcp_.cancel();
       }
+      return self->handler_({ errc::common::unambiguous_timeout });
     });
   }
 
@@ -195,6 +201,9 @@ private:
     const asio::ip::tcp::endpoint endpoint(address_, port_);
     tcp_.async_connect(endpoint, [self = shared_from_this()](std::error_code ec1) mutable {
       if (ec1) {
+        if (ec1 == asio::error::operation_aborted) {
+          return;
+        }
         self->deadline_.cancel();
         CB_LOG_DEBUG("DNS TCP connection has been aborted, address=\"{}:{}\", ec={}",
                      self->address_.to_string(),
@@ -220,14 +229,14 @@ private:
                           ec2 ? ec2.message() : "ok",
                           bytes_transferred2);
           if (ec2) {
+            if (ec2 == asio::error::operation_aborted) {
+              return;
+            }
             CB_LOG_DEBUG("DNS TCP write operation has been aborted, address=\"{}:{}\", ec={}",
                          self->address_.to_string(),
                          self->port_,
                          ec2.message());
             self->deadline_.cancel();
-            if (ec2 == asio::error::operation_aborted) {
-              ec2 = errc::common::unambiguous_timeout;
-            }
             return self->handler_({ ec2 });
           }
           asio::async_read(
@@ -244,6 +253,9 @@ private:
                                reinterpret_cast<std::uint8_t*>(&self->recv_buf_size_) +
                                  bytes_transferred3));
               if (ec3) {
+                if (ec3 == asio::error::operation_aborted) {
+                  return;
+                }
                 CB_LOG_DEBUG(
                   "DNS TCP buf size read operation has been aborted, address=\"{}:{}\", ec={}",
                   self->address_.to_string(),
@@ -259,7 +271,6 @@ private:
                 self->tcp_,
                 asio::buffer(self->recv_buf_),
                 [self](std::error_code ec4, std::size_t bytes_transferred4) mutable {
-                  self->deadline_.cancel();
                   CB_LOG_PROTOCOL(
                     "[DNS, TCP, IN] host=\"{}\", port={}, rc={}, bytes_received={}{:a}",
                     self->address_.to_string(),
@@ -269,6 +280,10 @@ private:
                     spdlog::to_hex(self->recv_buf_.data(),
                                    self->recv_buf_.data() + bytes_transferred4));
 
+                  if (ec4 == asio::error::operation_aborted) {
+                    return;
+                  }
+                  self->deadline_.cancel();
                   if (ec4) {
                     CB_LOG_DEBUG(
                       "DNS TCP read operation has been aborted, address=\"{}:{}\", ec={}",

data/ext/couchbase/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);

data/ext/couchbase/core/io/http_parser.cxx

@@ -17,8 +17,8 @@
 
 #include "http_parser.hxx"
 
-#include <fmt/core.h>
 #include <llhttp.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <algorithm>
 

data/ext/couchbase/core/io/http_session.cxx

@@ -19,10 +19,14 @@
 
 #include "core/logger/logger.hxx"
 #include "core/meta/version.hxx"
+#include "core/platform/base64.h"
 #include "core/platform/uuid.h"
 #include "core/service_type_fmt.hxx"
 
 #include <couchbase/error_codes.hxx>
+
+#include <spdlog/fmt/bin_to_hex.h>
+
 #include <utility>
 
 namespace couchbase::core::io

data/ext/couchbase/core/io/http_session.hxx

@@ -20,7 +20,6 @@
 #include <couchbase/build_config.hxx>
 
 #include "core/diagnostics.hxx"
-#include "core/impl/bootstrap_error.hxx"
 #include "core/origin.hxx"
 #include "core/platform/base64.h"
 #include "core/utils/movable_function.hxx"
@@ -30,9 +29,12 @@
 #include "http_streaming_parser.hxx"
 #include "http_streaming_response.hxx"
 #include "streams.hxx"
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+#include "core/impl/bootstrap_error.hxx"
+#endif
 
 #include <asio.hpp>
-#include <spdlog/fmt/bin_to_hex.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 #include <memory>
 #include <optional>

data/ext/couchbase/core/io/mcbp_command.hxx

@@ -36,7 +36,7 @@
 #include <couchbase/error_codes.hxx>
 
 #include <asio/steady_timer.hpp>
-#include <fmt/chrono.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 #include <functional>
 #include <utility>
@@ -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(),

data/ext/couchbase/core/key_value_config.cxx

@@ -15,8 +15,8 @@
 
 #include "key_value_config.hxx"
 
-#include <fmt/chrono.h>
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 
 namespace couchbase::core
 {

data/ext/couchbase/core/logger/logger.hxx

@@ -27,7 +27,7 @@
 
 #include "level.hxx"
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 #include <spdlog/fwd.h>
 
 #include <memory>

data/ext/couchbase/core/management/rbac_fmt.hxx

@@ -19,7 +19,7 @@
 
 #include "rbac.hxx"
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 template<>
 struct fmt::formatter<couchbase::core::management::rbac::auth_domain> {

data/ext/couchbase/core/mcbp/operation_queue.cxx

@@ -23,7 +23,7 @@
 
 #include <couchbase/error_codes.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <algorithm>
 #include <iterator>

data/ext/couchbase/core/mcbp/packet.cxx

@@ -22,8 +22,8 @@
 
 #include "core/fmt/key_value_status_code.hxx"
 
-#include <fmt/core.h>
 #include <spdlog/fmt/bin_to_hex.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <iterator>
 

data/ext/couchbase/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

data/ext/couchbase/core/meta/version.cxx

@@ -27,12 +27,12 @@
 #include <couchbase/build_version.hxx>
 
 #include <asio/version.hpp>
-#include <fmt/core.h>
 #include <hdr/hdr_histogram_version.h>
 #include <llhttp.h>
 #include <openssl/crypto.h>
 #include <openssl/x509.h>
 #include <snappy-stubs-public.h>
+#include <spdlog/fmt/bundled/core.h>
 #include <spdlog/version.h>
 
 #include <regex>
@@ -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(")");
       }
     }
   }

data/ext/couchbase/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()) {

data/ext/couchbase/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;
 

data/ext/couchbase/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{};

data/ext/couchbase/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{};

data/ext/couchbase/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{};

data/ext/couchbase/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{};

data/ext/couchbase/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 };

data/ext/couchbase/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{};

data/ext/couchbase/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{};

data/ext/couchbase/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 };

data/ext/couchbase/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{};

data/ext/couchbase/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{};

data/ext/couchbase/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{};

data/ext/couchbase/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{};

data/ext/couchbase/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{};

data/ext/couchbase/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{};