grpc 1.65.1 → 1.66.0.pre3

data/src/core/client_channel/subchannel.cc

@@ -37,7 +37,6 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
@@ -98,14 +97,11 @@ using ::grpc_event_engine::experimental::EventEngine;
 // ConnectedSubchannel
 //
 
-ConnectedSubchannel::ConnectedSubchannel(
-    const ChannelArgs& args,
-    RefCountedPtr<channelz::SubchannelNode> channelz_subchannel)
+ConnectedSubchannel::ConnectedSubchannel(const ChannelArgs& args)
     : RefCounted<ConnectedSubchannel>(
           GRPC_TRACE_FLAG_ENABLED(subchannel_refcount) ? "ConnectedSubchannel"
                                                        : nullptr),
-      args_(args),
-      channelz_subchannel_(std::move(channelz_subchannel)) {}
+      args_(args) {}
 
 //
 // LegacyConnectedSubchannel
@@ -115,14 +111,19 @@ class LegacyConnectedSubchannel : public ConnectedSubchannel {
  public:
   LegacyConnectedSubchannel(
       RefCountedPtr<grpc_channel_stack> channel_stack, const ChannelArgs& args,
-      RefCountedPtr<channelz::SubchannelNode> channelz_subchannel)
-      : ConnectedSubchannel(args, std::move(channelz_subchannel)),
+      RefCountedPtr<channelz::SubchannelNode> channelz_node)
+      : ConnectedSubchannel(args),
+        channelz_node_(std::move(channelz_node)),
         channel_stack_(std::move(channel_stack)) {}
 
   ~LegacyConnectedSubchannel() override {
     channel_stack_.reset(DEBUG_LOCATION, "ConnectedSubchannel");
   }
 
+  channelz::SubchannelNode* channelz_node() const {
+    return channelz_node_.get();
+  }
+
   void StartWatch(
       grpc_pollset_set* interested_parties,
       OrphanablePtr<ConnectivityStateWatcherInterface> watcher) override {
@@ -163,6 +164,7 @@ class LegacyConnectedSubchannel : public ConnectedSubchannel {
   }
 
  private:
+  RefCountedPtr<channelz::SubchannelNode> channelz_node_;
   RefCountedPtr<grpc_channel_stack> channel_stack_;
 };
 
@@ -192,9 +194,8 @@ class NewConnectedSubchannel : public ConnectedSubchannel {
   NewConnectedSubchannel(
       RefCountedPtr<UnstartedCallDestination> call_destination,
       RefCountedPtr<TransportCallDestination> transport,
-      const ChannelArgs& args,
-      RefCountedPtr<channelz::SubchannelNode> channelz_subchannel)
-      : ConnectedSubchannel(args, std::move(channelz_subchannel)),
+      const ChannelArgs& args)
+      : ConnectedSubchannel(args),
         call_destination_(std::move(call_destination)),
         transport_(std::move(transport)) {}
 
@@ -241,7 +242,8 @@ RefCountedPtr<SubchannelCall> SubchannelCall::Create(Args args,
 }
 
 SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
