grpc 1.73.0 → 1.75.0

data/src/core/load_balancing/child_policy_handler.cc

@@ -102,11 +102,10 @@ class ChildPolicyHandler::Helper final
     parent()->channel_control_helper()->RequestReresolution();
   }
 
-  void AddTraceEvent(TraceSeverity severity,
-                     absl::string_view message) override {
+  void AddTraceEvent(absl::string_view message) override {
     if (parent()->shutting_down_) return;
     if (!CalledByPendingChild() && !CalledByCurrentChild()) return;
-    parent()->channel_control_helper()->AddTraceEvent(severity, message);
+    parent()->channel_control_helper()->AddTraceEvent(message);
   }
 
   void set_child(LoadBalancingPolicy* child) { child_ = child; }
@@ -289,7 +288,6 @@ OrphanablePtr<LoadBalancingPolicy> ChildPolicyHandler::CreateChildPolicy(
               << lb_policy.get() << ")";
   }
   channel_control_helper()->AddTraceEvent(
-      ChannelControlHelper::TRACE_INFO,
       absl::StrCat("Created new LB policy \"", child_policy_name, "\""));
   grpc_pollset_set_add_pollset_set(lb_policy->interested_parties(),
                                    interested_parties());

data/src/core/load_balancing/delegating_helper.h

@@ -81,9 +81,8 @@ class LoadBalancingPolicy::DelegatingChannelControlHelper
     return parent_helper()->GetStatsPluginGroup();
   }
 
