grpc 1.64.0 → 1.68.1

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

@@ -16,6 +16,9 @@
 
 #include "src/core/load_balancing/outlier_detection/outlier_detection.h"
 
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/impl/connectivity_state.h>
+#include <grpc/support/port_platform.h>
 #include <inttypes.h>
 #include <stddef.h>
 
@@ -32,37 +35,23 @@
 
 #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"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/variant.h"
-
-#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"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/unique_type_name.h"
-#include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/json/json.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/load_balancing/child_policy_handler.h"
 #include "src/core/load_balancing/delegating_helper.h"
@@ -72,11 +61,18 @@
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/load_balancing/subchannel_interface.h"
 #include "src/core/resolver/endpoint_addresses.h"
+#include "src/core/util/debug_location.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/orphanable.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
+#include "src/core/util/unique_type_name.h"
+#include "src/core/util/validation_errors.h"
+#include "src/core/util/work_serializer.h"
 
 namespace grpc_core {
 
-TraceFlag grpc_outlier_detection_lb_trace(false, "outlier_detection_lb");
-
 namespace {
 
 using ::grpc_event_engine::experimental::EventEngine;
@@ -161,11 +157,14 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
     class WatcherWrapper final
         : public SubchannelInterface::ConnectivityStateWatcherInterface {
      public:
-      WatcherWrapper(std::shared_ptr<
+      WatcherWrapper(WeakRefCountedPtr<SubchannelWrapper> subchannel_wrapper,
+                     std::shared_ptr<
                          SubchannelInterface::ConnectivityStateWatcherInterface>
                          health_watcher,
                      bool ejected)
-          : watcher_(std::move(health_watcher)), ejected_(ejected) {}
+          : subchannel_wrapper_(std::move(subchannel_wrapper)),
+            watcher_(std::move(health_watcher)),
+            ejected_(ejected) {}
 
       void Eject() {
         ejected_ = true;
@@ -173,7 +172,8 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
           watcher_->OnConnectivityStateChange(
               GRPC_CHANNEL_TRANSIENT_FAILURE,
               absl::UnavailableError(
-                  "subchannel ejected by outlier detection"));
+                  absl::StrCat(subchannel_wrapper_->address(),
+                               ": subchannel ejected by outlier detection")));
         }
       }
 
@@ -194,7 +194,8 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
           if (ejected_) {
             new_state = GRPC_CHANNEL_TRANSIENT_FAILURE;
             status = absl::UnavailableError(
-                "subchannel ejected by outlier detection");
+                absl::StrCat(subchannel_wrapper_->address(),
+                             ": subchannel ejected by outlier detection"));
           }
           watcher_->OnConnectivityStateChange(new_state, status);
         }
@@ -205,6 +206,7 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
       }
 
      private:
+      WeakRefCountedPtr<SubchannelWrapper> subchannel_wrapper_;
       std::shared_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
           watcher_;
       absl::optional<grpc_connectivity_state> last_seen_state_;
@@ -465,7 +467,8 @@ void OutlierDetectionLb::SubchannelWrapper::AddDataWatcher(
   if (w->type() == HealthProducer::Type()) {
     auto* health_watcher = static_cast<HealthWatcher*>(watcher.get());
     auto watcher_wrapper = std::make_shared<WatcherWrapper>(
-        health_watcher->TakeWatcher(), ejected_);
+        WeakRefAsSubclass<SubchannelWrapper>(), health_watcher->TakeWatcher(),
+        ejected_);
     watcher_wrapper_ = watcher_wrapper.get();
     health_watcher->SetWatcher(std::move(watcher_wrapper));
   }
@@ -534,13 +537,10 @@ OutlierDetectionLb::Picker::Picker(OutlierDetectionLb* outlier_detection_lb,
                                    RefCountedPtr<SubchannelPicker> picker,
                                    bool counting_enabled)
     : picker_(std::move(picker)), counting_enabled_(counting_enabled) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] constructed new picker %p and counting "
-            "is %s",
-            outlier_detection_lb, this,
-            (counting_enabled ? "enabled" : "disabled"));
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+      << "[outlier_detection_lb " << outlier_detection_lb
+      << "] constructed new picker " << this << " and counting " << "is "
+      << (counting_enabled ? "enabled" : "disabled");
 }
 
 LoadBalancingPolicy::PickResult OutlierDetectionLb::Picker::Pick(
@@ -578,23 +578,19 @@ LoadBalancingPolicy::PickResult OutlierDetectionLb::Picker::Pick(
 
 OutlierDetectionLb::OutlierDetectionLb(Args args)
     : LoadBalancingPolicy(std::move(args)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] created", this);
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+      << "[outlier_detection_lb " << this << "] created";
 }
 
 OutlierDetectionLb::~OutlierDetectionLb() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] destroying outlier_detection LB policy",
-            this);
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+      << "[outlier_detection_lb " << this
+      << "] destroying outlier_detection LB policy";
 }
 
 void OutlierDetectionLb::ShutdownLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] shutting down", this);
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+      << "[outlier_detection_lb " << this << "] shutting down";
   ejection_timer_.reset();
   shutting_down_ = true;
   // Remove the child policy's interested_parties pollset_set from the
@@ -618,26 +614,22 @@ void OutlierDetectionLb::ResetBackoffLocked() {
 }
 
 absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] Received update", this);
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+      << "[outlier_detection_lb " << this << "] Received update";
   auto old_config = std::move(config_);
   // Update config.
   config_ = args.config.TakeAsSubclass<OutlierDetectionLbConfig>();
   // Update outlier detection timer.
   if (!config_->CountingEnabled()) {
     // No need for timer.  Cancel the current timer, if any.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-      gpr_log(GPR_INFO,
-              "[outlier_detection_lb %p] counting disabled, cancelling timer",
-              this);
-    }
+    GRPC_TRACE_LOG(outlier_detection_lb, 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(grpc_outlier_detection_lb_trace)) {
-      gpr_log(GPR_INFO, "[outlier_detection_lb %p] starting timer", this);
-    }
+    GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+        << "[outlier_detection_lb " << this << "] starting timer";
     ejection_timer_ = MakeOrphanable<EjectionTimer>(
         RefAsSubclass<OutlierDetectionLb>(), Timestamp::Now());
     for (const auto& p : endpoint_state_map_) {
@@ -649,11 +641,9 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
     // with the same start time.
     // Note that if the new deadline is in the past, the timer will fire
     // immediately.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-      gpr_log(GPR_INFO,
-              "[outlier_detection_lb %p] interval changed, replacing timer",
-              this);
-    }
+    GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+        << "[outlier_detection_lb " << this
+        << "] interval changed, replacing timer";
     ejection_timer_ = MakeOrphanable<EjectionTimer>(
         RefAsSubclass<OutlierDetectionLb>(), ejection_timer_->StartTime());
   }
@@ -670,11 +660,9 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
       // Find the entry in the endpoint map.
       auto it = endpoint_state_map_.find(key);
       if (it == endpoint_state_map_.end()) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-          gpr_log(GPR_INFO,
-                  "[outlier_detection_lb %p] adding endpoint entry for %s",
-                  this, key.ToString().c_str());
-        }
+        GRPC_TRACE_LOG(outlier_detection_lb, 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
         // subchannel map, creating the entry if needed.
@@ -682,12 +670,11 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
         for (const grpc_resolved_address& address : endpoint.addresses()) {
           auto it2 = subchannel_state_map_.find(address);
           if (it2 == subchannel_state_map_.end()) {
-            if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
+            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>())
@@ -700,12 +687,9 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
             key, MakeRefCounted<EndpointState>(std::move(subchannels)));
       } else if (!config_->CountingEnabled()) {
         // If counting is not enabled, reset state.
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-          gpr_log(GPR_INFO,
-                  "[outlier_detection_lb %p] counting disabled; disabling "
-                  "ejection for %s",
-                  this, key.ToString().c_str());
-        }
+        GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+            << "[outlier_detection_lb " << this
+            << "] counting disabled; disabling ejection for " << key.ToString();
         it->second->DisableEjection();
       }
     });
