grpc 1.65.2 → 1.66.0

data/src/core/load_balancing/round_robin/round_robin.cc

@@ -25,6 +25,7 @@
 #include <vector>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
@@ -185,11 +186,10 @@ RoundRobin::Picker::Picker(
   size_t index = absl::Uniform<size_t>(parent->bit_gen_, 0, pickers_.size());
   last_picked_index_.store(index, std::memory_order_relaxed);
   if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-    gpr_log(GPR_INFO,
-            "[RR %p picker %p] created picker from endpoint_list=%p "
-            "with %" PRIuPTR " READY children; last_picked_index_=%" PRIuPTR,
-            parent_, this, parent_->endpoint_list_.get(), pickers_.size(),
-            index);
+    LOG(INFO) << "[RR " << parent_ << " picker " << this
+              << "] created picker from endpoint_list="
+              << parent_->endpoint_list_.get() << " with " << pickers_.size()
+              << " READY children; last_picked_index_=" << index;
   }
 }
 
@@ -197,9 +197,9 @@ RoundRobin::PickResult RoundRobin::Picker::Pick(PickArgs args) {
   size_t index = last_picked_index_.fetch_add(1, std::memory_order_relaxed) %
                  pickers_.size();
   if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-    gpr_log(GPR_INFO,
-            "[RR %p picker %p] using picker index %" PRIuPTR ", picker=%p",
-            parent_, this, index, pickers_[index].get());
+    LOG(INFO) << "[RR " << parent_ << " picker " << this
+              << "] using picker index " << index
+              << ", picker=" << pickers_[index].get();
   }
   return pickers_[index]->Pick(args);
 }
@@ -210,13 +210,13 @@ RoundRobin::PickResult RoundRobin::Picker::Pick(PickArgs args) {
 
 RoundRobin::RoundRobin(Args args) : LoadBalancingPolicy(std::move(args)) {
   if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-    gpr_log(GPR_INFO, "[RR %p] Created", this);
+    LOG(INFO) << "[RR " << this << "] Created";
   }
 }
 
 RoundRobin::~RoundRobin() {
   if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-    gpr_log(GPR_INFO, "[RR %p] Destroying Round Robin policy", this);
+    LOG(INFO) << "[RR " << this << "] Destroying Round Robin policy";
   }
   CHECK(endpoint_list_ == nullptr);
   CHECK(latest_pending_endpoint_list_ == nullptr);
@@ -224,7 +224,7 @@ RoundRobin::~RoundRobin() {
 
 void RoundRobin::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-    gpr_log(GPR_INFO, "[RR %p] Shutting down", this);
+    LOG(INFO) << "[RR " << this << "] Shutting down";
   }
   shutdown_ = true;
   endpoint_list_.reset();
@@ -242,13 +242,13 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
   EndpointAddressesIterator* addresses = nullptr;
   if (args.addresses.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-      gpr_log(GPR_INFO, "[RR %p] received update", this);
+      LOG(INFO) << "[RR " << this << "] received update";
     }
     addresses = args.addresses->get();
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-      gpr_log(GPR_INFO, "[RR %p] received update with address error: %s", this,
-              args.addresses.status().ToString().c_str());
+      LOG(INFO) << "[RR " << this << "] received update with address error: "
+                << args.addresses.status();
     }
     // If we already have a child list, then keep using the existing
     // list, but still report back that the update was not accepted.
