grpc 1.65.1 → 1.66.0.pre3

data/src/core/lib/transport/connectivity_state.cc

@@ -18,7 +18,8 @@
 
 #include "src/core/lib/transport/connectivity_state.h"
 
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
+
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/debug_location.h"
@@ -72,9 +73,10 @@ class AsyncConnectivityStateWatcherInterface::Notifier {
   static void SendNotification(void* arg, grpc_error_handle /*ignored*/) {
     Notifier* self = static_cast<Notifier*>(arg);
     if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-      gpr_log(GPR_INFO, "watcher %p: delivering async notification for %s (%s)",
-              self->watcher_.get(), ConnectivityStateName(self->state_),
-              self->status_.ToString().c_str());
+      LOG(INFO) << "watcher " << self->watcher_.get()
+                << ": delivering async notification for "
+                << ConnectivityStateName(self->state_) << " ("
+                << self->status_.ToString() << ")";
     }
     self->watcher_->OnConnectivityStateChange(self->state_, self->status_);
     delete self;
@@ -103,10 +105,10 @@ ConnectivityStateTracker::~ConnectivityStateTracker() {
   if (current_state == GRPC_CHANNEL_SHUTDOWN) return;
   for (const auto& p : watchers_) {
     if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-      gpr_log(GPR_INFO,
-              "ConnectivityStateTracker %s[%p]: notifying watcher %p: %s -> %s",
-              name_, this, p.first, ConnectivityStateName(current_state),
-              ConnectivityStateName(GRPC_CHANNEL_SHUTDOWN));
+      LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
+                << "]: notifying watcher " << p.first << ": "
+                << ConnectivityStateName(current_state) << " -> "
+                << ConnectivityStateName(GRPC_CHANNEL_SHUTDOWN);
     }
     p.second->Notify(GRPC_CHANNEL_SHUTDOWN, absl::Status());
   }
@@ -116,17 +118,17 @@ void ConnectivityStateTracker::AddWatcher(
     grpc_connectivity_state initial_state,
     OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
   if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: add watcher %p", name_,
-            this, watcher.get());
+    LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
+              << "]: add watcher " << watcher.get();
   }
   grpc_connectivity_state current_state =
       state_.load(std::memory_order_relaxed);
   if (initial_state != current_state) {
     if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-      gpr_log(GPR_INFO,
-              "ConnectivityStateTracker %s[%p]: notifying watcher %p: %s -> %s",
-              name_, this, watcher.get(), ConnectivityStateName(initial_state),
-              ConnectivityStateName(current_state));
+      LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
+                << "]: notifying watcher " << watcher.get() << ": "
+                << ConnectivityStateName(initial_state) << " -> "
+                << ConnectivityStateName(current_state);
     }
     watcher->Notify(current_state, status_);
   }
@@ -140,8 +142,8 @@ void ConnectivityStateTracker::AddWatcher(
 void ConnectivityStateTracker::RemoveWatcher(
     ConnectivityStateWatcherInterface* watcher) {
   if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: remove watcher %p",
-            name_, this, watcher);
+    LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
+              << "]: remove watcher " << watcher;
   }
   watchers_.erase(watcher);
 }
@@ -153,18 +155,19 @@ void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
       state_.load(std::memory_order_relaxed);
   if (state == current_state) return;
   if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: %s -> %s (%s, %s)",
-            name_, this, ConnectivityStateName(current_state),
-            ConnectivityStateName(state), reason, status.ToString().c_str());
+    LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
+              << "]: " << ConnectivityStateName(current_state) << " -> "
+              << ConnectivityStateName(state) << " (" << reason << ", "
+              << status.ToString() << ")";
   }
   state_.store(state, std::memory_order_relaxed);
   status_ = status;
   for (const auto& p : watchers_) {
     if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-      gpr_log(GPR_INFO,
-              "ConnectivityStateTracker %s[%p]: notifying watcher %p: %s -> %s",
-              name_, this, p.first, ConnectivityStateName(current_state),
-              ConnectivityStateName(state));
+      LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
+                << "]: notifying watcher " << p.first << ": "
+                << ConnectivityStateName(current_state) << " -> "
+                << ConnectivityStateName(state);
     }
     p.second->Notify(state, status);
   }
