grpc 1.68.1 → 1.71.0

data/src/core/load_balancing/rls/rls.h

@@ -17,10 +17,106 @@
 #ifndef GRPC_SRC_CORE_LOAD_BALANCING_RLS_RLS_H
 #define GRPC_SRC_CORE_LOAD_BALANCING_RLS_RLS_H
 
-#include <grpc/support/port_platform.h>
+#include <map>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "src/core/load_balancing/lb_policy.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_object_loader.h"
+#include "src/core/util/time.h"
+#include "src/core/util/validation_errors.h"
 
 // A test-only channel arg to set the instance ID of the RLS LB
 // policy for use in metric labels.
 #define GRPC_ARG_TEST_ONLY_RLS_INSTANCE_ID "grpc.test-only.rls.instance_id"
 
+namespace grpc_core {
+
+// Parsed RLS LB policy configuration.
+class RlsLbConfig final : public LoadBalancingPolicy::Config {
+ public:
+  static constexpr Duration kMaxMaxAge = Duration::Minutes(5);
+
+  struct KeyBuilder {
+    std::map<std::string /*key*/, std::vector<std::string /*header*/>>
+        header_keys;
+    std::string host_key;
+    std::string service_key;
+    std::string method_key;
+    std::map<std::string /*key*/, std::string /*value*/> constant_keys;
+  };
+  using KeyBuilderMap = std::unordered_map<std::string /*path*/, KeyBuilder>;
+
+  RlsLbConfig() = default;
+
+  RlsLbConfig(const RlsLbConfig&) = delete;
+  RlsLbConfig& operator=(const RlsLbConfig&) = delete;
+
+  RlsLbConfig(RlsLbConfig&& other) = delete;
+  RlsLbConfig& operator=(RlsLbConfig&& other) = delete;
+
+  static absl::string_view Name() { return "rls_experimental"; }
+
+  absl::string_view name() const override { return Name(); }
+
+  const KeyBuilderMap& key_builder_map() const {
+    return route_lookup_config_.key_builder_map;
+  }
+  const std::string& lookup_service() const {
+    return route_lookup_config_.lookup_service;
+  }
+  Duration lookup_service_timeout() const {
+    return route_lookup_config_.lookup_service_timeout;
+  }
+  Duration max_age() const { return route_lookup_config_.max_age; }
+  Duration stale_age() const { return route_lookup_config_.stale_age; }
+  int64_t cache_size_bytes() const {
+    return route_lookup_config_.cache_size_bytes;
+  }
+  const std::string& default_target() const {
+    return route_lookup_config_.default_target;
+  }
+  const std::string& rls_channel_service_config() const {
+    return rls_channel_service_config_;
+  }
+  const Json& child_policy_config() const { return child_policy_config_; }
+  const std::string& child_policy_config_target_field_name() const {
+    return child_policy_config_target_field_name_;
+  }
+  RefCountedPtr<LoadBalancingPolicy::Config>
+  default_child_policy_parsed_config() const {
+    return default_child_policy_parsed_config_;
+  }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  void JsonPostLoad(const Json& json, const JsonArgs&,
+                    ValidationErrors* errors);
+
+ private:
+  struct RouteLookupConfig {
+    KeyBuilderMap key_builder_map;
+    std::string lookup_service;
+    Duration lookup_service_timeout = Duration::Seconds(10);
+    Duration max_age = kMaxMaxAge;
+    Duration stale_age = kMaxMaxAge;
+    int64_t cache_size_bytes = 0;
+    std::string default_target;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+    void JsonPostLoad(const Json& json, const JsonArgs& args,
+                      ValidationErrors* errors);
+  };
+
+  RouteLookupConfig route_lookup_config_;
+  std::string rls_channel_service_config_;
+  Json child_policy_config_;
+  std::string child_policy_config_target_field_name_;
+  RefCountedPtr<LoadBalancingPolicy::Config>
+      default_child_policy_parsed_config_;
+};
+
+}  // namespace grpc_core
+
 #endif  // GRPC_SRC_CORE_LOAD_BALANCING_RLS_RLS_H

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

@@ -22,6 +22,7 @@
 #include <algorithm>
 #include <atomic>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -34,9 +35,8 @@
 #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/config/core_configuration.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/transport/connectivity_state.h"
 #include "src/core/load_balancing/endpoint_list.h"