@@ -257,8 +257,8 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
   // Create new child list, replacing the previous pending list, if any.
   if (GRPC_TRACE_FLAG_ENABLED(round_robin) &&
       latest_pending_endpoint_list_ != nullptr) {
-    gpr_log(GPR_INFO, "[RR %p] replacing previous pending child list %p", this,
-            latest_pending_endpoint_list_.get());
+    LOG(INFO) << "[RR " << this << "] replacing previous pending child list "
+              << latest_pending_endpoint_list_.get();
   }
   std::vector<std::string> errors;
   latest_pending_endpoint_list_ = MakeOrphanable<RoundRobinEndpointList>(
@@ -268,8 +268,8 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
   // endpoint_list_ and report TRANSIENT_FAILURE.
   if (latest_pending_endpoint_list_->size() == 0) {
     if (GRPC_TRACE_FLAG_ENABLED(round_robin) && endpoint_list_ != nullptr) {
-      gpr_log(GPR_INFO, "[RR %p] replacing previous child list %p", this,
-              endpoint_list_.get());
+      LOG(INFO) << "[RR " << this << "] replacing previous child list "
+                << endpoint_list_.get();
     }
     endpoint_list_ = std::move(latest_pending_endpoint_list_);
     absl::Status status =
@@ -303,18 +303,19 @@ void RoundRobin::RoundRobinEndpointList::RoundRobinEndpoint::OnStateUpdate(
   auto* rr_endpoint_list = endpoint_list<RoundRobinEndpointList>();
   auto* round_robin = policy<RoundRobin>();
   if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-    gpr_log(
-        GPR_INFO,
-        "[RR %p] connectivity changed for child %p, endpoint_list %p "
-        "(index %" PRIuPTR " of %" PRIuPTR "): prev_state=%s new_state=%s (%s)",
-        round_robin, this, rr_endpoint_list, Index(), rr_endpoint_list->size(),
-        (old_state.has_value() ? ConnectivityStateName(*old_state) : "N/A"),
-        ConnectivityStateName(new_state), status.ToString().c_str());
+    LOG(INFO) << "[RR " << round_robin << "] connectivity changed for child "
+              << this << ", endpoint_list " << rr_endpoint_list << " (index "
+              << Index() << " of " << rr_endpoint_list->size()
+              << "): prev_state="
+              << (old_state.has_value() ? ConnectivityStateName(*old_state)
+                                        : "N/A")
+              << " new_state=" << ConnectivityStateName(new_state) << " ("
+              << status << ")";
   }
   if (new_state == GRPC_CHANNEL_IDLE) {
     if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-      gpr_log(GPR_INFO, "[RR %p] child %p reported IDLE; requesting connection",
-              round_robin, this);
+      LOG(INFO) << "[RR " << round_robin << "] child " << this
+                << " reported IDLE; requesting connection";
     }
     ExitIdleLocked();
   }
@@ -380,10 +381,10 @@ void RoundRobin::RoundRobinEndpointList::
           round_robin->endpoint_list_ != nullptr
               ? round_robin->endpoint_list_->CountersString()
               : "";
-      gpr_log(GPR_INFO,
-              "[RR %p] swapping out child list %p (%s) in favor of %p (%s)",
-              round_robin, round_robin->endpoint_list_.get(),
-              old_counters_string.c_str(), this, CountersString().c_str());
+      LOG(INFO) << "[RR " << round_robin << "] swapping out child list "
+                << round_robin->endpoint_list_.get() << " ("
+                << old_counters_string << ") in favor of " << this << " ("
+                << CountersString() << ")";
     }
     round_robin->endpoint_list_ =
         std::move(round_robin->latest_pending_endpoint_list_);
