grpc 1.62.3 → 1.63.0

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

@@ -16,6 +16,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/load_balancing/weighted_target/weighted_target.h"
+
 #include <string.h>
 
 #include <algorithm>
@@ -81,7 +83,7 @@ constexpr absl::string_view kWeightedTarget = "weighted_target_experimental";
 constexpr Duration kChildRetentionInterval = Duration::Minutes(15);
 
 // Config for weighted_target LB policy.
-class WeightedTargetLbConfig : public LoadBalancingPolicy::Config {
+class WeightedTargetLbConfig final : public LoadBalancingPolicy::Config {
  public:
   struct ChildConfig {
     uint32_t weight;
@@ -113,7 +115,7 @@ class WeightedTargetLbConfig : public LoadBalancingPolicy::Config {
 };
 
 // weighted_target LB policy.
-class WeightedTargetLb : public LoadBalancingPolicy {
+class WeightedTargetLb final : public LoadBalancingPolicy {
  public:
   explicit WeightedTargetLb(Args args);
 
@@ -125,7 +127,7 @@ class WeightedTargetLb : public LoadBalancingPolicy {
  private:
   // Picks a child using stateless WRR and then delegates to that
   // child's picker.
-  class WeightedPicker : public SubchannelPicker {
+  class WeightedPicker final : public SubchannelPicker {
    public:
     // Maintains a weighted list of pickers from each child that is in
     // ready state. The first element in the pair represents the end of a
@@ -149,7 +151,7 @@ class WeightedTargetLb : public LoadBalancingPolicy {
   };
 
   // Each WeightedChild holds a ref to its parent WeightedTargetLb.
-  class WeightedChild : public InternallyRefCounted<WeightedChild> {
+  class WeightedChild final : public InternallyRefCounted<WeightedChild> {
    public:
     WeightedChild(RefCountedPtr<WeightedTargetLb> weighted_target_policy,
                   const std::string& name);
@@ -160,7 +162,7 @@ class WeightedTargetLb : public LoadBalancingPolicy {
     absl::Status UpdateLocked(
         const WeightedTargetLbConfig::ChildConfig& config,
         absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses,
-        const std::string& resolution_note, const ChannelArgs& args);
+        const std::string& resolution_note, ChannelArgs args);
     void ResetBackoffLocked();
     void DeactivateLocked();
 
@@ -171,7 +173,7 @@ class WeightedTargetLb : public LoadBalancingPolicy {
     RefCountedPtr<SubchannelPicker> picker() const { return picker_; }
 
    private:
-    class Helper : public DelegatingChannelControlHelper {
+    class Helper final : public DelegatingChannelControlHelper {
      public:
       explicit Helper(RefCountedPtr<WeightedChild> weighted_child)
           : weighted_child_(std::move(weighted_child)) {}
@@ -191,7 +193,7 @@ class WeightedTargetLb : public LoadBalancingPolicy {
       RefCountedPtr<WeightedChild> weighted_child_;
     };
 
-    class DelayedRemovalTimer
+    class DelayedRemovalTimer final
         : public InternallyRefCounted<DelayedRemovalTimer> {
      public:
       explicit DelayedRemovalTimer(RefCountedPtr<WeightedChild> weighted_child);
@@ -592,7 +594,7 @@ WeightedTargetLb::WeightedChild::CreateChildPolicyLocked(
 absl::Status WeightedTargetLb::WeightedChild::UpdateLocked(
     const WeightedTargetLbConfig::ChildConfig& config,
     absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses,
-    const std::string& resolution_note, const ChannelArgs& args) {
+    const std::string& resolution_note, ChannelArgs args) {
   if (weighted_target_policy_->shutting_down_) return absl::OkStatus();
   // Update child weight.
   if (weight_ != config.weight &&
@@ -611,6 +613,7 @@ absl::Status WeightedTargetLb::WeightedChild::UpdateLocked(
     delayed_removal_timer_.reset();
   }
   // Create child policy if needed.
+  args = args.Set(GRPC_ARG_LB_WEIGHTED_TARGET_CHILD, name_);
   if (child_policy_ == nullptr) {
     child_policy_ = CreateChildPolicyLocked(args);
   }
@@ -619,7 +622,7 @@ absl::Status WeightedTargetLb::WeightedChild::UpdateLocked(
   update_args.config = config.config;
   update_args.addresses = std::move(addresses);
   update_args.resolution_note = resolution_note;
-  update_args.args = args;
+  update_args.args = std::move(args);
   // Update the policy.
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_weighted_target_trace)) {
     gpr_log(GPR_INFO,
@@ -729,7 +732,7 @@ const JsonLoaderInterface* WeightedTargetLbConfig::JsonLoader(const JsonArgs&) {
   return loader;
 }
 
-class WeightedTargetLbFactory : public LoadBalancingPolicyFactory {
+class WeightedTargetLbFactory final : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {

data/src/core/load_balancing/weighted_target/weighted_target.h

@@ -0,0 +1,28 @@
+//
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_WEIGHTED_TARGET_WEIGHTED_TARGET_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_WEIGHTED_TARGET_WEIGHTED_TARGET_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/resolver/endpoint_addresses.h"
+
+// Channel arg key indicating the weighted_target child name.
+#define GRPC_ARG_LB_WEIGHTED_TARGET_CHILD \
+   GRPC_ARG_NO_SUBCHANNEL_PREFIX "lb_weighted_target_child"
+
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_WEIGHTED_TARGET_WEIGHTED_TARGET_H

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

@@ -37,9 +37,6 @@
 #include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
-#include "src/core/load_balancing/address_filtering.h"
-#include "src/core/load_balancing/outlier_detection/outlier_detection.h"
-#include "src/core/load_balancing/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_cluster.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_health_status.h"
@@ -59,10 +56,13 @@
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/json/json_writer.h"
+#include "src/core/load_balancing/address_filtering.h"
 #include "src/core/load_balancing/delegating_helper.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"
+#include "src/core/load_balancing/outlier_detection/outlier_detection.h"
+#include "src/core/load_balancing/xds/xds_channel_args.h"
 #include "src/core/resolver/xds/xds_dependency_manager.h"
 
 namespace grpc_core {
@@ -85,7 +85,7 @@ using XdsConfig = XdsDependencyManager::XdsConfig;
 constexpr absl::string_view kCds = "cds_experimental";
 
 // Config for this LB policy.
-class CdsLbConfig : public LoadBalancingPolicy::Config {
+class CdsLbConfig final : public LoadBalancingPolicy::Config {
  public:
   CdsLbConfig() = default;
 
@@ -115,7 +115,7 @@ class CdsLbConfig : public LoadBalancingPolicy::Config {
 };
 
 // CDS LB policy.
-class CdsLb : public LoadBalancingPolicy {
+class CdsLb final : public LoadBalancingPolicy {
  public:
   explicit CdsLb(Args args);
 
@@ -232,7 +232,7 @@ std::string MakeChildPolicyName(absl::string_view cluster,
                       "}");
 }
 
-class PriorityEndpointIterator : public EndpointAddressesIterator {
+class PriorityEndpointIterator final : public EndpointAddressesIterator {
  public:
   PriorityEndpointIterator(
       std::string cluster_name,
@@ -254,7 +254,7 @@ class PriorityEndpointIterator : public EndpointAddressesIterator {
         const auto& locality = p.second;
         std::vector<RefCountedStringValue> hierarchical_path = {
             RefCountedStringValue(priority_child_name),
-            RefCountedStringValue(locality_name->AsHumanReadableString())};
+            locality_name->human_readable_string()};
         auto hierarchical_path_attr =
             MakeRefCounted<HierarchicalPathArg>(std::move(hierarchical_path));
         for (const auto& endpoint : locality.endpoints) {
@@ -731,7 +731,7 @@ void CdsLb::ReportTransientFailure(absl::Status status) {
 // factory
 //
 
-class CdsLbFactory : public LoadBalancingPolicyFactory {
+class CdsLbFactory final : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {

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

@@ -38,22 +38,22 @@
 #include <grpc/support/log.h>
 
 #include "src/core/client_channel/client_channel_internal.h"
-#include "src/core/load_balancing/backend_metric_data.h"
-#include "src/core/load_balancing/child_policy_handler.h"
-#include "src/core/load_balancing/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_client_grpc.h"
 #include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/ext/xds/xds_endpoint.h"
+#include "src/core/lib/channel/call_tracer.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/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/match.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/ref_counted_string.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -63,11 +63,14 @@
 #include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/security/credentials/xds/xds_credentials.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/load_balancing/backend_metric_data.h"
+#include "src/core/load_balancing/child_policy_handler.h"
 #include "src/core/load_balancing/delegating_helper.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"
 #include "src/core/load_balancing/subchannel_interface.h"
+#include "src/core/load_balancing/xds/xds_channel_args.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/resolver/xds/xds_dependency_manager.h"
 
@@ -77,20 +80,18 @@ TraceFlag grpc_xds_cluster_impl_lb_trace(false, "xds_cluster_impl_lb");
 
 namespace {
 
-using OptionalLabelComponent =
-    ClientCallTracer::CallAttemptTracer::OptionalLabelComponent;
 using XdsConfig = XdsDependencyManager::XdsConfig;
 
 //
 // global circuit breaker atomic map
 //
 
-class CircuitBreakerCallCounterMap {
+class CircuitBreakerCallCounterMap final {
  public:
   using Key =
       std::pair<std::string /*cluster*/, std::string /*eds_service_name*/>;
 
-  class CallCounter : public RefCounted<CallCounter> {
+  class CallCounter final : public RefCounted<CallCounter> {
    public:
     explicit CallCounter(Key key) : key_(std::move(key)) {}
     ~CallCounter() override;
@@ -151,7 +152,7 @@ CircuitBreakerCallCounterMap::CallCounter::~CallCounter() {
 constexpr absl::string_view kXdsClusterImpl = "xds_cluster_impl_experimental";
 
 // Config for xDS Cluster Impl LB policy.
-class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
+class XdsClusterImplLbConfig final : public LoadBalancingPolicy::Config {
  public:
   XdsClusterImplLbConfig() = default;
 
@@ -178,7 +179,7 @@ class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
 };
 
 // xDS Cluster Impl LB policy.
-class XdsClusterImplLb : public LoadBalancingPolicy {
+class XdsClusterImplLb final : public LoadBalancingPolicy {
  public:
   XdsClusterImplLb(RefCountedPtr<GrpcXdsClient> xds_client, Args args);
 
@@ -189,24 +190,48 @@ class XdsClusterImplLb : public LoadBalancingPolicy {
   void ResetBackoffLocked() override;
 
  private:
-  class StatsSubchannelWrapper : public DelegatingSubchannel {
+  class StatsSubchannelWrapper final : public DelegatingSubchannel {
    public:
+    // If load reporting is enabled and we have an XdsClusterLocalityStats
+    // object, that object already contains the locality label.  We
+    // need to store the locality label directly only in the case where
+    // load reporting is disabled.
+    using LocalityData = absl::variant<
+        RefCountedStringValue /*locality*/,
+        RefCountedPtr<XdsClusterLocalityStats> /*locality_stats*/>;
+
     StatsSubchannelWrapper(
         RefCountedPtr<SubchannelInterface> wrapped_subchannel,
-        RefCountedPtr<XdsClusterLocalityStats> locality_stats)
+        LocalityData locality_data)
         : DelegatingSubchannel(std::move(wrapped_subchannel)),
-          locality_stats_(std::move(locality_stats)) {}
+          locality_data_(std::move(locality_data)) {}
+
+    RefCountedStringValue locality() const {
+      return Match(
+          locality_data_,
+          [](RefCountedStringValue locality) { return locality; },
+          [](const RefCountedPtr<XdsClusterLocalityStats>& locality_stats) {
+            return locality_stats->locality_name()->human_readable_string();
+          });
+    }
 
     XdsClusterLocalityStats* locality_stats() const {
-      return locality_stats_.get();
+      return Match(
+          locality_data_,
+          [](const RefCountedStringValue&) {
+            return static_cast<XdsClusterLocalityStats*>(nullptr);
+          },
+          [](const RefCountedPtr<XdsClusterLocalityStats>& locality_stats) {
+            return locality_stats.get();
+          });
     }
 
    private:
-    RefCountedPtr<XdsClusterLocalityStats> locality_stats_;
+    LocalityData locality_data_;
   };
 
   // A picker that wraps the picker from the child to perform drops.
-  class Picker : public SubchannelPicker {
+  class Picker final : public SubchannelPicker {
    public:
     Picker(XdsClusterImplLb* xds_cluster_impl_lb,
            RefCountedPtr<SubchannelPicker> picker);
@@ -218,13 +243,14 @@ class XdsClusterImplLb : public LoadBalancingPolicy {
 
     RefCountedPtr<CircuitBreakerCallCounterMap::CallCounter> call_counter_;
     uint32_t max_concurrent_requests_;
-    std::shared_ptr<std::map<std::string, std::string>> service_labels_;
+    RefCountedStringValue service_telemetry_label_;
+    RefCountedStringValue namespace_telemetry_label_;
     RefCountedPtr<XdsEndpointResource::DropConfig> drop_config_;
     RefCountedPtr<XdsClusterDropStats> drop_stats_;
     RefCountedPtr<SubchannelPicker> picker_;
   };
 
-  class Helper
+  class Helper final
       : public ParentOwningDelegatingChannelControlHelper<XdsClusterImplLb> {
    public:
     explicit Helper(RefCountedPtr<XdsClusterImplLb> xds_cluster_impl_policy)
@@ -286,7 +312,7 @@ class XdsClusterImplLb : public LoadBalancingPolicy {
 // XdsClusterImplLb::Picker::SubchannelCallTracker
 //
 
-class XdsClusterImplLb::Picker::SubchannelCallTracker
+class XdsClusterImplLb::Picker::SubchannelCallTracker final
     : public LoadBalancingPolicy::SubchannelCallTrackerInterface {
  public:
   SubchannelCallTracker(
@@ -362,7 +388,10 @@ XdsClusterImplLb::Picker::Picker(XdsClusterImplLb* xds_cluster_impl_lb,
     : call_counter_(xds_cluster_impl_lb->call_counter_),
       max_concurrent_requests_(
           xds_cluster_impl_lb->cluster_resource_->max_concurrent_requests),
-      service_labels_(xds_cluster_impl_lb->cluster_resource_->telemetry_labels),
+      service_telemetry_label_(
+          xds_cluster_impl_lb->cluster_resource_->service_telemetry_label),
+      namespace_telemetry_label_(
+          xds_cluster_impl_lb->cluster_resource_->namespace_telemetry_label),
       drop_config_(xds_cluster_impl_lb->drop_config_),
       drop_stats_(xds_cluster_impl_lb->drop_stats_),
       picker_(std::move(picker)) {
@@ -375,9 +404,15 @@ XdsClusterImplLb::Picker::Picker(XdsClusterImplLb* xds_cluster_impl_lb,
 LoadBalancingPolicy::PickResult XdsClusterImplLb::Picker::Pick(
     LoadBalancingPolicy::PickArgs args) {
   auto* call_state = static_cast<ClientChannelLbCallState*>(args.call_state);
-  if (call_state->GetCallAttemptTracer() != nullptr) {
-    call_state->GetCallAttemptTracer()->AddOptionalLabels(
-        OptionalLabelComponent::kXdsServiceLabels, service_labels_);
+  auto* call_attempt_tracer = call_state->GetCallAttemptTracer();
+  if (call_attempt_tracer != nullptr) {
+    call_attempt_tracer->SetOptionalLabel(
+        ClientCallTracer::CallAttemptTracer::OptionalLabelKey::kXdsServiceName,
+        service_telemetry_label_);
+    call_attempt_tracer->SetOptionalLabel(
+        ClientCallTracer::CallAttemptTracer::OptionalLabelKey::
+            kXdsServiceNamespace,
+        namespace_telemetry_label_);
   }
   // Handle EDS drops.
   const std::string* drop_category;
@@ -404,16 +439,22 @@ LoadBalancingPolicy::PickResult XdsClusterImplLb::Picker::Pick(
   PickResult result = picker_->Pick(args);
   auto* complete_pick = absl::get_if<PickResult::Complete>(&result.result);
   if (complete_pick != nullptr) {
+    auto* subchannel_wrapper =
+        static_cast<StatsSubchannelWrapper*>(complete_pick->subchannel.get());
+    // Add locality label to per-call metrics if needed.
+    if (call_attempt_tracer != nullptr) {
+      call_attempt_tracer->SetOptionalLabel(
+          ClientCallTracer::CallAttemptTracer::OptionalLabelKey::kLocality,
+          subchannel_wrapper->locality());
+    }
+    // Handle load reporting.
     RefCountedPtr<XdsClusterLocalityStats> locality_stats;
-    if (drop_stats_ != nullptr) {  // If load reporting is enabled.
-      auto* subchannel_wrapper =
-          static_cast<StatsSubchannelWrapper*>(complete_pick->subchannel.get());
-      // Handle load reporting.
+    if (subchannel_wrapper->locality_stats() != nullptr) {
       locality_stats = subchannel_wrapper->locality_stats()->Ref(
           DEBUG_LOCATION, "SubchannelCallTracker");
-      // Unwrap subchannel to pass back up the stack.
-      complete_pick->subchannel = subchannel_wrapper->wrapped_subchannel();
     }
+    // Unwrap subchannel to pass back up the stack.
+    complete_pick->subchannel = subchannel_wrapper->wrapped_subchannel();
     // Inject subchannel call tracker to record call completion.
     complete_pick->subchannel_call_tracker =
         std::make_unique<SubchannelCallTracker>(
@@ -743,36 +784,39 @@ RefCountedPtr<SubchannelInterface> XdsClusterImplLb::Helper::CreateSubchannel(
     const grpc_resolved_address& address, const ChannelArgs& per_address_args,
     const ChannelArgs& args) {
   if (parent()->shutting_down_) return nullptr;
-  // If load reporting is enabled, wrap the subchannel such that it
-  // includes the locality stats object, which will be used by the Picker.
+  // Wrap the subchannel so that we pass along the locality label and
+  // (if load reporting is enabled) the locality stats object, which
+  // will be used by the picker.
+  auto locality_name = per_address_args.GetObjectRef<XdsLocalityName>();
+  RefCountedPtr<XdsClusterLocalityStats> locality_stats;
   if (parent()->cluster_resource_->lrs_load_reporting_server.has_value()) {
-    auto locality_name = per_address_args.GetObjectRef<XdsLocalityName>();
-    RefCountedPtr<XdsClusterLocalityStats> locality_stats =
-        parent()->xds_client_->AddClusterLocalityStats(
-            parent()->cluster_resource_->lrs_load_reporting_server.value(),
-            parent()->config_->cluster_name(),
-            GetEdsResourceName(*parent()->cluster_resource_),
-            std::move(locality_name));
-    if (locality_stats != nullptr) {
-      return MakeRefCounted<StatsSubchannelWrapper>(
-          parent()->channel_control_helper()->CreateSubchannel(
-              address, per_address_args, args),
-          std::move(locality_stats));
+    locality_stats = parent()->xds_client_->AddClusterLocalityStats(
+        parent()->cluster_resource_->lrs_load_reporting_server.value(),
+        parent()->config_->cluster_name(),
+        GetEdsResourceName(*parent()->cluster_resource_), locality_name);
+    if (locality_stats == nullptr) {
+      gpr_log(GPR_ERROR,
+              "[xds_cluster_impl_lb %p] Failed to get locality stats object "
+              "for LRS server %s, cluster %s, EDS service name %s; load "
+              "reports will not be generated",
+              parent(),
+              parent()
+                  ->cluster_resource_->lrs_load_reporting_server->server_uri()
+                  .c_str(),
+              parent()->config_->cluster_name().c_str(),
+              GetEdsResourceName(*parent()->cluster_resource_).c_str());
     }
-    gpr_log(GPR_ERROR,
-            "[xds_cluster_impl_lb %p] Failed to get locality stats object for "
-            "LRS server %s, cluster %s, EDS service name %s; load reports will "
-            "not be generated (not wrapping subchannel)",
-            parent(),
-            parent()
-                ->cluster_resource_->lrs_load_reporting_server->server_uri()
-                .c_str(),
-            parent()->config_->cluster_name().c_str(),
-            GetEdsResourceName(*parent()->cluster_resource_).c_str());
-  }
-  // Load reporting not enabled, so don't wrap the subchannel.
-  return parent()->channel_control_helper()->CreateSubchannel(
-      address, per_address_args, args);
+  }
+  StatsSubchannelWrapper::LocalityData locality_data;
+  if (locality_stats != nullptr) {
+    locality_data = std::move(locality_stats);
+  } else {
+    locality_data = locality_name->human_readable_string();
+  }
+  return MakeRefCounted<StatsSubchannelWrapper>(
+      parent()->channel_control_helper()->CreateSubchannel(
+          address, per_address_args, args),
+      std::move(locality_data));
 }
 
 void XdsClusterImplLb::Helper::UpdateState(
@@ -827,7 +871,7 @@ void XdsClusterImplLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
   }
 }
 
-class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
+class XdsClusterImplLbFactory final : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {

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

@@ -75,7 +75,7 @@ constexpr absl::string_view kXdsClusterManager =
     "xds_cluster_manager_experimental";
 
 // Config for xds_cluster_manager LB policy.
-class XdsClusterManagerLbConfig : public LoadBalancingPolicy::Config {
+class XdsClusterManagerLbConfig final : public LoadBalancingPolicy::Config {
  public:
   struct Child {
     RefCountedPtr<LoadBalancingPolicy::Config> config;
@@ -108,7 +108,7 @@ class XdsClusterManagerLbConfig : public LoadBalancingPolicy::Config {
 };
 
 // xds_cluster_manager LB policy.
-class XdsClusterManagerLb : public LoadBalancingPolicy {
+class XdsClusterManagerLb final : public LoadBalancingPolicy {
  public:
   explicit XdsClusterManagerLb(Args args);
 
@@ -121,7 +121,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
  private:
   // Picks a child using prefix or path matching and then delegates to that
   // child's picker.
-  class ClusterPicker : public SubchannelPicker {
+  class ClusterPicker final : public SubchannelPicker {
    public:
     // Maintains a map of cluster names to pickers.
     using ClusterMap = std::map<std::string /*cluster_name*/,
@@ -139,7 +139,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
   };
 
   // Each ClusterChild holds a ref to its parent XdsClusterManagerLb.
-  class ClusterChild : public InternallyRefCounted<ClusterChild> {
+  class ClusterChild final : public InternallyRefCounted<ClusterChild> {
    public:
     ClusterChild(RefCountedPtr<XdsClusterManagerLb> xds_cluster_manager_policy,
                  const std::string& name);
@@ -162,7 +162,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
     RefCountedPtr<SubchannelPicker> picker() const { return picker_; }
 
    private:
-    class Helper : public DelegatingChannelControlHelper {
+    class Helper final : public DelegatingChannelControlHelper {
      public:
       explicit Helper(RefCountedPtr<ClusterChild> xds_cluster_manager_child)
           : xds_cluster_manager_child_(std::move(xds_cluster_manager_child)) {}
@@ -625,7 +625,7 @@ const JsonLoaderInterface* XdsClusterManagerLbConfig::JsonLoader(
   return loader;
 }
 
-class XdsClusterManagerLbFactory : public LoadBalancingPolicyFactory {
+class XdsClusterManagerLbFactory final : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {