grpc 1.74.1 → 1.75.0.pre1

data/src/core/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -19,7 +19,6 @@
 #ifndef GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
 #define GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
 
-#include <ares.h>
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
@@ -36,6 +35,8 @@
 
 #if GRPC_ARES == 1
 
+#include <ares.h>
+
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
 typedef struct grpc_ares_ev_driver grpc_ares_ev_driver;

data/src/core/resolver/xds/xds_dependency_manager.cc

@@ -940,7 +940,7 @@ void XdsDependencyManager::MaybeReportUpdate() {
     endpoint_watchers_.erase(it++);
   }
   // Remove entries in dns_resolvers_ for any DNS name not in
-  // eds_resources_seen.
+  // dns_names_seen.
   for (auto it = dns_resolvers_.begin(); it != dns_resolvers_.end();) {
     const std::string& dns_name = it->first;
     if (dns_names_seen.find(dns_name) != dns_names_seen.end()) {

data/src/core/server/server.cc

@@ -1311,7 +1311,7 @@ grpc_error_handle Server::SetupTransport(Transport* transport,
                                          grpc_pollset* accepting_pollset,
                                          const ChannelArgs& args,
                                          const Blackboard* blackboard) {
-  GRPC_LATENT_SEE_INNER_SCOPE("Server::SetupTransport");
+  GRPC_LATENT_SEE_SCOPE("Server::SetupTransport");
   // Create channel.
   global_stats().IncrementServerChannelsCreated();
   // Set up channelz node.

data/src/core/server/server_call_tracer_filter.cc

@@ -18,81 +18,17 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <functional>
 #include <memory>
-#include <utility>
 
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "src/core/call/call_finalization.h"
 #include "src/core/config/core_configuration.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/cancel_callback.h"
-#include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/map.h"
-#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"
-#include "src/core/util/latent_see.h"
 
 namespace grpc_core {
 
-namespace {
-
-class ServerCallTracerFilter
-    : public ImplementChannelFilter<ServerCallTracerFilter> {
- public:
-  static const grpc_channel_filter kFilter;
-
-  static absl::string_view TypeName() { return "server_call_tracer"; }
-
-  static absl::StatusOr<std::unique_ptr<ServerCallTracerFilter>> Create(
-      const ChannelArgs& /*args*/, ChannelFilter::Args /*filter_args*/);
-
-  class Call {
-   public:
-    void OnClientInitialMetadata(ClientMetadata& client_initial_metadata) {
-      GRPC_LATENT_SEE_INNER_SCOPE(
-          "ServerCallTracerFilter::Call::OnClientInitialMetadata");
-      auto* call_tracer = MaybeGetContext<ServerCallTracer>();
-      if (call_tracer == nullptr) return;
-      call_tracer->RecordReceivedInitialMetadata(&client_initial_metadata);
-    }
-
-    void OnServerInitialMetadata(ServerMetadata& server_initial_metadata) {
-      GRPC_LATENT_SEE_INNER_SCOPE(
-          "ServerCallTracerFilter::Call::OnServerInitialMetadata");
-      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) {
-      GRPC_LATENT_SEE_INNER_SCOPE("ServerCallTracerFilter::Call::OnFinalize");
-      auto* call_tracer = MaybeGetContext<ServerCallTracer>();
-      if (call_tracer == nullptr) return;
-      call_tracer->RecordEnd(final_info);
-    }
-
-    void OnServerTrailingMetadata(ServerMetadata& server_trailing_metadata) {
-      GRPC_LATENT_SEE_INNER_SCOPE(
-          "ServerCallTracerFilter::Call::OnServerTrailingMetadata");
-      auto* call_tracer = MaybeGetContext<ServerCallTracer>();
-      if (call_tracer == nullptr) return;
-      call_tracer->RecordSendTrailingMetadata(&server_trailing_metadata);
-    }
-
-    static inline const NoInterceptor OnClientToServerMessage;
-    static inline const NoInterceptor OnClientToServerHalfClose;
-    static inline const NoInterceptor OnServerToClientMessage;
-  };
-};
-
 const grpc_channel_filter ServerCallTracerFilter::kFilter =
     MakePromiseBasedFilter<ServerCallTracerFilter, FilterEndpoint::kServer,
                            kFilterExaminesServerInitialMetadata>();
@@ -103,8 +39,6 @@ ServerCallTracerFilter::Create(const ChannelArgs& /*args*/,
   return std::make_unique<ServerCallTracerFilter>();
 }
 
-}  // namespace
-
 void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterFilter<ServerCallTracerFilter>(
       GRPC_SERVER_CHANNEL);

data/src/core/server/server_call_tracer_filter.h

@@ -17,10 +17,74 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <functional>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "src/core/call/call_finalization.h"
 #include "src/core/config/core_configuration.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/cancel_callback.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/pipe.h"
+#include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/call_tracer.h"
+#include "src/core/util/latent_see.h"
 
 namespace grpc_core {
 
+class ServerCallTracerFilter
+    : public ImplementChannelFilter<ServerCallTracerFilter> {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::string_view TypeName() { return "server_call_tracer"; }
+
+  static absl::StatusOr<std::unique_ptr<ServerCallTracerFilter>> Create(
+      const ChannelArgs& /*args*/, ChannelFilter::Args /*filter_args*/);
+
+  class Call {
+   public:
+    void OnClientInitialMetadata(ClientMetadata& client_initial_metadata) {
+      GRPC_LATENT_SEE_SCOPE(
+          "ServerCallTracerFilter::Call::OnClientInitialMetadata");
+      auto* call_tracer = MaybeGetContext<ServerCallTracerInterface>();
+      if (call_tracer == nullptr) return;
+      call_tracer->RecordReceivedInitialMetadata(&client_initial_metadata);
+    }
+
+    void OnServerInitialMetadata(ServerMetadata& server_initial_metadata) {
+      GRPC_LATENT_SEE_SCOPE(
+          "ServerCallTracerFilter::Call::OnServerInitialMetadata");
+      auto* call_tracer = MaybeGetContext<ServerCallTracerInterface>();
+      if (call_tracer == nullptr) return;
+      call_tracer->RecordSendInitialMetadata(&server_initial_metadata);
+    }
+
+    void OnFinalize(const grpc_call_final_info* final_info) {
+      GRPC_LATENT_SEE_SCOPE("ServerCallTracerFilter::Call::OnFinalize");
+      auto* call_tracer = MaybeGetContext<ServerCallTracerInterface>();
+      if (call_tracer == nullptr) return;
+      call_tracer->RecordEnd(final_info);
+    }
+
+    void OnServerTrailingMetadata(ServerMetadata& server_trailing_metadata) {
+      GRPC_LATENT_SEE_SCOPE(
+          "ServerCallTracerFilter::Call::OnServerTrailingMetadata");
+      auto* call_tracer = MaybeGetContext<ServerCallTracerInterface>();
+      if (call_tracer == nullptr) return;
+      call_tracer->RecordSendTrailingMetadata(&server_trailing_metadata);
+    }
+
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+  };
+};
+
 void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core

data/src/core/server/server_config_selector_filter.cc

@@ -144,7 +144,7 @@ void ServerConfigSelectorFilter::Orphan() {
 
 absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, ServerConfigSelectorFilter* filter) {
-  GRPC_LATENT_SEE_INNER_SCOPE(
+  GRPC_LATENT_SEE_SCOPE(
       "ServerConfigSelectorFilter::Call::OnClientInitialMetadata");
   auto sel = filter->config_selector();
   if (!sel.ok()) return sel.status();

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/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/metrics.h

@@ -285,12 +285,12 @@ class StatsPlugin {
 
   // Whether this stats plugin is enabled for the channel specified by \a scope.
   // Returns true and a channel-specific ScopeConfig which may then be used to
-  // configure the ClientCallTracer in GetClientCallTracer().
+  // configure the ClientCallTracerInterface in GetClientCallTracer().
   virtual std::pair<bool, std::shared_ptr<ScopeConfig>> IsEnabledForChannel(
       const experimental::StatsPluginChannelScope& scope) const = 0;
   // Whether this stats plugin is enabled for the server specified by \a args.
   // Returns true and a server-specific ScopeConfig which may then be used to
-  // configure the ServerCallTracer in GetServerCallTracer().
+  // configure the ServerCallTracerInterface in GetServerCallTracer().
   virtual std::pair<bool, std::shared_ptr<ScopeConfig>> IsEnabledForServer(
       const ChannelArgs& args) const = 0;
   // Gets a scope config for the client channel specified by \a scope. Note that
@@ -344,14 +344,14 @@ class StatsPlugin {
   virtual bool IsInstrumentEnabled(
       GlobalInstrumentsRegistry::GlobalInstrumentHandle handle) const = 0;
 
-  // Gets a ClientCallTracer associated with this stats plugin which can be used
-  // in a call.
-  virtual ClientCallTracer* GetClientCallTracer(
+  // Gets a ClientCallTracerInterface associated with this stats plugin which
+  // can be used in a call.
+  virtual ClientCallTracerInterface* GetClientCallTracer(
       const Slice& path, bool registered_method,
       std::shared_ptr<ScopeConfig> scope_config) = 0;
-  // Gets a ServerCallTracer associated with this stats plugin which can be used
-  // in a call.
-  virtual ServerCallTracer* GetServerCallTracer(
+  // Gets a ServerCallTracerInterface associated with this stats plugin which
+  // can be used in a call.
+  virtual ServerCallTracerInterface* GetServerCallTracer(
       std::shared_ptr<ScopeConfig> scope_config) = 0;
 
   // TODO(yijiem): This is an optimization for the StatsPlugin to create its own