@@ -396,8 +397,8 @@ void RoundRobin::RoundRobinEndpointList::
   // 3) ALL children are TRANSIENT_FAILURE => policy is TRANSIENT_FAILURE.
   if (num_ready_ > 0) {
     if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-      gpr_log(GPR_INFO, "[RR %p] reporting READY with child list %p",
-              round_robin, this);
+      LOG(INFO) << "[RR " << round_robin << "] reporting READY with child list "
+                << this;
     }
     std::vector<RefCountedPtr<LoadBalancingPolicy::SubchannelPicker>> pickers;
     for (const auto& endpoint : endpoints()) {
@@ -412,17 +413,17 @@ void RoundRobin::RoundRobinEndpointList::
         MakeRefCounted<Picker>(round_robin, std::move(pickers)));
   } else if (num_connecting_ > 0) {
     if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-      gpr_log(GPR_INFO, "[RR %p] reporting CONNECTING with child list %p",
-              round_robin, this);
+      LOG(INFO) << "[RR " << round_robin
+                << "] reporting CONNECTING with child list " << this;
     }
     round_robin->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_CONNECTING, absl::Status(),
         MakeRefCounted<QueuePicker>(nullptr));
   } else if (num_transient_failure_ == size()) {
     if (GRPC_TRACE_FLAG_ENABLED(round_robin)) {
-      gpr_log(GPR_INFO,
-              "[RR %p] reporting TRANSIENT_FAILURE with child list %p: %s",
-              round_robin, this, status_for_tf.ToString().c_str());
+      LOG(INFO) << "[RR " << round_robin
+                << "] reporting TRANSIENT_FAILURE with child list " << this
+                << ": " << status_for_tf;
     }
     if (!status_for_tf.ok()) {
       last_failure_ = absl::UnavailableError(

data/src/core/load_balancing/subchannel_interface.h

@@ -76,6 +76,8 @@ class SubchannelInterface : public DualRefCounted<SubchannelInterface> {
 
   // Cancels a connectivity state watch.
   // If the watcher has already been destroyed, this is a no-op.
+  // TODO(roth): This interface has an ABA issue.  Fix this before we
+  // make this API public.
   virtual void CancelConnectivityStateWatch(
       ConnectivityStateWatcherInterface* watcher) = 0;
 
@@ -96,6 +98,8 @@ class SubchannelInterface : public DualRefCounted<SubchannelInterface> {
       std::unique_ptr<DataWatcherInterface> watcher) = 0;
 
   // Cancels a data watch.
+  // TODO(roth): This interface has an ABA issue.  Fix this before we
+  // make this API public.
   virtual void CancelDataWatcher(DataWatcherInterface* watcher) = 0;
 
  protected:

data/src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -29,6 +29,7 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
@@ -41,7 +42,6 @@
 
 #include <grpc/event_engine/event_engine.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"
@@ -448,11 +448,11 @@ void WeightedRoundRobin::EndpointWeight::MaybeUpdateWeight(
   }
   if (weight == 0) {
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-      gpr_log(GPR_INFO,
-              "[WRR %p] subchannel %s: qps=%f, eps=%f, utilization=%f: "
-              "error_util_penalty=%f, weight=%f (not updating)",
-              wrr_.get(), key_.ToString().c_str(), qps, eps, utilization,
-              error_utilization_penalty, weight);
+      LOG(INFO) << "[WRR " << wrr_.get() << "] subchannel " << key_.ToString()
+                << ": qps=" << qps << ", eps=" << eps
+                << ", utilization=" << utilization
+                << ": error_util_penalty=" << error_utilization_penalty
+                << ", weight=" << weight << " (not updating)";
     }
     return;
   }
@@ -460,14 +460,14 @@ void WeightedRoundRobin::EndpointWeight::MaybeUpdateWeight(
   // Grab the lock and update the data.
   MutexLock lock(&mu_);
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO,
-            "[WRR %p] subchannel %s: qps=%f, eps=%f, utilization=%f "
-            "error_util_penalty=%f : setting weight=%f weight_=%f now=%s "
-            "last_update_time_=%s non_empty_since_=%s",
-            wrr_.get(), key_.ToString().c_str(), qps, eps, utilization,
-            error_utilization_penalty, weight, weight_, now.ToString().c_str(),
-            last_update_time_.ToString().c_str(),
-            non_empty_since_.ToString().c_str());
+    LOG(INFO) << "[WRR " << wrr_.get() << "] subchannel " << key_.ToString()
+              << ": qps=" << qps << ", eps=" << eps
+              << ", utilization=" << utilization
+              << " error_util_penalty=" << error_utilization_penalty
+              << " : setting weight=" << weight << " weight_=" << weight_
+              << " now=" << now.ToString()
+              << " last_update_time_=" << last_update_time_.ToString()
+              << " non_empty_since_=" << non_empty_since_.ToString();
   }
   if (non_empty_since_ == Timestamp::InfFuture()) non_empty_since_ = now;
   weight_ = weight;
@@ -479,15 +479,14 @@ float WeightedRoundRobin::EndpointWeight::GetWeight(
     uint64_t* num_not_yet_usable, uint64_t* num_stale) {
   MutexLock lock(&mu_);
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO,
-            "[WRR %p] subchannel %s: getting weight: now=%s "
-            "weight_expiration_period=%s blackout_period=%s "
-            "last_update_time_=%s non_empty_since_=%s weight_=%f",
-            wrr_.get(), key_.ToString().c_str(), now.ToString().c_str(),
-            weight_expiration_period.ToString().c_str(),
-            blackout_period.ToString().c_str(),
-            last_update_time_.ToString().c_str(),
-            non_empty_since_.ToString().c_str(), weight_);
+    LOG(INFO) << "[WRR " << wrr_.get() << "] subchannel " << key_.ToString()
+              << ": getting weight: now=" << now.ToString()
+              << " weight_expiration_period="
+              << weight_expiration_period.ToString()
+              << " blackout_period=" << blackout_period.ToString()
+              << " last_update_time_=" << last_update_time_.ToString()
+              << " non_empty_since_=" << non_empty_since_.ToString()
+              << " weight_=" << weight_;
   }
   // If the most recent update was longer ago than the expiration
   // period, reset non_empty_since_ so that we apply the blackout period
@@ -557,24 +556,25 @@ WeightedRoundRobin::Picker::Picker(RefCountedPtr<WeightedRoundRobin> wrr,
   global_stats().IncrementWrrSubchannelListSize(endpoint_list->size());
   global_stats().IncrementWrrSubchannelReadySize(endpoints_.size());
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO,
-            "[WRR %p picker %p] created picker from endpoint_list=%p "
-            "with %" PRIuPTR " subchannels",
-            wrr_.get(), this, endpoint_list, endpoints_.size());
+    LOG(INFO) << "[WRR " << wrr_.get() << " picker " << this
+              << "] created picker from endpoint_list=" << endpoint_list
+              << " with " << endpoints_.size() << " subchannels";
   }
   BuildSchedulerAndStartTimerLocked();
 }
 
 WeightedRoundRobin::Picker::~Picker() {
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO, "[WRR %p picker %p] destroying picker", wrr_.get(), this);
+    LOG(INFO) << "[WRR " << wrr_.get() << " picker " << this
+              << "] destroying picker";
   }
 }
 
 void WeightedRoundRobin::Picker::Orphaned() {
   MutexLock lock(&timer_mu_);
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO, "[WRR %p picker %p] cancelling timer", wrr_.get(), this);
+    LOG(INFO) << "[WRR " << wrr_.get() << " picker " << this
+              << "] cancelling timer";
   }
   wrr_->channel_control_helper()->GetEventEngine()->Cancel(*timer_handle_);
   timer_handle_.reset();