-    : connected_subchannel_(std::move(args.connected_subchannel)),
+    : connected_subchannel_(args.connected_subchannel
+                                .TakeAsSubclass<LegacyConnectedSubchannel>()),
       deadline_(args.deadline) {
   grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(this);
   const grpc_call_element_args call_args = {
@@ -260,7 +262,7 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
     return;
   }
   grpc_call_stack_set_pollset_or_pollset_set(callstk, args.pollent);
-  auto* channelz_node = connected_subchannel_->channelz_subchannel();
+  auto* channelz_node = connected_subchannel_->channelz_node();
   if (channelz_node != nullptr) {
     channelz_node->RecordCallStarted();
   }
@@ -271,7 +273,9 @@ void SubchannelCall::StartTransportStreamOpBatch(
   MaybeInterceptRecvTrailingMetadata(batch);
   grpc_call_stack* call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(this);
   grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
-  GRPC_CALL_LOG_OP(GPR_INFO, top_elem, batch);
+  GRPC_TRACE_LOG(channel, INFO)
+      << "OP[" << top_elem->filter->name << ":" << top_elem
+      << "]: " << grpc_transport_stream_op_batch_string(batch, false);
   top_elem->filter->start_transport_stream_op_batch(top_elem, batch);
 }
 
@@ -326,13 +330,9 @@ void SubchannelCall::Destroy(void* arg, grpc_error_handle /*error*/) {
 void SubchannelCall::MaybeInterceptRecvTrailingMetadata(
     grpc_transport_stream_op_batch* batch) {
   // only intercept payloads with recv trailing.
-  if (!batch->recv_trailing_metadata) {
-    return;
-  }
+  if (!batch->recv_trailing_metadata) return;
   // only add interceptor is channelz is enabled.
-  if (connected_subchannel_->channelz_subchannel() == nullptr) {
-    return;
-  }
+  if (connected_subchannel_->channelz_node() == nullptr) return;
   GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady,
                     this, grpc_schedule_on_exec_ctx);
   // save some state needed for the interception callback.
@@ -365,13 +365,13 @@ void SubchannelCall::RecvTrailingMetadataReady(void* arg,
   CHECK_NE(call->recv_trailing_metadata_, nullptr);
   grpc_status_code status = GRPC_STATUS_OK;
   GetCallStatus(&status, call->deadline_, call->recv_trailing_metadata_, error);
-  channelz::SubchannelNode* channelz_subchannel =
-      call->connected_subchannel_->channelz_subchannel();
-  CHECK_NE(channelz_subchannel, nullptr);
+  channelz::SubchannelNode* channelz_node =
+      call->connected_subchannel_->channelz_node();
+  CHECK_NE(channelz_node, nullptr);
   if (status == GRPC_STATUS_OK) {
-    channelz_subchannel->RecordCallSucceeded();
+    channelz_node->RecordCallSucceeded();
   } else {
-    channelz_subchannel->RecordCallFailed();
+    channelz_node->RecordCallFailed();
   }
   Closure::Run(DEBUG_LOCATION, call->original_recv_trailing_metadata_, error);
 }
@@ -418,10 +418,10 @@ class Subchannel::ConnectedSubchannelStateWatcher final
       if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE ||
           new_state == GRPC_CHANNEL_SHUTDOWN) {
         if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
-          gpr_log(GPR_INFO,
-                  "subchannel %p %s: Connected subchannel %p reports %s: %s", c,
-                  c->key_.ToString().c_str(), c->connected_subchannel_.get(),
-                  ConnectivityStateName(new_state), status.ToString().c_str());
+          LOG(INFO) << "subchannel " << c << " " << c->key_.ToString()
+                    << ": Connected subchannel "
+                    << c->connected_subchannel_.get() << " reports "
+                    << ConnectivityStateName(new_state) << ": " << status;
         }
         c->connected_subchannel_.reset();
         if (c->channelz_node() != nullptr) {
@@ -603,8 +603,8 @@ void Subchannel::ThrottleKeepaliveTime(int new_keepalive_time) {
   if (new_keepalive_time > keepalive_time_) {
     keepalive_time_ = new_keepalive_time;
     if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
-      gpr_log(GPR_INFO, "subchannel %p %s: throttling keepalive time to %d",
-              this, key_.ToString().c_str(), new_keepalive_time);
+      LOG(INFO) << "subchannel " << this << " " << key_.ToString()
+                << ": throttling keepalive time to " << new_keepalive_time;
     }
     args_ = args_.Set(GRPC_ARG_KEEPALIVE_TIME_MS, new_keepalive_time);
   }
@@ -758,8 +758,10 @@ void Subchannel::OnRetryTimer() {
 
 void Subchannel::OnRetryTimerLocked() {
   if (shutdown_) return;
-  gpr_log(GPR_INFO, "subchannel %p %s: backoff delay elapsed, reporting IDLE",
-          this, key_.ToString().c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
+    LOG(INFO) << "subchannel " << this << " " << key_.ToString()
+              << ": backoff delay elapsed, reporting IDLE";
+  }
   SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, absl::OkStatus());
 }
 
@@ -803,11 +805,12 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
   if (connecting_result_.transport == nullptr || !PublishTransportLocked()) {
     const Duration time_until_next_attempt =
         next_attempt_time_ - Timestamp::Now();
-    gpr_log(GPR_INFO,
-            "subchannel %p %s: connect failed (%s), backing off for %" PRId64
-            " ms",
-            this, key_.ToString().c_str(), StatusToString(error).c_str(),
-            time_until_next_attempt.millis());
+    if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
+      LOG(INFO) << "subchannel " << this << " " << key_.ToString()
+                << ": connect failed (" << StatusToString(error)
+                << "), backing off for " << time_until_next_attempt.millis()
+                << " ms";
+    }
     SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
                                grpc_error_to_absl_status(error));
     retry_timer_handle_ = event_engine_->RunAfter(
@@ -844,9 +847,8 @@ bool Subchannel::PublishTransportLocked() {
     absl::StatusOr<RefCountedPtr<grpc_channel_stack>> stack = builder.Build();
     if (!stack.ok()) {
       connecting_result_.Reset();
-      gpr_log(GPR_ERROR,
-              "subchannel %p %s: error initializing subchannel stack: %s", this,
-              key_.ToString().c_str(), stack.status().ToString().c_str());
+      LOG(ERROR) << "subchannel " << this << " " << key_.ToString()
+                 << ": error initializing subchannel stack: " << stack.status();
       return false;
     }
     connected_subchannel_ = MakeRefCounted<LegacyConnectedSubchannel>(
@@ -857,6 +859,24 @@ bool Subchannel::PublishTransportLocked() {
             ->client_transport());
     InterceptionChainBuilder builder(
         connecting_result_.channel_args.SetObject(transport.get()));
+    if (channelz_node_ != nullptr) {
+      // TODO(ctiller): If/when we have a good way to access the subchannel
+      // from a filter (maybe GetContext<Subchannel>?), consider replacing
+      // these two hooks with a filter so that we can avoid storing two
+      // separate refs to the channelz node in each connection.
+      builder.AddOnClientInitialMetadata(
+          [channelz_node = channelz_node_](ClientMetadata&) {
+            channelz_node->RecordCallStarted();
+          });
+      builder.AddOnServerTrailingMetadata(
+          [channelz_node = channelz_node_](ServerMetadata& metadata) {
+            if (IsStatusOk(metadata)) {
+              channelz_node->RecordCallSucceeded();
+            } else {
+              channelz_node->RecordCallFailed();
+            }
+          });
+    }
     CoreConfiguration::Get().channel_init().AddToInterceptionChainBuilder(
         GRPC_CLIENT_SUBCHANNEL, builder);
     auto transport_destination =
@@ -865,21 +885,20 @@ bool Subchannel::PublishTransportLocked() {
     auto call_destination = builder.Build(transport_destination);
     if (!call_destination.ok()) {
       connecting_result_.Reset();
-      gpr_log(GPR_ERROR,
-              "subchannel %p %s: error initializing subchannel stack: %s", this,
-              key_.ToString().c_str(),
-              call_destination.status().ToString().c_str());
+      LOG(ERROR) << "subchannel " << this << " " << key_.ToString()
+                 << ": error initializing subchannel stack: "
+                 << call_destination.status();
       return false;
     }
     connected_subchannel_ = MakeRefCounted<NewConnectedSubchannel>(
-        std::move(*call_destination), std::move(transport_destination), args_,
-        channelz_node_);
+        std::move(*call_destination), std::move(transport_destination), args_);
   }
   connecting_result_.Reset();
   // Publish.
   if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
-    gpr_log(GPR_INFO, "subchannel %p %s: new connected subchannel at %p", this,
-            key_.ToString().c_str(), connected_subchannel_.get());
+    LOG(INFO) << "subchannel " << this << " " << key_.ToString()
+              << ": new connected subchannel at "
+              << connected_subchannel_.get();
   }
   if (channelz_node_ != nullptr) {
     channelz_node_->SetChildSocket(std::move(socket_node));

data/src/core/client_channel/subchannel.h

@@ -66,9 +66,6 @@ class SubchannelCall;
 class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
  public:
   const ChannelArgs& args() const { return args_; }
-  channelz::SubchannelNode* channelz_subchannel() const {
-    return channelz_subchannel_.get();
-  }
 
   virtual void StartWatch(
       grpc_pollset_set* interested_parties,
@@ -85,17 +82,14 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
   virtual void Ping(grpc_closure* on_initiate, grpc_closure* on_ack) = 0;
 
  protected:
-  ConnectedSubchannel(
-      const ChannelArgs& args,
-      RefCountedPtr<channelz::SubchannelNode> channelz_subchannel);
+  explicit ConnectedSubchannel(const ChannelArgs& args);
 
  private:
   ChannelArgs args_;
-  // ref counted pointer to the channelz node in this connected subchannel's
-  // owning subchannel.
-  RefCountedPtr<channelz::SubchannelNode> channelz_subchannel_;
 };
 
+class LegacyConnectedSubchannel;
+
 // Implements the interface of RefCounted<>.
 class SubchannelCall final {
  public:
@@ -150,7 +144,7 @@ class SubchannelCall final {
 
   static void Destroy(void* arg, grpc_error_handle error);
 
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
+  RefCountedPtr<LegacyConnectedSubchannel> connected_subchannel_;
   grpc_closure* after_call_stack_destroy_ = nullptr;
   // State needed to support channelz interception of recv trailing metadata.
   grpc_closure recv_trailing_metadata_ready_;

data/src/core/ext/filters/backend_metrics/backend_metric_filter.cc

@@ -24,13 +24,13 @@
 #include <memory>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/strings/string_view.h"
 #include "upb/base/string_view.h"
 #include "upb/mem/arena.hpp"
 #include "xds/data/orca/v3/orca_load_report.upb.h"
 
 #include <grpc/impl/channel_arg_names.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
@@ -117,8 +117,7 @@ absl::optional<std::string> MaybeSerializeBackendMetrics(
 }  // namespace
 
 const grpc_channel_filter BackendMetricFilter::kFilter =
-    MakePromiseBasedFilter<BackendMetricFilter, FilterEndpoint::kServer>(
-        "backend_metric");
+    MakePromiseBasedFilter<BackendMetricFilter, FilterEndpoint::kServer>();
 
 absl::StatusOr<std::unique_ptr<BackendMetricFilter>>
 BackendMetricFilter::Create(const ChannelArgs&, ChannelFilter::Args) {
@@ -130,20 +129,20 @@ void BackendMetricFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
   auto* ctx = MaybeGetContext<BackendMetricProvider>();
   if (ctx == nullptr) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
-      gpr_log(GPR_INFO, "[%p] No BackendMetricProvider.", this);
+      LOG(INFO) << "[" << this << "] No BackendMetricProvider.";
     }
     return;
   }
   absl::optional<std::string> serialized = MaybeSerializeBackendMetrics(ctx);
   if (serialized.has_value() && !serialized->empty()) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
-      gpr_log(GPR_INFO, "[%p] Backend metrics serialized. size: %" PRIuPTR,
-              this, serialized->size());
+      LOG(INFO) << "[" << this
+                << "] Backend metrics serialized. size: " << serialized->size();
     }
     md.Set(EndpointLoadMetricsBinMetadata(),
            Slice::FromCopiedString(std::move(*serialized)));
   } else if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
-    gpr_log(GPR_INFO, "[%p] No backend metrics.", this);
+    LOG(INFO) << "[" << this << "] No backend metrics.";
   }
 }
 

