grpc 1.65.2 → 1.66.0.pre3

data/src/core/load_balancing/lb_policy.h

@@ -23,9 +23,9 @@
 #include <memory>
 #include <string>
 #include <utility>
-#include <vector>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/container/inlined_vector.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -33,6 +33,7 @@
 #include "absl/types/variant.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/slice.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/port_platform.h>
@@ -116,29 +117,35 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
    public:
     virtual ~MetadataInterface() = default;
 
-    //////////////////////////////////////////////////////////////////////////
-    // TODO(ctiller): DO NOT MAKE THIS A PUBLIC API YET
-    // This needs some API design to ensure we can add/remove/replace metadata
-    // keys... we're deliberately not doing so to save some time whilst
-    // cleaning up the internal metadata representation, but we should add
-    // something back before making this a public API.
-    //////////////////////////////////////////////////////////////////////////
-
-    /// Adds a key/value pair.
-    /// Does NOT take ownership of \a key or \a value.
-    /// Implementations must ensure that the key and value remain alive
-    /// until the call ends.  If desired, they may be allocated via
-    /// CallState::Alloc().
-    virtual void Add(absl::string_view key, absl::string_view value) = 0;
-
-    /// Produce a vector of metadata key/value strings for tests.
-    virtual std::vector<std::pair<std::string, std::string>>
-    TestOnlyCopyToVector() = 0;
-
     virtual absl::optional<absl::string_view> Lookup(
         absl::string_view key, std::string* buffer) const = 0;
   };
 
+  /// A list of metadata mutations to be returned along with a PickResult.
+  class MetadataMutations {
+   public:
+    /// Sets a key/value pair.  If the key is already present, it will
+    /// be replaced with the new value.
+    void Set(absl::string_view key, absl::string_view value) {
+      Set(key, grpc_event_engine::experimental::Slice::FromCopiedString(value));
+    }
+    void Set(absl::string_view key,
+             grpc_event_engine::experimental::Slice value) {
+      metadata_.push_back({key, std::move(value)});
+    }
+
+   private:
+    friend class MetadataMutationHandler;
+
+    // Avoid allocation if up to 3 additions per LB pick.  Most expected
+    // use cases should be no more than 2, so this gives us a bit of slack.
+    // But it should be cheap to increase this value if we start seeing use
+    // cases with more than 3 additions.
+    absl::InlinedVector<
+        std::pair<absl::string_view, grpc_event_engine::experimental::Slice>, 3>
+        metadata_;
+  };
+
   /// Arguments used when picking a subchannel for a call.
   struct PickArgs {
     /// The path of the call.  Indicates the RPC service and method name.
@@ -210,11 +217,24 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
       /// be used.
       std::unique_ptr<SubchannelCallTrackerInterface> subchannel_call_tracker;
 
+      /// Metadata mutations to be applied to the call.
+      MetadataMutations metadata_mutations;
+
+      /// Authority override for the RPC.
+      /// Will be used only if the application has not explicitly set
+      /// the authority for the RPC.
+      grpc_event_engine::experimental::Slice authority_override;
+
       explicit Complete(
           RefCountedPtr<SubchannelInterface> sc,
-          std::unique_ptr<SubchannelCallTrackerInterface> tracker = nullptr)
+          std::unique_ptr<SubchannelCallTrackerInterface> tracker = nullptr,
+          MetadataMutations md = MetadataMutations(),
+          grpc_event_engine::experimental::Slice authority =
+              grpc_event_engine::experimental::Slice())
           : subchannel(std::move(sc)),
-            subchannel_call_tracker(std::move(tracker)) {}
+            subchannel_call_tracker(std::move(tracker)),
+            metadata_mutations(std::move(md)),
+            authority_override(std::move(authority)) {}
     };
 
     /// Pick cannot be completed until something changes on the control

data/src/core/load_balancing/oob_backend_metric.cc

@@ -24,6 +24,7 @@
 #include <vector>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "google/protobuf/duration.upb.h"
@@ -34,7 +35,6 @@
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
@@ -147,7 +147,7 @@ class OrcaProducer::OrcaStreamEventHandler final
     if (status == GRPC_STATUS_UNIMPLEMENTED) {
       static const char kErrorMessage[] =
           "Orca stream returned UNIMPLEMENTED; disabling";
-      gpr_log(GPR_ERROR, kErrorMessage);
+      LOG(ERROR) << kErrorMessage;
       auto* channelz_node = producer_->subchannel_->channelz_node();
       if (channelz_node != nullptr) {
         channelz_node->AddTraceEvent(
@@ -275,8 +275,8 @@ void OrcaProducer::MaybeStartStreamLocked() {
 void OrcaProducer::NotifyWatchers(
     const BackendMetricData& backend_metric_data) {
   if (GRPC_TRACE_FLAG_ENABLED(orca_client)) {
-    gpr_log(GPR_INFO, "OrcaProducer %p: reporting backend metrics to watchers",
-            this);
+    LOG(INFO) << "OrcaProducer " << this
+              << ": reporting backend metrics to watchers";
   }
   MutexLock lock(&mu_);
   for (OrcaWatcher* watcher : watchers_) {

data/src/core/load_balancing/outlier_detection/outlier_detection.cc

@@ -32,6 +32,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/client_channel/subchannel_interface_internal.h"
@@ -533,11 +533,9 @@ OutlierDetectionLb::Picker::Picker(OutlierDetectionLb* outlier_detection_lb,
                                    bool counting_enabled)
     : picker_(std::move(picker)), counting_enabled_(counting_enabled) {
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] constructed new picker %p and counting "
-            "is %s",
-            outlier_detection_lb, this,
-            (counting_enabled ? "enabled" : "disabled"));
+    LOG(INFO) << "[outlier_detection_lb " << outlier_detection_lb
+              << "] constructed new picker " << this << " and counting "
+              << "is " << (counting_enabled ? "enabled" : "disabled");
   }
 }
 
@@ -577,21 +575,20 @@ LoadBalancingPolicy::PickResult OutlierDetectionLb::Picker::Pick(
 OutlierDetectionLb::OutlierDetectionLb(Args args)
     : LoadBalancingPolicy(std::move(args)) {
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] created", this);
+    LOG(INFO) << "[outlier_detection_lb " << this << "] created";
   }
 }
 
 OutlierDetectionLb::~OutlierDetectionLb() {
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] destroying outlier_detection LB policy",
-            this);
+    LOG(INFO) << "[outlier_detection_lb " << this
+              << "] destroying outlier_detection LB policy";
   }
 }
 
 void OutlierDetectionLb::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] shutting down", this);
+    LOG(INFO) << "[outlier_detection_lb " << this << "] shutting down";
   }
   ejection_timer_.reset();
   shutting_down_ = true;
@@ -617,7 +614,7 @@ void OutlierDetectionLb::ResetBackoffLocked() {
 
 absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] Received update", this);
+    LOG(INFO) << "[outlier_detection_lb " << this << "] Received update";
   }
   auto old_config = std::move(config_);
   // Update config.
@@ -626,15 +623,14 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
   if (!config_->CountingEnabled()) {
     // No need for timer.  Cancel the current timer, if any.
     if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-      gpr_log(GPR_INFO,
-              "[outlier_detection_lb %p] counting disabled, cancelling timer",
-              this);
+      LOG(INFO) << "[outlier_detection_lb " << this
+                << "] counting disabled, cancelling timer";
     }
     ejection_timer_.reset();
   } else if (ejection_timer_ == nullptr) {
     // No timer running.  Start it now.
     if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-      gpr_log(GPR_INFO, "[outlier_detection_lb %p] starting timer", this);
+      LOG(INFO) << "[outlier_detection_lb " << this << "] starting timer";
     }
     ejection_timer_ = MakeOrphanable<EjectionTimer>(
         RefAsSubclass<OutlierDetectionLb>(), Timestamp::Now());
@@ -648,9 +644,8 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
     // Note that if the new deadline is in the past, the timer will fire
     // immediately.
     if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-      gpr_log(GPR_INFO,
-              "[outlier_detection_lb %p] interval changed, replacing timer",
-              this);
+      LOG(INFO) << "[outlier_detection_lb " << this
+                << "] interval changed, replacing timer";
     }
     ejection_timer_ = MakeOrphanable<EjectionTimer>(
         RefAsSubclass<OutlierDetectionLb>(), ejection_timer_->StartTime());