@@ -586,9 +586,9 @@ WeightedRoundRobin::PickResult WeightedRoundRobin::Picker::Pick(PickArgs args) {
   CHECK(index < endpoints_.size());
   auto& endpoint_info = endpoints_[index];
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO,
-            "[WRR %p picker %p] returning index %" PRIuPTR ", picker=%p",
-            wrr_.get(), this, index, endpoint_info.picker.get());
+    LOG(INFO) << "[WRR " << wrr_.get() << " picker " << this
+              << "] returning index " << index
+              << ", picker=" << endpoint_info.picker.get();
   }
   auto result = endpoint_info.picker->Pick(args);
   // Collect per-call utilization data if needed.
@@ -642,8 +642,8 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
                            {wrr_->channel_control_helper()->GetTarget()},
                            {wrr_->locality_name_});
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO, "[WRR %p picker %p] new weights: %s", wrr_.get(), this,
-            absl::StrJoin(weights, " ").c_str());
+    LOG(INFO) << "[WRR " << wrr_.get() << " picker " << this
+              << "] new weights: " << absl::StrJoin(weights, " ");
   }
   auto scheduler_or = StaticStrideScheduler::Make(
       weights, [this]() { return wrr_->scheduler_state_.fetch_add(1); });
@@ -652,13 +652,13 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
     scheduler =
         std::make_shared<StaticStrideScheduler>(std::move(*scheduler_or));
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-      gpr_log(GPR_INFO, "[WRR %p picker %p] new scheduler: %p", wrr_.get(),
-              this, scheduler.get());
+      LOG(INFO) << "[WRR " << wrr_.get() << " picker " << this
+                << "] new scheduler: " << scheduler.get();
     }
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-      gpr_log(GPR_INFO, "[WRR %p picker %p] no scheduler, falling back to RR",
-              wrr_.get(), this);
+      LOG(INFO) << "[WRR " << wrr_.get() << " picker " << this
+                << "] no scheduler, falling back to RR";
     }
     stats_plugins.AddCounter(kMetricRrFallback, 1,
                              {wrr_->channel_control_helper()->GetTarget()},
@@ -670,8 +670,9 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
   }
   // Start timer.
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO, "[WRR %p picker %p] scheduling timer for %s", wrr_.get(),
-            this, config_->weight_update_period().ToString().c_str());
+    LOG(INFO) << "[WRR " << wrr_.get() << " picker " << this
+              << "] scheduling timer for "
+              << config_->weight_update_period().ToString();
   }
   timer_handle_ = wrr_->channel_control_helper()->GetEventEngine()->RunAfter(
       config_->weight_update_period(),
@@ -683,8 +684,8 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
           MutexLock lock(&self->timer_mu_);
           if (self->timer_handle_.has_value()) {
             if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-              gpr_log(GPR_INFO, "[WRR %p picker %p] timer fired",
-                      self->wrr_.get(), self.get());
+              LOG(INFO) << "[WRR " << self->wrr_.get() << " picker "
+                        << self.get() << "] timer fired";
             }
             self->BuildSchedulerAndStartTimerLocked();
           }
