grpc 1.56.2 → 1.57.0.pre1

data/src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.cc

@@ -25,6 +25,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/algorithm/container.h"
+#include "absl/random/random.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -40,11 +42,16 @@
 #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/gpr/string.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
@@ -55,6 +62,15 @@ namespace grpc_core {
 
 TraceFlag grpc_lb_pick_first_trace(false, "pick_first");
 
+// TODO(eostroukhov): Remove once this feature is no longer experimental.
+bool ShufflePickFirstEnabled() {
+  auto value = GetEnv("GRPC_EXPERIMENTAL_PICKFIRST_LB_CONFIG");
+  if (!value.has_value()) return false;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
+}
+
 namespace {
 
 //
@@ -63,6 +79,31 @@ namespace {
 
 constexpr absl::string_view kPickFirst = "pick_first";
 
+class PickFirstConfig : public LoadBalancingPolicy::Config {
+ public:
+  absl::string_view name() const override { return kPickFirst; }
+  bool shuffle_addresses() const { return shuffle_addresses_; }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto kJsonLoader =
+        JsonObjectLoader<PickFirstConfig>()
+            .OptionalField("shuffleAddressList",
+                           &PickFirstConfig::shuffle_addresses_)
+            .Finish();
+    return kJsonLoader;
+  }
+
+  void JsonPostLoad(const Json& /* json */, const JsonArgs& /* args */,
+                    ValidationErrors* /* errors */) {
+    if (!ShufflePickFirstEnabled()) {
+      shuffle_addresses_ = false;
+    }
+  }
+
+ private:
+  bool shuffle_addresses_ = false;
+};
+
 class PickFirst : public LoadBalancingPolicy {
  public:
   explicit PickFirst(Args args);
@@ -169,6 +210,8 @@ class PickFirst : public LoadBalancingPolicy {
   bool idle_ = false;
   // Are we shut down?
   bool shutdown_ = false;
+  // Random bit generator used for shuffling addresses if configured
+  absl::BitGen bit_gen_;
 };
 
 PickFirst::PickFirst(Args args) : LoadBalancingPolicy(std::move(args)) {
@@ -227,7 +270,8 @@ void PickFirst::AttemptToConnectUsingLatestUpdateArgsLocked() {
   }
   latest_pending_subchannel_list_ = MakeRefCounted<PickFirstSubchannelList>(
       this, std::move(addresses), latest_update_args_.args);
-  latest_pending_subchannel_list_->StartWatchingLocked();
+  latest_pending_subchannel_list_->StartWatchingLocked(
+      latest_update_args_.args);
   // Empty update or no valid subchannels.  Put the channel in
   // TRANSIENT_FAILURE and request re-resolution.
   if (latest_pending_subchannel_list_->num_subchannels() == 0) {
@@ -274,6 +318,11 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
     status = args.addresses.status();
   } else if (args.addresses->empty()) {
     status = absl::UnavailableError("address list must not be empty");
+  } else {
+    auto config = static_cast<PickFirstConfig*>(args.config.get());
+    if (config->shuffle_addresses()) {
+      absl::c_shuffle(*args.addresses, bit_gen_);
+    }
   }
   // TODO(roth): This is a hack to disable outlier_detection when used
   // with pick_first, for the reasons described in
@@ -282,9 +331,9 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
   if (args.addresses.ok()) {
     ServerAddressList addresses;
     for (const auto& address : *args.addresses) {
-      addresses.emplace_back(address.WithAttribute(
-          DisableOutlierDetectionAttribute::kName,
-          std::make_unique<DisableOutlierDetectionAttribute>()));
+      addresses.emplace_back(
+          address.address(),
+          address.args().Set(GRPC_ARG_OUTLIER_DETECTION_DISABLE, 1));
     }
     args.addresses = std::move(addresses);
   }
@@ -513,11 +562,6 @@ void PickFirst::PickFirstSubchannelData::ProcessUnselectedReadyLocked() {
   }
 }
 
-class PickFirstConfig : public LoadBalancingPolicy::Config {
- public:
-  absl::string_view name() const override { return kPickFirst; }
-};
-
 //
 // factory
 //
@@ -532,8 +576,9 @@ class PickFirstFactory : public LoadBalancingPolicyFactory {
   absl::string_view name() const override { return kPickFirst; }
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
-  ParseLoadBalancingConfig(const Json& /*json*/) const override {
-    return MakeRefCounted<PickFirstConfig>();
+  ParseLoadBalancingConfig(const Json& json) const override {
+    return LoadFromJson<RefCountedPtr<PickFirstConfig>>(
+        json, JsonArgs(), "errors validating pick_first LB policy config");
   }
 };
 

data/src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.h

@@ -0,0 +1,25 @@
+//
+// Copyright 2023 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_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_PICK_FIRST_PICK_FIRST_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_PICK_FIRST_PICK_FIRST_H
+
+namespace grpc_core {
+// TODO(eostroukhov): Remove once this feature is no longer experimental.
+bool ShufflePickFirstEnabled();
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_PICK_FIRST_PICK_FIRST_H

data/src/core/ext/filters/client_channel/lb_policy/priority/priority.cc

@@ -55,10 +55,10 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
+#include "src/core/lib/load_balancing/delegating_helper.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 
@@ -162,25 +162,23 @@ class PriorityLb : public LoadBalancingPolicy {
     bool FailoverTimerPending() const { return failover_timer_ != nullptr; }
 
    private:
-    class Helper : public ChannelControlHelper {
+    class Helper : public DelegatingChannelControlHelper {
      public:
       explicit Helper(RefCountedPtr<ChildPriority> priority)
           : priority_(std::move(priority)) {}
 
       ~Helper() override { priority_.reset(DEBUG_LOCATION, "Helper"); }
 
-      RefCountedPtr<SubchannelInterface> CreateSubchannel(
-          ServerAddress address, const ChannelArgs& args) override;
       void UpdateState(grpc_connectivity_state state,
                        const absl::Status& status,
                        RefCountedPtr<SubchannelPicker> picker) override;
       void RequestReresolution() override;
-      absl::string_view GetAuthority() override;
-      EventEngine* GetEventEngine() override;
-      void AddTraceEvent(TraceSeverity severity,
-                         absl::string_view message) override;
 
      private:
+      ChannelControlHelper* parent_helper() const override {
+        return priority_->priority_policy_->channel_control_helper();
+      }
+
       RefCountedPtr<ChildPriority> priority_;
     };
 
@@ -793,14 +791,6 @@ void PriorityLb::ChildPriority::MaybeReactivateLocked() {
 // PriorityLb::ChildPriority::Helper
 //
 
-RefCountedPtr<SubchannelInterface>
-PriorityLb::ChildPriority::Helper::CreateSubchannel(ServerAddress address,
-                                                    const ChannelArgs& args) {
-  if (priority_->priority_policy_->shutting_down_) return nullptr;
-  return priority_->priority_policy_->channel_control_helper()
-      ->CreateSubchannel(std::move(address), args);
-}
-
 void PriorityLb::ChildPriority::Helper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
     RefCountedPtr<SubchannelPicker> picker) {
@@ -817,22 +807,6 @@ void PriorityLb::ChildPriority::Helper::RequestReresolution() {
   priority_->priority_policy_->channel_control_helper()->RequestReresolution();
 }
 
-absl::string_view PriorityLb::ChildPriority::Helper::GetAuthority() {
-  return priority_->priority_policy_->channel_control_helper()->GetAuthority();
-}
-
-EventEngine* PriorityLb::ChildPriority::Helper::GetEventEngine() {
-  return priority_->priority_policy_->channel_control_helper()
-      ->GetEventEngine();
-}
-
-void PriorityLb::ChildPriority::Helper::AddTraceEvent(
-    TraceSeverity severity, absl::string_view message) {
-  if (priority_->priority_policy_->shutting_down_) return;
-  priority_->priority_policy_->channel_control_helper()->AddTraceEvent(severity,
-                                                                       message);
-}
-
 //
 // factory
 //

data/src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.cc

@@ -470,16 +470,14 @@ RingHash::RingHashSubchannelList::Ring::Ring(
   address_weights.reserve(subchannel_list->num_subchannels());
   for (size_t i = 0; i < subchannel_list->num_subchannels(); ++i) {
     RingHashSubchannelData* sd = subchannel_list->subchannel(i);
-    const ServerAddressWeightAttribute* weight_attribute = static_cast<
-        const ServerAddressWeightAttribute*>(sd->address().GetAttribute(
-        ServerAddressWeightAttribute::kServerAddressWeightAttributeKey));
+    auto weight_arg = sd->address().args().GetInt(GRPC_ARG_ADDRESS_WEIGHT);
     AddressWeight address_weight;
     address_weight.address =
         grpc_sockaddr_to_string(&sd->address().address(), false).value();
     // Weight should never be zero, but ignore it just in case, since
     // that value would screw up the ring-building algorithm.
-    if (weight_attribute != nullptr && weight_attribute->weight() > 0) {
-      address_weight.weight = weight_attribute->weight();
+    if (weight_arg.value_or(0) > 0) {
+      address_weight.weight = *weight_arg;
     }
     sum += address_weight.weight;
     address_weights.push_back(std::move(address_weight));
@@ -816,7 +814,7 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
   }
   latest_pending_subchannel_list_ = MakeRefCounted<RingHashSubchannelList>(
       this, std::move(addresses), args.args);
-  latest_pending_subchannel_list_->StartWatchingLocked();
+  latest_pending_subchannel_list_->StartWatchingLocked(args.args);
   // If we have no existing list or the new list is empty, immediately
   // promote the new list.
   // Otherwise, do nothing; the new list will be promoted when the

data/src/core/ext/filters/client_channel/lb_policy/rls/rls.cc

@@ -48,7 +48,6 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 #include "upb/base/string_view.h"
 #include "upb/upb.hpp"
@@ -88,10 +87,10 @@
 #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/lib/load_balancing/delegating_helper.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -103,7 +102,6 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/uri/uri_parser.h"
 #include "src/proto/grpc/lookup/v1/rls.upb.h"
 
 namespace grpc_core {
@@ -325,7 +323,7 @@ class RlsLb : public LoadBalancingPolicy {
    private:
     // ChannelControlHelper object that allows the child policy to update state
     // with the wrapper.
-    class ChildPolicyHelper : public LoadBalancingPolicy::ChannelControlHelper {
+    class ChildPolicyHelper : public DelegatingChannelControlHelper {
      public:
       explicit ChildPolicyHelper(WeakRefCountedPtr<ChildPolicyWrapper> wrapper)
           : wrapper_(std::move(wrapper)) {}
@@ -333,18 +331,15 @@ class RlsLb : public LoadBalancingPolicy {
         wrapper_.reset(DEBUG_LOCATION, "ChildPolicyHelper");
       }
 
-      RefCountedPtr<SubchannelInterface> CreateSubchannel(
-          ServerAddress address, const ChannelArgs& args) override;
       void UpdateState(grpc_connectivity_state state,
                        const absl::Status& status,
                        RefCountedPtr<SubchannelPicker> picker) override;
-      void RequestReresolution() override;
-      absl::string_view GetAuthority() override;
-      grpc_event_engine::experimental::EventEngine* GetEventEngine() override;
-      void AddTraceEvent(TraceSeverity severity,
-                         absl::string_view message) override;
 
      private:
+      ChannelControlHelper* parent_helper() const override {
+        return wrapper_->lb_policy_->channel_control_helper();
+      }
+
       WeakRefCountedPtr<ChildPolicyWrapper> wrapper_;
     };
 
@@ -696,9 +691,6 @@ class RlsLb : public LoadBalancingPolicy {
   // Updates the picker in the work serializer.
   void UpdatePickerLocked() ABSL_LOCKS_EXCLUDED(&mu_);
 
-  // The name of the server for the channel.
-  std::string server_name_;
-
   // Mutex to guard LB policy state that is accessed by the picker.
   Mutex mu_;
   bool is_shutdown_ ABSL_GUARDED_BY(mu_) = false;
@@ -866,21 +858,6 @@ absl::Status RlsLb::ChildPolicyWrapper::MaybeFinishUpdate() {
 // RlsLb::ChildPolicyWrapper::ChildPolicyHelper
 //
 
-RefCountedPtr<SubchannelInterface>
-RlsLb::ChildPolicyWrapper::ChildPolicyHelper::CreateSubchannel(
-    ServerAddress address, const ChannelArgs& args) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
-    gpr_log(GPR_INFO,
-            "[rlslb %p] ChildPolicyWrapper=%p [%s] ChildPolicyHelper=%p: "
-            "CreateSubchannel() for %s",
-            wrapper_->lb_policy_.get(), wrapper_.get(),
-            wrapper_->target_.c_str(), this, address.ToString().c_str());
-  }
-  if (wrapper_->is_shutdown_) return nullptr;
-  return wrapper_->lb_policy_->channel_control_helper()->CreateSubchannel(
-      std::move(address), args);
-}
-
 void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
     RefCountedPtr<SubchannelPicker> picker) {
@@ -910,34 +887,6 @@ void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::UpdateState(
   wrapper_->lb_policy_->UpdatePickerLocked();
 }
 
-void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::RequestReresolution() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
-    gpr_log(GPR_INFO,
-            "[rlslb %p] ChildPolicyWrapper=%p [%s] ChildPolicyHelper=%p: "
-            "RequestReresolution",
-            wrapper_->lb_policy_.get(), wrapper_.get(),
-            wrapper_->target_.c_str(), this);
-  }
-  if (wrapper_->is_shutdown_) return;
-  wrapper_->lb_policy_->channel_control_helper()->RequestReresolution();
-}
-
-absl::string_view RlsLb::ChildPolicyWrapper::ChildPolicyHelper::GetAuthority() {
-  return wrapper_->lb_policy_->channel_control_helper()->GetAuthority();
-}
-
-grpc_event_engine::experimental::EventEngine*
-RlsLb::ChildPolicyWrapper::ChildPolicyHelper::GetEventEngine() {
-  return wrapper_->lb_policy_->channel_control_helper()->GetEventEngine();
-}
-
-void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::AddTraceEvent(
-    TraceSeverity severity, absl::string_view message) {
-  if (wrapper_->is_shutdown_) return;
-  wrapper_->lb_policy_->channel_control_helper()->AddTraceEvent(severity,
-                                                                message);
-}
-
 //
 // RlsLb::Picker
 //
@@ -945,7 +894,7 @@ void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::AddTraceEvent(
 // Builds the key to be used for a request based on path and initial_metadata.
 std::map<std::string, std::string> BuildKeyMap(
     const RlsLbConfig::KeyBuilderMap& key_builder_map, absl::string_view path,
-    const std::string& host,
+    absl::string_view host,
     const LoadBalancingPolicy::MetadataInterface* initial_metadata) {
   size_t last_slash_pos = path.npos;  // May need this a few times, so cache it.
   // Find key builder for this path.
@@ -981,7 +930,7 @@ std::map<std::string, std::string> BuildKeyMap(
                  key_builder->constant_keys.end());
   // Add host key.
   if (!key_builder->host_key.empty()) {
-    key_map[key_builder->host_key] = host;
+    key_map[key_builder->host_key] = std::string(host);
   }
   // Add service key.
   if (!key_builder->service_key.empty()) {
@@ -1016,9 +965,10 @@ RlsLb::Picker::Picker(RefCountedPtr<RlsLb> lb_policy)
 
 LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
   // Construct key for request.
-  RequestKey key = {BuildKeyMap(config_->key_builder_map(), args.path,
-                                lb_policy_->server_name_,
-                                args.initial_metadata)};
+  RequestKey key = {
+      BuildKeyMap(config_->key_builder_map(), args.path,
+                  lb_policy_->channel_control_helper()->GetAuthority(),
+                  args.initial_metadata)};
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] picker=%p: request keys: %s",
             lb_policy_.get(), this, key.ToString().c_str());
@@ -1562,11 +1512,13 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
           GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace) ? "RlsChannel" : nullptr),
       lb_policy_(std::move(lb_policy)) {
   // Get channel creds from parent channel.
-  // TODO(roth): Once we eliminate insecure builds, get this via a
-  // method on the helper instead of digging through channel args.
-  auto* creds = lb_policy_->channel_args_.GetObject<grpc_channel_credentials>();
+  // Note that we are using the "unsafe" channel creds here, which do
+  // include any associated call creds.  This is safe in this case,
+  // because we are using the parent channel's authority on the RLS channel.
+  auto creds =
+      lb_policy_->channel_control_helper()->GetUnsafeChannelCredentials();
   // Use the parent channel's authority.
-  std::string authority(lb_policy_->channel_control_helper()->GetAuthority());
+  auto authority = lb_policy_->channel_control_helper()->GetAuthority();
   ChannelArgs args = ChannelArgs()
                          .Set(GRPC_ARG_DEFAULT_AUTHORITY, authority)
                          .Set(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, 1);
@@ -1589,7 +1541,7 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
                .Set(GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION, 1);
   }
   channel_ = grpc_channel_create(lb_policy_->config_->lookup_service().c_str(),
-                                 creds, args.ToC().get());
+                                 creds.get(), args.ToC().get());
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] RlsChannel=%p: created channel %p for %s",
             lb_policy_.get(), this, channel_,
@@ -1901,18 +1853,7 @@ RlsLb::ResponseInfo RlsLb::RlsRequest::ParseResponseProto() {
 // RlsLb
 //
 
-std::string GetServerUri(const ChannelArgs& args) {
-  auto server_uri_str = args.GetString(GRPC_ARG_SERVER_URI);
-  GPR_ASSERT(server_uri_str.has_value());
-  absl::StatusOr<URI> uri = URI::Parse(*server_uri_str);
-  GPR_ASSERT(uri.ok());
-  return std::string(absl::StripPrefix(uri->path(), "/"));
-}
-
-RlsLb::RlsLb(Args args)
-    : LoadBalancingPolicy(std::move(args)),
-      server_name_(GetServerUri(channel_args())),
-      cache_(this) {
+RlsLb::RlsLb(Args args) : LoadBalancingPolicy(std::move(args)), cache_(this) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] policy created", this);
   }

data/src/core/ext/filters/client_channel/lb_policy/round_robin/round_robin.cc

@@ -298,7 +298,7 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
   }
   latest_pending_subchannel_list_ = MakeRefCounted<RoundRobinSubchannelList>(
       this, std::move(addresses), args.args);
-  latest_pending_subchannel_list_->StartWatchingLocked();
+  latest_pending_subchannel_list_->StartWatchingLocked(args.args);
   // If the new list is empty, immediately promote it to
   // subchannel_list_ and report TRANSIENT_FAILURE.
   if (latest_pending_subchannel_list_->num_subchannels() == 0) {

data/src/core/ext/filters/client_channel/lb_policy/subchannel_list.h

@@ -158,7 +158,7 @@ class SubchannelData {
   // Starts watching the connectivity state of the subchannel.
   // ProcessConnectivityChangeLocked() will be called whenever the
   // connectivity state changes.
-  void StartConnectivityWatchLocked();
+  void StartConnectivityWatchLocked(const ChannelArgs& args);
 
   // Cancels watching the connectivity state of the subchannel.
   void CancelConnectivityWatchLocked(const char* reason);
@@ -173,6 +173,7 @@ class SubchannelData {
   // Will be non-null when the subchannel's state is being watched.
   SubchannelInterface::ConnectivityStateWatcherInterface* pending_watcher_ =
       nullptr;
+  SubchannelInterface::DataWatcherInterface* health_watcher_ = nullptr;
   // Data updated by the watcher.
   absl::optional<grpc_connectivity_state> connectivity_state_;
   absl::Status connectivity_status_;
@@ -184,7 +185,7 @@ class SubchannelList : public DualRefCounted<SubchannelListType> {
  public:
   // Starts watching the connectivity state of all subchannels.
   // Must be called immediately after instantiation.
-  void StartWatchingLocked();
+  void StartWatchingLocked(const ChannelArgs& args);
 
   // The number of subchannels in the list.
   size_t num_subchannels() const { return subchannels_.size(); }
@@ -259,7 +260,7 @@ void SubchannelData<SubchannelListType, SubchannelDataType>::Watcher::
         GPR_INFO,
         "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
         " (subchannel %p): connectivity changed: old_state=%s, new_state=%s, "
-        "status=%s, shutting_down=%d, pending_watcher=%p",
+        "status=%s, shutting_down=%d, pending_watcher=%p, health_watcher=%p",
         subchannel_list_->tracer(), subchannel_list_->policy(),
         subchannel_list_.get(), subchannel_data_->Index(),
         subchannel_list_->num_subchannels(),
@@ -268,10 +269,12 @@ void SubchannelData<SubchannelListType, SubchannelDataType>::Watcher::
              ? ConnectivityStateName(*subchannel_data_->connectivity_state_)
              : "N/A"),
         ConnectivityStateName(new_state), status.ToString().c_str(),
-        subchannel_list_->shutting_down(), subchannel_data_->pending_watcher_);
+        subchannel_list_->shutting_down(), subchannel_data_->pending_watcher_,
+        subchannel_data_->health_watcher_);
   }
   if (!subchannel_list_->shutting_down() &&
-      subchannel_data_->pending_watcher_ != nullptr) {
+      (subchannel_data_->pending_watcher_ != nullptr ||
+       subchannel_data_->health_watcher_ != nullptr)) {
     absl::optional<grpc_connectivity_state> old_state =
         subchannel_data_->connectivity_state_;
     subchannel_data_->connectivity_state_ = new_state;
@@ -322,8 +325,8 @@ void SubchannelData<SubchannelListType,
 }
 
 template <typename SubchannelListType, typename SubchannelDataType>
-void SubchannelData<SubchannelListType,
-                    SubchannelDataType>::StartConnectivityWatchLocked() {
+void SubchannelData<SubchannelListType, SubchannelDataType>::
+    StartConnectivityWatchLocked(const ChannelArgs& args) {
   if (GPR_UNLIKELY(subchannel_list_->tracer() != nullptr)) {
     gpr_log(
         GPR_INFO,
@@ -336,14 +339,16 @@ void SubchannelData<SubchannelListType,
         subchannel_list()->health_check_service_name_.value_or("N/A").c_str());
   }
   GPR_ASSERT(pending_watcher_ == nullptr);
+  GPR_ASSERT(health_watcher_ == nullptr);
   auto watcher = std::make_unique<Watcher>(
       this, subchannel_list()->WeakRef(DEBUG_LOCATION, "Watcher"));
-  pending_watcher_ = watcher.get();
   if (subchannel_list()->health_check_service_name_.has_value()) {
-    subchannel_->AddDataWatcher(MakeHealthCheckWatcher(
-        subchannel_list_->work_serializer(),
-        *subchannel_list()->health_check_service_name_, std::move(watcher)));
+    auto health_watcher = MakeHealthCheckWatcher(
+        subchannel_list_->work_serializer(), args, std::move(watcher));
+    health_watcher_ = health_watcher.get();
+    subchannel_->AddDataWatcher(std::move(health_watcher));
   } else {
+    pending_watcher_ = watcher.get();
     subchannel_->WatchConnectivityState(std::move(watcher));
   }
 }
@@ -360,12 +365,19 @@ void SubchannelData<SubchannelListType, SubchannelDataType>::
               subchannel_list_, Index(), subchannel_list_->num_subchannels(),
               subchannel_.get(), reason);
     }
-    // No need to cancel if using health checking, because the data
-    // watcher will be destroyed automatically when the subchannel is.
-    if (!subchannel_list()->health_check_service_name_.has_value()) {
-      subchannel_->CancelConnectivityStateWatch(pending_watcher_);
-    }
+    subchannel_->CancelConnectivityStateWatch(pending_watcher_);
     pending_watcher_ = nullptr;
+  } else if (health_watcher_ != nullptr) {
+    if (GPR_UNLIKELY(subchannel_list_->tracer() != nullptr)) {
+      gpr_log(GPR_INFO,
+              "[%s %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
+              " (subchannel %p): canceling health watch (%s)",
+              subchannel_list_->tracer(), subchannel_list_->policy(),
+              subchannel_list_, Index(), subchannel_list_->num_subchannels(),
+              subchannel_.get(), reason);
+    }
+    subchannel_->CancelDataWatcher(health_watcher_);
+    health_watcher_ = nullptr;
   }
 }
 
@@ -434,10 +446,10 @@ SubchannelList<SubchannelListType, SubchannelDataType>::~SubchannelList() {
 }
 
 template <typename SubchannelListType, typename SubchannelDataType>
-void SubchannelList<SubchannelListType,
-                    SubchannelDataType>::StartWatchingLocked() {
+void SubchannelList<SubchannelListType, SubchannelDataType>::
+    StartWatchingLocked(const ChannelArgs& args) {
   for (auto& sd : subchannels_) {
-    sd->StartConnectivityWatchLocked();
+    sd->StartConnectivityWatchLocked(args);
   }
 }
 

data/src/core/ext/filters/client_channel/lb_policy/weighted_round_robin/weighted_round_robin.cc

@@ -703,7 +703,7 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
   latest_pending_subchannel_list_ =
       MakeRefCounted<WeightedRoundRobinSubchannelList>(
           this, std::move(addresses), args.args);
-  latest_pending_subchannel_list_->StartWatchingLocked();
+  latest_pending_subchannel_list_->StartWatchingLocked(args.args);
   // If the new list is empty, immediately promote it to
   // subchannel_list_ and report TRANSIENT_FAILURE.
   if (latest_pending_subchannel_list_->num_subchannels() == 0) {