grpc 1.64.3 → 1.65.0

data/src/core/server/server.h

@@ -38,14 +38,15 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/compression.h>
 #include <grpc/grpc.h>
+#include <grpc/passive_listener.h>
 #include <grpc/slice.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/channelz/channelz.h"
 #include "src/core/lib/backoff/random_early_detection.h"
-#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -68,14 +69,16 @@
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server_interface.h"
+#include "src/core/telemetry/call_tracer.h"
 
 #define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS "grpc.server.max_pending_requests"
 #define GRPC_ARG_SERVER_MAX_PENDING_REQUESTS_HARD_LIMIT \
   "grpc.server.max_pending_requests_hard_limit"
 
 namespace grpc_core {
-
-extern TraceFlag grpc_server_channel_trace;
+namespace experimental {
+class PassiveListenerImpl;
+}  // namespace experimental
 
 class Server : public ServerInterface,
                public InternallyRefCounted<Server>,
@@ -112,7 +115,7 @@ class Server : public ServerInterface,
   /// Interface for listeners.
   /// Implementations must override the Orphan() method, which should stop
   /// listening and initiate destruction of the listener.
-  class ListenerInterface : public Orphanable {
+  class ListenerInterface : public InternallyRefCounted<ListenerInterface> {
    public:
     ~ListenerInterface() override = default;
 
@@ -211,56 +214,57 @@ class Server : public ServerInterface,
 
   void SendGoaways() ABSL_LOCKS_EXCLUDED(mu_global_, mu_call_);
 
+  grpc_compression_options compression_options() const override {
+    return compression_options_;
+  }
+
  private:
+  // note: the grpc_core::Server redundant namespace qualification is
+  // required for older gcc versions.
+  // TODO(yashykt): eliminate this friend statement as part of your upcoming
+  // server listener refactoring.
+  friend absl::Status(::grpc_server_add_passive_listener)(
+      grpc_core::Server* server, grpc_server_credentials* credentials,
+      std::shared_ptr<grpc_core::experimental::PassiveListenerImpl>
+          passive_listener);
   struct RequestedCall;
 
   class RequestMatcherInterface;
-  class RealRequestMatcherFilterStack;
-  class RealRequestMatcherPromises;
+  class RealRequestMatcher;
   class AllocatingRequestMatcherBase;
   class AllocatingRequestMatcherBatch;
   class AllocatingRequestMatcherRegistered;
 
-  class ChannelData final : public ServerTransport::Acceptor {
+  class ChannelData final {
    public:
     ChannelData() = default;
     ~ChannelData();
 
     void InitTransport(RefCountedPtr<Server> server,
-                       OrphanablePtr<Channel> channel, size_t cq_idx,
+                       RefCountedPtr<Channel> channel, size_t cq_idx,
                        Transport* transport, intptr_t channelz_socket_uuid);
 
     RefCountedPtr<Server> server() const { return server_; }
     Channel* channel() const { return channel_.get(); }
     size_t cq_idx() const { return cq_idx_; }
 
-    RegisteredMethod* GetRegisteredMethod(const absl::string_view& host,
-                                          const absl::string_view& path);
     // Filter vtable functions.
     static grpc_error_handle InitChannelElement(
         grpc_channel_element* elem, grpc_channel_element_args* args);
     static void DestroyChannelElement(grpc_channel_element* elem);
-    static ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-        grpc_channel_element* elem, CallArgs call_args, NextPromiseFactory);
-    void InitCall(RefCountedPtr<CallSpineInterface> call);
-
-    Arena* CreateArena() override;
-    absl::StatusOr<CallInitiator> CreateCall(
-        ClientMetadataHandle client_initial_metadata, Arena* arena) override;
 
    private:
     class ConnectivityWatcher;
 
     static void AcceptStream(void* arg, Transport* /*transport*/,
                              const void* transport_server_data);
-    void SetRegisteredMethodOnMetadata(ClientMetadata& metadata);
 
     void Destroy() ABSL_EXCLUSIVE_LOCKS_REQUIRED(server_->mu_global_);
 
     static void FinishDestroy(void* arg, grpc_error_handle error);
 
     RefCountedPtr<Server> server_;
-    OrphanablePtr<Channel> channel_;
+    RefCountedPtr<Channel> channel_;
     // The index into Server::cqs_ of the CQ used as a starting point for
     // where to publish new incoming calls.
     size_t cq_idx_;
@@ -384,6 +388,12 @@ class Server : public ServerInterface,
     using is_transparent = void;
   };
 
+  class TransportConnectivityWatcher;
+
+  RegisteredMethod* GetRegisteredMethod(const absl::string_view& host,
+                                        const absl::string_view& path);
+  void SetRegisteredMethodOnMetadata(ClientMetadata& metadata);
+
   static void ListenerDestroyDone(void* arg, grpc_error_handle error);
 
   static void DoneShutdownEvent(void* server,
@@ -445,6 +455,10 @@ class Server : public ServerInterface,
     return shutdown_refs_.load(std::memory_order_acquire) == 0;
   }
 
+  auto MatchAndPublishCall(CallHandler call_handler);
+  absl::StatusOr<RefCountedPtr<UnstartedCallDestination>> MakeCallDestination(
+      const ChannelArgs& args);
+
   ChannelArgs const channel_args_;
   RefCountedPtr<channelz::ServerNode> channelz_node_;
   std::unique_ptr<grpc_server_config_fetcher> config_fetcher_;
@@ -453,6 +467,7 @@ class Server : public ServerInterface,
   std::vector<grpc_completion_queue*> cqs_;
   std::vector<grpc_pollset*> pollsets_;
   bool started_ = false;
+  const grpc_compression_options compression_options_;
 
   // The two following mutexes control access to server-state.
   // mu_global_ controls access to non-call-related state (e.g., channel state).
@@ -500,6 +515,9 @@ class Server : public ServerInterface,
   absl::BitGen bitgen_ ABSL_GUARDED_BY(mu_call_);
 
   std::list<ChannelData*> channels_;
+  absl::flat_hash_set<OrphanablePtr<ServerTransport>> connections_
+      ABSL_GUARDED_BY(mu_global_);
+  size_t connections_open_ ABSL_GUARDED_BY(mu_global_) = 0;
 
   std::list<Listener> listeners_;
   size_t listeners_destroyed_ = 0;

data/src/core/server/server_call_tracer_filter.cc

@@ -26,11 +26,9 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/call_finalization.h"
-#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/promise/arena_promise.h"
@@ -40,6 +38,7 @@
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/call_tracer.h"
 
 namespace grpc_core {
 
@@ -56,42 +55,37 @@ class ServerCallTracerFilter
   class Call {
    public:
     void OnClientInitialMetadata(ClientMetadata& client_initial_metadata) {
-      auto* call_tracer = CallTracer();
+      auto* call_tracer = MaybeGetContext<ServerCallTracer>();
       if (call_tracer == nullptr) return;
       call_tracer->RecordReceivedInitialMetadata(&client_initial_metadata);
     }
 
     void OnServerInitialMetadata(ServerMetadata& server_initial_metadata) {
-      auto* call_tracer = CallTracer();
+      auto* call_tracer = MaybeGetContext<ServerCallTracer>();
       if (call_tracer == nullptr) return;
       call_tracer->RecordSendInitialMetadata(&server_initial_metadata);
     }
 
     void OnFinalize(const grpc_call_final_info* final_info) {
-      auto* call_tracer = CallTracer();
+      auto* call_tracer = MaybeGetContext<ServerCallTracer>();
       if (call_tracer == nullptr) return;
       call_tracer->RecordEnd(final_info);
     }
 
     void OnServerTrailingMetadata(ServerMetadata& server_trailing_metadata) {
-      auto* call_tracer = CallTracer();
+      auto* call_tracer = MaybeGetContext<ServerCallTracer>();
       if (call_tracer == nullptr) return;
       call_tracer->RecordSendTrailingMetadata(&server_trailing_metadata);
     }
 
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
-
-   private:
-    static ServerCallTracer* CallTracer() {
-      auto* call_context = GetContext<grpc_call_context_element>();
-      return static_cast<ServerCallTracer*>(
-          call_context[GRPC_CONTEXT_CALL_TRACER].value);
-    }
   };
 };
 
 const NoInterceptor ServerCallTracerFilter::Call::OnClientToServerMessage;
+const NoInterceptor ServerCallTracerFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor ServerCallTracerFilter::Call::OnServerToClientMessage;
 
 const grpc_channel_filter ServerCallTracerFilter::kFilter =
@@ -108,7 +102,6 @@ ServerCallTracerFilter::Create(const ChannelArgs& /*args*/,
 }  // namespace
 
 void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder) {
-  if (IsChaoticGoodEnabled()) return;
   builder->channel_init()->RegisterFilter<ServerCallTracerFilter>(
       GRPC_SERVER_CHANNEL);
 }

data/src/core/server/server_config_selector.h

@@ -24,13 +24,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_parser.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 

data/src/core/server/server_config_selector_filter.cc

@@ -28,7 +28,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -72,6 +71,7 @@ class ServerConfigSelectorFilter final
     static const NoInterceptor OnServerInitialMetadata;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };
@@ -148,8 +148,7 @@ absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
     return absl::UnavailableError(StatusToString(call_config.status()));
   }
   auto* service_config_call_data =
-      GetContext<Arena>()->New<ServiceConfigCallData>(
-          GetContext<Arena>(), GetContext<grpc_call_context_element>());
+      GetContext<Arena>()->New<ServiceConfigCallData>(GetContext<Arena>());
   service_config_call_data->SetServiceConfig(
       std::move(call_config->service_config), call_config->method_configs);
   return absl::OkStatus();
@@ -158,6 +157,7 @@ absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
 const NoInterceptor ServerConfigSelectorFilter::Call::OnServerInitialMetadata;
 const NoInterceptor ServerConfigSelectorFilter::Call::OnServerTrailingMetadata;
 const NoInterceptor ServerConfigSelectorFilter::Call::OnClientToServerMessage;
+const NoInterceptor ServerConfigSelectorFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor ServerConfigSelectorFilter::Call::OnServerToClientMessage;
 const NoInterceptor ServerConfigSelectorFilter::Call::OnFinalize;
 

data/src/core/server/server_interface.h

@@ -17,6 +17,7 @@
 #ifndef GRPC_SRC_CORE_SERVER_SERVER_INTERFACE_H
 #define GRPC_SRC_CORE_SERVER_SERVER_INTERFACE_H
 
+#include <grpc/impl/compression_types.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/channelz/channelz.h"
@@ -36,6 +37,7 @@ class ServerInterface {
   virtual const ChannelArgs& channel_args() const = 0;
   virtual channelz::ServerNode* channelz_node() const = 0;
   virtual ServerCallTracerFactory* server_call_tracer_factory() const = 0;
+  virtual grpc_compression_options compression_options() const = 0;
 };
 
 }  // namespace grpc_core

