couchbase 3.7.0 → 3.8.0

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

@@ -17,14 +17,17 @@
 
 #pragma once
 
+#include <couchbase/error_codes.hxx>
+
 #include "core/error_context/key_value.hxx"
 #include "core/impl/get_replica.hxx"
 #include "core/impl/replica_utils.hxx"
 #include "core/logger/logger.hxx"
 #include "core/operations/document_get.hxx"
 #include "core/operations/operation_traits.hxx"
+#include "core/public_fwd.hxx"
+#include "core/tracing/constants.hxx"
 #include "core/utils/movable_function.hxx"
-#include "couchbase/error_codes.hxx"
 
 #include <memory>
 #include <mutex>
@@ -54,6 +57,7 @@ struct get_all_replicas_request {
   core::document_id id;
   std::optional<std::chrono::milliseconds> timeout{};
   couchbase::read_preference read_preference{ couchbase::read_preference::no_preference };
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
   template<typename Core, typename Handler>
   void execute(Core core, Handler handler)
@@ -64,6 +68,7 @@ struct get_all_replicas_request {
        id = id,
        timeout = timeout,
        read_preference = read_preference,
+       parent_span = std::move(parent_span),
        h = std::forward<Handler>(handler)](
         std::error_code ec, std::shared_ptr<topology::configuration> config) mutable {
         if (ec) {
@@ -104,11 +109,40 @@ struct get_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_get_replica : tracing::operation::mcbp_get,
+            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_get_replica
+                                                : tracing::operation::mcbp_get);
+            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);
             core->execute(
-              impl::get_replica_request{ std::move(replica_id), timeout }, [ctx](auto&& resp) {
+              impl::get_replica_request{
+                std::move(replica_id),
+                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_);
@@ -139,36 +173,52 @@ struct get_all_replicas_request {
                 }
               });
           } else {
-            core->execute(get_request{ document_id{ id }, {}, {}, timeout }, [ctx](auto&& resp) {
-              handler_type local_handler{};
-              {
-                std::scoped_lock lock(ctx->mutex_);
-                if (ctx->done_) {
-                  return;
+            core->execute(
+              get_request{
+                document_id{ id },
+                {},
+                {},
+                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();
                 }
-                --ctx->expected_responses_;
-                if (resp.ctx.ec()) {
-                  if (ctx->expected_responses_ > 0) {
-                    // just ignore the response
+                handler_type local_handler{};
+                {
+                  std::scoped_lock lock(ctx->mutex_);
+                  if (ctx->done_) {
                     return;
                   }
-                } else {
-                  ctx->result_.emplace_back(get_all_replicas_response::entry{
-                    std::move(resp.value), resp.cas, resp.flags, false /* active */ });
-                }
-                if (ctx->expected_responses_ == 0) {
-                  ctx->done_ = true;
-                  std::swap(local_handler, ctx->handler_);
+                  --ctx->expected_responses_;
+                  if (resp.ctx.ec()) {
+                    if (ctx->expected_responses_ > 0) {
+                      // just ignore the response
+                      return;
+                    }
+                  } else {
+                    ctx->result_.emplace_back(get_all_replicas_response::entry{
+                      std::move(resp.value), resp.cas, resp.flags, false /* active */ });
+                  }
+                  if (ctx->expected_responses_ == 0) {
+                    ctx->done_ = true;
+                    std::swap(local_handler, ctx->handler_);
+                  }
                 }
-              }
-              if (local_handler) {
-                if (ctx->result_.empty()) {
-                  // Return an error only when we have no results from any replica.
-                  return local_handler({ std::move(resp.ctx), {} });
+                if (local_handler) {
+                  if (ctx->result_.empty()) {
+                    // Return an error only when we have no results from any replica.
+                    return local_handler({ std::move(resp.ctx), {} });
+                  }
+                  return local_handler({ {}, std::move(ctx->result_) });
                 }
-                return local_handler({ {}, std::move(ctx->result_) });
-              }
-            });
+              });
           }
         }
       });

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

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

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

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

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

@@ -20,6 +20,7 @@
 #include "core/error_context/key_value.hxx"
 #include "core/impl/get_replica.hxx"
 #include "core/impl/replica_utils.hxx"
+#include "core/impl/with_cancellation.hxx"
 #include "core/operations/document_get.hxx"
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
@@ -51,6 +52,7 @@ struct get_any_replica_request {
   core::document_id id;
   std::optional<std::chrono::milliseconds> timeout{};
   couchbase::read_preference read_preference{ couchbase::read_preference::no_preference };
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
   template<typename Core, typename Handler>
   void execute(Core core, Handler handler)
@@ -61,6 +63,7 @@ struct get_any_replica_request {
        id = id,
        timeout = timeout,
        read_preference = read_preference,
+       parent_span = std::move(parent_span),
        h = std::forward<Handler>(handler)](
         std::error_code ec, std::shared_ptr<topology::configuration> config) mutable {
         const auto [e, origin] = core->origin();
@@ -91,20 +94,71 @@ struct get_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_get_replica : tracing::operation::mcbp_get,
+            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_get_replica
+                                                : tracing::operation::mcbp_get);
+            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);
+            impl::with_cancellation<impl::get_replica_request> req{
+              {
+                std::move(replica_id),
+                timeout,
+                {},
+                {},
+                {},
+                subop_span,
+              },
+            };
+            ctx->add_cancellation_token(req.cancel_token);
             core->execute(
-              impl::get_replica_request{ std::move(replica_id), timeout }, [ctx](auto&& resp) {
+              std::move(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_) {
@@ -121,6 +175,10 @@ struct get_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) {
                   return local_handler(response_type{
@@ -128,8 +186,27 @@ struct get_any_replica_request {
                 }
               });
           } else {
-            core->execute(get_request{ id, {}, {}, timeout }, [ctx](auto&& resp) {
+            impl::with_cancellation<get_request> req{
+              {
+                id,
+                {},
+                {},
+                timeout,
+                {},
+                subop_span,
+              },
+            };
+            ctx->add_cancellation_token(req.cancel_token);
+            core->execute(std::move(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_) {
@@ -146,6 +223,10 @@ struct get_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) {
                 return local_handler(response_type{

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,6 +23,7 @@
 #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>
@@ -152,14 +153,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_);
@@ -206,8 +232,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_);

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);
+                  }
+                });
               }
             }
           });