grpc 1.70.1 → 1.71.0

data/src/core/load_balancing/health_check_client.cc

@@ -24,6 +24,7 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
@@ -35,7 +36,6 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/subchannel.h"
@@ -63,31 +63,6 @@
 
 namespace grpc_core {
 
-namespace {
-
-// A fire-and-forget class to asynchronously drain a WorkSerializer queue.
-class AsyncWorkSerializerDrainer final {
- public:
-  explicit AsyncWorkSerializerDrainer(
-      std::shared_ptr<WorkSerializer> work_serializer)
-      : work_serializer_(std::move(work_serializer)) {
-    GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
-    ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
-  }
-
- private:
-  static void RunInExecCtx(void* arg, grpc_error_handle) {
-    auto* self = static_cast<AsyncWorkSerializerDrainer*>(arg);
-    self->work_serializer_->DrainQueue();
-    delete self;
-  }
-
-  std::shared_ptr<WorkSerializer> work_serializer_;
-  grpc_closure closure_;
-};
-
-}  // namespace
-
 //
 // HealthProducer::HealthChecker
 //
@@ -147,15 +122,12 @@ void HealthProducer::HealthChecker::NotifyWatchersLocked(
   GRPC_TRACE_LOG(health_check_client, INFO)
       << "HealthProducer " << producer_.get() << " HealthChecker " << this
       << ": reporting state " << ConnectivityStateName(state) << " to watchers";
-  work_serializer_->Schedule(
-      [self = Ref(), state, status = std::move(status)]() {
-        MutexLock lock(&self->producer_->mu_);
-        for (HealthWatcher* watcher : self->watchers_) {
-          watcher->Notify(state, status);
-        }
-      },
-      DEBUG_LOCATION);
-  new AsyncWorkSerializerDrainer(work_serializer_);
+  work_serializer_->Run([self = Ref(), state, status = std::move(status)]() {
+    MutexLock lock(&self->producer_->mu_);
+    for (HealthWatcher* watcher : self->watchers_) {
+      watcher->Notify(state, status);
+    }
+  });
 }
 
 void HealthProducer::HealthChecker::OnHealthWatchStatusChange(
@@ -168,7 +140,7 @@ void HealthProducer::HealthChecker::OnHealthWatchStatusChange(
         status.code(), absl::StrCat(producer_->subchannel_->address(), ": ",
                                     status.message()));
   }
-  work_serializer_->Schedule(
+  work_serializer_->Run(
       [self = Ref(), state, status = std::move(use_status)]() mutable {
         MutexLock lock(&self->producer_->mu_);
         if (self->stream_client_ != nullptr) {
@@ -178,9 +150,7 @@ void HealthProducer::HealthChecker::OnHealthWatchStatusChange(
             watcher->Notify(state, self->status_);
           }
         }
-      },
-      DEBUG_LOCATION);
-  new AsyncWorkSerializerDrainer(work_serializer_);
+      });
 }
 
 //
@@ -359,7 +329,7 @@ void HealthProducer::Orphaned() {
 
 void HealthProducer::AddWatcher(
     HealthWatcher* watcher,
-    const absl::optional<std::string>& health_check_service_name) {
+    const std::optional<std::string>& health_check_service_name) {
   MutexLock lock(&mu_);
   grpc_pollset_set_add_pollset_set(interested_parties_,
                                    watcher->interested_parties());
@@ -380,7 +350,7 @@ void HealthProducer::AddWatcher(
 
 void HealthProducer::RemoveWatcher(
     HealthWatcher* watcher,
-    const absl::optional<std::string>& health_check_service_name) {
+    const std::optional<std::string>& health_check_service_name) {
   MutexLock lock(&mu_);
   grpc_pollset_set_del_pollset_set(interested_parties_,
                                    watcher->interested_parties());
@@ -412,8 +382,8 @@ void HealthProducer::OnConnectivityStateChange(grpc_connectivity_state state,
   }
   state_ = state;
   status_ = status;
-  for (const auto& p : health_checkers_) {
-    p.second->OnConnectivityStateChangeLocked(state, status);
+  for (const auto& [_, health_checker] : health_checkers_) {
+    health_checker->OnConnectivityStateChangeLocked(state, status);
   }
   for (HealthWatcher* watcher : non_health_watchers_) {
     watcher->Notify(state, status);
@@ -466,12 +436,10 @@ void HealthWatcher::SetSubchannel(Subchannel* subchannel) {
 }
 
 void HealthWatcher::Notify(grpc_connectivity_state state, absl::Status status) {
-  work_serializer_->Schedule(
+  work_serializer_->Run(
       [watcher = watcher_, state, status = std::move(status)]() mutable {
         watcher->OnConnectivityStateChange(state, std::move(status));
-      },
-      DEBUG_LOCATION);
-  new AsyncWorkSerializerDrainer(work_serializer_);
+      });
 }
 
 //
@@ -483,7 +451,7 @@ MakeHealthCheckWatcher(
     std::shared_ptr<WorkSerializer> work_serializer, const ChannelArgs& args,
     std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
         watcher) {
-  absl::optional<std::string> health_check_service_name;
+  std::optional<std::string> health_check_service_name;
   if (!args.GetBool(GRPC_ARG_INHIBIT_HEALTH_CHECKING).value_or(false)) {
     health_check_service_name =
         args.GetOwnedString(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME);

data/src/core/load_balancing/health_check_client_internal.h

@@ -22,6 +22,7 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <utility>
@@ -29,7 +30,6 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/client_channel/subchannel_interface_internal.h"
 #include "src/core/client_channel/subchannel_stream_client.h"
@@ -65,10 +65,10 @@ class HealthProducer final : public Subchannel::DataProducerInterface {
   UniqueTypeName type() const override { return Type(); }
 
   void AddWatcher(HealthWatcher* watcher,
-                  const absl::optional<std::string>& health_check_service_name);
+                  const std::optional<std::string>& health_check_service_name);
   void RemoveWatcher(
       HealthWatcher* watcher,
-      const absl::optional<std::string>& health_check_service_name);
+      const std::optional<std::string>& health_check_service_name);
 
  private:
   class ConnectivityWatcher;
@@ -124,7 +124,7 @@ class HealthProducer final : public Subchannel::DataProducerInterface {
         std::make_shared<WorkSerializer>(
             producer_->subchannel_->event_engine());
 
-    absl::optional<grpc_connectivity_state> state_
+    std::optional<grpc_connectivity_state> state_
         ABSL_GUARDED_BY(&HealthProducer::mu_);
     absl::Status status_ ABSL_GUARDED_BY(&HealthProducer::mu_);
     OrphanablePtr<SubchannelStreamClient> stream_client_
@@ -142,7 +142,7 @@ class HealthProducer final : public Subchannel::DataProducerInterface {
   grpc_pollset_set* interested_parties_;
 
   Mutex mu_;
-  absl::optional<grpc_connectivity_state> state_ ABSL_GUARDED_BY(&mu_);
+  std::optional<grpc_connectivity_state> state_ ABSL_GUARDED_BY(&mu_);
   absl::Status status_ ABSL_GUARDED_BY(&mu_);
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_
       ABSL_GUARDED_BY(&mu_);
@@ -157,7 +157,7 @@ class HealthWatcher final : public InternalSubchannelDataWatcherInterface {
  public:
   HealthWatcher(
       std::shared_ptr<WorkSerializer> work_serializer,
-      absl::optional<std::string> health_check_service_name,
+      std::optional<std::string> health_check_service_name,
       std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
           watcher)
       : work_serializer_(std::move(work_serializer)),
@@ -190,7 +190,7 @@ class HealthWatcher final : public InternalSubchannelDataWatcherInterface {
 
  private:
   std::shared_ptr<WorkSerializer> work_serializer_;
-  absl::optional<std::string> health_check_service_name_;
+  std::optional<std::string> health_check_service_name_;
   std::shared_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
       watcher_;
   RefCountedPtr<HealthProducer> producer_;

data/src/core/load_balancing/lb_policy.cc

@@ -79,12 +79,10 @@ LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
                  GRPC_CLOSURE_CREATE(
                      [](void* arg, grpc_error_handle /*error*/) {
                        auto* parent = static_cast<LoadBalancingPolicy*>(arg);
-                       parent->work_serializer()->Run(
-                           [parent]() {
-                             parent->ExitIdleLocked();
-                             parent->Unref();
-                           },
-                           DEBUG_LOCATION);
+                       parent->work_serializer()->Run([parent]() {
+                         parent->ExitIdleLocked();
+                         parent->Unref();
+                       });
                      },
                      parent, nullptr),
                  absl::OkStatus());

data/src/core/load_balancing/lb_policy.h

@@ -26,16 +26,16 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 
 #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"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -115,7 +115,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
    public:
     virtual ~MetadataInterface() = default;
 
-    virtual absl::optional<absl::string_view> Lookup(
+    virtual std::optional<absl::string_view> Lookup(
         absl::string_view key, std::string* buffer) const = 0;
   };
 
@@ -253,7 +253,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
     // A pick result must be one of these types.
     // Default to Queue, just to allow default construction.
-    absl::variant<Complete, Queue, Fail, Drop> result = Queue();
+    std::variant<Complete, Queue, Fail, Drop> result = Queue();
 
     PickResult() = default;
     // NOLINTNEXTLINE(google-explicit-constructor)

data/src/core/load_balancing/lb_policy_registry.cc

@@ -108,15 +108,16 @@ LoadBalancingPolicyRegistry::ParseLoadBalancingConfigHelper(
       return absl::InvalidArgumentError("oneOf violation");
     }
     auto it = lb_config.object().begin();
-    if (it->second.type() != Json::Type::kObject) {
+    auto& [policy_name, config] = *it;
+    if (config.type() != Json::Type::kObject) {
       return absl::InvalidArgumentError("child entry should be of type object");
     }
     // If we support this policy, then select it.
-    if (LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
-            it->first.c_str(), nullptr)) {
+    if (LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(policy_name,
+                                                               nullptr)) {
       return it;
     }
-    policies_tried.push_back(it->first);
+    policies_tried.push_back(policy_name);
   }
   return absl::FailedPreconditionError(absl::StrCat(
       "No known policies in list: ", absl::StrJoin(policies_tried, " ")));
@@ -126,15 +127,16 @@ absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
 LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(const Json& json) const {
   auto policy = ParseLoadBalancingConfigHelper(json);
   if (!policy.ok()) return policy.status();
+  auto& [policy_name, config] = **policy;
   // Find factory.
   LoadBalancingPolicyFactory* factory =
-      GetLoadBalancingPolicyFactory((*policy)->first.c_str());
+      GetLoadBalancingPolicyFactory(policy_name);
   if (factory == nullptr) {
-    return absl::FailedPreconditionError(absl::StrFormat(
-        "Factory not found for policy \"%s\"", (*policy)->first));
+    return absl::FailedPreconditionError(
+        absl::StrFormat("Factory not found for policy \"%s\"", policy_name));
   }
   // Parse load balancing config via factory.
-  return factory->ParseLoadBalancingConfig((*policy)->second);
+  return factory->ParseLoadBalancingConfig(config);
 }
 
 }  // namespace grpc_core

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

@@ -31,6 +31,7 @@
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
@@ -41,7 +42,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 #include "src/core/client_channel/subchannel_interface_internal.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -209,25 +209,17 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
       WeakRefCountedPtr<SubchannelWrapper> subchannel_wrapper_;
       std::shared_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
           watcher_;
-      absl::optional<grpc_connectivity_state> last_seen_state_;
+      std::optional<grpc_connectivity_state> last_seen_state_;
       absl::Status last_seen_status_;
       bool ejected_;
     };
 
     void Orphaned() override {
-      if (!IsWorkSerializerDispatchEnabled()) {
-        if (subchannel_state_ != nullptr) {
-          subchannel_state_->RemoveSubchannel(this);
+      work_serializer_->Run([self = WeakRefAsSubclass<SubchannelWrapper>()]() {
+        if (self->subchannel_state_ != nullptr) {
+          self->subchannel_state_->RemoveSubchannel(self.get());
         }
-        return;
-      }
-      work_serializer_->Run(
-          [self = WeakRefAsSubclass<SubchannelWrapper>()]() {
-            if (self->subchannel_state_ != nullptr) {
-              self->subchannel_state_->RemoveSubchannel(self.get());
-            }
-          },
-          DEBUG_LOCATION);
+      });
     }
 
     std::shared_ptr<WorkSerializer> work_serializer_;
@@ -295,11 +287,11 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
       active_bucket_.store(current_bucket_.get());
     }
 
-    absl::optional<std::pair<double, uint64_t>> GetSuccessRateAndVolume() {
+    std::optional<std::pair<double, uint64_t>> GetSuccessRateAndVolume() {
       uint64_t total_request =
           backup_bucket_->successes + backup_bucket_->failures;
       if (total_request == 0) {
-        return absl::nullopt;
+        return std::nullopt;
       }
       double success_rate =
           backup_bucket_->successes * 100.0 /
@@ -312,7 +304,7 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
 
     void AddFailureCount() { active_bucket_.load()->failures.fetch_add(1); }
 
-    absl::optional<Timestamp> ejection_time() const { return ejection_time_; }
+    std::optional<Timestamp> ejection_time() const { return ejection_time_; }
 
     void Eject(const Timestamp& time) {
       ejection_time_ = time;
@@ -369,7 +361,7 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
     // Points to either current_bucket or active_bucket.
     std::atomic<Bucket*> active_bucket_{current_bucket_.get()};
     uint32_t multiplier_ = 0;
-    absl::optional<Timestamp> ejection_time_;
+    std::optional<Timestamp> ejection_time_;
   };
 
   // A picker that wraps the picker from the child to perform outlier detection.
@@ -413,7 +405,7 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
     void OnTimerLocked();
 
     RefCountedPtr<OutlierDetectionLb> parent_;
-    absl::optional<EventEngine::TaskHandle> timer_handle_;
+    std::optional<EventEngine::TaskHandle> timer_handle_;
     Timestamp start_time_;
     absl::BitGen bit_gen_;
   };
@@ -551,7 +543,7 @@ LoadBalancingPolicy::PickResult OutlierDetectionLb::Picker::Pick(
   }
   // Delegate to child picker
   PickResult result = picker_->Pick(args);
-  auto* complete_pick = absl::get_if<PickResult::Complete>(&result.result);
+  auto* complete_pick = std::get_if<PickResult::Complete>(&result.result);
   if (complete_pick != nullptr) {
     auto* subchannel_wrapper =
         static_cast<SubchannelWrapper*>(complete_pick->subchannel.get());
@@ -632,8 +624,8 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
         << "[outlier_detection_lb " << this << "] starting timer";
     ejection_timer_ = MakeOrphanable<EjectionTimer>(
         RefAsSubclass<OutlierDetectionLb>(), Timestamp::Now());
-    for (const auto& p : endpoint_state_map_) {
-      p.second->RotateBucket();  // Reset call counters.
+    for (const auto& [_, endpoint_state] : endpoint_state_map_) {
+      endpoint_state->RotateBucket();  // Reset call counters.
     }
   } else if (old_config->outlier_detection_config().interval !=
              config_->outlier_detection_config().interval) {
@@ -696,17 +688,18 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
     // Remove any entries we no longer need in the subchannel map.
     for (auto it = subchannel_state_map_.begin();
          it != subchannel_state_map_.end();) {
-      if (current_addresses.find(it->first) == current_addresses.end()) {
+      auto& [address, subchannel_state] = *it;
+      if (current_addresses.find(address) == current_addresses.end()) {
         if (GRPC_TRACE_FLAG_ENABLED(outlier_detection_lb)) {
           std::string address_str =
-              grpc_sockaddr_to_string(&it->first, false).value_or("<unknown>");
+              grpc_sockaddr_to_string(&address, false).value_or("<unknown>");
           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
         // for a while, and we don't need them to do any call tracking.
-        it->second->set_endpoint_state(nullptr);
+        subchannel_state->set_endpoint_state(nullptr);
         it = subchannel_state_map_.erase(it);
       } else {
         ++it;
@@ -715,10 +708,13 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
     // Remove any entries we no longer need in the endpoint map.
     for (auto it = endpoint_state_map_.begin();
          it != endpoint_state_map_.end();) {
-      if (current_endpoints.find(it->first) == current_endpoints.end()) {
+      auto& endpoint_addresses = it->first;
+      if (current_endpoints.find(endpoint_addresses) ==
+          current_endpoints.end()) {
         GRPC_TRACE_LOG(outlier_detection_lb, INFO)
             << "[outlier_detection_lb " << this
-            << "] removing endpoint map entry " << it->first.ToString();
+            << "] removing endpoint map entry "
+            << endpoint_addresses.ToString();
         it = endpoint_state_map_.erase(it);
       } else {
         ++it;
@@ -836,12 +832,10 @@ OutlierDetectionLb::EjectionTimer::EjectionTimer(
       << "] 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;
         ExecCtx exec_ctx;
         auto self_ptr = self.get();
         self_ptr->parent_->work_serializer()->Run(
-            [self = std::move(self)]() { self->OnTimerLocked(); },
-            DEBUG_LOCATION);
+            [self = std::move(self)]() { self->OnTimerLocked(); });
       });
 }
 
@@ -865,33 +859,28 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
   double success_rate_sum = 0;
   auto time_now = Timestamp::Now();
   auto& config = parent_->config_->outlier_detection_config();
-  for (auto& state : parent_->endpoint_state_map_) {
-    auto* endpoint_state = state.second.get();
+  for (auto& [_, endpoint_state] : parent_->endpoint_state_map_) {
     // For each address, swap the call counter's buckets in that address's
     // map entry.
     endpoint_state->RotateBucket();
     // Gather data to run success rate algorithm or failure percentage
     // algorithm.
-    if (endpoint_state->ejection_time().has_value()) {
-      ++ejected_host_count;
-    }
-    absl::optional<std::pair<double, uint64_t>> host_success_rate_and_volume =
+    if (endpoint_state->ejection_time().has_value()) ++ejected_host_count;
+    std::optional<std::pair<double, uint64_t>> host_success_rate_and_volume =
         endpoint_state->GetSuccessRateAndVolume();
-    if (!host_success_rate_and_volume.has_value()) {
-      continue;
-    }
-    double success_rate = host_success_rate_and_volume->first;
-    uint64_t request_volume = host_success_rate_and_volume->second;
+    if (!host_success_rate_and_volume.has_value()) continue;
+    auto [success_rate, request_volume] = *host_success_rate_and_volume;
     if (config.success_rate_ejection.has_value()) {
       if (request_volume >= config.success_rate_ejection->request_volume) {
-        success_rate_ejection_candidates[endpoint_state] = success_rate;
+        success_rate_ejection_candidates[endpoint_state.get()] = success_rate;
         success_rate_sum += success_rate;
       }
     }
     if (config.failure_percentage_ejection.has_value()) {
       if (request_volume >=
           config.failure_percentage_ejection->request_volume) {
-        failure_percentage_ejection_candidates[endpoint_state] = success_rate;
+        failure_percentage_ejection_candidates[endpoint_state.get()] =
+            success_rate;
       }
     }
   }
@@ -917,8 +906,8 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
     // (success_rate_ejection.stdev_factor / 1000))
     double mean = success_rate_sum / success_rate_ejection_candidates.size();
     double variance = 0;
-    for (const auto& p : success_rate_ejection_candidates) {
-      variance += std::pow(p.second - mean, 2);
+    for (const auto& [_, success_rate] : success_rate_ejection_candidates) {
+      variance += std::pow(success_rate - mean, 2);
     }
     variance /= success_rate_ejection_candidates.size();
     double stdev = std::sqrt(variance);
@@ -928,12 +917,13 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
     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) {
+    for (auto& [endpoint_state, success_rate] :
+         success_rate_ejection_candidates) {
       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) {
+          << "] checking candidate " << endpoint_state
+          << ": success_rate=" << success_rate;
+      if (success_rate < 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();
@@ -950,7 +940,7 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
           GRPC_TRACE_LOG(outlier_detection_lb, INFO)
               << "[outlier_detection_lb " << parent_.get()
               << "] ejecting candidate";
-          candidate.first->Eject(time_now);
+          endpoint_state->Eject(time_now);
           ++ejected_host_count;
         }
       }
@@ -966,15 +956,16 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
         << config.failure_percentage_ejection->threshold
         << ", enforcement_percentage="
         << config.failure_percentage_ejection->enforcement_percentage;
-    for (auto& candidate : failure_percentage_ejection_candidates) {
+    for (auto& [endpoint_state, success_rate] :
+         failure_percentage_ejection_candidates) {
       GRPC_TRACE_LOG(outlier_detection_lb, INFO)
           << "[outlier_detection_lb " << parent_.get()
-          << "] checking candidate " << candidate.first
-          << ": success_rate=" << candidate.second;
+          << "] checking candidate " << endpoint_state
+          << ": success_rate=" << success_rate;
       // Extra check to make sure success rate algorithm didn't already
       // eject this backend.
-      if (candidate.first->ejection_time().has_value()) continue;
-      if ((100.0 - candidate.second) >
+      if (endpoint_state->ejection_time().has_value()) continue;
+      if ((100.0 - success_rate) >
           config.failure_percentage_ejection->threshold) {
         uint32_t random_key = absl::Uniform(bit_gen_, 1, 100);
         double current_percent =
@@ -993,7 +984,7 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
           GRPC_TRACE_LOG(outlier_detection_lb, INFO)
               << "[outlier_detection_lb " << parent_.get()
               << "] ejecting candidate";
-          candidate.first->Eject(time_now);
+          endpoint_state->Eject(time_now);
           ++ejected_host_count;
         }
       }
@@ -1005,14 +996,13 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
   //   current time is after ejection_timestamp + min(base_ejection_time *
   //   multiplier, max(base_ejection_time, max_ejection_time)), un-eject the
   //   address.
-  for (auto& state : parent_->endpoint_state_map_) {
-    auto* endpoint_state = state.second.get();
+  for (auto& [address_set, endpoint_state] : parent_->endpoint_state_map_) {
     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)) {
       LOG(INFO) << "[outlier_detection_lb " << parent_.get()
-                << "] unejected endpoint " << state.first.ToString() << " ("
-                << endpoint_state << ")";
+                << "] unejected endpoint " << address_set.ToString() << " ("
+                << endpoint_state.get() << ")";
     }
   }
   parent_->ejection_timer_ =
@@ -1046,15 +1036,14 @@ class OutlierDetectionLbFactory final : public LoadBalancingPolicyFactory {
         auto it = json.object().find("childPolicy");
         if (it == json.object().end()) {
           errors.AddError("field not present");
+        } else if (auto child_policy_config =
+                       CoreConfiguration::Get()
+                           .lb_policy_registry()
+                           .ParseLoadBalancingConfig(it->second);
+                   !child_policy_config.ok()) {
+          errors.AddError(child_policy_config.status().message());
         } else {
-          auto child_policy_config = CoreConfiguration::Get()
-                                         .lb_policy_registry()
-                                         .ParseLoadBalancingConfig(it->second);
-          if (!child_policy_config.ok()) {
-            errors.AddError(child_policy_config.status().message());
-          } else {
-            child_policy = std::move(*child_policy_config);
-          }
+          child_policy = std::move(*child_policy_config);
         }
       }
     }

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

@@ -20,7 +20,8 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>  // for uint32_t
 
-#include "absl/types/optional.h"
+#include <optional>
+
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/json/json_object_loader.h"
@@ -70,8 +71,8 @@ struct OutlierDetectionConfig {
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
     void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors);
   };
-  absl::optional<SuccessRateEjection> success_rate_ejection;
-  absl::optional<FailurePercentageEjection> failure_percentage_ejection;
+  std::optional<SuccessRateEjection> success_rate_ejection;
+  std::optional<FailurePercentageEjection> failure_percentage_ejection;
 
   bool operator==(const OutlierDetectionConfig& other) const {
     return interval == other.interval &&