@@ -69,9 +69,9 @@ class RoundRobin final : public LoadBalancingPolicy {
    public:
     RoundRobinEndpointList(RefCountedPtr<RoundRobin> round_robin,
                            EndpointAddressesIterator* endpoints,
-                           const ChannelArgs& args,
+                           const ChannelArgs& args, std::string resolution_note,
                            std::vector<std::string>* errors)
-        : EndpointList(std::move(round_robin),
+        : EndpointList(std::move(round_robin), std::move(resolution_note),
                        GRPC_TRACE_FLAG_ENABLED(round_robin)
                            ? "RoundRobinEndpointList"
                            : nullptr) {
@@ -102,7 +102,7 @@ class RoundRobin final : public LoadBalancingPolicy {
 
      private:
       // Called when the child policy reports a connectivity state update.
-      void OnStateUpdate(absl::optional<grpc_connectivity_state> old_state,
+      void OnStateUpdate(std::optional<grpc_connectivity_state> old_state,
                          grpc_connectivity_state new_state,
                          const absl::Status& status) override;
     };
@@ -115,7 +115,7 @@ class RoundRobin final : public LoadBalancingPolicy {
     // Updates the counters of children in each state when a
     // child transitions from old_state to new_state.
     void UpdateStateCountersLocked(
-        absl::optional<grpc_connectivity_state> old_state,
+        std::optional<grpc_connectivity_state> old_state,
         grpc_connectivity_state new_state);
 
     // Ensures that the right child list is used and then updates
@@ -249,7 +249,7 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
   std::vector<std::string> errors;
   latest_pending_endpoint_list_ = MakeOrphanable<RoundRobinEndpointList>(
       RefAsSubclass<RoundRobin>(DEBUG_LOCATION, "RoundRobinEndpointList"),
-      addresses, args.args, &errors);
+      addresses, args.args, std::move(args.resolution_note), &errors);
   // If the new list is empty, immediately promote it to
   // endpoint_list_ and report TRANSIENT_FAILURE.
   if (latest_pending_endpoint_list_->size() == 0) {
@@ -258,13 +258,10 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
                 << endpoint_list_.get();
     }
     endpoint_list_ = std::move(latest_pending_endpoint_list_);
-    absl::Status status =
-        args.addresses.ok() ? absl::UnavailableError(absl::StrCat(
-                                  "empty address list: ", args.resolution_note))
-                            : args.addresses.status();
-    channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-        MakeRefCounted<TransientFailurePicker>(status));
+    absl::Status status = args.addresses.ok()
+                              ? absl::UnavailableError("empty address list")
+                              : args.addresses.status();
+    endpoint_list_->ReportTransientFailure(status);
     return status;
   }
   // Otherwise, if this is the initial update, immediately promote it to
@@ -284,7 +281,7 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
 //
 
 void RoundRobin::RoundRobinEndpointList::RoundRobinEndpoint::OnStateUpdate(
-    absl::optional<grpc_connectivity_state> old_state,
+    std::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state, const absl::Status& status) {
   auto* rr_endpoint_list = endpoint_list<RoundRobinEndpointList>();
   auto* round_robin = policy<RoundRobin>();
@@ -314,7 +311,7 @@ void RoundRobin::RoundRobinEndpointList::RoundRobinEndpoint::OnStateUpdate(
 //
 
 void RoundRobin::RoundRobinEndpointList::UpdateStateCountersLocked(
-    absl::optional<grpc_connectivity_state> old_state,
+    std::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state) {
   // We treat IDLE the same as CONNECTING, since it will immediately
   // transition into that state anyway.
@@ -393,7 +390,7 @@ void RoundRobin::RoundRobinEndpointList::
         << "[RR " << round_robin << "] reporting CONNECTING with child list "
         << this;
     round_robin->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_CONNECTING, absl::Status(),
+        GRPC_CHANNEL_CONNECTING, absl::OkStatus(),
         MakeRefCounted<QueuePicker>(nullptr));
   } else if (num_transient_failure_ == size()) {
     GRPC_TRACE_LOG(round_robin, INFO)
@@ -405,9 +402,7 @@ void RoundRobin::RoundRobinEndpointList::
           absl::StrCat("connections to all backends failing; last error: ",
                        status_for_tf.message()));
     }
-    round_robin->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE, last_failure_,
-        MakeRefCounted<TransientFailurePicker>(last_failure_));
+    ReportTransientFailure(last_failure_);
   }
 }
 

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