@@ -176,8 +179,8 @@ void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
 grpc_connectivity_state ConnectivityStateTracker::state() const {
   grpc_connectivity_state state = state_.load(std::memory_order_relaxed);
   if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
-    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: get current state: %s",
-            name_, this, ConnectivityStateName(state));
+    LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
+              << "]: get current state: " << ConnectivityStateName(state);
   }
   return state;
 }

data/src/core/lib/transport/interception_chain.cc

@@ -32,15 +32,14 @@ std::atomic<size_t> InterceptionChainBuilder::next_filter_id_{0};
 // HijackedCall
 
 CallInitiator HijackedCall::MakeCall() {
-  auto metadata = Arena::MakePooled<ClientMetadata>();
+  auto metadata = Arena::MakePooledForOverwrite<ClientMetadata>();
   *metadata = metadata_->Copy();
   return MakeCallWithMetadata(std::move(metadata));
 }
 
 CallInitiator HijackedCall::MakeCallWithMetadata(
     ClientMetadataHandle metadata) {
-  auto call = MakeCallPair(std::move(metadata), call_handler_.event_engine(),
-                           call_handler_.arena()->Ref());
+  auto call = MakeCallPair(std::move(metadata), call_handler_.arena()->Ref());
   destination_->StartCall(std::move(call.handler));
   return std::move(call.initiator);
 }
@@ -58,7 +57,8 @@ class CallStarter final : public UnstartedCallDestination {
   }
 
   void StartCall(UnstartedCallHandler unstarted_call_handler) override {
-    destination_->HandleCall(unstarted_call_handler.StartCall(stack_));
+    unstarted_call_handler.AddCallStack(stack_);
+    destination_->HandleCall(unstarted_call_handler.StartCall());
   }
 
  private:
@@ -79,16 +79,8 @@ class TerminalInterceptor final : public UnstartedCallDestination {
   }
 
   void StartCall(UnstartedCallHandler unstarted_call_handler) override {
-    unstarted_call_handler.SpawnGuarded(
-        "start_call",
-        Map(interception_chain_detail::HijackCall(unstarted_call_handler,
-                                                  destination_, stack_),
-            [](ValueOrFailure<HijackedCall> hijacked_call) -> StatusFlag {
-              if (!hijacked_call.ok()) return Failure{};
-              ForwardCall(hijacked_call.value().original_call_handler(),
-                          hijacked_call.value().MakeLastCall());
-              return Success{};
-            }));
+    unstarted_call_handler.AddCallStack(stack_);
+    destination_->StartCall(unstarted_call_handler);
   }
 
  private:

data/src/core/lib/transport/interception_chain.h

@@ -64,56 +64,64 @@ class HijackedCall final {
   CallHandler call_handler_;
 };
 
-namespace interception_chain_detail {
-
-inline auto HijackCall(UnstartedCallHandler unstarted_call_handler,
-                       RefCountedPtr<UnstartedCallDestination> destination,
-                       RefCountedPtr<CallFilters::Stack> stack) {
-  auto call_handler = unstarted_call_handler.StartCall(stack);
-  return Map(
-      call_handler.PullClientInitialMetadata(),
-      [call_handler,
-       destination](ValueOrFailure<ClientMetadataHandle> metadata) mutable
-      -> ValueOrFailure<HijackedCall> {
-        if (!metadata.ok()) return Failure{};
-        return HijackedCall(std::move(metadata.value()), std::move(destination),
-                            std::move(call_handler));
-      });
-}
-
-}  // namespace interception_chain_detail
-
 // A delegating UnstartedCallDestination for use as a hijacking filter.
+//
+// This class provides the final StartCall method, and delegates to the
+// InterceptCall() method for the actual interception. It has the same semantics
+// as StartCall, but affords the implementation the ability to prepare the
+// UnstartedCallHandler appropriately.
+//
 // Implementations may look at the unprocessed initial metadata
