grpc 1.62.0 → 1.63.2

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

@@ -44,8 +44,6 @@
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
-#include "src/core/load_balancing/child_policy_handler.h"
-#include "src/core/load_balancing/health_check_client_internal.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"
@@ -66,7 +64,9 @@
 #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"
+#include "src/core/load_balancing/health_check_client_internal.h"
 #include "src/core/load_balancing/lb_policy.h"
 #include "src/core/load_balancing/lb_policy_factory.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
@@ -85,7 +85,7 @@ constexpr absl::string_view kOutlierDetection =
     "outlier_detection_experimental";
 
 // Config for xDS Cluster Impl LB policy.
-class OutlierDetectionLbConfig : public LoadBalancingPolicy::Config {
+class OutlierDetectionLbConfig final : public LoadBalancingPolicy::Config {
  public:
   OutlierDetectionLbConfig(
       OutlierDetectionConfig outlier_detection_config,
@@ -114,7 +114,7 @@ class OutlierDetectionLbConfig : public LoadBalancingPolicy::Config {
 };
 
 // xDS Cluster Impl LB policy.
-class OutlierDetectionLb : public LoadBalancingPolicy {
+class OutlierDetectionLb final : public LoadBalancingPolicy {
  public:
   explicit OutlierDetectionLb(Args args);
 
@@ -128,7 +128,7 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
   class SubchannelState;
   class EndpointState;
 
-  class SubchannelWrapper : public DelegatingSubchannel {
+  class SubchannelWrapper final : public DelegatingSubchannel {
    public:
     SubchannelWrapper(std::shared_ptr<WorkSerializer> work_serializer,
                       RefCountedPtr<SubchannelState> subchannel_state,
@@ -144,22 +144,6 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
       }
     }
 
-    void Orphan() override {
-      if (!IsWorkSerializerDispatchEnabled()) {
-        if (subchannel_state_ != nullptr) {
-          subchannel_state_->RemoveSubchannel(this);
-        }
-        return;
-      }
-      work_serializer_->Run(
-          [self = WeakRefAsSubclass<SubchannelWrapper>()]() {
-            if (self->subchannel_state_ != nullptr) {
-              self->subchannel_state_->RemoveSubchannel(self.get());
-            }
-          },
-          DEBUG_LOCATION);
-    }
-
     void Eject();
 
     void Uneject();
@@ -174,7 +158,7 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
     }
 
    private:
-    class WatcherWrapper
+    class WatcherWrapper final
         : public SubchannelInterface::ConnectivityStateWatcherInterface {
      public:
       WatcherWrapper(std::shared_ptr<
@@ -228,13 +212,29 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
       bool ejected_;
     };
 
+    void Orphaned() override {
+      if (!IsWorkSerializerDispatchEnabled()) {
+        if (subchannel_state_ != nullptr) {
+          subchannel_state_->RemoveSubchannel(this);
+        }
+        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_;
     RefCountedPtr<SubchannelState> subchannel_state_;
     bool ejected_ = false;
     WatcherWrapper* watcher_wrapper_ = nullptr;
   };
 
-  class SubchannelState : public RefCounted<SubchannelState> {
+  class SubchannelState final : public RefCounted<SubchannelState> {
    public:
     void AddSubchannel(SubchannelWrapper* wrapper) {
       subchannels_.insert(wrapper);
@@ -277,7 +277,7 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
     RefCountedPtr<EndpointState> endpoint_state_ ABSL_GUARDED_BY(mu_);
   };
 
-  class EndpointState : public RefCounted<EndpointState> {
+  class EndpointState final : public RefCounted<EndpointState> {
    public:
     explicit EndpointState(std::set<SubchannelState*> subchannels)
         : subchannels_(std::move(subchannels)) {
@@ -371,7 +371,7 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
   };
 
   // A picker that wraps the picker from the child to perform outlier detection.
-  class Picker : public SubchannelPicker {
+  class Picker final : public SubchannelPicker {
    public:
     Picker(OutlierDetectionLb* outlier_detection_lb,
            RefCountedPtr<SubchannelPicker> picker, bool counting_enabled);
@@ -384,7 +384,7 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
     bool counting_enabled_;
   };
 
-  class Helper
+  class Helper final
       : public ParentOwningDelegatingChannelControlHelper<OutlierDetectionLb> {
    public:
     explicit Helper(RefCountedPtr<OutlierDetectionLb> outlier_detection_policy)
@@ -398,7 +398,7 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
                      RefCountedPtr<SubchannelPicker> picker) override;
   };
 
-  class EjectionTimer : public InternallyRefCounted<EjectionTimer> {
+  class EjectionTimer final : public InternallyRefCounted<EjectionTimer> {
    public:
     EjectionTimer(RefCountedPtr<OutlierDetectionLb> parent,
                   Timestamp start_time);
@@ -483,7 +483,7 @@ void OutlierDetectionLb::SubchannelWrapper::CancelDataWatcher(
 // OutlierDetectionLb::Picker::SubchannelCallTracker
 //
 
-class OutlierDetectionLb::Picker::SubchannelCallTracker
+class OutlierDetectionLb::Picker::SubchannelCallTracker final
     : public LoadBalancingPolicy::SubchannelCallTrackerInterface {
  public:
   SubchannelCallTracker(
@@ -1068,7 +1068,7 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
 // factory
 //
 
-class OutlierDetectionLbFactory : public LoadBalancingPolicyFactory {
+class OutlierDetectionLbFactory final : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {

data/src/core/load_balancing/pick_first/pick_first.cc

@@ -44,9 +44,9 @@
 #include "src/core/load_balancing/health_check_client.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/metrics.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/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -78,7 +78,26 @@ namespace {
 
 constexpr absl::string_view kPickFirst = "pick_first";
 
-class PickFirstConfig : public LoadBalancingPolicy::Config {
+const auto kMetricDisconnections =
+    GlobalInstrumentsRegistry::RegisterUInt64Counter(
+        "grpc.lb.pick_first.disconnections",
+        "EXPERIMENTAL.  Number of times the selected subchannel becomes "
+        "disconnected.",
+        "{disconnection}", {kMetricLabelTarget}, {}, false);
+
+const auto kMetricConnectionAttemptsSucceeded =
+    GlobalInstrumentsRegistry::RegisterUInt64Counter(
+        "grpc.lb.pick_first.connection_attempts_succeeded",
+        "EXPERIMENTAL.  Number of successful connection attempts.",
+        "{attempt}", {kMetricLabelTarget}, {}, false);
+
+const auto kMetricConnectionAttemptsFailed =
+    GlobalInstrumentsRegistry::RegisterUInt64Counter(
+        "grpc.lb.pick_first.connection_attempts_failed",
+        "EXPERIMENTAL.  Number of failed connection attempts.",
+        "{attempt}", {kMetricLabelTarget}, {}, false);
+
+class PickFirstConfig final : public LoadBalancingPolicy::Config {
  public:
   absl::string_view name() const override { return kPickFirst; }
   bool shuffle_addresses() const { return shuffle_addresses_; }
@@ -96,7 +115,7 @@ class PickFirstConfig : public LoadBalancingPolicy::Config {
   bool shuffle_addresses_ = false;
 };
 
-class PickFirst : public LoadBalancingPolicy {
+class PickFirst final : public LoadBalancingPolicy {
  public:
   explicit PickFirst(Args args);
 
@@ -109,9 +128,9 @@ class PickFirst : public LoadBalancingPolicy {
  private:
   ~PickFirst() override;
 
-  class SubchannelList : public InternallyRefCounted<SubchannelList> {
+  class SubchannelList final : public InternallyRefCounted<SubchannelList> {
    public:
-    class SubchannelData {
+    class SubchannelData final {
      public:
       SubchannelData(SubchannelList* subchannel_list, size_t index,
                      RefCountedPtr<SubchannelInterface> subchannel);
@@ -143,7 +162,7 @@ class PickFirst : public LoadBalancingPolicy {
 
      private:
       // Watcher for subchannel connectivity state.
-      class Watcher
+      class Watcher final
           : public SubchannelInterface::ConnectivityStateWatcherInterface {
        public:
         Watcher(RefCountedPtr<SubchannelList> subchannel_list, size_t index)
@@ -178,10 +197,6 @@ class PickFirst : public LoadBalancingPolicy {
       // subchannel.
       void ProcessUnselectedReadyLocked();
 
-      // Reacts to the current connectivity state while trying to connect.
-      // TODO(roth): Remove this when we remove the Happy Eyeballs experiment.
-      void ReactToConnectivityStateLocked();
-
       // Backpointer to owning subchannel list.  Not owned.
       SubchannelList* subchannel_list_;
       const size_t index_;
@@ -254,9 +269,6 @@ class PickFirst : public LoadBalancingPolicy {
     // finished processing.
     bool shutting_down_ = false;
 
-    // TODO(roth): Remove this when we remove the Happy Eyeballs experiment.
-    bool in_transient_failure_ = false;
-
     size_t num_subchannels_seen_initial_notification_ = 0;
 
     // The index into subchannels_ to which we are currently attempting
@@ -275,7 +287,7 @@ class PickFirst : public LoadBalancingPolicy {
     absl::Status last_failure_;
   };
 
-  class HealthWatcher
+  class HealthWatcher final
       : public SubchannelInterface::ConnectivityStateWatcherInterface {
    public:
     explicit HealthWatcher(RefCountedPtr<PickFirst> policy)
@@ -296,7 +308,7 @@ class PickFirst : public LoadBalancingPolicy {
     RefCountedPtr<PickFirst> policy_;
   };
 
-  class Picker : public SubchannelPicker {
+  class Picker final : public SubchannelPicker {
    public:
     explicit Picker(RefCountedPtr<SubchannelInterface> subchannel)
         : subchannel_(std::move(subchannel)) {}
@@ -455,7 +467,7 @@ absl::string_view GetAddressFamily(const grpc_resolved_address& address) {
 
 // An endpoint list iterator that returns only entries for a specific
 // address family, as indicated by the URI scheme.
-class AddressFamilyIterator {
+class AddressFamilyIterator final {
  public:
   AddressFamilyIterator(absl::string_view scheme, size_t index)
       : scheme_(scheme), index_(index) {}
@@ -513,34 +525,30 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
       for (const auto& endpoint : endpoints) {
         for (const auto& address : endpoint.addresses()) {
           flattened_endpoints.emplace_back(address, endpoint.args());
-          if (IsPickFirstHappyEyeballsEnabled()) {
-            absl::string_view scheme = GetAddressFamily(address);
-            bool inserted = address_families.insert(scheme).second;
-            if (inserted) {
-              address_family_order.emplace_back(scheme,
-                                                flattened_endpoints.size() - 1);
-            }
+          absl::string_view scheme = GetAddressFamily(address);
+          bool inserted = address_families.insert(scheme).second;
+          if (inserted) {
+            address_family_order.emplace_back(scheme,
+                                              flattened_endpoints.size() - 1);
           }
         }
       }
       endpoints = std::move(flattened_endpoints);
       // Interleave addresses as per RFC-8305 section 4.
-      if (IsPickFirstHappyEyeballsEnabled()) {
-        EndpointAddressesList interleaved_endpoints;
-        interleaved_endpoints.reserve(endpoints.size());
-        std::vector<bool> endpoints_moved(endpoints.size());
-        size_t scheme_index = 0;
-        for (size_t i = 0; i < endpoints.size(); ++i) {
-          EndpointAddresses* endpoint;
-          do {
-            auto& iterator = address_family_order[scheme_index++ %
-                                                  address_family_order.size()];
-            endpoint = iterator.Next(endpoints, &endpoints_moved);
-          } while (endpoint == nullptr);
-          interleaved_endpoints.emplace_back(std::move(*endpoint));
-        }
-        endpoints = std::move(interleaved_endpoints);
+      EndpointAddressesList interleaved_endpoints;
+      interleaved_endpoints.reserve(endpoints.size());
+      std::vector<bool> endpoints_moved(endpoints.size());
+      size_t scheme_index = 0;
+      for (size_t i = 0; i < endpoints.size(); ++i) {
+        EndpointAddresses* endpoint;
+        do {
+          auto& iterator = address_family_order[scheme_index++ %
+                                                address_family_order.size()];
+          endpoint = iterator.Next(endpoints, &endpoints_moved);
+        } while (endpoint == nullptr);
+        interleaved_endpoints.emplace_back(std::move(*endpoint));
       }
+      endpoints = std::move(interleaved_endpoints);
       args.addresses =
           std::make_shared<EndpointAddressesListIterator>(std::move(endpoints));
     }
@@ -675,6 +683,9 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
         p->latest_pending_subchannel_list_.get());
   }
   if (subchannel_list_->shutting_down_ || pending_watcher_ == nullptr) return;
+  auto& stats_plugins =
+      subchannel_list_->policy_->channel_control_helper()
+          ->GetStatsPluginGroup();
   // The notification must be for a subchannel in either the current or
   // latest pending subchannel lists.
   GPR_ASSERT(subchannel_list_ == p->subchannel_list_.get() ||
@@ -693,6 +704,9 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
     }
     // Any state change is considered to be a failure of the existing
     // connection.
+    stats_plugins.AddCounter(
+        kMetricDisconnections, 1,
+        {subchannel_list_->policy_->channel_control_helper()->GetTarget()}, {});
     // TODO(roth): We could check the connectivity states of all the
     // subchannels here, just in case one of them happens to be READY,
     // and we could switch to that rather than going IDLE.
@@ -712,9 +726,7 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
       p->UnsetSelectedSubchannel();
       p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
       // Set our state to that of the pending subchannel list.
-      if (IsPickFirstHappyEyeballsEnabled()
-              ? p->subchannel_list_->IsHappyEyeballsPassComplete()
-              : p->subchannel_list_->in_transient_failure_) {
+      if (p->subchannel_list_->IsHappyEyeballsPassComplete()) {
         status = absl::UnavailableError(absl::StrCat(
             "selected subchannel failed; switching to pending update; "
             "last failure: ",
@@ -746,8 +758,15 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
   //    select in place of the current one.
   // If the subchannel is READY, use it.
   if (new_state == GRPC_CHANNEL_READY) {
-    if (!IsPickFirstHappyEyeballsEnabled()) {
-      subchannel_list_->in_transient_failure_ = false;
+    // We consider it a successful connection attempt only if the
+    // previous state was CONNECTING.  In particular, we don't want to
+    // increment this counter if we got a new address list and found the
+    // existing connection already in state READY.
+    if (old_state == GRPC_CHANNEL_CONNECTING) {
+      stats_plugins.AddCounter(
+          kMetricConnectionAttemptsSucceeded, 1,
+          {subchannel_list_->policy_->channel_control_helper()->GetTarget()},
+          {});
     }
     ProcessUnselectedReadyLocked();
     return;
@@ -771,20 +790,15 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
   // see its initial notification.  Start trying to connect, starting
   // with the first subchannel.
   if (!old_state.has_value()) {
-    if (!IsPickFirstHappyEyeballsEnabled()) {
-      subchannel_list_->subchannels_.front().ReactToConnectivityStateLocked();
-      return;
-    }
     subchannel_list_->StartConnectingNextSubchannel();
     return;
   }
-  if (!IsPickFirstHappyEyeballsEnabled()) {
-    // Ignore any other updates for subchannels we're not currently trying to
-    // connect to.
-    if (index_ != subchannel_list_->attempting_index_) return;
-    // React to the connectivity state.
-    ReactToConnectivityStateLocked();
-    return;
+  // We've already started trying to connect.  Any subchannel that
+  // reports TF is a connection attempt failure.
+  if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+    stats_plugins.AddCounter(
+        kMetricConnectionAttemptsFailed, 1,
+        {subchannel_list_->policy_->channel_control_helper()->GetTarget()}, {});
   }
   // Otherwise, process connectivity state change.
   switch (*connectivity_state_) {
@@ -855,99 +869,6 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
   }
 }
 
-void PickFirst::SubchannelList::SubchannelData::
-    ReactToConnectivityStateLocked() {
-  PickFirst* p = subchannel_list_->policy_.get();
-  // Otherwise, process connectivity state.
-  switch (connectivity_state_.value()) {
-    case GRPC_CHANNEL_READY:
-      // Already handled this case above, so this should not happen.
-      GPR_UNREACHABLE_CODE(break);
-    case GRPC_CHANNEL_TRANSIENT_FAILURE: {
-      // Find the next subchannel not in state TRANSIENT_FAILURE.
-      // We skip subchannels in state TRANSIENT_FAILURE to avoid a
-      // large recursion that could overflow the stack.
-      SubchannelData* found_subchannel = nullptr;
-      for (size_t next_index = index_ + 1;
-           next_index < subchannel_list_->size(); ++next_index) {
-        SubchannelData* sc = &subchannel_list_->subchannels_[next_index];
-        GPR_ASSERT(sc->connectivity_state_.has_value());
-        if (sc->connectivity_state_ != GRPC_CHANNEL_TRANSIENT_FAILURE) {
-          subchannel_list_->attempting_index_ = next_index;
-          found_subchannel = sc;
-          break;
-        }
-      }
-      // If we found another subchannel in the list not in state
-      // TRANSIENT_FAILURE, trigger the right behavior for that subchannel.
-      if (found_subchannel != nullptr) {
-        found_subchannel->ReactToConnectivityStateLocked();
-        break;
-      }
-      // We didn't find another subchannel not in state TRANSIENT_FAILURE,
-      // so report TRANSIENT_FAILURE and wait for the first subchannel
-      // in the list to report IDLE before continuing.
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
-        gpr_log(GPR_INFO,
-                "Pick First %p subchannel list %p failed to connect to "
-                "all subchannels",
-                p, subchannel_list_);
-      }
-      subchannel_list_->attempting_index_ = 0;
-      subchannel_list_->in_transient_failure_ = true;
-      // In case 2, swap to the new subchannel list.  This means reporting
-      // TRANSIENT_FAILURE and dropping the existing (working) connection,
-      // but we can't ignore what the control plane has told us.
-      if (subchannel_list_ == p->latest_pending_subchannel_list_.get()) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
-          gpr_log(GPR_INFO,
-                  "Pick First %p promoting pending subchannel list %p to "
-                  "replace %p",
-                  p, p->latest_pending_subchannel_list_.get(),
-                  p->subchannel_list_.get());
-        }
-        p->UnsetSelectedSubchannel();
-        p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
-      }
-      // If this is the current subchannel list (either because we were
-      // in case 1 or because we were in case 2 and just promoted it to
-      // be the current list), re-resolve and report new state.
-      if (subchannel_list_ == p->subchannel_list_.get()) {
-        p->channel_control_helper()->RequestReresolution();
-        absl::Status status = absl::UnavailableError(absl::StrCat(
-            (p->omit_status_message_prefix_
-                 ? ""
-                 : "failed to connect to all addresses; last error: "),
-            connectivity_status_.ToString()));
-        p->UpdateState(GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-                       MakeRefCounted<TransientFailurePicker>(status));
-      }
-      // If the first subchannel is already IDLE, trigger the next connection
-      // attempt immediately. Otherwise, we'll wait for it to report
-      // its own connectivity state change.
-      auto& subchannel0 = subchannel_list_->subchannels_.front();
-      if (subchannel0.connectivity_state_ == GRPC_CHANNEL_IDLE) {
-        subchannel0.subchannel_->RequestConnection();
-      }
-      break;
-    }
-    case GRPC_CHANNEL_IDLE:
-      subchannel_->RequestConnection();
-      break;
-    case GRPC_CHANNEL_CONNECTING:
-      // Only update connectivity state in case 1, and only if we're not
-      // already in TRANSIENT_FAILURE.
-      if (subchannel_list_ == p->subchannel_list_.get() &&
-          p->state_ != GRPC_CHANNEL_TRANSIENT_FAILURE) {
-        p->UpdateState(GRPC_CHANNEL_CONNECTING, absl::Status(),
-                       MakeRefCounted<QueuePicker>(nullptr));
-      }
-      break;
-    case GRPC_CHANNEL_SHUTDOWN:
-      GPR_UNREACHABLE_CODE(break);
-  }
-}
-
 void PickFirst::SubchannelList::SubchannelData::RequestConnectionWithTimer() {
   GPR_ASSERT(connectivity_state_.has_value());
   if (connectivity_state_ == GRPC_CHANNEL_IDLE) {
@@ -1022,6 +943,7 @@ void PickFirst::SubchannelList::SubchannelData::ProcessUnselectedReadyLocked() {
               p, p->latest_pending_subchannel_list_.get(),
               p->subchannel_list_.get());
     }
+    p->UnsetSelectedSubchannel();
     p->subchannel_list_ = std::move(p->latest_pending_subchannel_list_);
   }
   // Cases 1 and 2.
@@ -1206,7 +1128,7 @@ void PickFirst::SubchannelList::MaybeFinishHappyEyeballsPass() {
 // factory
 //
 
-class PickFirstFactory : public LoadBalancingPolicyFactory {
+class PickFirstFactory final : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {

data/src/core/load_balancing/priority/priority.cc

@@ -83,7 +83,7 @@ constexpr Duration kChildRetentionInterval = Duration::Minutes(15);
 constexpr Duration kDefaultChildFailoverTimeout = Duration::Seconds(10);
 
 // Config for priority LB policy.
-class PriorityLbConfig : public LoadBalancingPolicy::Config {
+class PriorityLbConfig final : public LoadBalancingPolicy::Config {
  public:
   struct PriorityLbChild {
     RefCountedPtr<LoadBalancingPolicy::Config> config;
@@ -119,7 +119,7 @@ class PriorityLbConfig : public LoadBalancingPolicy::Config {
 };
 
 // priority LB policy.
-class PriorityLb : public LoadBalancingPolicy {
+class PriorityLb final : public LoadBalancingPolicy {
  public:
   explicit PriorityLb(Args args);
 
@@ -131,7 +131,7 @@ class PriorityLb : public LoadBalancingPolicy {
 
  private:
   // Each ChildPriority holds a ref to the PriorityLb.
-  class ChildPriority : public InternallyRefCounted<ChildPriority> {
+  class ChildPriority final : public InternallyRefCounted<ChildPriority> {
    public:
     ChildPriority(RefCountedPtr<PriorityLb> priority_policy, std::string name);
 
@@ -163,7 +163,7 @@ class PriorityLb : public LoadBalancingPolicy {
     bool FailoverTimerPending() const { return failover_timer_ != nullptr; }
 
    private:
-    class Helper : public DelegatingChannelControlHelper {
+    class Helper final : public DelegatingChannelControlHelper {
      public:
       explicit Helper(RefCountedPtr<ChildPriority> priority)
           : priority_(std::move(priority)) {}
@@ -183,7 +183,8 @@ class PriorityLb : public LoadBalancingPolicy {
       RefCountedPtr<ChildPriority> priority_;
     };
 
-    class DeactivationTimer : public InternallyRefCounted<DeactivationTimer> {
+    class DeactivationTimer final
+        : public InternallyRefCounted<DeactivationTimer> {
      public:
       explicit DeactivationTimer(RefCountedPtr<ChildPriority> child_priority);
 
@@ -196,7 +197,7 @@ class PriorityLb : public LoadBalancingPolicy {
       absl::optional<EventEngine::TaskHandle> timer_handle_;
     };
 
-    class FailoverTimer : public InternallyRefCounted<FailoverTimer> {
+    class FailoverTimer final : public InternallyRefCounted<FailoverTimer> {
      public:
       explicit FailoverTimer(RefCountedPtr<ChildPriority> child_priority);
 
@@ -874,7 +875,7 @@ void PriorityLbConfig::JsonPostLoad(const Json& /*json*/, const JsonArgs&,
   }
 }
 
-class PriorityLbFactory : public LoadBalancingPolicyFactory {
+class PriorityLbFactory final : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {

data/src/core/load_balancing/ring_hash/ring_hash.cc

@@ -114,7 +114,7 @@ namespace {
 
 constexpr absl::string_view kRingHash = "ring_hash_experimental";
 
-class RingHashLbConfig : public LoadBalancingPolicy::Config {
+class RingHashLbConfig final : public LoadBalancingPolicy::Config {
  public:
   RingHashLbConfig(size_t min_ring_size, size_t max_ring_size)
       : min_ring_size_(min_ring_size), max_ring_size_(max_ring_size) {}
@@ -133,7 +133,7 @@ class RingHashLbConfig : public LoadBalancingPolicy::Config {
 
 constexpr size_t kRingSizeCapDefault = 4096;
 
-class RingHash : public LoadBalancingPolicy {
+class RingHash final : public LoadBalancingPolicy {
  public:
   explicit RingHash(Args args);
 
@@ -144,7 +144,7 @@ class RingHash : public LoadBalancingPolicy {
 
  private:
   // A ring computed based on a config and address list.
-  class Ring : public RefCounted<Ring> {
+  class Ring final : public RefCounted<Ring> {
    public:
     struct RingEntry {
       uint64_t hash;
@@ -160,7 +160,7 @@ class RingHash : public LoadBalancingPolicy {
   };
 
   // State for a particular endpoint.  Delegates to a pick_first child policy.
-  class RingHashEndpoint : public InternallyRefCounted<RingHashEndpoint> {
+  class RingHashEndpoint final : public InternallyRefCounted<RingHashEndpoint> {
    public:
     // index is the index into RingHash::endpoints_ of this endpoint.
     RingHashEndpoint(RefCountedPtr<RingHash> ring_hash, size_t index)
@@ -216,7 +216,7 @@ class RingHash : public LoadBalancingPolicy {
     RefCountedPtr<SubchannelPicker> picker_;
   };
 
-  class Picker : public SubchannelPicker {
+  class Picker final : public SubchannelPicker {
    public:
     explicit Picker(RefCountedPtr<RingHash> ring_hash)
         : ring_hash_(std::move(ring_hash)),
@@ -232,7 +232,7 @@ class RingHash : public LoadBalancingPolicy {
    private:
     // A fire-and-forget class that schedules endpoint connection attempts
     // on the control plane WorkSerializer.
-    class EndpointConnectionAttempter {
+    class EndpointConnectionAttempter final {
      public:
       EndpointConnectionAttempter(RefCountedPtr<RingHash> ring_hash,
                                   RefCountedPtr<RingHashEndpoint> endpoint)
@@ -462,7 +462,7 @@ RingHash::Ring::Ring(RingHash* ring_hash, RingHashLbConfig* config) {
 // RingHash::RingHashEndpoint::Helper
 //
 
-class RingHash::RingHashEndpoint::Helper
+class RingHash::RingHashEndpoint::Helper final
     : public LoadBalancingPolicy::DelegatingChannelControlHelper {
  public:
   explicit Helper(RefCountedPtr<RingHashEndpoint> endpoint)
@@ -849,7 +849,7 @@ void RingHash::UpdateAggregatedConnectivityStateLocked(
 // factory
 //
 
-class RingHashFactory : public LoadBalancingPolicyFactory {
+class RingHashFactory final : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {

data/src/core/load_balancing/ring_hash/ring_hash.h

@@ -30,7 +30,7 @@
 
 namespace grpc_core {
 
-class RequestHashAttribute
+class RequestHashAttribute final
     : public ServiceConfigCallData::CallAttributeInterface {
  public:
   static UniqueTypeName TypeName();