@@ -49,14 +49,14 @@ constexpr double kMaxRatio = 10;
 // weights that are possibly accepting. In this case, without kMinRatio, it
 // would potentially require WeightedRoundRobin to perform thousands of picks
 // until it gets a single channel with near-zero weight. This was a part of what
-// hapenned in b/276292666.
+// happened in b/276292666.
 //
 // The current value of 0.01 was chosen without any experimenting. It should
 // ensure that WeightedRoundRobin doesn't do much more than an order of 100
 // picks of non-accepting channels with high weights in such corner cases. But
 // it also makes WeightedRoundRobin to send slightly more requests to
 // potentially very bad tasks (that would have near-zero weights) than zero.
-// This is not necesserily a downside, though. Perhaps this is not a problem at
+// This is not necessarily a downside, though. Perhaps this is not a problem at
 // all and we should increase this value (to 0.05 or 0.1) to save CPU cycles.
 //
 // Note that this class treats weights that are exactly equal to zero as unknown
@@ -76,11 +76,11 @@ constexpr double kMinRatio = 0.01;
 
 }  // namespace
 
-absl::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
+std::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
     absl::Span<const float> float_weights,
     absl::AnyInvocable<uint32_t()> next_sequence_func) {
-  if (float_weights.empty()) return absl::nullopt;
-  if (float_weights.size() == 1) return absl::nullopt;
+  if (float_weights.empty()) return std::nullopt;
+  if (float_weights.size() == 1) return std::nullopt;
 
   // TODO(b/190488683): should we normalize negative weights to 0?
 
@@ -96,7 +96,7 @@ absl::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
     }
   }
 
-  if (num_zero_weight_channels == n) return absl::nullopt;
+  if (num_zero_weight_channels == n) return std::nullopt;
 
   // Mean of non-zero weights before scaling to `kMaxWeight`.
   const double unscaled_mean =

data/src/core/load_balancing/weighted_round_robin/static_stride_scheduler.h

