grpc 1.73.0 → 1.75.0

data/src/core/server/xds_server_config_fetcher.cc

@@ -70,6 +70,7 @@
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_impl.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/match.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -210,6 +211,9 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
   absl::StatusOr<ChannelArgs> UpdateChannelArgsForConnection(
       const ChannelArgs& args, grpc_endpoint* tcp) override;
 
+  void UpdateBlackboard(const Blackboard* old_blackboard,
+                        Blackboard* new_blackboard) override;
+
   // Invoked by ListenerWatcher to start fetching referenced RDS resources.
   void StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ListenerWatcher::mu_);
@@ -248,6 +252,10 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
           route_config);
   void OnAmbientError(const std::string& resource_name, absl::Status status);
 
+  // Executes cb once for each unique filter chain object in the LDS resource.
+  void ForEachFilterChain(
+      absl::FunctionRef<void(XdsListenerResource::FilterChainData&)> cb);
+
   RefCountedPtr<GrpcXdsClient> xds_client_;
   // This ref is only kept around till the FilterChainMatchManager becomes
   // ready.
@@ -402,7 +410,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       return static_resource_.status();
     }
     return XdsServerConfigSelector::Create(
-        static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
             .http_filter_registry(),
         static_resource_.value(), http_filters_);
   }
@@ -529,7 +537,7 @@ void XdsServerConfigFetcher::StartWatch(
   XdsListenerResourceType::StartWatch(
       xds_client_.get(),
       ListenerResourceName(
-          static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+          DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
               .server_listener_resource_name_template(),
           listening_address),
       std::move(listener_watcher));
@@ -546,7 +554,7 @@ void XdsServerConfigFetcher::CancelWatch(
     XdsListenerResourceType::CancelWatch(
         xds_client_.get(),
         ListenerResourceName(
-            static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+            DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
                 .server_listener_resource_name_template(),
             it->second->listening_address()),
         it->second, false /* delay_unsubscription */);
@@ -685,37 +693,47 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       default_filter_chain_(std::move(default_filter_chain)) {}
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher) {
-  // Get the set of RDS resources to watch on. Also get the set of
-  // FilterChainData so that we can reverse the list of HTTP filters since
-  // received data moves *up* the stack in Core.
-  std::set<std::string> resource_names;
+    ForEachFilterChain(
+        absl::FunctionRef<void(XdsListenerResource::FilterChainData&)> cb) {
+  // A given FilterChainData object may appear more than once in the map,
+  // but we want to invoke the callback exactly once for each
+  // FilterChainData object.  Therefore, we start by constructing a set
+  // of all FilterChainData objects by address, to weed out duplicates.
   std::set<XdsListenerResource::FilterChainData*> filter_chain_data_set;
   for (const auto& destination_ip : filter_chain_map_.destination_ip_vector) {
     for (const auto& source_type : destination_ip.source_types_array) {
       for (const auto& source_ip : source_type) {
         for (const auto& source_port_pair : source_ip.ports_map) {
           auto* filter_chain_data = source_port_pair.second.data.get();
-          const auto* rds_name = std::get_if<std::string>(
-              &filter_chain_data->http_connection_manager.route_config);
-          if (rds_name != nullptr) resource_names.insert(*rds_name);
           filter_chain_data_set.insert(filter_chain_data);
         }
       }
     }
   }
-  if (default_filter_chain_.has_value()) {
-    auto& hcm = default_filter_chain_->http_connection_manager;
-    const auto* rds_name = std::get_if<std::string>(&hcm.route_config);
-    if (rds_name != nullptr) resource_names.insert(*rds_name);
-    std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
-  }
-  // Reverse the lists of HTTP filters in all the filter chains
+  // Invoke the callback once for each FilterChainData object.
   for (auto* filter_chain_data : filter_chain_data_set) {
-    auto& hcm = filter_chain_data->http_connection_manager;
-    std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
+    cb(*filter_chain_data);
   }
-  // Start watching on referenced RDS resources
+  // Also invoke the callback for the default filter chain, if present.
+  if (default_filter_chain_.has_value()) {
+    cb(*default_filter_chain_);
+  }
+}
+
+void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
+    StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher) {
+  // Get the set of RDS resources to watch on. Also reverse the list of
+  // HTTP filters in each filter chain, since received data moves *up*
+  // the stack on the server side.
+  std::set<std::string> resource_names;
+  ForEachFilterChain(
+      [&](XdsListenerResource::FilterChainData& filter_chain_data) {
+        auto& hcm = filter_chain_data.http_connection_manager;
+        const auto* rds_name = std::get_if<std::string>(&hcm.route_config);
+        if (rds_name != nullptr) resource_names.insert(*rds_name);
+        std::reverse(hcm.http_filters.begin(), hcm.http_filters.end());
+      });
+  // Start watching referenced RDS resources.
   struct WatcherToStart {
     std::string resource_name;
     RefCountedPtr<RouteConfigWatcher> watcher;
@@ -1026,7 +1044,7 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
   // flows *up* the stack.
   std::vector<const grpc_channel_filter*> filters;
   const auto& http_filter_registry =
-      static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
           .http_filter_registry();
   for (const auto& http_filter :
        filter_chain->http_connection_manager.http_filters) {
@@ -1090,6 +1108,26 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
   return args;
 }
 
+void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
+    UpdateBlackboard(const Blackboard* old_blackboard,
+                     Blackboard* new_blackboard) {
+  const auto& http_filter_registry =
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+          .http_filter_registry();
+  ForEachFilterChain(
+      [&](XdsListenerResource::FilterChainData& filter_chain_data) {
+        auto& hcm = filter_chain_data.http_connection_manager;
+        for (const auto& http_filter : hcm.http_filters) {
+          const XdsHttpFilterImpl* filter_impl =
+              http_filter_registry.GetFilterForType(
+                  http_filter.config.config_proto_type_name);
+          CHECK_NE(filter_impl, nullptr);  // Enforced in config validation.
+          filter_impl->UpdateBlackboard(http_filter.config, old_blackboard,
+                                        new_blackboard);
+        }
+      });
+}
+
 //
 // XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::XdsServerConfigSelector
 //
@@ -1237,7 +1275,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     return resource.status();
   }
   return XdsServerConfigSelector::Create(
-      static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
           .http_filter_registry(),
       resource.value(), http_filters_);
 }
@@ -1269,7 +1307,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     watcher_->OnServerConfigSelectorUpdate(resource_.status());
   } else {
     watcher_->OnServerConfigSelectorUpdate(XdsServerConfigSelector::Create(
-        static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
             .http_filter_registry(),
         *resource_, http_filters_));
   }