@@ -669,9 +664,8 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
       auto it = endpoint_state_map_.find(key);
       if (it == endpoint_state_map_.end()) {
         if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-          gpr_log(GPR_INFO,
-                  "[outlier_detection_lb %p] adding endpoint entry for %s",
-                  this, key.ToString().c_str());
+          LOG(INFO) << "[outlier_detection_lb " << this
+                    << "] adding endpoint entry for " << key.ToString();
         }
         // The endpoint is not present in the map, so we'll need to add it.
         // Start by getting a pointer to the entry for each address in the
@@ -683,9 +677,8 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
             if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
               std::string address_str = grpc_sockaddr_to_string(&address, false)
                                             .value_or("<unknown>");
-              gpr_log(GPR_INFO,
-                      "[outlier_detection_lb %p] adding address entry for %s",
-                      this, address_str.c_str());
+              LOG(INFO) << "[outlier_detection_lb " << this
+                        << "] adding address entry for " << address_str;
             }
             it2 = subchannel_state_map_
                       .emplace(address, MakeRefCounted<SubchannelState>())
@@ -699,10 +692,9 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
       } else if (!config_->CountingEnabled()) {
         // If counting is not enabled, reset state.
         if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-          gpr_log(GPR_INFO,
-                  "[outlier_detection_lb %p] counting disabled; disabling "
-                  "ejection for %s",
-                  this, key.ToString().c_str());
+          LOG(INFO) << "[outlier_detection_lb " << this
+                    << "] counting disabled; disabling ejection for "
+                    << key.ToString();
         }
         it->second->DisableEjection();
       }
@@ -714,9 +706,8 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
         if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
           std::string address_str =
               grpc_sockaddr_to_string(&it->first, false).value_or("<unknown>");
-          gpr_log(GPR_INFO,
-                  "[outlier_detection_lb %p] removing subchannel map entry %s",
-                  this, address_str.c_str());
+          LOG(INFO) << "[outlier_detection_lb " << this
+                    << "] removing subchannel map entry " << address_str;
         }
         // Don't hold a ref to the corresponding EndpointState object,
         // because there could be subchannel wrappers keeping this alive
@@ -732,9 +723,8 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
          it != endpoint_state_map_.end();) {
       if (current_endpoints.find(it->first) == current_endpoints.end()) {
         if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-          gpr_log(GPR_INFO,
-                  "[outlier_detection_lb %p] removing endpoint map entry %s",
-                  this, it->first.ToString().c_str());
+          LOG(INFO) << "[outlier_detection_lb " << this
+                    << "] removing endpoint map entry " << it->first.ToString();
         }
         it = endpoint_state_map_.erase(it);
       } else {
@@ -753,9 +743,8 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
   update_args.config = config_->child_policy();
   update_args.args = std::move(args.args);
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] Updating child policy handler %p", this,
-            child_policy_.get());
+    LOG(INFO) << "[outlier_detection_lb " << this
+              << "] Updating child policy handler " << child_policy_.get();
   }
   return child_policy_->UpdateLocked(std::move(update_args));
 }
@@ -765,11 +754,10 @@ void OutlierDetectionLb::MaybeUpdatePickerLocked() {
     auto outlier_detection_picker =
         MakeRefCounted<Picker>(this, picker_, config_->CountingEnabled());
     if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-      gpr_log(GPR_INFO,
-              "[outlier_detection_lb %p] updating connectivity: state=%s "
-              "status=(%s) picker=%p",
-              this, ConnectivityStateName(state_), status_.ToString().c_str(),
-              outlier_detection_picker.get());
+      LOG(INFO) << "[outlier_detection_lb " << this
+                << "] updating connectivity: state="
+                << ConnectivityStateName(state_) << " status=(" << status_
+                << ") picker=" << outlier_detection_picker.get();
     }
     channel_control_helper()->UpdateState(state_, status_,
                                           std::move(outlier_detection_picker));
@@ -787,9 +775,8 @@ OrphanablePtr<LoadBalancingPolicy> OutlierDetectionLb::CreateChildPolicyLocked(
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
                                          &outlier_detection_lb_trace);
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] Created new child policy handler %p",
-            this, lb_policy.get());
+    LOG(INFO) << "[outlier_detection_lb " << this
+              << "] Created new child policy handler " << lb_policy.get();
   }
   // Add our interested_parties pollset_set to that of the newly created
   // child policy. This will make the child policy progress upon activity on
@@ -815,10 +802,9 @@ RefCountedPtr<SubchannelInterface> OutlierDetectionLb::Helper::CreateSubchannel(
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
     std::string address_str =
         grpc_sockaddr_to_string(&address, false).value_or("<unknown>");
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] creating subchannel for %s, "
-            "subchannel state %p",
-            parent(), address_str.c_str(), subchannel_state.get());
+    LOG(INFO) << "[outlier_detection_lb " << parent()
+              << "] creating subchannel for " << address_str
+              << ", subchannel state " << subchannel_state.get();
   }
   auto subchannel = MakeRefCounted<SubchannelWrapper>(
       parent()->work_serializer(), subchannel_state,
@@ -835,11 +821,10 @@ void OutlierDetectionLb::Helper::UpdateState(
     RefCountedPtr<SubchannelPicker> picker) {
   if (parent()->shutting_down_) return;
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] child connectivity state update: "
-            "state=%s (%s) picker=%p",
-            parent(), ConnectivityStateName(state), status.ToString().c_str(),
-            picker.get());
+    LOG(INFO) << "[outlier_detection_lb " << parent()
+              << "] child connectivity state update: state="
+              << ConnectivityStateName(state) << " (" << status
+              << ") picker=" << picker.get();
   }
   // Save the state and picker.
   parent()->state_ = state;
@@ -858,8 +843,8 @@ OutlierDetectionLb::EjectionTimer::EjectionTimer(
     : parent_(std::move(parent)), start_time_(start_time) {
   auto interval = parent_->config_->outlier_detection_config().interval;
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] ejection timer will run in %s",
-            parent_.get(), interval.ToString().c_str());
+    LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+              << "] ejection timer will run in " << interval.ToString();
   }
   timer_handle_ = parent_->channel_control_helper()->GetEventEngine()->RunAfter(
       interval, [self = Ref(DEBUG_LOCATION, "EjectionTimer")]() mutable {
@@ -884,8 +869,8 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
   if (!timer_handle_.has_value()) return;
   timer_handle_.reset();
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] ejection timer running",
-            parent_.get());
+    LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+              << "] ejection timer running";
   }
   std::map<EndpointState*, double> success_rate_ejection_candidates;
   std::map<EndpointState*, double> failure_percentage_ejection_candidates;
@@ -924,25 +909,24 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
     }
   }
   if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] found %" PRIuPTR
-            " success rate candidates and %" PRIuPTR
-            " failure percentage candidates; ejected_host_count=%" PRIuPTR
-            "; success_rate_sum=%.3f",
-            parent_.get(), success_rate_ejection_candidates.size(),
-            failure_percentage_ejection_candidates.size(), ejected_host_count,
-            success_rate_sum);
+    LOG(INFO) << "[outlier_detection_lb " << parent_.get() << "] found "
+              << success_rate_ejection_candidates.size()
+              << " success rate candidates and "
+              << failure_percentage_ejection_candidates.size()
+              << " failure percentage candidates; ejected_host_count="
+              << ejected_host_count << "; success_rate_sum="
+              << absl::StrFormat("%.3f", success_rate_sum);
   }
   // success rate algorithm
   if (!success_rate_ejection_candidates.empty() &&
       success_rate_ejection_candidates.size() >=
           config.success_rate_ejection->minimum_hosts) {
     if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-      gpr_log(GPR_INFO,
-              "[outlier_detection_lb %p] running success rate algorithm: "
-              "stdev_factor=%d, enforcement_percentage=%d",
-              parent_.get(), config.success_rate_ejection->stdev_factor,
-              config.success_rate_ejection->enforcement_percentage);
+      LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                << "] running success rate algorithm: "
+                << "stdev_factor=" << config.success_rate_ejection->stdev_factor
+                << ", enforcement_percentage="
+                << config.success_rate_ejection->enforcement_percentage;
     }
     // calculate ejection threshold: (mean - stdev *
     // (success_rate_ejection.stdev_factor / 1000))