data/src/core/ext/filters/backend_metrics/backend_metric_filter.h

@@ -35,6 +35,8 @@ class BackendMetricFilter : public ImplementChannelFilter<BackendMetricFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "backend_metric"; }
+
   static absl::StatusOr<std::unique_ptr<BackendMetricFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args);
 

data/src/core/ext/filters/census/grpc_context.cc

@@ -22,18 +22,18 @@
 #include <grpc/grpc.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
 
 void grpc_census_call_set_context(grpc_call* call, census_context* context) {
-  GRPC_API_TRACE("grpc_census_call_set_context(call=%p, census_context=%p)", 2,
-                 (call, context));
+  GRPC_TRACE_LOG(api, INFO) << "grpc_census_call_set_context(call=" << call
+                            << ", census_context=" << context << ")";
   if (context != nullptr) {
     grpc_call_get_arena(call)->SetContext<census_context>(context);
   }
 }
 
 census_context* grpc_census_call_get_context(grpc_call* call) {
-  GRPC_API_TRACE("grpc_census_call_get_context(call=%p)", 1, (call));
+  GRPC_TRACE_LOG(api, INFO)
+      << "grpc_census_call_get_context(call=" << call << ")";
   return grpc_call_get_arena(call)->GetContext<census_context>();
 }