@@ -1304,7 +1342,7 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
     LOG(ERROR) << "Failed to create xds client: " << xds_client.status();
     return nullptr;
   }
-  if (static_cast<const grpc_core::GrpcXdsBootstrap&>(
+  if (grpc_core::DownCast<const grpc_core::GrpcXdsBootstrap&>(
           (*xds_client)->bootstrap())
           .server_listener_resource_name_template()
           .empty()) {

data/src/core/service_config/service_config.h

@@ -72,7 +72,7 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
   /// lifetime of the returned object is tied to the lifetime of the
   /// ServiceConfig object.
   virtual ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(
-      size_t index) = 0;
+      size_t index) const = 0;
 
   /// Retrieves the vector of parsed configs for the method identified
   /// by \a path.  The lifetime of the returned vector and contained objects

data/src/core/service_config/service_config_channel_arg_filter.cc

@@ -17,85 +17,30 @@
 // This filter reads GRPC_ARG_SERVICE_CONFIG and populates ServiceConfigCallData
 // in the call context per call for direct channels.
 
+#include "src/core/service_config/service_config_channel_arg_filter.h"
+
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/port_platform.h>
 
-#include <functional>
-#include <memory>
-#include <optional>
-#include <string>
-#include <utility>
-
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/ext/filters/message_size/message_size_filter.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/promise_based_filter.h"
-#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/transport.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_call_data.h"
-#include "src/core/service_config/service_config_impl.h"
 #include "src/core/service_config/service_config_parser.h"
 #include "src/core/util/latent_see.h"
 #include "src/core/util/ref_counted_ptr.h"
 
 namespace grpc_core {
 
-namespace {
-
-class ServiceConfigChannelArgFilter final
-    : public ImplementChannelFilter<ServiceConfigChannelArgFilter> {
- public:
-  static const grpc_channel_filter kFilter;
-
-  static absl::string_view TypeName() { return "service_config_channel_arg"; }
-
-  static absl::StatusOr<std::unique_ptr<ServiceConfigChannelArgFilter>> Create(
-      const ChannelArgs& args, ChannelFilter::Args) {
-    return std::make_unique<ServiceConfigChannelArgFilter>(args);
-  }
-
-  explicit ServiceConfigChannelArgFilter(const ChannelArgs& args) {
-    auto service_config_str = args.GetOwnedString(GRPC_ARG_SERVICE_CONFIG);
-    if (service_config_str.has_value()) {
-      auto service_config =
-          ServiceConfigImpl::Create(args, *service_config_str);
-      if (!service_config.ok()) {
-        LOG(ERROR) << service_config.status().ToString();
-      } else {
-        service_config_ = std::move(*service_config);
-      }
-    }
-  }
-
-  class Call {
-   public:
-    void OnClientInitialMetadata(ClientMetadata& md,
-                                 ServiceConfigChannelArgFilter* filter);
-    static inline const NoInterceptor OnServerInitialMetadata;
-    static inline const NoInterceptor OnServerTrailingMetadata;
-    static inline const NoInterceptor OnClientToServerMessage;
-    static inline const NoInterceptor OnClientToServerHalfClose;
-    static inline const NoInterceptor OnServerToClientMessage;
-    static inline const NoInterceptor OnFinalize;
-  };
-
- private:
-  RefCountedPtr<ServiceConfig> service_config_;
-};
-
 void ServiceConfigChannelArgFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, ServiceConfigChannelArgFilter* filter) {
-  GRPC_LATENT_SEE_INNER_SCOPE(
+  GRPC_LATENT_SEE_SCOPE(
       "ServiceConfigChannelArgFilter::Call::OnClientInitialMetadata");
   const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
   if (filter->service_config_ != nullptr) {
@@ -112,8 +57,6 @@ const grpc_channel_filter ServiceConfigChannelArgFilter::kFilter =
     MakePromiseBasedFilter<ServiceConfigChannelArgFilter,
                            FilterEndpoint::kClient>();
 
-}  // namespace
-
 void RegisterServiceConfigChannelArgFilter(
     CoreConfiguration::Builder* builder) {
   builder->channel_init()

data/src/core/service_config/service_config_channel_arg_filter.h

@@ -0,0 +1,82 @@
+//
+// Copyright 2020 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// This filter reads GRPC_ARG_SERVICE_CONFIG and populates ServiceConfigCallData
+// in the call context per call for direct channels.
+
+#ifndef GRPC_SRC_CORE_SERVICE_CONFIG_SERVICE_CONFIG_CHANNEL_ARG_FILTER_H
+#define GRPC_SRC_CORE_SERVICE_CONFIG_SERVICE_CONFIG_CHANNEL_ARG_FILTER_H
+
+#include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
+#include <stddef.h>
+
+#include <memory>
+
+#include "absl/status/statusor.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/service_config/service_config.h"
+#include "src/core/service_config/service_config_impl.h"
+#include "src/core/util/ref_counted_ptr.h"
+
+namespace grpc_core {
+
+class ServiceConfigChannelArgFilter final
+    : public ImplementChannelFilter<ServiceConfigChannelArgFilter> {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::string_view TypeName() { return "service_config_channel_arg"; }
+
+  static absl::StatusOr<std::unique_ptr<ServiceConfigChannelArgFilter>> Create(
+      const ChannelArgs& args, ChannelFilter::Args) {
+    return std::make_unique<ServiceConfigChannelArgFilter>(args);
+  }
+
+  explicit ServiceConfigChannelArgFilter(const ChannelArgs& args) {
+    auto service_config_str = args.GetOwnedString(GRPC_ARG_SERVICE_CONFIG);
+    if (service_config_str.has_value()) {
+      auto service_config =
+          ServiceConfigImpl::Create(args, *service_config_str);
+      if (!service_config.ok()) {
+        LOG(ERROR) << service_config.status().ToString();
+      } else {
+        service_config_ = std::move(*service_config);
+      }
+    }
+  }
+
+  class Call {
+   public:
+    void OnClientInitialMetadata(ClientMetadata& md,
+                                 ServiceConfigChannelArgFilter* filter);
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
+  };
+
+ private:
+  RefCountedPtr<ServiceConfig> service_config_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_SERVICE_CONFIG_SERVICE_CONFIG_CHANNEL_ARG_FILTER_H

data/src/core/service_config/service_config_impl.h

@@ -86,7 +86,7 @@ class ServiceConfigImpl final : public ServiceConfig {
   /// lifetime of the returned object is tied to the lifetime of the
   /// ServiceConfig object.
   ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(
-      size_t index) override {
+      size_t index) const override {
     DCHECK(index < parsed_global_configs_.size());
     return parsed_global_configs_[index].get();
   }

data/src/core/telemetry/call_tracer.cc

@@ -78,10 +78,10 @@ absl::string_view ServerCallTracerFactory::ChannelArgName() {
   return kServerCallTracerFactoryChannelArgName;
 }
 
-class DelegatingClientCallTracer : public ClientCallTracer {
+class DelegatingClientCallTracer : public ClientCallTracerInterface {
  public:
   class DelegatingClientCallAttemptTracer
-      : public ClientCallTracer::CallAttemptTracer {
+      : public ClientCallTracerInterface::CallAttemptTracer {
    public:
     explicit DelegatingClientCallAttemptTracer(
         std::vector<CallAttemptTracer*> tracers)
@@ -190,7 +190,7 @@ class DelegatingClientCallTracer : public ClientCallTracer {
     // call at any moment).
     std::vector<CallAttemptTracer*> tracers_;
   };
-  explicit DelegatingClientCallTracer(ClientCallTracer* tracer)
+  explicit DelegatingClientCallTracer(ClientCallTracerInterface* tracer)
       : tracers_{tracer} {}
   ~DelegatingClientCallTracer() override {}
   CallAttemptTracer* StartNewAttempt(bool is_transparent_retry) override {
@@ -224,15 +224,17 @@ class DelegatingClientCallTracer : public ClientCallTracer {
   // will be adding call tracers to the context and these are already
   // synchronized through promises/call combiners (single promise running per
   // call at any moment).
-  void AddTracer(ClientCallTracer* tracer) { tracers_.push_back(tracer); }
+  void AddTracer(ClientCallTracerInterface* tracer) {
+    tracers_.push_back(tracer);
+  }
 
  private:
-  std::vector<ClientCallTracer*> tracers_;
+  std::vector<ClientCallTracerInterface*> tracers_;
 };
 
-class DelegatingServerCallTracer : public ServerCallTracer {
+class DelegatingServerCallTracer : public ServerCallTracerInterface {
  public:
-  explicit DelegatingServerCallTracer(ServerCallTracer* tracer)
+  explicit DelegatingServerCallTracer(ServerCallTracerInterface* tracer)
       : tracers_{tracer} {}
   ~DelegatingServerCallTracer() override {}
   void RecordSendInitialMetadata(
@@ -319,23 +321,26 @@ class DelegatingServerCallTracer : public ServerCallTracer {
   bool IsSampled() override { return tracers_[0]->IsSampled(); }
   bool IsDelegatingTracer() override { return true; }
 
-  void AddTracer(ServerCallTracer* tracer) { tracers_.push_back(tracer); }
+  void AddTracer(ServerCallTracerInterface* tracer) {
+    tracers_.push_back(tracer);
+  }
 
  private:
   // The ServerCallTracerFilter will be responsible for making sure that the
   // tracers are added in a thread-safe manner. It is imagined that the filter
   // will just invoke the factories in the server call tracer factory list
   // sequentially, removing the need for any synchronization.
-  std::vector<ServerCallTracer*> tracers_;
+  std::vector<ServerCallTracerInterface*> tracers_;
 };
 
-void AddClientCallTracerToContext(Arena* arena, ClientCallTracer* tracer) {
+void AddClientCallTracerToContext(Arena* arena,
+                                  ClientCallTracerInterface* tracer) {
   if (arena->GetContext<CallTracerAnnotationInterface>() == nullptr) {
     // This is the first call tracer. Set it directly.
     arena->SetContext<CallTracerAnnotationInterface>(tracer);
   } else {
     // There was already a call tracer present.
-    auto* orig_tracer = DownCast<ClientCallTracer*>(
+    auto* orig_tracer = DownCast<ClientCallTracerInterface*>(
         arena->GetContext<CallTracerAnnotationInterface>());
     if (orig_tracer->IsDelegatingTracer()) {
       // We already created a delegating tracer. Just add the new tracer to the
@@ -353,7 +358,8 @@ void AddClientCallTracerToContext(Arena* arena, ClientCallTracer* tracer) {
   }
 }
 
-void AddServerCallTracerToContext(Arena* arena, ServerCallTracer* tracer) {
+void AddServerCallTracerToContext(Arena* arena,
+                                  ServerCallTracerInterface* tracer) {
   DCHECK_EQ(arena->GetContext<CallTracerInterface>(),
             arena->GetContext<CallTracerAnnotationInterface>());
   if (arena->GetContext<CallTracerAnnotationInterface>() == nullptr) {
@@ -362,7 +368,7 @@ void AddServerCallTracerToContext(Arena* arena, ServerCallTracer* tracer) {
     arena->SetContext<CallTracerInterface>(tracer);
   } else {
     // There was already a call tracer present.
-    auto* orig_tracer = DownCast<ServerCallTracer*>(
+    auto* orig_tracer = DownCast<ServerCallTracerInterface*>(
         arena->GetContext<CallTracerAnnotationInterface>());
     if (orig_tracer->IsDelegatingTracer()) {
       // We already created a delegating tracer. Just add the new tracer to the
@@ -381,4 +387,4 @@ void AddServerCallTracerToContext(Arena* arena, ServerCallTracer* tracer) {
   }
 }
 
-}  // namespace grpc_core
+}  // namespace grpc_core

data/src/core/telemetry/call_tracer.h

@@ -44,9 +44,9 @@ namespace grpc_core {
 // The interface hierarchy is as follows -
 //                 CallTracerAnnotationInterface
 //                    |                  |
-//        ClientCallTracer       CallTracerInterface
+//        ClientCallTracerInterface       CallTracerInterface
 //                                |              |
-//                      CallAttemptTracer    ServerCallTracer
+//                      CallAttemptTracer    ServerCallTracerInterface
 
 // The base class for all tracer implementations.
 class CallTracerAnnotationInterface {
@@ -129,10 +129,13 @@ class CallTracerInterface : public CallTracerAnnotationInterface {
   virtual std::shared_ptr<TcpCallTracer> StartNewTcpTrace() = 0;
 };
 
+class ClientCallTracerInterface;
+class ServerCallTracerInterface;
+
 // Interface for a tracer that records activities on a call. Actual attempts for
 // this call are traced with CallAttemptTracer after invoking RecordNewAttempt()
 // on the ClientCallTracer object.
-class ClientCallTracer : public CallTracerAnnotationInterface {
+class ClientCallTracerInterface : public CallTracerAnnotationInterface {
  public:
   // Interface for a tracer that records activities on a particular call
   // attempt.
@@ -170,22 +173,22 @@ class ClientCallTracer : public CallTracerAnnotationInterface {
                                   RefCountedStringValue value) = 0;
   };
 
-  ~ClientCallTracer() override {}
+  ~ClientCallTracerInterface() override {}
 
   // Records a new attempt for the associated call. \a transparent denotes
   // whether the attempt is being made as a transparent retry or as a
   // non-transparent retry/hedging attempt. (There will be at least one attempt
-  // even if the call is not being retried.) The `ClientCallTracer` object
-  // retains ownership to the newly created `CallAttemptTracer` object.
+  // even if the call is not being retried.) The `ClientCallTracerInterface`
+  // object retains ownership to the newly created `CallAttemptTracer` object.
   // RecordEnd() serves as an indication that the call stack is done with all
   // API calls, and the tracer library is free to destroy it after that.
   virtual CallAttemptTracer* StartNewAttempt(bool is_transparent_retry) = 0;
 };
 
 // Interface for a tracer that records activities on a server call.
-class ServerCallTracer : public CallTracerInterface {
+class ServerCallTracerInterface : public CallTracerInterface {
  public:
-  ~ServerCallTracer() override {}
+  ~ServerCallTracerInterface() override {}
   // TODO(yashykt): The following two methods `RecordReceivedTrailingMetadata`
   // and `RecordEnd` should be moved into CallTracerInterface.
   virtual void RecordReceivedTrailingMetadata(
@@ -195,15 +198,15 @@ class ServerCallTracer : public CallTracerInterface {
   virtual void RecordEnd(const grpc_call_final_info* final_info) = 0;
 };
 
-// Interface for a factory that can create a ServerCallTracer object per
-// server call.
+// Interface for a factory that can create a ServerCallTracerInterface object
+// per server call.
 class ServerCallTracerFactory {
  public:
   struct RawPointerChannelArgTag {};
 
   virtual ~ServerCallTracerFactory() {}
 
-  virtual ServerCallTracer* CreateNewServerCallTracer(
+  virtual ServerCallTracerInterface* CreateNewServerCallTracer(
       Arena* arena, const ChannelArgs& channel_args) = 0;
 
   // Returns true if a server is to be traced, false otherwise.
@@ -228,11 +231,13 @@ class ServerCallTracerFactory {
 // Convenience functions to add call tracers to a call context. Allows setting
 // multiple call tracers to a single call. It is only valid to add client call
 // tracers before the client_channel filter sees the send_initial_metadata op.
-void AddClientCallTracerToContext(Arena* arena, ClientCallTracer* tracer);
+void AddClientCallTracerToContext(Arena* arena,
+                                  ClientCallTracerInterface* tracer);
 
 // TODO(yashykt): We want server call tracers to be registered through the
 // ServerCallTracerFactory, which has yet to be made into a list.
-void AddServerCallTracerToContext(Arena* arena, ServerCallTracer* tracer);
+void AddServerCallTracerToContext(Arena* arena,
+                                  ServerCallTracerInterface* tracer);
 
 template <>
 struct ArenaContextType<CallTracerInterface> {
@@ -245,20 +250,20 @@ struct ArenaContextType<CallTracerAnnotationInterface> {
 };
 
 template <>
-struct ContextSubclass<ClientCallTracer::CallAttemptTracer> {
+struct ContextSubclass<ClientCallTracerInterface::CallAttemptTracer> {
   using Base = CallTracerInterface;
 };
 
 template <>
-struct ContextSubclass<ServerCallTracer> {
+struct ContextSubclass<ServerCallTracerInterface> {
   using Base = CallTracerInterface;
 };
 
 template <>
-struct ContextSubclass<ClientCallTracer> {
+struct ContextSubclass<ClientCallTracerInterface> {
   using Base = CallTracerAnnotationInterface;
 };
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_TELEMETRY_CALL_TRACER_H
+#endif  // GRPC_SRC_CORE_TELEMETRY_CALL_TRACER_H

data/src/core/telemetry/context_list_entry.cc

@@ -0,0 +1,38 @@
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/core/telemetry/context_list_entry.h"
+
+namespace grpc_core {
+
+namespace {
+CopyContextFn g_get_copied_context_fn = nullptr;
+DeleteContextFn g_delete_copied_context_fn = nullptr;
+}  // namespace
+
+void GrpcHttp2SetCopyContextFn(CopyContextFn fn) {
+  g_get_copied_context_fn = fn;
+}
+
+void GrpcHttp2SetDeleteContextFn(DeleteContextFn fn) {
+  g_delete_copied_context_fn = fn;
+}
+
+CopyContextFn GrpcHttp2GetCopyContextFn() { return g_get_copied_context_fn; }
+
+DeleteContextFn GrpcHttp2GetDeleteContextFn() {
+  return g_delete_copied_context_fn;
+}
+
+}  // namespace grpc_core