@@ -957,27 +941,26 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
         static_cast<double>(config.success_rate_ejection->stdev_factor) / 1000;
     double ejection_threshold = mean - stdev * success_rate_stdev_factor;
     if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-      gpr_log(GPR_INFO,
-              "[outlier_detection_lb %p] stdev=%.3f, ejection_threshold=%.3f",
-              parent_.get(), stdev, ejection_threshold);
+      LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                << "] stdev=" << stdev
+                << ", ejection_threshold=" << ejection_threshold;
     }
     for (auto& candidate : success_rate_ejection_candidates) {
       if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-        gpr_log(GPR_INFO,
-                "[outlier_detection_lb %p] checking candidate %p: "
-                "success_rate=%.3f",
-                parent_.get(), candidate.first, candidate.second);
+        LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                  << "] checking candidate " << candidate.first
+                  << ": success_rate=" << candidate.second;
       }
       if (candidate.second < ejection_threshold) {
         uint32_t random_key = absl::Uniform(bit_gen_, 1, 100);
         double current_percent =
             100.0 * ejected_host_count / parent_->endpoint_state_map_.size();
         if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-          gpr_log(GPR_INFO,
-                  "[outlier_detection_lb %p] random_key=%d "
-                  "ejected_host_count=%" PRIuPTR " current_percent=%.3f",
-                  parent_.get(), random_key, ejected_host_count,
-                  current_percent);
+          LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                    << "] random_key=" << random_key
+                    << " ejected_host_count=" << ejected_host_count
+                    << " current_percent="
+                    << absl::StrFormat("%.3f", current_percent);
         }
         if (random_key < config.success_rate_ejection->enforcement_percentage &&
             (ejected_host_count == 0 ||
@@ -985,8 +968,8 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
           // Eject and record the timestamp for use when ejecting addresses in
           // this iteration.
           if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-            gpr_log(GPR_INFO, "[outlier_detection_lb %p] ejecting candidate",
-                    parent_.get());
+            LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                      << "] ejecting candidate";
           }
           candidate.first->Eject(time_now);
           ++ejected_host_count;
@@ -999,18 +982,17 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
       failure_percentage_ejection_candidates.size() >=
           config.failure_percentage_ejection->minimum_hosts) {
     if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-      gpr_log(GPR_INFO,
-              "[outlier_detection_lb %p] running failure percentage algorithm: "
-              "threshold=%d, enforcement_percentage=%d",
-              parent_.get(), config.failure_percentage_ejection->threshold,
-              config.failure_percentage_ejection->enforcement_percentage);
+      LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                << "] running failure percentage algorithm: "
+                << "threshold=" << config.failure_percentage_ejection->threshold
+                << ", enforcement_percentage="
+                << config.failure_percentage_ejection->enforcement_percentage;
     }
     for (auto& candidate : failure_percentage_ejection_candidates) {
       if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-        gpr_log(GPR_INFO,
-                "[outlier_detection_lb %p] checking candidate %p: "
-                "success_rate=%.3f",
-                parent_.get(), candidate.first, candidate.second);
+        LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                  << "] checking candidate " << candidate.first
+                  << ": success_rate=" << candidate.second;
       }
       // Extra check to make sure success rate algorithm didn't already
       // eject this backend.
@@ -1021,11 +1003,10 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
         double current_percent =
             100.0 * ejected_host_count / parent_->endpoint_state_map_.size();
         if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-          gpr_log(GPR_INFO,
-                  "[outlier_detection_lb %p] random_key=%d "
-                  "ejected_host_count=%" PRIuPTR " current_percent=%.3f",
-                  parent_.get(), random_key, ejected_host_count,
-                  current_percent);
+          LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                    << "] random_key=" << random_key
+                    << " ejected_host_count=" << ejected_host_count
+                    << " current_percent=" << current_percent;
         }
         if (random_key <
                 config.failure_percentage_ejection->enforcement_percentage &&
@@ -1034,8 +1015,8 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
           // Eject and record the timestamp for use when ejecting addresses in
           // this iteration.
           if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-            gpr_log(GPR_INFO, "[outlier_detection_lb %p] ejecting candidate",
-                    parent_.get());
+            LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                      << "] ejecting candidate";
           }
           candidate.first->Eject(time_now);
           ++ejected_host_count;
@@ -1054,8 +1035,9 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
     const bool unejected = endpoint_state->MaybeUneject(
         config.base_ejection_time.millis(), config.max_ejection_time.millis());
     if (unejected && GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
-      gpr_log(GPR_INFO, "[outlier_detection_lb %p] unejected endpoint %s (%p)",
-              parent_.get(), state.first.ToString().c_str(), endpoint_state);
+      LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                << "] unejected endpoint " << state.first.ToString() << " ("
+                << endpoint_state << ")";
     }
   }
   parent_->ejection_timer_ =