data/src/core/ext/filters/channel_idle/legacy_channel_idle_filter.cc

@@ -51,6 +51,7 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/http2_errors.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -70,13 +71,6 @@ const auto kMaxConnectionAgeJitter = 0.1;
 
 }  // namespace
 
-#define GRPC_IDLE_FILTER_LOG(format, ...)                               \
-  do {                                                                  \
-    if (GRPC_TRACE_FLAG_ENABLED(client_idle_filter)) {                  \
-      gpr_log(GPR_INFO, "(client idle filter) " format, ##__VA_ARGS__); \
-    }                                                                   \
-  } while (0)
-
 Duration GetClientIdleTimeout(const ChannelArgs& args) {
   return args.GetDurationFromIntMillis(GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS)
       .value_or(kDefaultIdleTimeout);
@@ -176,6 +170,9 @@ void LegacyMaxAgeFilter::PostInit() {
 
   // Start the max age timer
   if (max_connection_age_ != Duration::Infinity()) {
+    auto arena = SimpleArenaAllocator(0)->MakeArena();
+    arena->SetContext<grpc_event_engine::experimental::EventEngine>(
+        channel_stack->EventEngine());
     max_age_activity_.Set(MakeActivity(
         TrySeq(
             // First sleep until the max connection age
@@ -213,7 +210,7 @@ void LegacyMaxAgeFilter::PostInit() {
           // (if it did not, it was cancelled)
           if (status.ok()) CloseChannel();
         },
-        channel_stack->EventEngine()));
+        std::move(arena)));
   }
 }
 
@@ -255,7 +252,8 @@ void LegacyChannelIdleFilter::DecreaseCallCount() {
 }
 
 void LegacyChannelIdleFilter::StartIdleTimer() {
-  GRPC_IDLE_FILTER_LOG("timer has started");
+  GRPC_TRACE_LOG(client_idle_filter, INFO)
+      << "(client idle filter) timer has started";
   auto idle_filter_state = idle_filter_state_;
   // Hold a ref to the channel stack for the timer callback.
   auto channel_stack = channel_stack_->Ref();
@@ -270,12 +268,15 @@ void LegacyChannelIdleFilter::StartIdleTimer() {
                     }
                   });
   });