@@ -713,12 +697,11 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
     for (auto it = subchannel_state_map_.begin();
          it != subchannel_state_map_.end();) {
       if (current_addresses.find(it->first) == current_addresses.end()) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
+        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
@@ -733,11 +716,9 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
     for (auto it = endpoint_state_map_.begin();
          it != endpoint_state_map_.end();) {
       if (current_endpoints.find(it->first) == current_endpoints.end()) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-          gpr_log(GPR_INFO,
-                  "[outlier_detection_lb %p] removing endpoint map entry %s",
-                  this, it->first.ToString().c_str());
-        }
+        GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+            << "[outlier_detection_lb " << this
+            << "] removing endpoint map entry " << it->first.ToString();
         it = endpoint_state_map_.erase(it);
       } else {
         ++it;
@@ -754,11 +735,9 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
   update_args.resolution_note = std::move(args.resolution_note);
   update_args.config = config_->child_policy();
   update_args.args = std::move(args.args);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] Updating child policy handler %p", this,
-            child_policy_.get());
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+      << "[outlier_detection_lb " << this << "] Updating child policy handler "
+      << child_policy_.get();
   return child_policy_->UpdateLocked(std::move(update_args));
 }
 
@@ -766,13 +745,11 @@ void OutlierDetectionLb::MaybeUpdatePickerLocked() {
   if (picker_ != nullptr) {
     auto outlier_detection_picker =
         MakeRefCounted<Picker>(this, picker_, config_->CountingEnabled());
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-      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());
-    }
+    GRPC_TRACE_LOG(outlier_detection_lb, 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,12 +764,10 @@ OrphanablePtr<LoadBalancingPolicy> OutlierDetectionLb::CreateChildPolicyLocked(
       RefAsSubclass<OutlierDetectionLb>(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
-                                         &grpc_outlier_detection_lb_trace);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    gpr_log(GPR_INFO,
-            "[outlier_detection_lb %p] Created new child policy handler %p",
-            this, lb_policy.get());
-  }
+                                         &outlier_detection_lb_trace);
+  GRPC_TRACE_LOG(outlier_detection_lb, 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
   // this policy, which in turn is tied to the application's call.
@@ -814,13 +789,12 @@ RefCountedPtr<SubchannelInterface> OutlierDetectionLb::Helper::CreateSubchannel(
   if (it != parent()->subchannel_state_map_.end()) {
     subchannel_state = it->second->Ref();
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
+  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,
@@ -836,13 +810,11 @@ void OutlierDetectionLb::Helper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
     RefCountedPtr<SubchannelPicker> picker) {
   if (parent()->shutting_down_) return;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    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());
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+      << "[outlier_detection_lb " << parent()
+      << "] child connectivity state update: state="
+      << ConnectivityStateName(state) << " (" << status
+      << ") picker=" << picker.get();
   // Save the state and picker.
   parent()->state_ = state;
   parent()->status_ = status;
@@ -859,10 +831,9 @@ OutlierDetectionLb::EjectionTimer::EjectionTimer(
     RefCountedPtr<OutlierDetectionLb> parent, Timestamp start_time)
     : parent_(std::move(parent)), start_time_(start_time) {
   auto interval = parent_->config_->outlier_detection_config().interval;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] ejection timer will run in %s",
-            parent_.get(), interval.ToString().c_str());
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, 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 {
         ApplicationCallbackExecCtx callback_exec_ctx;
@@ -885,10 +856,9 @@ void OutlierDetectionLb::EjectionTimer::Orphan() {
 void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
   if (!timer_handle_.has_value()) return;
   timer_handle_.reset();
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    gpr_log(GPR_INFO, "[outlier_detection_lb %p] ejection timer running",
-            parent_.get());
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, 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;
   size_t ejected_host_count = 0;
@@ -925,27 +895,24 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
       }
     }
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-    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);
-  }
+  GRPC_TRACE_LOG(outlier_detection_lb, 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(grpc_outlier_detection_lb_trace)) {
-      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);
-    }
+    GRPC_TRACE_LOG(outlier_detection_lb, 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))
     double mean = success_rate_sum / success_rate_ejection_candidates.size();