-// and decide to do one of two things:
+// and decide to do one of three things:
 //
 // 1. It can hijack the call. Returns a HijackedCall object that can
 //    be used to start new calls with the same metadata.
 //
 // 2. It can consume the call by calling `Consume`.
 //
+// 3. It can pass the call through to the next interceptor by calling
+//    `PassThrough`.
+//
 // Upon the StartCall call the UnstartedCallHandler will be from the last
 // *Interceptor* in the call chain (without having been processed by any
 // intervening filters) -- note that this is commonly not useful (not enough
 // guarantees), and so it's usually better to Hijack and examine the metadata.
+
 class Interceptor : public UnstartedCallDestination {
+ public:
+  void StartCall(UnstartedCallHandler unstarted_call_handler) final {
+    unstarted_call_handler.AddCallStack(filter_stack_);
+    InterceptCall(std::move(unstarted_call_handler));
+  }
+
  protected:
+  virtual void InterceptCall(UnstartedCallHandler unstarted_call_handler) = 0;
+
   // Returns a promise that resolves to a HijackedCall instance.
   // Hijacking is the process of taking over a call and starting one or more new
   // ones.
   auto Hijack(UnstartedCallHandler unstarted_call_handler) {
-    return interception_chain_detail::HijackCall(
-        std::move(unstarted_call_handler), wrapped_destination_, filter_stack_);
+    auto call_handler = unstarted_call_handler.StartCall();
+    return Map(call_handler.PullClientInitialMetadata(),
+               [call_handler, destination = wrapped_destination_](
+                   ValueOrFailure<ClientMetadataHandle> metadata) mutable
+               -> ValueOrFailure<HijackedCall> {
+                 if (!metadata.ok()) return Failure{};
+                 return HijackedCall(std::move(metadata.value()),
+                                     std::move(destination),
+                                     std::move(call_handler));
+               });
   }
 
   // Consume this call - it will not be passed on to any further filters.
   CallHandler Consume(UnstartedCallHandler unstarted_call_handler) {
-    return unstarted_call_handler.StartCall(filter_stack_);
+    return unstarted_call_handler.StartCall();
   }
 
-  // TODO(ctiller): Consider a Passthrough() method that allows the call to be
-  // passed on to the next filter in the chain without any interception by the
-  // current filter.
+  // Pass through this call to the next filter.
+  void PassThrough(UnstartedCallHandler unstarted_call_handler) {
+    wrapped_destination_->StartCall(std::move(unstarted_call_handler));
+  }
 
  private:
   friend class InterceptionChainBuilder;

data/src/core/lib/transport/metadata.cc

@@ -17,12 +17,12 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
-ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status,
-                                              Arena* arena) {
-  auto hdl = arena->MakePooled<ServerMetadata>();
+ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
   grpc_status_code code;
   std::string message;
   grpc_error_get_status(status, Timestamp::InfFuture(), &code, &message,
@@ -34,4 +34,28 @@ ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status,
   return hdl;
 }
 
+ServerMetadataHandle CancelledServerMetadataFromStatus(
+    const absl::Status& status) {
+  auto hdl = ServerMetadataFromStatus(status);
+  hdl->Set(GrpcCallWasCancelled(), true);
+  return hdl;
+}
+
+ServerMetadataHandle ServerMetadataFromStatus(grpc_status_code code,
+                                              absl::string_view message) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
+  hdl->Set(GrpcStatusMetadata(), code);
+  hdl->Set(GrpcMessageMetadata(), Slice::FromCopiedString(message));
+  return hdl;
+}
+
+ServerMetadataHandle CancelledServerMetadataFromStatus(
+    grpc_status_code code, absl::string_view message) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
+  hdl->Set(GrpcStatusMetadata(), code);
+  hdl->Set(GrpcMessageMetadata(), Slice::FromCopiedString(message));
+  hdl->Set(GrpcCallWasCancelled(), true);
+  return hdl;
+}
+
 }  // namespace grpc_core

data/src/core/lib/transport/metadata.h

@@ -31,6 +31,19 @@ using ServerMetadataHandle = Arena::PoolPtr<ServerMetadata>;
 using ClientMetadata = grpc_metadata_batch;
 using ClientMetadataHandle = Arena::PoolPtr<ClientMetadata>;
 