+  auto arena = SimpleArenaAllocator()->MakeArena();
+  arena->SetContext<grpc_event_engine::experimental::EventEngine>(
+      channel_stack_->EventEngine());
   activity_.Set(MakeActivity(
       std::move(promise), ExecCtxWakeupScheduler{},
       [channel_stack, this](absl::Status status) {
         if (status.ok()) CloseChannel();
       },
-      channel_stack->EventEngine()));
+      std::move(arena)));
 }
 
 void LegacyChannelIdleFilter::CloseChannel() {
@@ -289,11 +290,9 @@ void LegacyChannelIdleFilter::CloseChannel() {
 }
 
 const grpc_channel_filter LegacyClientIdleFilter::kFilter =
-    MakePromiseBasedFilter<LegacyClientIdleFilter, FilterEndpoint::kClient>(
-        "client_idle");
+    MakePromiseBasedFilter<LegacyClientIdleFilter, FilterEndpoint::kClient>();
 const grpc_channel_filter LegacyMaxAgeFilter::kFilter =
-    MakePromiseBasedFilter<LegacyMaxAgeFilter, FilterEndpoint::kServer>(
-        "max_age");
+    MakePromiseBasedFilter<LegacyMaxAgeFilter, FilterEndpoint::kServer>();
 
 void RegisterLegacyChannelIdleFilters(CoreConfiguration::Builder* builder) {
   builder->channel_init()

data/src/core/ext/filters/channel_idle/legacy_channel_idle_filter.h

@@ -96,6 +96,8 @@ class LegacyClientIdleFilter final : public LegacyChannelIdleFilter {
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "client_idle"; }
+
   static absl::StatusOr<std::unique_ptr<LegacyClientIdleFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
@@ -107,6 +109,8 @@ class LegacyMaxAgeFilter final : public LegacyChannelIdleFilter {
   static const grpc_channel_filter kFilter;
   struct Config;
 
+  static absl::string_view TypeName() { return "max_age"; }
+
   static absl::StatusOr<std::unique_ptr<LegacyMaxAgeFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 

data/src/core/ext/filters/fault_injection/fault_injection_filter.cc

@@ -27,6 +27,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -36,7 +37,6 @@
 #include "absl/types/optional.h"
 
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 
 #include "src/core/ext/filters/fault_injection/fault_injection_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -151,8 +151,8 @@ ArenaPromise<absl::Status> FaultInjectionFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, FaultInjectionFilter* filter) {
   auto decision = filter->MakeInjectionDecision(md);
   if (GRPC_TRACE_FLAG_ENABLED(fault_injection_filter)) {
-    gpr_log(GPR_INFO, "chand=%p: Fault injection triggered %s", this,
-            decision.ToString().c_str());
+    LOG(INFO) << "chand=" << this << ": Fault injection triggered "
+              << decision.ToString();
   }
   auto delay = decision.DelayUntil();
   return TrySeq(Sleep(delay), [decision = std::move(decision)]() {
@@ -270,8 +270,7 @@ std::string FaultInjectionFilter::InjectionDecision::ToString() const {
 }
 
 const grpc_channel_filter FaultInjectionFilter::kFilter =
-    MakePromiseBasedFilter<FaultInjectionFilter, FilterEndpoint::kClient>(
-        "fault_injection_filter");
+    MakePromiseBasedFilter<FaultInjectionFilter, FilterEndpoint::kClient>();
 
 void FaultInjectionFilterRegister(CoreConfiguration::Builder* builder) {
   FaultInjectionServiceConfigParser::Register(builder);

data/src/core/ext/filters/fault_injection/fault_injection_filter.h

@@ -45,6 +45,8 @@ class FaultInjectionFilter
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "fault_injection_filter"; }
+
   static absl::StatusOr<std::unique_ptr<FaultInjectionFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -59,7 +59,7 @@ const NoInterceptor HttpClientFilter::Call::OnFinalize;
 
 const grpc_channel_filter HttpClientFilter::kFilter =
     MakePromiseBasedFilter<HttpClientFilter, FilterEndpoint::kClient,
-                           kFilterExaminesServerInitialMetadata>("http-client");
+                           kFilterExaminesServerInitialMetadata>();
 
 namespace {
 absl::Status CheckServerMetadata(ServerMetadata* b) {

data/src/core/ext/filters/http/client/http_client_filter.h

@@ -35,6 +35,8 @@ class HttpClientFilter : public ImplementChannelFilter<HttpClientFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "http-client"; }
+
   static absl::StatusOr<std::unique_ptr<HttpClientFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -66,8 +66,7 @@ void ClientAuthorityFilter::Call::OnClientInitialMetadata(
 }
 
 const grpc_channel_filter ClientAuthorityFilter::kFilter =
-    MakePromiseBasedFilter<ClientAuthorityFilter, FilterEndpoint::kClient>(
-        "authority");
+    MakePromiseBasedFilter<ClientAuthorityFilter, FilterEndpoint::kClient>();
 
 namespace {
 bool NeedsClientAuthorityFilter(const ChannelArgs& args) {

data/src/core/ext/filters/http/client_authority_filter.h

@@ -39,6 +39,8 @@ class ClientAuthorityFilter final
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "authority"; }
+
   static absl::StatusOr<std::unique_ptr<ClientAuthorityFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args);
 

data/src/core/ext/filters/http/message_compress/compression_filter.cc

@@ -32,7 +32,6 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/compression_types.h>
-#include <grpc/support/log.h>
 
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -66,12 +65,12 @@ const grpc_channel_filter ClientCompressionFilter::kFilter =
     MakePromiseBasedFilter<ClientCompressionFilter, FilterEndpoint::kClient,
                            kFilterExaminesServerInitialMetadata |
                                kFilterExaminesInboundMessages |
-                               kFilterExaminesOutboundMessages>("compression");
+                               kFilterExaminesOutboundMessages>();
 const grpc_channel_filter ServerCompressionFilter::kFilter =
     MakePromiseBasedFilter<ServerCompressionFilter, FilterEndpoint::kServer,
                            kFilterExaminesServerInitialMetadata |
                                kFilterExaminesInboundMessages |
-                               kFilterExaminesOutboundMessages>("compression");
+                               kFilterExaminesOutboundMessages>();
 
 absl::StatusOr<std::unique_ptr<ClientCompressionFilter>>
 ClientCompressionFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
@@ -104,9 +103,8 @@ ChannelCompression::ChannelCompression(const ChannelArgs& args)
                                          &name)) {
       name = "<unknown>";
     }
-    gpr_log(GPR_ERROR,
-            "default compression algorithm %s not enabled: switching to none",
-            name);
+    LOG(ERROR) << "default compression algorithm " << name
+               << " not enabled: switching to none";
     default_compression_algorithm_ = GRPC_COMPRESS_NONE;
   }
 }
@@ -114,8 +112,8 @@ ChannelCompression::ChannelCompression(const ChannelArgs& args)
 MessageHandle ChannelCompression::CompressMessage(
     MessageHandle message, grpc_compression_algorithm algorithm) const {
   if (GRPC_TRACE_FLAG_ENABLED(compression)) {
-    gpr_log(GPR_INFO, "CompressMessage: len=%" PRIdPTR " alg=%d flags=%d",
-            message->payload()->Length(), algorithm, message->flags());
+    LOG(INFO) << "CompressMessage: len=" << message->payload()->Length()
+              << " alg=" << algorithm << " flags=" << message->flags();
   }
   auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {
@@ -144,10 +142,10 @@ MessageHandle ChannelCompression::CompressMessage(
       const float savings_ratio = 1.0f - static_cast<float>(after_size) /
                                              static_cast<float>(before_size);
       CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
-      gpr_log(GPR_INFO,
-              "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
-              " bytes (%.2f%% savings)",
-              algo_name, before_size, after_size, 100 * savings_ratio);
+      LOG(INFO) << absl::StrFormat(
+          "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
+          " bytes (%.2f%% savings)",
+          algo_name, before_size, after_size, 100 * savings_ratio);
     }
     tmp.Swap(payload);
     flags |= GRPC_WRITE_INTERNAL_COMPRESS;
@@ -158,10 +156,9 @@ MessageHandle ChannelCompression::CompressMessage(
     if (GRPC_TRACE_FLAG_ENABLED(compression)) {
       const char* algo_name;
       CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
-      gpr_log(GPR_INFO,
-              "Algorithm '%s' enabled but decided not to compress. Input size: "
-              "%" PRIuPTR,
-              algo_name, payload->Length());
+      LOG(INFO) << "Algorithm '" << algo_name
+                << "' enabled but decided not to compress. Input size: "
+                << payload->Length();
     }
   }
   return message;
@@ -170,9 +167,9 @@ MessageHandle ChannelCompression::CompressMessage(
 absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
     bool is_client, MessageHandle message, DecompressArgs args) const {
   if (GRPC_TRACE_FLAG_ENABLED(compression)) {
-    gpr_log(GPR_INFO, "DecompressMessage: len=%" PRIdPTR " max=%d alg=%d",
-            message->payload()->Length(),
-            args.max_recv_message_length.value_or(-1), args.algorithm);
+    LOG(INFO) << "DecompressMessage: len=" << message->payload()->Length()
+              << " max=" << args.max_recv_message_length.value_or(-1)
+              << " alg=" << args.algorithm;
   }
   auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {