couchbase 3.7.0 → 3.8.1

data/ext/couchbase/core/operations/document_get_projected.cxx

@@ -210,14 +210,13 @@ get_projected_request::make_response(key_value_error_context&& ctx,
           response.ctx.override_ec(errc::common::parsing_failure);
           return response;
         }
-        tao::json::value new_doc;
+        tao::json::value new_doc = tao::json::empty_object;
         for (const auto& projection : projections) {
           if (auto value_to_apply = subdoc_lookup(full_doc, projection)) {
             subdoc_apply_projection(new_doc, projection, *value_to_apply, preserve_array_indexes);
-          } else {
-            response.ctx.override_ec(errc::key_value::path_not_found);
-            return response;
           }
+          // We ignore paths that were not found, similar to how we ignore them in the subdoc
+          // multi-lookup below.
         }
         response.value = utils::json::generate_binary(new_doc);
       }

data/ext/couchbase/core/operations/document_get_projected.hxx

@@ -62,13 +62,4 @@ struct get_projected_request {
                                    const encoded_response_type& encoded) const
     -> get_projected_response;
 };
-
 } // namespace couchbase::core::operations
-
-namespace couchbase::core::io::mcbp_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::get_projected_request>
-  : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_increment.hxx

@@ -79,9 +79,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::increment_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::increment_request>
-  : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_insert.hxx

@@ -77,8 +77,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::insert_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::insert_request> : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_lookup_in.hxx

@@ -72,13 +72,4 @@ struct lookup_in_request {
                                    const encoded_response_type& encoded) const
     -> lookup_in_response;
 };
-
 } // namespace couchbase::core::operations
-namespace couchbase::core::io::mcbp_traits
-{
-
-template<>
-struct supports_parent_span<couchbase::core::operations::lookup_in_request>
-  : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_lookup_in_all_replicas.hxx

@@ -23,10 +23,12 @@
 #include "core/impl/subdoc/command.hxx"
 #include "core/operations/document_lookup_in.hxx"
 #include "core/operations/operation_traits.hxx"
+#include "core/tracing/constants.hxx"
 #include "core/utils/movable_function.hxx"
 
 #include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/error_codes.hxx>
+#include <couchbase/node_id.hxx>
 
 #include <functional>
 #include <memory>
@@ -49,6 +51,7 @@ struct lookup_in_all_replicas_response {
     couchbase::cas cas{};
     bool deleted{ false };
     bool is_replica{ true };
+    couchbase::node_id dispatched_to_node_id{};
   };
   subdocument_error_context ctx{};
   std::vector<entry> entries{};
@@ -152,14 +155,39 @@ struct lookup_in_all_replicas_request {
             auto ctx = std::make_shared<replica_context>(std::move(h), nodes.size());
 
             for (const auto& node : nodes) {
+              auto subop_span = core->tracer()->create_span(
+                node.is_replica ? tracing::operation::mcbp_lookup_in_replica
+                                : tracing::operation::mcbp_lookup_in,
+                parent_span);
+
+              if (subop_span->uses_tags()) {
+                subop_span->add_tag(tracing::attributes::op::service, tracing::service::key_value);
+                subop_span->add_tag(tracing::attributes::op::operation_name,
+                                    node.is_replica ? tracing::operation::mcbp_lookup_in_replica
+                                                    : tracing::operation::mcbp_lookup_in);
+                subop_span->add_tag(tracing::attributes::op::bucket_name, id.bucket());
+                subop_span->add_tag(tracing::attributes::op::scope_name, id.scope());
+                subop_span->add_tag(tracing::attributes::op::collection_name, id.collection());
+              }
+
               if (node.is_replica) {
                 document_id replica_id{ id };
                 replica_id.node_index(node.index);
                 auto replica_req = impl::lookup_in_replica_request{
-                  std::move(replica_id), specs, timeout, parent_span
+                  std::move(replica_id),
+                  specs,
+                  timeout,
+                  subop_span,
                 };
                 replica_req.access_deleted = access_deleted;
-                core->execute(replica_req, [ctx](auto&& resp) {
+                core->execute(replica_req, [ctx, subop_span](auto&& resp) {
+                  {
+                    if (subop_span->uses_tags()) {
+                      subop_span->add_tag(tracing::attributes::op::retry_count,
+                                          resp.ctx.retry_attempts());
+                    }
+                    subop_span->end();
+                  }
                   handler_type local_handler{};
                   {
                     std::scoped_lock lock(ctx->mutex_);
@@ -177,6 +205,7 @@ struct lookup_in_all_replicas_request {
                       top_entry.cas = resp.cas;
                       top_entry.deleted = resp.deleted;
                       top_entry.is_replica = true;
+                      top_entry.dispatched_to_node_id = resp.ctx.last_dispatched_to_node_id();
                       for (auto& field : resp.fields) {
                         lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
                         lookup_in_entry.path = field.path;
@@ -206,8 +235,24 @@ struct lookup_in_all_replicas_request {
                 });
               } else {
                 core->execute(
-                  lookup_in_request{ document_id{ id }, {}, {}, false, specs, timeout },
-                  [ctx](auto&& resp) {
+                  lookup_in_request{
+                    document_id{ id },
+                    {},
+                    {},
+                    false,
+                    specs,
+                    timeout,
+                    {},
+                    subop_span,
+                  },
+                  [ctx, subop_span](auto&& resp) {
+                    {
+                      if (subop_span->uses_tags()) {
+                        subop_span->add_tag(tracing::attributes::op::retry_count,
+                                            resp.ctx.retry_attempts());
+                      }
+                      subop_span->end();
+                    }
                     handler_type local_handler{};
                     {
                       std::scoped_lock lock(ctx->mutex_);
@@ -225,6 +270,7 @@ struct lookup_in_all_replicas_request {
                         top_entry.cas = resp.cas;
                         top_entry.deleted = resp.deleted;
                         top_entry.is_replica = false;
+                        top_entry.dispatched_to_node_id = resp.ctx.last_dispatched_to_node_id();
                         for (auto& field : resp.fields) {
                           lookup_in_all_replicas_response::entry::lookup_in_entry lookup_in_entry{};
                           lookup_in_entry.path = field.path;

data/ext/couchbase/core/operations/document_lookup_in_any_replica.hxx

@@ -21,8 +21,10 @@
 #include "core/impl/lookup_in_replica.hxx"
 #include "core/impl/replica_utils.hxx"
 #include "core/impl/subdoc/command.hxx"
+#include "core/impl/with_cancellation.hxx"
 #include "core/operations/document_lookup_in.hxx"
 #include "core/operations/operation_traits.hxx"
+#include "core/tracing/constants.hxx"
 #include "core/utils/movable_function.hxx"
 
 #include <couchbase/codec/encoded_value.hxx>
@@ -139,23 +141,71 @@ struct lookup_in_any_replica_request {
               {
               }
 
+              void add_cancellation_token(std::shared_ptr<impl::cancellation_token> token)
+              {
+                std::scoped_lock<std::mutex> lock(cancel_tokens_mutex_);
+                cancel_tokens_.emplace_back(std::move(token));
+              }
+
+              auto get_cancellation_tokens()
+                -> std::vector<std::shared_ptr<impl::cancellation_token>>
+              {
+                std::vector<std::shared_ptr<impl::cancellation_token>> tokens{};
+                {
+                  std::scoped_lock<std::mutex> lock(cancel_tokens_mutex_);
+                  std::swap(tokens, cancel_tokens_);
+                }
+                return tokens;
+              }
+
               handler_type handler_;
               std::size_t expected_responses_;
               bool done_{ false };
               std::mutex mutex_{};
+              std::vector<std::shared_ptr<impl::cancellation_token>> cancel_tokens_{};
+              std::mutex cancel_tokens_mutex_{};
             };
             auto ctx = std::make_shared<replica_context>(std::move(h), nodes.size());
 
             for (const auto& node : nodes) {
+              auto subop_span = core->tracer()->create_span(
+                node.is_replica ? tracing::operation::mcbp_lookup_in_replica
+                                : tracing::operation::mcbp_lookup_in,
+                parent_span);
+
+              if (subop_span->uses_tags()) {
+                subop_span->add_tag(tracing::attributes::op::service, tracing::service::key_value);
+                subop_span->add_tag(tracing::attributes::op::operation_name,
+                                    node.is_replica ? tracing::operation::mcbp_lookup_in_replica
+                                                    : tracing::operation::mcbp_lookup_in);
+                subop_span->add_tag(tracing::attributes::op::bucket_name, id.bucket());
+                subop_span->add_tag(tracing::attributes::op::scope_name, id.scope());
+                subop_span->add_tag(tracing::attributes::op::collection_name, id.collection());
+              }
+
               if (node.is_replica) {
                 document_id replica_id{ id };
                 replica_id.node_index(node.index);
-                auto replica_req = impl::lookup_in_replica_request{
-                  std::move(replica_id), specs, timeout, parent_span
+                impl::with_cancellation<impl::lookup_in_replica_request> replica_req{
+                  {
+                    std::move(replica_id),
+                    specs,
+                    timeout,
+                    subop_span,
+                  },
                 };
+                ctx->add_cancellation_token(replica_req.cancel_token);
                 replica_req.access_deleted = access_deleted;
-                core->execute(replica_req, [ctx](auto&& resp) {
+                core->execute(replica_req, [ctx, subop_span](auto&& resp) {
+                  {
+                    if (subop_span->uses_tags()) {
+                      subop_span->add_tag(tracing::attributes::op::retry_count,
+                                          resp.ctx.retry_attempts());
+                    }
+                    subop_span->end();
+                  }
                   handler_type local_handler;
+                  std::vector<std::shared_ptr<impl::cancellation_token>> cancel_tokens;
                   {
                     std::scoped_lock lock(ctx->mutex_);
                     if (ctx->done_) {
@@ -172,6 +222,10 @@ struct lookup_in_any_replica_request {
                     }
                     ctx->done_ = true;
                     std::swap(local_handler, ctx->handler_);
+                    cancel_tokens = ctx->get_cancellation_tokens();
+                  }
+                  for (const auto& token : cancel_tokens) {
+                    token->cancel();
                   }
                   if (local_handler) {
                     response_type res{};
@@ -194,46 +248,70 @@ struct lookup_in_any_replica_request {
                   }
                 });
               } else {
-                core->execute(lookup_in_request{ id, {}, {}, false, specs, timeout },
-                              [ctx](auto&& resp) {
-                                handler_type local_handler{};
-                                {
-                                  std::scoped_lock lock(ctx->mutex_);
-                                  if (ctx->done_) {
-                                    return;
-                                  }
-                                  --ctx->expected_responses_;
-                                  if (resp.ctx.ec()) {
-                                    if (ctx->expected_responses_ > 0) {
-                                      // just ignore the response
-                                      return;
-                                    }
-                                    // consider document irretrievable and give up
-                                    resp.ctx.override_ec(errc::key_value::document_irretrievable);
-                                  }
-                                  ctx->done_ = true;
-                                  std::swap(local_handler, ctx->handler_);
-                                }
-                                if (local_handler) {
-                                  auto res = response_type{};
-                                  res.ctx = resp.ctx;
-                                  res.cas = resp.cas;
-                                  res.deleted = resp.deleted;
-                                  res.is_replica = false;
-                                  for (auto& field : resp.fields) {
-                                    auto lookup_in_entry = lookup_in_any_replica_response::entry{};
-                                    lookup_in_entry.path = field.path;
-                                    lookup_in_entry.value = field.value;
-                                    lookup_in_entry.status = field.status;
-                                    lookup_in_entry.ec = field.ec;
-                                    lookup_in_entry.exists = field.exists;
-                                    lookup_in_entry.original_index = field.original_index;
-                                    lookup_in_entry.opcode = field.opcode;
-                                    res.fields.emplace_back(lookup_in_entry);
-                                  }
-                                  return local_handler(res);
-                                }
-                              });
+                impl::with_cancellation<lookup_in_request> req{
+                  {
+                    id,
+                    {},
+                    {},
+                    false,
+                    specs,
+                    timeout,
+                    {},
+                    subop_span,
+                  },
+                };
+                ctx->add_cancellation_token(req.cancel_token);
+                core->execute(std::move(req), [subop_span, ctx](auto&& resp) {
+                  {
+                    if (subop_span->uses_tags()) {
+                      subop_span->add_tag(tracing::attributes::op::retry_count,
+                                          resp.ctx.retry_attempts());
+                    }
+                    subop_span->end();
+                  }
+                  handler_type local_handler{};
+                  std::vector<std::shared_ptr<impl::cancellation_token>> cancel_tokens;
+                  {
+                    std::scoped_lock lock(ctx->mutex_);
+                    if (ctx->done_) {
+                      return;
+                    }
+                    --ctx->expected_responses_;
+                    if (resp.ctx.ec()) {
+                      if (ctx->expected_responses_ > 0) {
+                        // just ignore the response
+                        return;
+                      }
+                      // consider document irretrievable and give up
+                      resp.ctx.override_ec(errc::key_value::document_irretrievable);
+                    }
+                    ctx->done_ = true;
+                    std::swap(local_handler, ctx->handler_);
+                    cancel_tokens = ctx->get_cancellation_tokens();
+                  }
+                  for (const auto& token : cancel_tokens) {
+                    token->cancel();
+                  }
+                  if (local_handler) {
+                    auto res = response_type{};
+                    res.ctx = resp.ctx;
+                    res.cas = resp.cas;
+                    res.deleted = resp.deleted;
+                    res.is_replica = false;
+                    for (auto& field : resp.fields) {
+                      auto lookup_in_entry = lookup_in_any_replica_response::entry{};
+                      lookup_in_entry.path = field.path;
+                      lookup_in_entry.value = field.value;
+                      lookup_in_entry.status = field.status;
+                      lookup_in_entry.ec = field.ec;
+                      lookup_in_entry.exists = field.exists;
+                      lookup_in_entry.original_index = field.original_index;
+                      lookup_in_entry.opcode = field.opcode;
+                      res.fields.emplace_back(lookup_in_entry);
+                    }
+                    return local_handler(res);
+                  }
+                });
               }
             }
           });

data/ext/couchbase/core/operations/document_mutate_in.hxx

@@ -95,9 +95,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::mutate_in_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::mutate_in_request>
-  : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_prepend.hxx

@@ -76,8 +76,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::prepend_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::prepend_request> : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_query.cxx

@@ -20,6 +20,7 @@
 #include "core/cluster_options.hxx"
 #include "core/logger/logger.hxx"
 #include "core/operations/management/error_utils.hxx"
+#include "core/utils/contains_string.hxx"
 #include "core/utils/duration_parser.hxx"
 #include "core/utils/json.hxx"
 
@@ -28,13 +29,11 @@
 #include <gsl/assert>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations
 {
 auto
-query_request::encode_to(query_request::encoded_request_type& encoded,
-                         http_context& context) -> std::error_code
+query_request::encode_to(query_request::encoded_request_type& encoded, http_context& context)
+  -> std::error_code
 {
   ctx_.emplace(context);
   tao::json::value body{
@@ -209,8 +208,8 @@ query_request::encode_to(query_request::encoded_request_type& encoded,
 }
 
 auto
-query_request::make_response(error_context::query&& ctx,
-                             const encoded_response_type& encoded) -> query_response
+query_request::make_response(error_context::query&& ctx, const encoded_response_type& encoded)
+  -> query_response
 {
   query_response response{ std::move(ctx) };
   response.ctx.statement = statement;
@@ -374,13 +373,14 @@ query_request::make_response(error_context::query&& ctx,
             response.ctx.ec = errc::common::index_exists;
             break;
           case 5000: /* IKey: "Internal Error" */
-            if (std::regex_search(response.ctx.first_error_message,
-                                  std::regex{ ".*[iI]ndex .*already exist.*" })) {
+            if (utils::contains_string(response.ctx.first_error_message, "index", true) &&
+                utils::contains_string(response.ctx.first_error_message, "already exist", true)) {
               response.ctx.ec = errc::common::index_exists;
-            } else if (response.ctx.first_error_message.find("Index does not exist") !=
-                         std::string::npos ||
-                       std::regex_search(response.ctx.first_error_message,
-                                         std::regex{ ".*[iI]ndex .*[nN]ot [fF]ound.*" })) {
+            } else if (utils::contains_string(response.ctx.first_error_message,
+                                              "Index does not exist") ||
+                       (utils::contains_string(response.ctx.first_error_message, "index", true) &&
+                        utils::contains_string(
+                          response.ctx.first_error_message, "not found", true))) {
               response.ctx.ec = errc::common::index_not_found;
             } else if (response.ctx.first_error_message.find("Bucket Not Found") !=
                        std::string::npos) {

data/ext/couchbase/core/operations/document_query.hxx

@@ -130,10 +130,6 @@ template<>
 struct supports_sticky_node<couchbase::core::operations::query_request> : public std::true_type {
 };
 
-template<>
-struct supports_parent_span<couchbase::core::operations::query_request> : public std::true_type {
-};
-
 template<>
 struct supports_readonly<couchbase::core::operations::query_request> : public std::true_type {
 };

data/ext/couchbase/core/operations/document_remove.hxx

@@ -75,8 +75,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::remove_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::remove_request> : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_replace.hxx

@@ -79,8 +79,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::replace_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::replace_request> : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_search.hxx

@@ -174,11 +174,4 @@ struct search_request {
 
   std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 };
-
 } // namespace couchbase::core::operations
-namespace couchbase::core::io::http_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::search_request> : public std::true_type {
-};
-} // namespace couchbase::core::io::http_traits

data/ext/couchbase/core/operations/document_touch.hxx

@@ -55,11 +55,4 @@ struct touch_request {
   [[nodiscard]] auto make_response(key_value_error_context&& ctx,
                                    const encoded_response_type& encoded) const -> touch_response;
 };
-
 } // namespace couchbase::core::operations
-namespace couchbase::core::io::mcbp_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::touch_request> : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_unlock.hxx

@@ -57,9 +57,3 @@ struct unlock_request {
 };
 
 } // namespace couchbase::core::operations
-namespace couchbase::core::io::mcbp_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::unlock_request> : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_upsert.hxx

@@ -78,8 +78,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::upsert_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::upsert_request> : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_view.cxx

@@ -15,7 +15,9 @@
  *   limitations under the License.
  */
 
+#define COUCHBASE_CXX_CLIENT_IGNORE_CORE_DEPRECATIONS
 #include "document_view.hxx"
+#undef COUCHBASE_CXX_CLIENT_IGNORE_CORE_DEPRECATIONS
 
 #include "core/utils/join_strings.hxx"
 #include "core/utils/json.hxx"

data/ext/couchbase/core/operations/document_view.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "core/deprecation_utils.hxx"
 #include "core/design_document_namespace.hxx"
 #include "core/error_context/view.hxx"
 #include "core/io/http_context.hxx"
@@ -54,7 +55,10 @@ struct document_view_response {
   std::optional<problem> error{};
 };
 
-struct document_view_request {
+struct COUCHBASE_DEPRECATED(
+  "1.3.0",
+  "Views are deprecated in Couchbase Server 7.0+. Instead of views, use the Query "
+  "Service (SQL++).") document_view_request {
   using response_type = document_view_response;
   using encoded_request_type = io::http_request;
   using encoded_response_type = io::http_response;
@@ -97,19 +101,12 @@ struct document_view_request {
   std::optional<std::chrono::milliseconds> timeout{};
   std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
-  [[nodiscard]] auto encode_to(encoded_request_type& encoded,
-                               http_context& context) -> std::error_code;
+  [[nodiscard]] auto encode_to(encoded_request_type& encoded, http_context& context)
+    -> std::error_code;
 
-  [[nodiscard]] auto make_response(error_context::view&& ctx, const encoded_response_type& encoded)
-    const -> document_view_response;
+  [[nodiscard]] auto make_response(error_context::view&& ctx,
+                                   const encoded_response_type& encoded) const
+    -> document_view_response;
 };
 
 } // namespace couchbase::core::operations
-
-namespace couchbase::core::io::http_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::document_view_request>
-  : public std::true_type {
-};
-} // namespace couchbase::core::io::http_traits

data/ext/couchbase/core/operations/http_noop.hxx

@@ -21,6 +21,7 @@
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
 #include "core/platform/uuid.h"
+#include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::operations
@@ -41,6 +42,7 @@ struct http_noop_request {
 
   std::optional<std::string> client_context_id{};
   std::optional<std::chrono::milliseconds> timeout{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
   [[nodiscard]] auto encode_to(encoded_request_type& encoded,
                                http_context& context) -> std::error_code;

data/ext/couchbase/core/operations/management/analytics_dataset_create.hxx

@@ -22,6 +22,7 @@
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
 #include "core/platform/uuid.h"
+#include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::operations::management
@@ -50,6 +51,7 @@ struct analytics_dataset_create_request {
   std::optional<std::chrono::milliseconds> timeout{};
 
   bool ignore_if_exists{ false };
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
   [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
                                           http_context& context) const;

data/ext/couchbase/core/operations/management/analytics_dataset_drop.hxx

@@ -22,6 +22,7 @@
 #include "core/io/http_context.hxx"
 #include "core/io/http_message.hxx"
 #include "core/platform/uuid.h"
+#include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::operations::management
@@ -47,6 +48,7 @@ struct analytics_dataset_drop_request {
   bool ignore_if_does_not_exist{ false };
   std::optional<std::string> client_context_id{};
   std::optional<std::chrono::milliseconds> timeout{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
   [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
                                           http_context& context) const;