+// TODO(ctiller): separate when we have different types for client/server
+// metadata.
+template <typename Sink>
+void AbslStringify(Sink& sink, const Arena::PoolPtr<grpc_metadata_batch>& md) {
+  if (md == nullptr) {
+    sink.Append("nullptr");
+    return;
+  }
+  sink.Append("ServerMetadata{");
+  sink.Append(md->DebugString());
+  sink.Append("}");
+}
+
 // Ok/not-ok check for trailing metadata, so that it can be used as result types
 // for TrySeq.
 inline bool IsStatusOk(const ServerMetadataHandle& m) {
@@ -38,8 +51,30 @@ inline bool IsStatusOk(const ServerMetadataHandle& m) {
          GRPC_STATUS_OK;
 }
 
-ServerMetadataHandle ServerMetadataFromStatus(
-    const absl::Status& status, Arena* arena = GetContext<Arena>());
+// Convert absl::Status to ServerMetadata
+ServerMetadataHandle ServerMetadataFromStatus(const absl::Status& status);
+// Convert absl::Status to ServerMetadata, and set GrpcCallWasCancelled() to
+// true
+ServerMetadataHandle CancelledServerMetadataFromStatus(
+    const absl::Status& status);
+// Server metadata with status code set
+inline ServerMetadataHandle ServerMetadataFromStatus(grpc_status_code code) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
+  hdl->Set(GrpcStatusMetadata(), code);
+  return hdl;
+}
+inline ServerMetadataHandle CancelledServerMetadataFromStatus(
+    grpc_status_code code) {
+  auto hdl = Arena::MakePooledForOverwrite<ServerMetadata>();
+  hdl->Set(GrpcStatusMetadata(), code);
+  hdl->Set(GrpcCallWasCancelled(), true);
+  return hdl;
+}
+// The same, but with an error string
+ServerMetadataHandle ServerMetadataFromStatus(grpc_status_code code,
+                                              absl::string_view message);
+ServerMetadataHandle CancelledServerMetadataFromStatus(
+    grpc_status_code code, absl::string_view message);
 
 template <>
 struct StatusCastImpl<ServerMetadataHandle, absl::Status> {

data/src/core/lib/transport/metadata_batch.h

@@ -1322,6 +1322,11 @@ class MetadataMap {
     return builder.TakeOutput();
   }
 
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const MetadataMap& map) {
+    sink.Append(map.DebugString());
+  }
+
   // Get the pointer to the value of some known metadata.
   // Returns nullptr if the metadata is not present.
   // Causes a compilation error if Which is not an element of Traits.

data/src/core/lib/transport/transport.h