-  void AddTraceEvent(TraceSeverity severity,
-                     absl::string_view message) override {
-    parent_helper()->AddTraceEvent(severity, message);
+  void AddTraceEvent(absl::string_view message) override {
+    parent_helper()->AddTraceEvent(message);
   }
 
  private:

data/src/core/load_balancing/endpoint_list.cc

@@ -28,10 +28,12 @@
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
+#include "absl/random/random.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/load_balancing/delegating_helper.h"
 #include "src/core/load_balancing/lb_policy.h"
@@ -42,6 +44,7 @@
 #include "src/core/util/json/json.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 
 namespace grpc_core {
 
@@ -168,10 +171,34 @@ void EndpointList::Init(
                                               const ChannelArgs&)>
         create_endpoint) {
   if (endpoints == nullptr) return;
+  if (!IsRrWrrConnectFromRandomIndexEnabled()) {
+    endpoints->ForEach([&](const EndpointAddresses& endpoint) {
+      endpoints_.push_back(
+          create_endpoint(Ref(DEBUG_LOCATION, "Endpoint"), endpoint, args));
+    });
+    return;
+  }
+  // If all clients get the same endpoint list in the same order, and they
+  // all start connection attempts in that order, and all connection attempts
+  // take approximately the same amount of time, then all clients are
+  // likely to connect to the first endpoint in the list before any of
+  // the others.  As soon as the client has that initial connection,
+  // it will send all queued RPCs on that connection while it waits for
+  // other endpoints to become connected.  This can result in sending a
+  // potentially large burst of traffic to the first endpoint in the list.
+  // To avoid that, we start connecting from a random index into the list.
+  std::vector<EndpointAddresses> endpoint_list;
   endpoints->ForEach([&](const EndpointAddresses& endpoint) {
-    endpoints_.push_back(
-        create_endpoint(Ref(DEBUG_LOCATION, "Endpoint"), endpoint, args));
+    endpoint_list.push_back(endpoint);
   });
+  endpoints_.resize(endpoint_list.size());
+  size_t start_index = absl::Uniform(SharedBitGen(), 0UL, endpoint_list.size());
+  for (size_t i = 0; i < endpoint_list.size(); ++i) {
+    size_t index = (start_index + i) % endpoint_list.size();
+    EndpointAddresses& endpoint = endpoint_list[index];
+    endpoints_[index] =
+        create_endpoint(Ref(DEBUG_LOCATION, "Endpoint"), endpoint, args);
+  }
 }
 
 void EndpointList::ResetBackoffLocked() {

data/src/core/load_balancing/grpclb/client_load_reporting_filter.cc

@@ -50,7 +50,7 @@ ClientLoadReportingFilter::Create(const ChannelArgs&, ChannelFilter::Args) {
 
 void ClientLoadReportingFilter::Call::OnClientInitialMetadata(
     ClientMetadata& client_initial_metadata) {
-  GRPC_LATENT_SEE_INNER_SCOPE(
+  GRPC_LATENT_SEE_SCOPE(
       "ClientLoadReportingFilter::Call::OnClientInitialMetadata");
   // Handle client initial metadata.
   // Grab client stats object from metadata.
@@ -62,14 +62,14 @@ void ClientLoadReportingFilter::Call::OnClientInitialMetadata(
 }
 
 void ClientLoadReportingFilter::Call::OnServerInitialMetadata(ServerMetadata&) {
-  GRPC_LATENT_SEE_INNER_SCOPE(
+  GRPC_LATENT_SEE_SCOPE(
       "ClientLoadReportingFilter::Call::OnServerInitialMetadata");
   saw_initial_metadata_ = true;
 }
 
 void ClientLoadReportingFilter::Call::OnServerTrailingMetadata(
     ServerMetadata& server_trailing_metadata) {
-  GRPC_LATENT_SEE_INNER_SCOPE(
+  GRPC_LATENT_SEE_SCOPE(
       "ClientLoadReportingFilter::Call::OnServerTrailingMetadata");
   if (client_stats_ != nullptr) {
     client_stats_->AddCallFinished(

data/src/core/load_balancing/grpclb/client_load_reporting_filter.h

@@ -31,7 +31,7 @@
 
 namespace grpc_core {
 
-class ClientLoadReportingFilter final
+class ClientLoadReportingFilter
     : public ImplementChannelFilter<ClientLoadReportingFilter> {
  public:
   static const grpc_channel_filter kFilter;

data/src/core/load_balancing/health_check_client.cc

@@ -221,11 +221,7 @@ class HealthProducer::HealthChecker::HealthStreamEventHandler final
       LOG(ERROR) << kErrorMessage;
       auto* channelz_node =
           health_checker_->producer_->subchannel_->channelz_node();
-      if (channelz_node != nullptr) {
-        channelz_node->AddTraceEvent(
-            channelz::ChannelTrace::Error,
-            grpc_slice_from_static_string(kErrorMessage));
-      }
+      GRPC_CHANNELZ_LOG(channelz_node) << kErrorMessage;
       SetHealthStatusLocked(client, GRPC_CHANNEL_READY, kErrorMessage);
     }
   }

data/src/core/load_balancing/lb_policy.h

@@ -336,9 +336,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     GetStatsPluginGroup() = 0;
 
     /// Adds a trace message associated with the channel.
-    enum TraceSeverity { TRACE_INFO, TRACE_WARNING, TRACE_ERROR };
-    virtual void AddTraceEvent(TraceSeverity severity,
-                               absl::string_view message) = 0;
+    virtual void AddTraceEvent(absl::string_view message) = 0;
   };
 
   class DelegatingChannelControlHelper;

data/src/core/load_balancing/oob_backend_metric.cc

@@ -145,11 +145,7 @@ class OrcaProducer::OrcaStreamEventHandler final
           "Orca stream returned UNIMPLEMENTED; disabling";
       LOG(ERROR) << kErrorMessage;
       auto* channelz_node = producer_->subchannel_->channelz_node();
-      if (channelz_node != nullptr) {
-        channelz_node->AddTraceEvent(
-            channelz::ChannelTrace::Error,
-            grpc_slice_from_static_string(kErrorMessage));
-      }
+      GRPC_CHANNELZ_LOG(channelz_node) << kErrorMessage;
     }
   }
 

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

@@ -528,6 +528,9 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
     });
     if (endpoints.empty()) {
       status = absl::UnavailableError("address list must not be empty");
+      // TODO(roth): Replace this one-off special case with a more
+      // general solution.
+      if (IsPickFirstIgnoreEmptyUpdatesEnabled()) args.addresses = status;
     } else {
       // Shuffle the list if needed.
       auto config = static_cast<PickFirstConfig*>(args.config.get());
@@ -872,11 +875,18 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
   // Otherwise, process connectivity state change.
   switch (*connectivity_state_) {
     case GRPC_CHANNEL_TRANSIENT_FAILURE: {
-      bool prev_seen_transient_failure =
-          std::exchange(seen_transient_failure_, true);
       // If this is the first failure we've seen on this subchannel,
       // then we're still in the Happy Eyeballs pass.
-      if (!prev_seen_transient_failure && seen_transient_failure_) {
+      if (!seen_transient_failure_) {
+        // Only set seen_transient_failure_ on subchannels that we've
+        // already gotten to in this Happy Eyeballs pass.  We don't want
+        // to do this if a subchannel that we haven't yet gotten to reports
+        // TF, since that connection attempt might have been triggered by a
+        // different channel, and the subchannel may already be back in IDLE
+        // by the time we get there later in our Happy Eyeballs pass.
+        if (index_ <= subchannel_list_->attempting_index_) {
+          seen_transient_failure_ = true;
+        }
         // If a connection attempt fails before the timer fires, then
         // cancel the timer and start connecting on the next subchannel.
         if (index_ == subchannel_list_->attempting_index_) {
@@ -887,8 +897,8 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
           ++subchannel_list_->attempting_index_;
           subchannel_list_->StartConnectingNextSubchannel();
         } else {
-          // If this was the last subchannel to fail, check if the Happy
-          // Eyeballs pass is complete.
+          // In case this was the last subchannel to fail, check if the
+          // Happy Eyeballs pass is complete.
           subchannel_list_->MaybeFinishHappyEyeballsPass();
         }
       } else if (subchannel_list_->IsHappyEyeballsPassComplete()) {

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

@@ -397,7 +397,14 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
             cluster_name_, new_cluster_config->cluster->use_http_connect,
             endpoint_config.endpoints,
             child_name_state_.priority_child_numbers);
-        update_args.resolution_note = endpoint_config.resolution_note;
+        std::vector<absl::string_view> resolution_notes;
+        if (!args.resolution_note.empty()) {
+          resolution_notes.emplace_back(args.resolution_note);
+        }
+        if (!endpoint_config.resolution_note.empty()) {
+          resolution_notes.emplace_back(endpoint_config.resolution_note);
+        }
+        update_args.resolution_note = absl::StrJoin(resolution_notes, "; ");
         // Construct child policy config.
         child_policy_config_json = CreateChildPolicyConfigForLeafCluster(
             *new_cluster_config, endpoint_config, aggregate_cluster_resource);
@@ -405,6 +412,8 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
       // Aggregate cluster.
       [&](const XdsConfig::ClusterConfig::AggregateConfig& aggregate_config) {
         child_name_state_.Reset();
+        // Populate resolution_note for child policy.
+        update_args.resolution_note = aggregate_config.resolution_note;
         // Construct child policy config.
         child_policy_config_json =
             CreateChildPolicyConfigForAggregateCluster(aggregate_config);

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

@@ -407,10 +407,11 @@ LoadBalancingPolicy::PickResult XdsClusterImplLb::Picker::Pick(
   auto* call_attempt_tracer = call_state->GetCallAttemptTracer();
   if (call_attempt_tracer != nullptr) {
     call_attempt_tracer->SetOptionalLabel(
-        ClientCallTracer::CallAttemptTracer::OptionalLabelKey::kXdsServiceName,
+        ClientCallTracerInterface::CallAttemptTracer::OptionalLabelKey::
+            kXdsServiceName,
         service_telemetry_label_);
     call_attempt_tracer->SetOptionalLabel(
-        ClientCallTracer::CallAttemptTracer::OptionalLabelKey::
+        ClientCallTracerInterface::CallAttemptTracer::OptionalLabelKey::
             kXdsServiceNamespace,
         namespace_telemetry_label_);
   }
@@ -444,7 +445,8 @@ LoadBalancingPolicy::PickResult XdsClusterImplLb::Picker::Pick(
     // Add locality label to per-call metrics if needed.
     if (call_attempt_tracer != nullptr) {
       call_attempt_tracer->SetOptionalLabel(
-          ClientCallTracer::CallAttemptTracer::OptionalLabelKey::kLocality,
+          ClientCallTracerInterface::CallAttemptTracer::OptionalLabelKey::
+              kLocality,
           subchannel_wrapper->locality());
     }
     // Handle load reporting.

data/src/core/net/socket_mutator.cc

@@ -0,0 +1,19 @@
+//
+//
+// Copyright 2015 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.
+//
+//
+
+// TODO(hork): move src/core/lib/iomgr/socket_mutator.cc here

data/src/core/net/socket_mutator.h

@@ -0,0 +1,25 @@
+//
+//
+// Copyright 2015 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_NET_SOCKET_MUTATOR_H
+#define GRPC_SRC_CORE_NET_SOCKET_MUTATOR_H
+
+// TODO(hork): move src/core/lib/iomgr/socket_mutator.h here
+#include "src/core/lib/iomgr/socket_mutator.h"
+
+#endif  // GRPC_SRC_CORE_NET_SOCKET_MUTATOR_H

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -71,6 +71,7 @@ extern void RegisterConnectedChannel(CoreConfiguration::Builder* builder);
 extern void RegisterLoadBalancedCallDestination(
     CoreConfiguration::Builder* builder);
 extern void RegisterChttp2Transport(CoreConfiguration::Builder* builder);
+extern void RegisterFusedFilters(CoreConfiguration::Builder* builder);
 #ifndef GRPC_NO_RLS
 extern void RegisterRlsLbPolicy(CoreConfiguration::Builder* builder);
 #endif  // !GRPC_NO_RLS
@@ -100,13 +101,17 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterHttpConnectHandshaker(builder);
   RegisterTCPConnectHandshaker(builder);
   RegisterChttp2Transport(builder);
+#ifndef GRPC_MINIMAL_LB_POLICY
   RegisterPriorityLbPolicy(builder);
   RegisterOutlierDetectionLbPolicy(builder);
   RegisterWeightedTargetLbPolicy(builder);
+#endif
   RegisterPickFirstLbPolicy(builder);
+#ifndef GRPC_MINIMAL_LB_POLICY
   RegisterRoundRobinLbPolicy(builder);
   RegisterRingHashLbPolicy(builder);
   RegisterWeightedRoundRobinLbPolicy(builder);
+#endif
   BuildClientChannelConfiguration(builder);
   SecurityRegisterHandshakerFactories(builder);
   RegisterClientAuthorityFilter(builder);
@@ -131,6 +136,7 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterBackendMetricFilter(builder);
   RegisterSecurityFilters(builder);
   RegisterExtraFilters(builder);
+  RegisterFusedFilters(builder);
   RegisterBuiltins(builder);
 }
 

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -28,6 +28,7 @@ extern void GcpAuthenticationFilterRegister(
 extern void RegisterXdsChannelStackModifier(
     CoreConfiguration::Builder* builder);
 extern void RegisterChannelDefaultCreds(CoreConfiguration::Builder* builder);
+extern void RegisterDefaultCallCreds(CoreConfiguration::Builder* builder);
 extern void RegisterXdsResolver(CoreConfiguration::Builder* builder);
 extern void RegisterCloud2ProdResolver(CoreConfiguration::Builder* builder);
 extern void RegisterXdsClusterManagerLbPolicy(
@@ -52,6 +53,7 @@ void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
   GcpAuthenticationFilterRegister(builder);
   RegisterXdsChannelStackModifier(builder);
   RegisterChannelDefaultCreds(builder);
+  RegisterDefaultCallCreds(builder);
   RegisterXdsResolver(builder);
   RegisterCloud2ProdResolver(builder);
   RegisterXdsClusterManagerLbPolicy(builder);

data/src/core/resolver/dns/c_ares/grpc_ares_ev_driver.h

@@ -19,7 +19,6 @@
 #ifndef GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H
 #define GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H
 
-#include <ares.h>
 #include <grpc/support/port_platform.h>
 
 #include <memory>
@@ -31,6 +30,10 @@
 #include "src/core/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/util/sync.h"
 
+#if GRPC_ARES == 1
+
+#include <ares.h>
+
 namespace grpc_core {
 
 // A wrapped fd that integrates with the grpc iomgr of the current platform.
@@ -85,4 +88,6 @@ std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(Mutex* mu);
 
 }  // namespace grpc_core
 
+#endif  // GRPC_ARES
+
 #endif  // GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_EV_DRIVER_H

data/src/core/resolver/dns/c_ares/grpc_ares_ev_driver_windows.cc

@@ -20,7 +20,6 @@
 #include "src/core/lib/iomgr/port.h"  // IWYU pragma: keep
 #if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 
-#include <ares.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 #include <grpc/support/string_util.h>
@@ -41,6 +40,8 @@
 #include "src/core/lib/iomgr/tcp_windows.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
+// We pull in ares.h transitively here, ares.h is not self-contained
+// w.r.t. windows headers though, so make sure pull them in above.
 #include "src/core/resolver/dns/c_ares/grpc_ares_ev_driver.h"
 #include "src/core/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/util/crash.h"

data/src/core/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -484,14 +484,17 @@ static void grpc_ares_notify_on_event_locked(grpc_ares_ev_driver* ev_driver)
       }
     }
   }
-  // Any remaining fds in ev_driver->fds were not returned by ares_getsock() and
-  // are therefore no longer in use, so they can be shut down and removed from
-  // the list.
+  // We may be shutting down to completion of all requests, or due to a timeout
+  // or explicit caller-triggered cancellation. In any of these cases, shut
+  // down and destroy any remaining fds.
   while (ev_driver->fds != nullptr) {
     fd_node* cur = ev_driver->fds;
     ev_driver->fds = ev_driver->fds->next;
-    fd_node_shutdown_locked(cur, "c-ares fd shutdown");
-    if (!cur->readable_registered && !cur->writable_registered) {
+    if (ev_driver->shutting_down) {
+      fd_node_shutdown_locked(cur, "grpc_ares_notify_on_event_locked");
+    }
+    if (cur->already_shutdown && !cur->readable_registered &&
+        !cur->writable_registered) {
       fd_node_destroy_locked(cur);
     } else {
       cur->next = new_list;

data/src/core/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -19,7 +19,6 @@
 #ifndef GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
 #define GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
 
-#include <ares.h>
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
@@ -36,6 +35,8 @@
 
 #if GRPC_ARES == 1
 
+#include <ares.h>
+
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
 typedef struct grpc_ares_ev_driver grpc_ares_ev_driver;

data/src/core/resolver/xds/xds_config.cc

@@ -41,10 +41,10 @@ XdsConfig::ClusterConfig::ClusterConfig(
 
 XdsConfig::ClusterConfig::ClusterConfig(
     std::shared_ptr<const XdsClusterResource> cluster,
-    std::vector<absl::string_view> leaf_clusters)
+    std::vector<absl::string_view> leaf_clusters, std::string resolution_note)
     : cluster(std::move(cluster)),
       children(absl::in_place_type_t<AggregateConfig>(),
-               std::move(leaf_clusters)) {}
+               std::move(leaf_clusters), std::move(resolution_note)) {}
 
 //
 // XdsConfig
@@ -81,7 +81,10 @@ std::string XdsConfig::ToString() const {
           [&](const ClusterConfig::AggregateConfig& aggregate_config) {
             parts.push_back(absl::StrCat(
                 "        leaf_clusters: [",
-                absl::StrJoin(aggregate_config.leaf_clusters, ", "), "]\n"));
+                absl::StrJoin(aggregate_config.leaf_clusters, ", "),
+                "],\n"
+                "        resolution_note: \"",
+                aggregate_config.resolution_note, "\"\n"));
           });
       parts.push_back(
           "      }\n"

data/src/core/resolver/xds/xds_config.h

@@ -66,11 +66,15 @@ struct XdsConfig : public RefCounted<XdsConfig> {
     // The list of leaf clusters for an aggregate cluster.
     struct AggregateConfig {
       std::vector<absl::string_view> leaf_clusters;
+      std::string resolution_note;
 
-      explicit AggregateConfig(std::vector<absl::string_view> leaf_clusters)
-          : leaf_clusters(std::move(leaf_clusters)) {}
+      AggregateConfig(std::vector<absl::string_view> leaf_clusters,
+                      std::string resolution_note)
+          : leaf_clusters(std::move(leaf_clusters)),
+            resolution_note(std::move(resolution_note)) {}
       bool operator==(const AggregateConfig& other) const {
-        return leaf_clusters == other.leaf_clusters;
+        return leaf_clusters == other.leaf_clusters &&
+               resolution_note == other.resolution_note;
       }
     };
     std::variant<EndpointConfig, AggregateConfig> children;
@@ -81,7 +85,8 @@ struct XdsConfig : public RefCounted<XdsConfig> {
                   std::string resolution_note);
     // Ctor for aggregate clusters.
     ClusterConfig(std::shared_ptr<const XdsClusterResource> cluster,
-                  std::vector<absl::string_view> leaf_clusters);
+                  std::vector<absl::string_view> leaf_clusters,
+                  std::string resolution_note);
 
     bool operator==(const ClusterConfig& other) const {
       return cluster == other.cluster && children == other.children;

data/src/core/resolver/xds/xds_dependency_manager.cc

@@ -656,8 +656,12 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         cluster_config_map,
     std::set<absl::string_view>* eds_resources_seen,
     std::set<absl::string_view>* dns_names_seen,
-    absl::StatusOr<std::vector<absl::string_view>>* leaf_clusters) {
-  if (depth > 0) CHECK_NE(leaf_clusters, nullptr);
+    absl::StatusOr<std::vector<absl::string_view>>* leaf_clusters,
+    std::vector<std::string>* resolution_notes) {
+  if (depth > 0) {
+    CHECK_NE(leaf_clusters, nullptr);
+    CHECK_NE(resolution_notes, nullptr);
+  }
   if (depth == kMaxXdsAggregateClusterRecursionDepth) {
     *leaf_clusters =
         absl::UnavailableError("aggregate cluster graph exceeds max depth");
@@ -687,6 +691,9 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
   // If there was an error fetching the CDS resource, report the error.
   if (!state.update.ok()) {
     cluster_config = state.update.status();
+    if (resolution_notes != nullptr) {
+      resolution_notes->emplace_back(state.update.status().message());
+    }
     return true;
   }
   // If we don't have the resource yet, we can't return a config yet.
@@ -785,12 +792,13 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         // Recursively expand leaf clusters.
         absl::StatusOr<std::vector<absl::string_view>> child_leaf_clusters;
         child_leaf_clusters.emplace();
+        std::vector<std::string> child_resolution_notes;
         bool have_all_resources = true;
         for (const std::string& child_name :
              aggregate.prioritized_cluster_names) {
           have_all_resources &= PopulateClusterConfigMap(
               child_name, depth + 1, cluster_config_map, eds_resources_seen,
-              dns_names_seen, &child_leaf_clusters);
+              dns_names_seen, &child_leaf_clusters, &child_resolution_notes);
           if (!child_leaf_clusters.ok()) break;
         }
         // Note that we cannot use the cluster_config reference we
@@ -807,12 +815,18 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
           }
           return true;
         }
-        // If needed, propagate leaf cluster list up the tree.
+        // If needed, propagate leaf cluster list and resolution note
+        // lists up the tree.
         if (leaf_clusters != nullptr) {
           (*leaf_clusters)
               ->insert((*leaf_clusters)->end(), child_leaf_clusters->begin(),
                        child_leaf_clusters->end());
         }
+        if (resolution_notes != nullptr) {
+          resolution_notes->insert(resolution_notes->end(),
+                                   child_resolution_notes.begin(),
+                                   child_resolution_notes.end());
+        }
         // If there are no leaf clusters, report an error for the cluster.
         if (have_all_resources && child_leaf_clusters->empty()) {
           aggregate_cluster_config = absl::UnavailableError(
@@ -825,8 +839,9 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         // at the root of the tree, because we need to make sure the list
         // of underlying cluster names stays alive so that the leaf cluster
         // list of the root aggregate cluster can point to those strings.
-        aggregate_cluster_config.emplace(std::move(cluster_resource),
-                                         std::move(*child_leaf_clusters));
+        aggregate_cluster_config.emplace(
+            std::move(cluster_resource), std::move(*child_leaf_clusters),
+            absl::StrJoin(child_resolution_notes, "; "));
         return have_all_resources;
       });
 }
@@ -925,7 +940,7 @@ void XdsDependencyManager::MaybeReportUpdate() {
     endpoint_watchers_.erase(it++);
   }
   // Remove entries in dns_resolvers_ for any DNS name not in
-  // eds_resources_seen.
+  // dns_names_seen.
   for (auto it = dns_resolvers_.begin(); it != dns_resolvers_.end();) {
     const std::string& dns_name = it->first;
     if (dns_names_seen.find(dns_name) != dns_names_seen.end()) {

data/src/core/resolver/xds/xds_dependency_manager.h

@@ -172,7 +172,8 @@ class XdsDependencyManager final : public RefCounted<XdsDependencyManager>,
           cluster_config_map,
       std::set<absl::string_view>* eds_resources_seen,
       std::set<absl::string_view>* dns_names_seen,
-      absl::StatusOr<std::vector<absl::string_view>>* leaf_clusters = nullptr);
+      absl::StatusOr<std::vector<absl::string_view>>* leaf_clusters = nullptr,
+      std::vector<std::string>* resolution_notes = nullptr);
 
   // Called when an external cluster subscription is unreffed.
   void OnClusterSubscriptionUnref(absl::string_view cluster_name,