data/src/core/server/xds_channel_stack_modifier.cc

@@ -27,9 +27,9 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 namespace {

data/src/core/server/xds_channel_stack_modifier.h

@@ -29,9 +29,9 @@
 
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_core {
 

data/src/core/server/xds_server_config_fetcher.cc

@@ -95,9 +95,6 @@ namespace {
 
 using ReadDelayHandle = XdsClient::ReadDelayHandle;
 
-TraceFlag grpc_xds_server_config_fetcher_trace(false,
-                                               "xds_server_config_fetcher");
-
 // A server config fetcher that fetches the information for configuring server
 // listeners from the xDS control plane.
 class XdsServerConfigFetcher final : public grpc_server_config_fetcher {
@@ -587,7 +584,7 @@ XdsServerConfigFetcher::ListenerWatcher::ListenerWatcher(
 void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
     std::shared_ptr<const XdsListenerResource> listener,
     RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_server_config_fetcher_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_server_config_fetcher)) {
     gpr_log(GPR_INFO,
             "[ListenerWatcher %p] Received LDS update from xds client %p: %s",
             this, xds_client_.get(), listener->ToString().c_str());

data/src/core/service_config/service_config.h

@@ -24,9 +24,9 @@
 #include <grpc/slice.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/service_config/service_config_parser.h"
+#include "src/core/util/useful.h"
 
 // The main purpose of the code here is to parse the service config in
 // JSON form, which will look like this:

data/src/core/service_config/service_config_call_data.h

@@ -24,7 +24,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/chunked_vector.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
@@ -49,11 +48,7 @@ class ServiceConfigCallData {
     virtual UniqueTypeName type() const = 0;
   };
 
-  ServiceConfigCallData(Arena* arena, grpc_call_context_element* call_context)
-      : call_attributes_(arena) {
-    call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = this;
-    call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].destroy = Destroy;
-  }
+  explicit ServiceConfigCallData(Arena* arena);
 
   virtual ~ServiceConfigCallData() = default;
 
@@ -101,16 +96,23 @@ class ServiceConfigCallData {
   }
 
  private:
-  static void Destroy(void* ptr) {
-    auto* self = static_cast<ServiceConfigCallData*>(ptr);
-    self->~ServiceConfigCallData();
-  }
-
   RefCountedPtr<ServiceConfig> service_config_;
   const ServiceConfigParser::ParsedConfigVector* method_configs_ = nullptr;
   ChunkedVector<CallAttributeInterface*, 4> call_attributes_;
 };
 
+template <>
+struct ArenaContextType<ServiceConfigCallData> {
+  static void Destroy(ServiceConfigCallData* ptr) {
+    ptr->~ServiceConfigCallData();
+  }
+};
+
+inline ServiceConfigCallData::ServiceConfigCallData(Arena* arena)
+    : call_attributes_(arena) {
+  arena->SetContext<ServiceConfigCallData>(this);
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H

data/src/core/service_config/service_config_channel_arg_filter.cc

@@ -22,6 +22,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
@@ -34,7 +35,6 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -69,7 +69,7 @@ class ServiceConfigChannelArgFilter final
       auto service_config =
           ServiceConfigImpl::Create(args, *service_config_str);
       if (!service_config.ok()) {
-        gpr_log(GPR_ERROR, "%s", service_config.status().ToString().c_str());
+        LOG(ERROR) << service_config.status().ToString();
       } else {
         service_config_ = std::move(*service_config);
       }
@@ -83,6 +83,7 @@ class ServiceConfigChannelArgFilter final
     static const NoInterceptor OnServerInitialMetadata;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };
@@ -97,6 +98,8 @@ const NoInterceptor
     ServiceConfigChannelArgFilter::Call::OnServerTrailingMetadata;
 const NoInterceptor
     ServiceConfigChannelArgFilter::Call::OnClientToServerMessage;
+const NoInterceptor
+    ServiceConfigChannelArgFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor
     ServiceConfigChannelArgFilter::Call::OnServerToClientMessage;
 const NoInterceptor ServiceConfigChannelArgFilter::Call::OnFinalize;
@@ -109,8 +112,7 @@ void ServiceConfigChannelArgFilter::Call::OnClientInitialMetadata(
         md.get_pointer(HttpPathMetadata())->c_slice());
   }
   auto* arena = GetContext<Arena>();
-  auto* service_config_call_data = arena->New<ServiceConfigCallData>(
-      arena, GetContext<grpc_call_context_element>());
+  auto* service_config_call_data = arena->New<ServiceConfigCallData>(arena);
   service_config_call_data->SetServiceConfig(filter->service_config_,
                                              method_configs);
 }

data/src/core/service_config/service_config_impl.cc

@@ -31,14 +31,14 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_args.h"
-#include "src/core/lib/json/json_object_loader.h"
-#include "src/core/lib/json/json_reader.h"
-#include "src/core/lib/json/json_writer.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/service_config/service_config_parser.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
+#include "src/core/util/json/json_reader.h"
+#include "src/core/util/json/json_writer.h"
 
 namespace grpc_core {
 

data/src/core/service_config/service_config_impl.h

@@ -35,10 +35,10 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/json/json.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_parser.h"
+#include "src/core/util/json/json.h"
 
 // The main purpose of the code here is to parse the service config in
 // JSON form, which will look like this:

data/src/core/service_config/service_config_parser.cc

@@ -20,9 +20,8 @@
 
 #include <string>
 
-#include "absl/strings/str_cat.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {
@@ -35,10 +34,8 @@ void ServiceConfigParser::Builder::RegisterParser(
     std::unique_ptr<Parser> parser) {
   for (const auto& registered_parser : registered_parsers_) {
     if (registered_parser->name() == parser->name()) {
-      gpr_log(GPR_ERROR, "%s",
-              absl::StrCat("Parser with name '", parser->name(),
-                           "' already registered")
-                  .c_str());
+      LOG(ERROR) << "Parser with name '" << parser->name()
+                 << "' already registered";
       // We'll otherwise crash later.
       abort();
     }

data/src/core/service_config/service_config_parser.h

@@ -30,7 +30,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/json/json.h"
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 

data/src/core/{lib/channel → telemetry}/call_tracer.cc

@@ -16,7 +16,7 @@
 //
 //
 
-#include "src/core/lib/channel/call_tracer.h"
+#include "src/core/telemetry/call_tracer.h"
 
 #include <memory>
 #include <utility>
@@ -27,8 +27,8 @@
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/tcp_tracer.h"
 #include "src/core/lib/promise/context.h"
+#include "src/core/telemetry/tcp_tracer.h"
 
 namespace grpc_core {
 
@@ -299,63 +299,53 @@ class DelegatingServerCallTracer : public ServerCallTracer {
   std::vector<ServerCallTracer*> tracers_;
 };
 
-void AddClientCallTracerToContext(grpc_call_context_element* call_context,
-                                  ClientCallTracer* tracer) {
-  if (call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value ==
-      nullptr) {
+void AddClientCallTracerToContext(Arena* arena, ClientCallTracer* tracer) {
+  if (arena->GetContext<CallTracerAnnotationInterface>() == nullptr) {
     // This is the first call tracer. Set it directly.
-    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value = tracer;
-    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].destroy =
-        nullptr;
+    arena->SetContext<CallTracerAnnotationInterface>(tracer);
   } else {
     // There was already a call tracer present.
-    auto* orig_tracer = static_cast<ClientCallTracer*>(
-        call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
+    auto* orig_tracer = DownCast<ClientCallTracer*>(
+        arena->GetContext<CallTracerAnnotationInterface>());
     if (orig_tracer->IsDelegatingTracer()) {
       // We already created a delegating tracer. Just add the new tracer to the
       // list.
-      static_cast<DelegatingClientCallTracer*>(orig_tracer)->AddTracer(tracer);
+      DownCast<DelegatingClientCallTracer*>(orig_tracer)->AddTracer(tracer);
     } else {
       // Create a new delegating tracer and add the first tracer and the new
       // tracer to the list.
       auto* delegating_tracer =
           GetContext<Arena>()->ManagedNew<DelegatingClientCallTracer>(
               orig_tracer);
-      call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value =
-          delegating_tracer;
+      arena->SetContext<CallTracerAnnotationInterface>(delegating_tracer);
       delegating_tracer->AddTracer(tracer);
     }
   }
 }
 
-void AddServerCallTracerToContext(grpc_call_context_element* call_context,
-                                  ServerCallTracer* tracer) {
-  DCHECK(call_context[GRPC_CONTEXT_CALL_TRACER].value ==
-         call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
-  if (call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value ==
-      nullptr) {
+void AddServerCallTracerToContext(Arena* arena, ServerCallTracer* tracer) {
+  DCHECK_EQ(arena->GetContext<CallTracerInterface>(),
+            arena->GetContext<CallTracerAnnotationInterface>());
+  if (arena->GetContext<CallTracerAnnotationInterface>() == nullptr) {
     // This is the first call tracer. Set it directly.
-    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value = tracer;
-    call_context[GRPC_CONTEXT_CALL_TRACER].value = tracer;
-    call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].destroy =
-        nullptr;
+    arena->SetContext<CallTracerAnnotationInterface>(tracer);
+    arena->SetContext<CallTracerInterface>(tracer);
   } else {
     // There was already a call tracer present.
-    auto* orig_tracer = static_cast<ServerCallTracer*>(
-        call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value);
+    auto* orig_tracer = DownCast<ServerCallTracer*>(
+        arena->GetContext<CallTracerAnnotationInterface>());
     if (orig_tracer->IsDelegatingTracer()) {
       // We already created a delegating tracer. Just add the new tracer to the
       // list.
-      static_cast<DelegatingServerCallTracer*>(orig_tracer)->AddTracer(tracer);
+      DownCast<DelegatingServerCallTracer*>(orig_tracer)->AddTracer(tracer);
     } else {
       // Create a new delegating tracer and add the first tracer and the new
       // tracer to the list.
       auto* delegating_tracer =
           GetContext<Arena>()->ManagedNew<DelegatingServerCallTracer>(
               orig_tracer);
-      call_context[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE].value =
-          delegating_tracer;
-      call_context[GRPC_CONTEXT_CALL_TRACER].value = delegating_tracer;
+      arena->SetContext<CallTracerAnnotationInterface>(delegating_tracer);
+      arena->SetContext<CallTracerInterface>(delegating_tracer);
       delegating_tracer->AddTracer(tracer);
     }
   }