@@ -28,6 +28,7 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -35,7 +36,6 @@
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
@@ -191,8 +191,8 @@ void grpc_stream_ref_init(grpc_stream_refcount* refcount, int initial_refs,
 inline void grpc_stream_ref(grpc_stream_refcount* refcount,
                             const char* reason) {
   if (GRPC_TRACE_FLAG_ENABLED(stream_refcount)) {
-    gpr_log(GPR_DEBUG, "%s %p:%p REF %s", refcount->object_type, refcount,
-            refcount->destroy.cb_arg, reason);
+    VLOG(2) << refcount->object_type << " " << refcount << ":"
+            << refcount->destroy.cb_arg << " REF " << reason;
   }
   refcount->refs.RefNonZero(DEBUG_LOCATION, reason);
 }
@@ -208,8 +208,8 @@ void grpc_stream_destroy(grpc_stream_refcount* refcount);
 inline void grpc_stream_unref(grpc_stream_refcount* refcount,
                               const char* reason) {
   if (GRPC_TRACE_FLAG_ENABLED(stream_refcount)) {
-    gpr_log(GPR_DEBUG, "%s %p:%p UNREF %s", refcount->object_type, refcount,
-            refcount->destroy.cb_arg, reason);
+    VLOG(2) << refcount->object_type << " " << refcount << ":"
+            << refcount->destroy.cb_arg << " UNREF " << reason;
   }
   if (GPR_UNLIKELY(refcount->refs.Unref(DEBUG_LOCATION, reason))) {
     grpc_stream_destroy(refcount);
@@ -508,6 +508,8 @@ class Transport : public InternallyRefCounted<Transport> {
   struct RawPointerChannelArgTag {};
   static absl::string_view ChannelArgName() { return GRPC_ARG_TRANSPORT; }
 
+  using InternallyRefCounted<Transport>::InternallyRefCounted;
+
   // Though internally ref counted transports expose their "Ref" method to
   // create a RefCountedPtr to themselves. The OrphanablePtr owner is the
   // singleton decision maker on whether the transport should be destroyed or
@@ -601,6 +603,7 @@ class FilterStackTransport : public Transport {
 
 class ClientTransport : public Transport {
  public:
+  using Transport::Transport;
   virtual void StartCall(CallHandler call_handler) = 0;
 
  protected:
@@ -609,6 +612,7 @@ class ClientTransport : public Transport {
 
 class ServerTransport : public Transport {
  public:
+  using Transport::Transport;
   // Called once slightly after transport setup to register the accept function.
   virtual void SetCallDestination(
       RefCountedPtr<UnstartedCallDestination> unstarted_call_handler) = 0;

data/src/core/load_balancing/child_policy_handler.cc

@@ -20,12 +20,12 @@
 #include <string>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/impl/connectivity_state.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -68,11 +68,10 @@ class ChildPolicyHandler::Helper final
     // into place.
     if (CalledByPendingChild()) {
       if (GRPC_TRACE_FLAG_ENABLED_OBJ(*(parent()->tracer_))) {
-        gpr_log(GPR_INFO,
-                "[child_policy_handler %p] helper %p: pending child policy %p "
-                "reports state=%s (%s)",
-                parent(), this, child_, ConnectivityStateName(state),
-                status.ToString().c_str());
+        LOG(INFO) << "[child_policy_handler " << parent() << "] helper " << this
+                  << ": pending child policy " << child_
+                  << " reports state=" << ConnectivityStateName(state) << " ("
+                  << status << ")";
       }
       if (state == GRPC_CHANNEL_CONNECTING) return;
       grpc_pollset_set_del_pollset_set(
@@ -98,8 +97,8 @@ class ChildPolicyHandler::Helper final
             : parent()->child_policy_.get();
     if (child_ != latest_child_policy) return;
     if (GRPC_TRACE_FLAG_ENABLED_OBJ(*(parent()->tracer_))) {
-      gpr_log(GPR_INFO, "[child_policy_handler %p] requesting re-resolution",
-              parent());
+      LOG(INFO) << "[child_policy_handler " << parent()
+                << "] requesting re-resolution";
     }
     parent()->channel_control_helper()->RequestReresolution();
   }
@@ -133,13 +132,13 @@ class ChildPolicyHandler::Helper final
 
 void ChildPolicyHandler::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED_OBJ(*tracer_)) {
-    gpr_log(GPR_INFO, "[child_policy_handler %p] shutting down", this);
+    LOG(INFO) << "[child_policy_handler " << this << "] shutting down";
   }
   shutting_down_ = true;
   if (child_policy_ != nullptr) {
     if (GRPC_TRACE_FLAG_ENABLED_OBJ(*tracer_)) {
-      gpr_log(GPR_INFO, "[child_policy_handler %p] shutting down lb_policy %p",
-              this, child_policy_.get());
+      LOG(INFO) << "[child_policy_handler " << this
+                << "] shutting down lb_policy " << child_policy_.get();
     }
     grpc_pollset_set_del_pollset_set(child_policy_->interested_parties(),
                                      interested_parties());
@@ -147,9 +146,9 @@ void ChildPolicyHandler::ShutdownLocked() {
   }
   if (pending_child_policy_ != nullptr) {
     if (GRPC_TRACE_FLAG_ENABLED_OBJ(*tracer_)) {
-      gpr_log(GPR_INFO,
-              "[child_policy_handler %p] shutting down pending lb_policy %p",
-              this, pending_child_policy_.get());
+      LOG(INFO) << "[child_policy_handler " << this
+                << "] shutting down pending lb_policy "
+                << pending_child_policy_.get();
     }
     grpc_pollset_set_del_pollset_set(
         pending_child_policy_->interested_parties(), interested_parties());
@@ -224,10 +223,9 @@ absl::Status ChildPolicyHandler::UpdateLocked(UpdateArgs args) {
     // switch to the new policy, even if the new policy stays in
     // CONNECTING for a very long period of time.
     if (GRPC_TRACE_FLAG_ENABLED_OBJ(*tracer_)) {
-      gpr_log(GPR_INFO,
-              "[child_policy_handler %p] creating new %schild policy %s", this,
-              child_policy_ == nullptr ? "" : "pending ",
-              std::string(args.config->name()).c_str());
+      LOG(INFO) << "[child_policy_handler " << this << "] creating new "
+                << (child_policy_ == nullptr ? "" : "pending ")
+                << "child policy " << args.config->name();
     }
     auto& lb_policy =
         child_policy_ == nullptr ? child_policy_ : pending_child_policy_;
@@ -244,10 +242,10 @@ absl::Status ChildPolicyHandler::UpdateLocked(UpdateArgs args) {
   CHECK_NE(policy_to_update, nullptr);
   // Update the policy.
   if (GRPC_TRACE_FLAG_ENABLED_OBJ(*tracer_)) {
-    gpr_log(GPR_INFO, "[child_policy_handler %p] updating %schild policy %p",
-            this,
-            policy_to_update == pending_child_policy_.get() ? "pending " : "",
-            policy_to_update);
+    LOG(INFO) << "[child_policy_handler " << this << "] updating "
+              << (policy_to_update == pending_child_policy_.get() ? "pending "
+                                                                  : "")
+              << "child policy " << policy_to_update;
   }
   return policy_to_update->UpdateLocked(std::move(args));
 }
@@ -282,15 +280,14 @@ OrphanablePtr<LoadBalancingPolicy> ChildPolicyHandler::CreateChildPolicy(
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       CreateLoadBalancingPolicy(child_policy_name, std::move(lb_policy_args));
   if (GPR_UNLIKELY(lb_policy == nullptr)) {
-    gpr_log(GPR_ERROR, "could not create LB policy \"%s\"",
-            std::string(child_policy_name).c_str());
+    LOG(ERROR) << "could not create LB policy \"" << child_policy_name << "\"";
     return nullptr;
   }
   helper->set_child(lb_policy.get());
   if (GRPC_TRACE_FLAG_ENABLED_OBJ(*tracer_)) {
-    gpr_log(GPR_INFO,
-            "[child_policy_handler %p] created new LB policy \"%s\" (%p)", this,
-            std::string(child_policy_name).c_str(), lb_policy.get());
+    LOG(INFO) << "[child_policy_handler " << this
+              << "] created new LB policy \"" << child_policy_name << "\" ("
+              << lb_policy.get() << ")";
   }
   channel_control_helper()->AddTraceEvent(
       ChannelControlHelper::TRACE_INFO,

data/src/core/load_balancing/grpclb/client_load_reporting_filter.cc

@@ -46,8 +46,7 @@ const NoInterceptor ClientLoadReportingFilter::Call::OnFinalize;
 
 const grpc_channel_filter ClientLoadReportingFilter::kFilter =
     MakePromiseBasedFilter<ClientLoadReportingFilter, FilterEndpoint::kClient,
-                           kFilterExaminesServerInitialMetadata>(
-        "client_load_reporting");
+                           kFilterExaminesServerInitialMetadata>();
 
 absl::StatusOr<std::unique_ptr<ClientLoadReportingFilter>>
 ClientLoadReportingFilter::Create(const ChannelArgs&, ChannelFilter::Args) {

data/src/core/load_balancing/grpclb/client_load_reporting_filter.h

@@ -28,6 +28,7 @@
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/load_balancing/grpclb/grpclb_client_stats.h"
 
 namespace grpc_core {
 
@@ -36,6 +37,8 @@ class ClientLoadReportingFilter final
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "client_load_reporting"; }
+
   class Call {
    public:
     void OnClientInitialMetadata(ClientMetadata& client_initial_metadata);