@@ -708,14 +709,14 @@ WeightedRoundRobin::WeightedRoundRobin(Args args)
                          .GetString(GRPC_ARG_LB_WEIGHTED_TARGET_CHILD)
                          .value_or("")) {
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO, "[WRR %p] Created -- locality_name=\"%s\"", this,
-            std::string(locality_name_).c_str());
+    LOG(INFO) << "[WRR " << this << "] Created -- locality_name=\""
+              << std::string(locality_name_) << "\"";
   }
 }
 
 WeightedRoundRobin::~WeightedRoundRobin() {
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO, "[WRR %p] Destroying Round Robin policy", this);
+    LOG(INFO) << "[WRR " << this << "] Destroying Round Robin policy";
   }
   CHECK(endpoint_list_ == nullptr);
   CHECK(latest_pending_endpoint_list_ == nullptr);
@@ -723,7 +724,7 @@ WeightedRoundRobin::~WeightedRoundRobin() {
 
 void WeightedRoundRobin::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO, "[WRR %p] Shutting down", this);
+    LOG(INFO) << "[WRR " << this << "] Shutting down";
   }
   shutdown_ = true;
   endpoint_list_.reset();
@@ -743,7 +744,7 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
   std::shared_ptr<EndpointAddressesIterator> addresses;
   if (args.addresses.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-      gpr_log(GPR_INFO, "[WRR %p] received update", this);
+      LOG(INFO) << "[WRR " << this << "] received update";
     }
     // Weed out duplicate endpoints.  Also sort the endpoints so that if
     // the set of endpoints doesn't change, their indexes in the endpoint
@@ -771,8 +772,8 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
             ordered_addresses.begin(), ordered_addresses.end()));
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-      gpr_log(GPR_INFO, "[WRR %p] received update with address error: %s", this,
-              args.addresses.status().ToString().c_str());
+      LOG(INFO) << "[WRR " << this << "] received update with address error: "
+                << args.addresses.status().ToString();
     }
     // If we already have an endpoint list, then keep using the existing
     // list, but still report back that the update was not accepted.
@@ -781,8 +782,9 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
   // Create new endpoint list, replacing the previous pending list, if any.
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb) &&
       latest_pending_endpoint_list_ != nullptr) {
-    gpr_log(GPR_INFO, "[WRR %p] replacing previous pending endpoint list %p",
-            this, latest_pending_endpoint_list_.get());
+    LOG(INFO) << "[WRR " << this
+              << "] replacing previous pending endpoint list "
+              << latest_pending_endpoint_list_.get();
   }
   std::vector<std::string> errors;
   latest_pending_endpoint_list_ = MakeOrphanable<WrrEndpointList>(
@@ -792,8 +794,8 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
   if (latest_pending_endpoint_list_->size() == 0) {
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb) &&
         endpoint_list_ != nullptr) {
-      gpr_log(GPR_INFO, "[WRR %p] replacing previous endpoint list %p", this,
-              endpoint_list_.get());
+      LOG(INFO) << "[WRR " << this << "] replacing previous endpoint list "
+                << endpoint_list_.get();
     }
     endpoint_list_ = std::move(latest_pending_endpoint_list_);
     absl::Status status =