@@ -21,10 +21,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/types/optional.h"
 #include "absl/types/span.h"
 
 namespace grpc_core {
@@ -41,12 +41,12 @@ namespace grpc_core {
 class StaticStrideScheduler final {
  public:
   // Constructs and returns a new StaticStrideScheduler, or nullopt if all
-  // wieghts are zero or |weights| <= 1. All weights must be >=0.
+  // weights are zero or |weights| <= 1. All weights must be >=0.
   // `next_sequence_func` should return a rate monotonically increasing sequence
   // number, which may wrap. `float_weights` does not need to live beyond the
   // function. Caller is responsible for ensuring `next_sequence_func` remains
   // valid for all calls to `Pick()`.
-  static absl::optional<StaticStrideScheduler> Make(
+  static std::optional<StaticStrideScheduler> Make(
       absl::Span<const float> float_weights,
       absl::AnyInvocable<uint32_t()> next_sequence_func);
 

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

@@ -24,10 +24,12 @@
 #include <atomic>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
@@ -40,10 +42,8 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
+#include "src/core/config/core_configuration.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/iomgr/exec_ctx.h"
@@ -267,7 +267,7 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
           const ChannelArgs& args) override;
 
       // Called when the child policy reports a connectivity state update.
-      void OnStateUpdate(absl::optional<grpc_connectivity_state> old_state,
+      void OnStateUpdate(std::optional<grpc_connectivity_state> old_state,
                          grpc_connectivity_state new_state,
                          const absl::Status& status) override;
 
@@ -276,8 +276,9 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
 
     WrrEndpointList(RefCountedPtr<WeightedRoundRobin> wrr,
                     EndpointAddressesIterator* endpoints,
-                    const ChannelArgs& args, std::vector<std::string>* errors)
-        : EndpointList(std::move(wrr),
+                    const ChannelArgs& args, std::string resolution_note,
+                    std::vector<std::string>* errors)
+        : EndpointList(std::move(wrr), std::move(resolution_note),
                        GRPC_TRACE_FLAG_ENABLED(weighted_round_robin_lb)
                            ? "WrrEndpointList"
                            : nullptr) {
@@ -299,7 +300,7 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
     // Updates the counters of children in each state when a
     // child transitions from old_state to new_state.
     void UpdateStateCountersLocked(
-        absl::optional<grpc_connectivity_state> old_state,
+        std::optional<grpc_connectivity_state> old_state,
         grpc_connectivity_state new_state);
 
     // Ensures that the right child list is used and then updates
@@ -382,7 +383,7 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
         ABSL_GUARDED_BY(&scheduler_mu_);
 
     Mutex timer_mu_ ABSL_ACQUIRED_BEFORE(&scheduler_mu_);
-    absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+    std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
         timer_handle_ ABSL_GUARDED_BY(&timer_mu_);
 
     // Used when falling back to RR.
@@ -581,7 +582,7 @@ WeightedRoundRobin::PickResult WeightedRoundRobin::Picker::Pick(PickArgs args) {
   auto result = endpoint_info.picker->Pick(args);
   // Collect per-call utilization data if needed.
   if (!config_->enable_oob_load_report()) {
-    auto* complete = absl::get_if<PickResult::Complete>(&result.result);
+    auto* complete = std::get_if<PickResult::Complete>(&result.result);
     if (complete != nullptr) {
       complete->subchannel_call_tracker =
           std::make_unique<SubchannelCallTracker>(
@@ -666,7 +667,6 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
       config_->weight_update_period(),
       [self = WeakRefAsSubclass<Picker>(),
        work_serializer = wrr_->work_serializer()]() mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         {
           MutexLock lock(&self->timer_mu_);
@@ -677,11 +677,6 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
             self->BuildSchedulerAndStartTimerLocked();
           }
         }
-        if (!IsWorkSerializerDispatchEnabled()) {
-          // Release the picker ref inside the WorkSerializer.
-          work_serializer->Run([self = std::move(self)]() {}, DEBUG_LOCATION);
-          return;
-        }
         self.reset();
       });
 }
@@ -770,7 +765,8 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
   }
   std::vector<std::string> errors;
   latest_pending_endpoint_list_ = MakeOrphanable<WrrEndpointList>(
-      RefAsSubclass<WeightedRoundRobin>(), addresses.get(), args.args, &errors);
+      RefAsSubclass<WeightedRoundRobin>(), addresses.get(), args.args,
+      std::move(args.resolution_note), &errors);
   // If the new list is empty, immediately promote it to
   // endpoint_list_ and report TRANSIENT_FAILURE.
   if (latest_pending_endpoint_list_->size() == 0) {
@@ -780,13 +776,10 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
                 << endpoint_list_.get();
     }
     endpoint_list_ = std::move(latest_pending_endpoint_list_);
-    absl::Status status =
-        args.addresses.ok() ? absl::UnavailableError(absl::StrCat(
-                                  "empty address list: ", args.resolution_note))
-                            : args.addresses.status();
-    channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-        MakeRefCounted<TransientFailurePicker>(status));
+    absl::Status status = args.addresses.ok()
+                              ? absl::UnavailableError("empty address list")
+                              : args.addresses.status();
+    endpoint_list_->ReportTransientFailure(status);
     return status;
   }
   // Otherwise, if this is the initial update, immediately promote it to
@@ -853,7 +846,7 @@ WeightedRoundRobin::WrrEndpointList::WrrEndpoint::CreateSubchannel(
 }
 
 void WeightedRoundRobin::WrrEndpointList::WrrEndpoint::OnStateUpdate(
-    absl::optional<grpc_connectivity_state> old_state,
+    std::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state, const absl::Status& status) {
   auto* wrr_endpoint_list = endpoint_list<WrrEndpointList>();
   auto* wrr = policy<WeightedRoundRobin>();
@@ -900,7 +893,7 @@ void WeightedRoundRobin::WrrEndpointList::WrrEndpoint::OnStateUpdate(
 //
 
 void WeightedRoundRobin::WrrEndpointList::UpdateStateCountersLocked(
-    absl::optional<grpc_connectivity_state> old_state,
+    std::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state) {
   // We treat IDLE the same as CONNECTING, since it will immediately
   // transition into that state anyway.
@@ -962,14 +955,14 @@ void WeightedRoundRobin::WrrEndpointList::
     GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
         << "[WRR " << wrr << "] reporting READY with endpoint list " << this;
     wrr->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_READY, absl::Status(),
+        GRPC_CHANNEL_READY, absl::OkStatus(),
         MakeRefCounted<Picker>(wrr->RefAsSubclass<WeightedRoundRobin>(), this));
   } else if (num_connecting_ > 0) {
     GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
         << "[WRR " << wrr << "] reporting CONNECTING with endpoint list "
         << this;
     wrr->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_CONNECTING, absl::Status(),
+        GRPC_CHANNEL_CONNECTING, absl::OkStatus(),
         MakeRefCounted<QueuePicker>(nullptr));
   } else if (num_transient_failure_ == size()) {
     GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
@@ -980,9 +973,7 @@ void WeightedRoundRobin::WrrEndpointList::
           absl::StrCat("connections to all backends failing; last error: ",
                        status_for_tf.ToString()));
     }