@@ -958,38 +925,31 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
     const double success_rate_stdev_factor =
         static_cast<double>(config.success_rate_ejection->stdev_factor) / 1000;
     double ejection_threshold = mean - stdev * success_rate_stdev_factor;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-      gpr_log(GPR_INFO,
-              "[outlier_detection_lb %p] stdev=%.3f, ejection_threshold=%.3f",
-              parent_.get(), stdev, ejection_threshold);
-    }
+    GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+        << "[outlier_detection_lb " << parent_.get() << "] stdev=" << stdev
+        << ", ejection_threshold=" << ejection_threshold;
     for (auto& candidate : success_rate_ejection_candidates) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-        gpr_log(GPR_INFO,
-                "[outlier_detection_lb %p] checking candidate %p: "
-                "success_rate=%.3f",
-                parent_.get(), candidate.first, candidate.second);
-      }
+      GRPC_TRACE_LOG(outlier_detection_lb, 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(grpc_outlier_detection_lb_trace)) {
-          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);
-        }
+        GRPC_TRACE_LOG(outlier_detection_lb, 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 ||
              (current_percent < config.max_ejection_percent))) {
           // Eject and record the timestamp for use when ejecting addresses in
           // this iteration.
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-            gpr_log(GPR_INFO, "[outlier_detection_lb %p] ejecting candidate",
-                    parent_.get());
-          }
+          GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+              << "[outlier_detection_lb " << parent_.get()
+              << "] ejecting candidate";
           candidate.first->Eject(time_now);
           ++ejected_host_count;
         }
@@ -1000,20 +960,17 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
   if (!failure_percentage_ejection_candidates.empty() &&
       failure_percentage_ejection_candidates.size() >=
           config.failure_percentage_ejection->minimum_hosts) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-      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);
-    }
+    GRPC_TRACE_LOG(outlier_detection_lb, 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(grpc_outlier_detection_lb_trace)) {
-        gpr_log(GPR_INFO,
-                "[outlier_detection_lb %p] checking candidate %p: "
-                "success_rate=%.3f",
-                parent_.get(), candidate.first, candidate.second);
-      }
+      GRPC_TRACE_LOG(outlier_detection_lb, 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.
       if (candidate.first->ejection_time().has_value()) continue;
@@ -1022,23 +979,20 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
         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(grpc_outlier_detection_lb_trace)) {
-          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);
-        }
+        GRPC_TRACE_LOG(outlier_detection_lb, 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 &&
             (ejected_host_count == 0 ||
              (current_percent < config.max_ejection_percent))) {
           // Eject and record the timestamp for use when ejecting addresses in
           // this iteration.
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-            gpr_log(GPR_INFO, "[outlier_detection_lb %p] ejecting candidate",
-                    parent_.get());
-          }
+          GRPC_TRACE_LOG(outlier_detection_lb, INFO)
+              << "[outlier_detection_lb " << parent_.get()
+              << "] ejecting candidate";
           candidate.first->Eject(time_now);
           ++ejected_host_count;
         }
@@ -1055,9 +1009,10 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
     auto* endpoint_state = state.second.get();
     const bool unejected = endpoint_state->MaybeUneject(
         config.base_ejection_time.millis(), config.max_ejection_time.millis());
-    if (unejected && GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
-      gpr_log(GPR_INFO, "[outlier_detection_lb %p] unejected endpoint %s (%p)",
-              parent_.get(), state.first.ToString().c_str(), endpoint_state);
+    if (unejected && GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
+      LOG(INFO) << "[outlier_detection_lb " << parent_.get()
+                << "] unejected endpoint " << state.first.ToString() << " ("
+                << endpoint_state << ")";
     }
   }
   parent_->ejection_timer_ =

data/src/core/load_balancing/outlier_detection/outlier_detection.h

@@ -17,17 +17,15 @@
 #ifndef GRPC_SRC_CORE_LOAD_BALANCING_OUTLIER_DETECTION_OUTLIER_DETECTION_H
 #define GRPC_SRC_CORE_LOAD_BALANCING_OUTLIER_DETECTION_OUTLIER_DETECTION_H
 
+#include <grpc/support/port_platform.h>
 #include <stdint.h>  // for uint32_t
 
 #include "absl/types/optional.h"
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_args.h"
-#include "src/core/lib/json/json_object_loader.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
+#include "src/core/util/time.h"
+#include "src/core/util/validation_errors.h"
 
 namespace grpc_core {