@@ -874,19 +876,19 @@ void WeightedRoundRobin::WrrEndpointList::WrrEndpoint::OnStateUpdate(
   auto* wrr_endpoint_list = endpoint_list<WrrEndpointList>();
   auto* wrr = policy<WeightedRoundRobin>();
   if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-    gpr_log(GPR_INFO,
-            "[WRR %p] connectivity changed for child %p, endpoint_list %p "
-            "(index %" PRIuPTR " of %" PRIuPTR
-            "): prev_state=%s new_state=%s (%s)",
-            wrr, this, wrr_endpoint_list, Index(), wrr_endpoint_list->size(),
-            (old_state.has_value() ? ConnectivityStateName(*old_state) : "N/A"),
-            ConnectivityStateName(new_state), status.ToString().c_str());
+    LOG(INFO) << "[WRR " << wrr << "] connectivity changed for child " << this
+              << ", endpoint_list " << wrr_endpoint_list << " (index "
+              << Index() << " of " << wrr_endpoint_list->size()
+              << "): prev_state="
+              << (old_state.has_value() ? ConnectivityStateName(*old_state)
+                                        : "N/A")
+              << " new_state=" << ConnectivityStateName(new_state) << " ("
+              << status << ")";
   }
   if (new_state == GRPC_CHANNEL_IDLE) {
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-      gpr_log(GPR_INFO,
-              "[WRR %p] child %p reported IDLE; requesting connection", wrr,
-              this);
+      LOG(INFO) << "[WRR " << wrr << "] child " << this
+                << " reported IDLE; requesting connection";
     }
     ExitIdleLocked();
   } else if (new_state == GRPC_CHANNEL_READY) {
@@ -968,10 +970,9 @@ void WeightedRoundRobin::WrrEndpointList::
       const std::string old_counters_string =
           wrr->endpoint_list_ != nullptr ? wrr->endpoint_list_->CountersString()
                                          : "";
-      gpr_log(GPR_INFO,
-              "[WRR %p] swapping out endpoint list %p (%s) in favor of %p (%s)",
-              wrr, wrr->endpoint_list_.get(), old_counters_string.c_str(), this,
-              CountersString().c_str());
+      LOG(INFO) << "[WRR " << wrr << "] swapping out endpoint list "
+                << wrr->endpoint_list_.get() << " (" << old_counters_string
+                << ") in favor of " << this << " (" << CountersString() << ")";
     }
     wrr->endpoint_list_ = std::move(wrr->latest_pending_endpoint_list_);
   }
@@ -983,25 +984,25 @@ void WeightedRoundRobin::WrrEndpointList::
   // 3) ALL children are TRANSIENT_FAILURE => policy is TRANSIENT_FAILURE.
   if (num_ready_ > 0) {
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-      gpr_log(GPR_INFO, "[WRR %p] reporting READY with endpoint list %p", wrr,
-              this);
+      LOG(INFO) << "[WRR " << wrr << "] reporting READY with endpoint list "
+                << this;
     }
     wrr->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_READY, absl::Status(),
         MakeRefCounted<Picker>(wrr->RefAsSubclass<WeightedRoundRobin>(), this));
   } else if (num_connecting_ > 0) {
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-      gpr_log(GPR_INFO, "[WRR %p] reporting CONNECTING with endpoint list %p",
-              wrr, this);
+      LOG(INFO) << "[WRR " << wrr
+                << "] reporting CONNECTING with endpoint list " << this;
     }
     wrr->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_CONNECTING, absl::Status(),
         MakeRefCounted<QueuePicker>(nullptr));
   } else if (num_transient_failure_ == size()) {
     if (GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)) {
-      gpr_log(GPR_INFO,
-              "[WRR %p] reporting TRANSIENT_FAILURE with endpoint list %p: %s",
-              wrr, this, status_for_tf.ToString().c_str());
+      LOG(INFO) << "[WRR " << wrr
+                << "] reporting TRANSIENT_FAILURE with endpoint list " << this
+                << ": " << status_for_tf;
     }
     if (!status_for_tf.ok()) {
       last_failure_ = absl::UnavailableError(