-    wrr->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE, last_failure_,
-        MakeRefCounted<TransientFailurePicker>(last_failure_));
+    ReportTransientFailure(last_failure_);
   }
 }
 

data/src/core/load_balancing/weighted_target/weighted_target.cc

@@ -25,6 +25,7 @@
 #include <cstdint>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -39,9 +40,8 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
+#include "src/core/config/core_configuration.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/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -200,7 +200,7 @@ class WeightedTargetLb final : public LoadBalancingPolicy {
       void OnTimerLocked();
 
       RefCountedPtr<WeightedChild> weighted_child_;
-      absl::optional<EventEngine::TaskHandle> timer_handle_;
+      std::optional<EventEngine::TaskHandle> timer_handle_;
     };
 
     // Methods for dealing with the child policy.
@@ -300,7 +300,7 @@ void WeightedTargetLb::ShutdownLocked() {
 }
 
 void WeightedTargetLb::ResetBackoffLocked() {
-  for (auto& p : targets_) p.second->ResetBackoffLocked();
+  for (auto& [_, child] : targets_) child->ResetBackoffLocked();
 }
 
 absl::Status WeightedTargetLb::UpdateLocked(UpdateArgs args) {
@@ -311,9 +311,7 @@ absl::Status WeightedTargetLb::UpdateLocked(UpdateArgs args) {
   // Update config.
   config_ = args.config.TakeAsSubclass<WeightedTargetLbConfig>();
   // Deactivate the targets not in the new config.
-  for (const auto& p : targets_) {
-    const std::string& name = p.first;
-    WeightedChild* child = p.second.get();
+  for (const auto& [name, child] : targets_) {
     if (config_->target_map().find(name) == config_->target_map().end()) {
       child->DeactivateLocked();
     }
@@ -322,9 +320,7 @@ absl::Status WeightedTargetLb::UpdateLocked(UpdateArgs args) {
   absl::StatusOr<HierarchicalAddressMap> address_map =
       MakeHierarchicalAddressMap(args.addresses);
   std::vector<std::string> errors;
-  for (const auto& p : config_->target_map()) {
-    const std::string& name = p.first;
-    const WeightedTargetLbConfig::ChildConfig& config = p.second;
+  for (const auto& [name, config] : config_->target_map()) {
     auto& target = targets_[name];
     // Create child if it does not already exist.
     if (target == nullptr) {
@@ -392,9 +388,7 @@ void WeightedTargetLb::UpdateStateLocked() {
   // the aggregated state.
   size_t num_connecting = 0;
   size_t num_idle = 0;
-  for (const auto& p : targets_) {
-    const std::string& child_name = p.first;
-    const WeightedChild* child = p.second.get();
+  for (const auto& [child_name, child] : targets_) {
     // Skip the targets that are not in the latest update.
     if (config_->target_map().find(child_name) == config_->target_map().end()) {
       continue;
@@ -471,13 +465,11 @@ WeightedTargetLb::WeightedChild::DelayedRemovalTimer::DelayedRemovalTimer(
       weighted_child_->weighted_target_policy_->channel_control_helper()
           ->GetEventEngine()
           ->RunAfter(kChildRetentionInterval, [self = Ref()]() mutable {
-            ApplicationCallbackExecCtx app_exec_ctx;
             ExecCtx exec_ctx;
             auto* self_ptr = self.get();  // Avoid use-after-move problem.
             self_ptr->weighted_child_->weighted_target_policy_
                 ->work_serializer()
-                ->Run([self = std::move(self)] { self->OnTimerLocked(); },
-                      DEBUG_LOCATION);
+                ->Run([self = std::move(self)] { self->OnTimerLocked(); });
           });
 }
 

data/src/core/load_balancing/xds/cds.cc

@@ -22,10 +22,12 @@
 #include <algorithm>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/log/check.h"
@@ -34,10 +36,8 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
+#include "src/core/config/core_configuration.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/iomgr/pollset_set.h"
 #include "src/core/load_balancing/address_filtering.h"
@@ -240,9 +240,7 @@ class PriorityEndpointIterator final : public EndpointAddressesIterator {
       const auto& priority_entry = priority_list[priority];
       std::string priority_child_name =
           MakeChildPolicyName(cluster_name_, priority_child_numbers_[priority]);
-      for (const auto& p : priority_entry.localities) {
-        const auto& locality_name = p.first;
-        const auto& locality = p.second;
+      for (const auto& [locality_name, locality] : priority_entry.localities) {
         std::vector<RefCountedStringValue> hierarchical_path = {
             RefCountedStringValue(priority_child_name),
             locality_name->human_readable_string()};
@@ -348,7 +346,7 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
       // Can't do this for an aggregate cluster, because even if the aggregate
       // cluster itself didn't change, the leaf clusters may have changed.
       if (*new_cluster_config == *old_cluster_config &&
-          absl::holds_alternative<XdsConfig::ClusterConfig::EndpointConfig>(
+          std::holds_alternative<XdsConfig::ClusterConfig::EndpointConfig>(
               new_cluster_config->children)) {
         return absl::OkStatus();
       }
@@ -359,7 +357,7 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
   static constexpr absl::string_view kArgXdsAggregateClusterName =
       GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_aggregate_cluster_name";
   if (XdsAggregateClusterBackwardCompatibilityEnabled()) {
-    if (absl::holds_alternative<XdsConfig::ClusterConfig::EndpointConfig>(
+    if (std::holds_alternative<XdsConfig::ClusterConfig::EndpointConfig>(
             new_cluster_config->children)) {
       auto aggregate_cluster = args.args.GetString(kArgXdsAggregateClusterName);
       if (aggregate_cluster.has_value()) {
@@ -458,7 +456,7 @@ CdsLb::ChildNameState CdsLb::ComputeChildNames(
     const XdsConfig::ClusterConfig* old_cluster,
     const XdsConfig::ClusterConfig& new_cluster,
     const XdsConfig::ClusterConfig::EndpointConfig& endpoint_config) const {
-  CHECK(!absl::holds_alternative<XdsConfig::ClusterConfig::AggregateConfig>(
+  CHECK(!std::holds_alternative<XdsConfig::ClusterConfig::AggregateConfig>(
       new_cluster.children));
   // First, build some maps from locality to child number and the reverse
   // from old_cluster and child_name_state_.
@@ -468,7 +466,7 @@ CdsLb::ChildNameState CdsLb::ComputeChildNames(
       child_locality_map;
   if (old_cluster != nullptr) {
     auto* old_endpoint_config =
-        absl::get_if<XdsConfig::ClusterConfig::EndpointConfig>(
+        std::get_if<XdsConfig::ClusterConfig::EndpointConfig>(
             &old_cluster->children);
     if (old_endpoint_config != nullptr) {
       const auto& prev_priority_list =
@@ -478,8 +476,7 @@ CdsLb::ChildNameState CdsLb::ComputeChildNames(
         size_t child_number =
             child_name_state_.priority_child_numbers[priority];
         const auto& localities = prev_priority_list[priority].localities;
-        for (const auto& p : localities) {
-          XdsLocalityName* locality_name = p.first;
+        for (const auto& [locality_name, _] : localities) {
           locality_child_map[locality_name] = child_number;
           child_locality_map[child_number].insert(locality_name);
         }
@@ -495,11 +492,10 @@ CdsLb::ChildNameState CdsLb::ComputeChildNames(
       GetUpdatePriorityList(endpoint_config.endpoints.get());
   for (size_t priority = 0; priority < priority_list.size(); ++priority) {
     const auto& localities = priority_list[priority].localities;
-    absl::optional<size_t> child_number;
+    std::optional<size_t> child_number;
     // If one of the localities in this priority already existed, reuse its
     // child number.
-    for (const auto& p : localities) {
-      XdsLocalityName* locality_name = p.first;
+    for (const auto& [locality_name, _] : localities) {
       if (!child_number.has_value()) {
         auto it = locality_child_map.find(locality_name);
         if (it != locality_child_map.end()) {
@@ -542,7 +538,7 @@ Json CdsLb::CreateChildPolicyConfigForLeafCluster(
     const XdsClusterResource* aggregate_cluster_resource) {
   const auto& cluster_resource = *new_cluster.cluster;
   const bool is_logical_dns =
-      absl::holds_alternative<XdsClusterResource::LogicalDns>(
+      std::holds_alternative<XdsClusterResource::LogicalDns>(
           cluster_resource.type);
   // Determine what xDS LB policy to use.
   Json xds_lb_policy;