grpc 1.66.0 → 1.67.0.pre1

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

@@ -43,71 +43,6 @@ constexpr int kMaxXdsAggregateClusterRecursionDepth = 16;
 
 }  // namespace
 
-//
-// XdsDependencyManager::XdsConfig::ClusterConfig
-//
-
-XdsDependencyManager::XdsConfig::ClusterConfig::ClusterConfig(
-    std::shared_ptr<const XdsClusterResource> cluster,
-    std::shared_ptr<const XdsEndpointResource> endpoints,
-    std::string resolution_note)
-    : cluster(std::move(cluster)),
-      children(absl::in_place_type_t<EndpointConfig>(), std::move(endpoints),
-               std::move(resolution_note)) {}
-
-XdsDependencyManager::XdsConfig::ClusterConfig::ClusterConfig(
-    std::shared_ptr<const XdsClusterResource> cluster,
-    std::vector<absl::string_view> leaf_clusters)
-    : cluster(std::move(cluster)),
-      children(absl::in_place_type_t<AggregateConfig>(),
-               std::move(leaf_clusters)) {}
-
-//
-// XdsDependencyManager::XdsConfig
-//
-
-std::string XdsDependencyManager::XdsConfig::ToString() const {
-  std::vector<std::string> parts = {
-      "{\n  listener: {",     listener->ToString(),
-      "}\n  route_config: {", route_config->ToString(),
-      "}\n  virtual_host: {", virtual_host->ToString(),
-      "}\n  clusters: {\n"};
-  for (const auto& p : clusters) {
-    parts.push_back(absl::StrCat("    \"", p.first, "\": "));
-    if (!p.second.ok()) {
-      parts.push_back(p.second.status().ToString());
-      parts.push_back("\n");
-    } else {
-      parts.push_back(
-          absl::StrCat("      {\n"
-                       "        cluster: {",
-                       p.second->cluster->ToString(), "}\n"));
-      Match(
-          p.second->children,
-          [&](const ClusterConfig::EndpointConfig& endpoint_config) {
-            parts.push_back(
-                absl::StrCat("        endpoints: {",
-                             endpoint_config.endpoints == nullptr
-                                 ? "<null>"
-                                 : endpoint_config.endpoints->ToString(),
-                             "}\n"
-                             "        resolution_note: \"",
-                             endpoint_config.resolution_note, "\"\n"));
-          },
-          [&](const ClusterConfig::AggregateConfig& aggregate_config) {
-            parts.push_back(absl::StrCat(
-                "        leaf_clusters: [",
-                absl::StrJoin(aggregate_config.leaf_clusters, ", "), "]\n"));
-          });
-      parts.push_back(
-          "      }\n"
-          "    ]\n");
-    }
-  }
-  parts.push_back("  }\n}");
-  return absl::StrJoin(parts, "");
-}
-
 //
 // XdsDependencyManager::ListenerWatcher
 //
@@ -364,10 +299,9 @@ XdsDependencyManager::XdsDependencyManager(
       listener_resource_name_(std::move(listener_resource_name)),
       args_(std::move(args)),
       interested_parties_(interested_parties) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] starting watch for listener " << listener_resource_name_;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[XdsDependencyManager " << this << "] starting watch for listener "
+      << listener_resource_name_;
   auto listener_watcher = MakeRefCounted<ListenerWatcher>(Ref());
   listener_watcher_ = listener_watcher.get();
   XdsListenerResourceType::StartWatch(
@@ -375,9 +309,8 @@ XdsDependencyManager::XdsDependencyManager(
 }
 
 void XdsDependencyManager::Orphan() {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this << "] shutting down";
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[XdsDependencyManager " << this << "] shutting down";
   if (listener_watcher_ != nullptr) {
     XdsListenerResourceType::CancelWatch(
         xds_client_.get(), listener_resource_name_, listener_watcher_,
@@ -420,10 +353,8 @@ void XdsDependencyManager::ResetBackoff() {
 
 void XdsDependencyManager::OnListenerUpdate(
     std::shared_ptr<const XdsListenerResource> listener) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] received Listener update";
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[XdsDependencyManager " << this << "] received Listener update";
   if (xds_client_ == nullptr) return;
   const auto* hcm = absl::get_if<XdsListenerResource::HttpConnectionManager>(
       &listener->listener);
@@ -453,11 +384,9 @@ void XdsDependencyManager::OnListenerUpdate(
           }
           // Start watch for the new RDS resource name.
           route_config_name_ = rds_name;
-          if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-            LOG(INFO) << "[XdsDependencyManager " << this
-                      << "] starting watch for route config "
-                      << route_config_name_;
-          }
+          GRPC_TRACE_LOG(xds_resolver, INFO)
+              << "[XdsDependencyManager " << this
+              << "] starting watch for route config " << route_config_name_;
           auto watcher =
               MakeRefCounted<RouteConfigWatcher>(Ref(), route_config_name_);
           route_config_watcher_ = watcher.get();
@@ -540,11 +469,9 @@ absl::flat_hash_set<absl::string_view> GetClustersFromVirtualHost(
 void XdsDependencyManager::OnRouteConfigUpdate(
     const std::string& name,
     std::shared_ptr<const XdsRouteConfigResource> route_config) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] received RouteConfig update for "
-              << (name.empty() ? "<inline>" : name);
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO) << "[XdsDependencyManager " << this
+                                     << "] received RouteConfig update for "
+                                     << (name.empty() ? "<inline>" : name);
   if (xds_client_ == nullptr) return;
   // Ignore updates for stale names.
   if (name.empty()) {
@@ -575,20 +502,18 @@ void XdsDependencyManager::OnRouteConfigUpdate(
 }
 
 void XdsDependencyManager::OnError(std::string context, absl::Status status) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] received Listener or RouteConfig error: " << context << " "
-              << status;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[XdsDependencyManager " << this
+      << "] received Listener or RouteConfig error: " << context << " "
+      << status;
   if (xds_client_ == nullptr) return;
   if (current_virtual_host_ != nullptr) return;
   watcher_->OnError(context, std::move(status));
 }
 
 void XdsDependencyManager::OnResourceDoesNotExist(std::string context) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this << "] " << context;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[XdsDependencyManager " << this << "] " << context;
   if (xds_client_ == nullptr) return;
   current_virtual_host_ = nullptr;
   watcher_->OnResourceDoesNotExist(std::move(context));
@@ -597,10 +522,8 @@ void XdsDependencyManager::OnResourceDoesNotExist(std::string context) {
 void XdsDependencyManager::OnClusterUpdate(
     const std::string& name,
     std::shared_ptr<const XdsClusterResource> cluster) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] received Cluster update: " << name;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO) << "[XdsDependencyManager " << this
+                                     << "] received Cluster update: " << name;
   if (xds_client_ == nullptr) return;
   auto it = cluster_watchers_.find(name);
   if (it == cluster_watchers_.end()) return;
@@ -610,10 +533,9 @@ void XdsDependencyManager::OnClusterUpdate(
 
 void XdsDependencyManager::OnClusterError(const std::string& name,
                                           absl::Status status) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] received Cluster error: " << name << " " << status;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[XdsDependencyManager " << this
+      << "] received Cluster error: " << name << " " << status;
   if (xds_client_ == nullptr) return;
   auto it = cluster_watchers_.find(name);
   if (it == cluster_watchers_.end()) return;
@@ -625,10 +547,8 @@ void XdsDependencyManager::OnClusterError(const std::string& name,
 }
 
 void XdsDependencyManager::OnClusterDoesNotExist(const std::string& name) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] Cluster does not exist: " << name;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO) << "[XdsDependencyManager " << this
+                                     << "] Cluster does not exist: " << name;
   if (xds_client_ == nullptr) return;
   auto it = cluster_watchers_.find(name);
   if (it == cluster_watchers_.end()) return;
@@ -640,10 +560,8 @@ void XdsDependencyManager::OnClusterDoesNotExist(const std::string& name) {
 void XdsDependencyManager::OnEndpointUpdate(
     const std::string& name,
     std::shared_ptr<const XdsEndpointResource> endpoint) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] received Endpoint update: " << name;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO) << "[XdsDependencyManager " << this
+                                     << "] received Endpoint update: " << name;
   if (xds_client_ == nullptr) return;
   auto it = endpoint_watchers_.find(name);
   if (it == endpoint_watchers_.end()) return;
@@ -672,10 +590,9 @@ void XdsDependencyManager::OnEndpointUpdate(
 
 void XdsDependencyManager::OnEndpointError(const std::string& name,
                                            absl::Status status) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] received Endpoint error: " << name << " " << status;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[XdsDependencyManager " << this
+      << "] received Endpoint error: " << name << " " << status;
   if (xds_client_ == nullptr) return;
   auto it = endpoint_watchers_.find(name);
   if (it == endpoint_watchers_.end()) return;
@@ -687,10 +604,8 @@ void XdsDependencyManager::OnEndpointError(const std::string& name,
 }
 
 void XdsDependencyManager::OnEndpointDoesNotExist(const std::string& name) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] Endpoint does not exist: " << name;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO) << "[XdsDependencyManager " << this
+                                     << "] Endpoint does not exist: " << name;
   if (xds_client_ == nullptr) return;
   auto it = endpoint_watchers_.find(name);
   if (it == endpoint_watchers_.end()) return;
@@ -702,10 +617,8 @@ void XdsDependencyManager::OnEndpointDoesNotExist(const std::string& name) {
 
 void XdsDependencyManager::OnDnsResult(const std::string& dns_name,
                                        Resolver::Result result) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] received DNS update: " << dns_name;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO) << "[XdsDependencyManager " << this
+                                     << "] received DNS update: " << dns_name;
   if (xds_client_ == nullptr) return;
   auto it = dns_resolvers_.find(dns_name);
   if (it == dns_resolvers_.end()) return;
@@ -765,10 +678,9 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
   // Create a new watcher if needed.
   if (state.watcher == nullptr) {
     auto watcher = MakeRefCounted<ClusterWatcher>(Ref(), name);
-    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      LOG(INFO) << "[XdsDependencyManager " << this
-                << "] starting watch for cluster " << name;
-    }
+    GRPC_TRACE_LOG(xds_resolver, INFO)
+        << "[XdsDependencyManager " << this << "] starting watch for cluster "
+        << name;
     state.watcher = watcher.get();
     XdsClusterResourceType::StartWatch(xds_client_.get(), name,
                                        std::move(watcher));
@@ -792,10 +704,9 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         // Start EDS watch if needed.
         auto& eds_state = endpoint_watchers_[eds_resource_name];
         if (eds_state.watcher == nullptr) {
-          if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-            LOG(INFO) << "[XdsDependencyManager " << this
-                      << "] starting watch for endpoint " << eds_resource_name;
-          }
+          GRPC_TRACE_LOG(xds_resolver, INFO)
+              << "[XdsDependencyManager " << this
+              << "] starting watch for endpoint " << eds_resource_name;
           auto watcher =
               MakeRefCounted<EndpointWatcher>(Ref(), eds_resource_name);
           eds_state.watcher = watcher.get();
@@ -820,10 +731,9 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         // Start DNS resolver if needed.
         auto& dns_state = dns_resolvers_[logical_dns.hostname];
         if (dns_state.resolver == nullptr) {
-          if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-            LOG(INFO) << "[XdsDependencyManager " << this
-                      << "] starting DNS resolver for " << logical_dns.hostname;
-          }
+          GRPC_TRACE_LOG(xds_resolver, INFO)
+              << "[XdsDependencyManager " << this
+              << "] starting DNS resolver for " << logical_dns.hostname;
           auto* fake_resolver_response_generator = args_.GetPointer<
               FakeResolverResponseGenerator>(
               GRPC_ARG_XDS_LOGICAL_DNS_CLUSTER_FAKE_RESOLVER_RESPONSE_GENERATOR);
@@ -987,10 +897,9 @@ void XdsDependencyManager::MaybeReportUpdate() {
       ++it;
       continue;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      LOG(INFO) << "[XdsDependencyManager " << this
-                << "] cancelling watch for cluster " << cluster_name;
-    }
+    GRPC_TRACE_LOG(xds_resolver, INFO)
+        << "[XdsDependencyManager " << this << "] cancelling watch for cluster "
+        << cluster_name;
     XdsClusterResourceType::CancelWatch(xds_client_.get(), cluster_name,
                                         it->second.watcher,
                                         /*delay_unsubscription=*/false);
@@ -1005,10 +914,9 @@ void XdsDependencyManager::MaybeReportUpdate() {
       ++it;
       continue;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      LOG(INFO) << "[XdsDependencyManager " << this
-                << "] cancelling watch for EDS resource " << eds_resource_name;
-    }
+    GRPC_TRACE_LOG(xds_resolver, INFO)
+        << "[XdsDependencyManager " << this
+        << "] cancelling watch for EDS resource " << eds_resource_name;
     XdsEndpointResourceType::CancelWatch(xds_client_.get(), eds_resource_name,
                                          it->second.watcher,
                                          /*delay_unsubscription=*/false);
@@ -1022,24 +930,21 @@ void XdsDependencyManager::MaybeReportUpdate() {
       ++it;
       continue;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      LOG(INFO) << "[XdsDependencyManager " << this
-                << "] shutting down DNS resolver for " << dns_name;
-    }
+    GRPC_TRACE_LOG(xds_resolver, INFO)
+        << "[XdsDependencyManager " << this
+        << "] shutting down DNS resolver for " << dns_name;
     dns_resolvers_.erase(it++);
   }
   // If we have all the data we need, then send an update.
   if (!have_all_resources) {
-    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      LOG(INFO) << "[XdsDependencyManager " << this
-                << "] missing data -- NOT returning config";
-    }
+    GRPC_TRACE_LOG(xds_resolver, INFO)
+        << "[XdsDependencyManager " << this
+        << "] missing data -- NOT returning config";
     return;
   }
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[XdsDependencyManager " << this
-              << "] returning config: " << config->ToString();
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[XdsDependencyManager " << this
+      << "] returning config: " << config->ToString();
   watcher_->OnUpdate(std::move(config));
 }
 

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

@@ -21,10 +21,9 @@
 #include "absl/container/flat_hash_set.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/resolver/resolver.h"
+#include "src/core/resolver/xds/xds_config.h"
 #include "src/core/xds/grpc/xds_client_grpc.h"
 #include "src/core/xds/grpc/xds_cluster.h"
 #include "src/core/xds/grpc/xds_endpoint.h"
@@ -38,73 +37,6 @@ namespace grpc_core {
 class XdsDependencyManager final : public RefCounted<XdsDependencyManager>,
                                    public Orphanable {
  public:
-  struct XdsConfig : public RefCounted<XdsConfig> {
-    // Listener resource.  Always non-null.
-    std::shared_ptr<const XdsListenerResource> listener;
-    // RouteConfig resource.  Will be populated even if RouteConfig is
-    // inlined into the Listener resource.
-    std::shared_ptr<const XdsRouteConfigResource> route_config;
-    // Virtual host.  Points into route_config.  Will always be non-null.
-    const XdsRouteConfigResource::VirtualHost* virtual_host;
-
-    struct ClusterConfig {
-      // Cluster resource.  Always non-null.
-      std::shared_ptr<const XdsClusterResource> cluster;
-      // Endpoint info for EDS and LOGICAL_DNS clusters.  If there was an
-      // error, endpoints will be null and resolution_note will be set.
-      struct EndpointConfig {
-        std::shared_ptr<const XdsEndpointResource> endpoints;
-        std::string resolution_note;
-
-        EndpointConfig(std::shared_ptr<const XdsEndpointResource> endpoints,
-                       std::string resolution_note)
-            : endpoints(std::move(endpoints)),
-              resolution_note(std::move(resolution_note)) {}
-        bool operator==(const EndpointConfig& other) const {
-          return endpoints == other.endpoints &&
-                 resolution_note == other.resolution_note;
-        }
-      };
-      // The list of leaf clusters for an aggregate cluster.
-      struct AggregateConfig {
-        std::vector<absl::string_view> leaf_clusters;
-
-        explicit AggregateConfig(std::vector<absl::string_view> leaf_clusters)
-            : leaf_clusters(std::move(leaf_clusters)) {}
-        bool operator==(const AggregateConfig& other) const {
-          return leaf_clusters == other.leaf_clusters;
-        }
-      };
-      absl::variant<EndpointConfig, AggregateConfig> children;
-
-      // Ctor for leaf clusters.
-      ClusterConfig(std::shared_ptr<const XdsClusterResource> cluster,
-                    std::shared_ptr<const XdsEndpointResource> endpoints,
-                    std::string resolution_note);
-      // Ctor for aggregate clusters.
-      ClusterConfig(std::shared_ptr<const XdsClusterResource> cluster,
-                    std::vector<absl::string_view> leaf_clusters);
-
-      bool operator==(const ClusterConfig& other) const {
-        return cluster == other.cluster && children == other.children;
-      }
-    };
-    // Cluster map.  A cluster will have a non-OK status if either
-    // (a) there was an error and we did not already have a valid
-    // resource or (b) the resource does not exist.
-    absl::flat_hash_map<std::string, absl::StatusOr<ClusterConfig>> clusters;
-
-    std::string ToString() const;
-
-    static absl::string_view ChannelArgName() {
-      return GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_config";
-    }
-    static int ChannelArgsCompare(const XdsConfig* a, const XdsConfig* b) {
-      return QsortCompare(a, b);
-    }
-    static constexpr bool ChannelArgUseConstPtr() { return true; }
-  };
-
   class Watcher {
    public:
     virtual ~Watcher() = default;

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

@@ -110,17 +110,14 @@ class XdsResolver final : public Resolver {
         uri_(std::move(args.uri)),
         data_plane_authority_(std::move(data_plane_authority)),
         channel_id_(absl::Uniform<uint64_t>(absl::BitGen())) {
-    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      LOG(INFO) << "[xds_resolver " << this << "] created for URI "
-                << uri_.ToString() << "; data plane authority is "
-                << data_plane_authority_;
-    }
+    GRPC_TRACE_LOG(xds_resolver, INFO)
+        << "[xds_resolver " << this << "] created for URI " << uri_.ToString()
+        << "; data plane authority is " << data_plane_authority_;
   }
 
   ~XdsResolver() override {
-    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      LOG(INFO) << "[xds_resolver " << this << "] destroyed";
-    }
+    GRPC_TRACE_LOG(xds_resolver, INFO)
+        << "[xds_resolver " << this << "] destroyed";
   }
 
   void StartLocked() override;
@@ -142,8 +139,7 @@ class XdsResolver final : public Resolver {
     explicit XdsWatcher(RefCountedPtr<XdsResolver> resolver)
         : resolver_(std::move(resolver)) {}
 
-    void OnUpdate(
-        RefCountedPtr<const XdsDependencyManager::XdsConfig> config) override {
+    void OnUpdate(RefCountedPtr<const XdsConfig> config) override {
       resolver_->OnUpdate(std::move(config));
     }
 
@@ -366,7 +362,7 @@ class XdsResolver final : public Resolver {
     return it->second->Ref();
   }
 
-  void OnUpdate(RefCountedPtr<const XdsDependencyManager::XdsConfig> config);
+  void OnUpdate(RefCountedPtr<const XdsConfig> config);
   void OnError(absl::string_view context, absl::Status status);
   void OnResourceDoesNotExist(std::string context);
 
@@ -385,7 +381,7 @@ class XdsResolver final : public Resolver {
   const uint64_t channel_id_;
 
   OrphanablePtr<XdsDependencyManager> dependency_mgr_;
-  RefCountedPtr<const XdsDependencyManager::XdsConfig> current_config_;
+  RefCountedPtr<const XdsConfig> current_config_;
   std::map<absl::string_view, WeakRefCountedPtr<ClusterRef>> cluster_ref_map_;
 };
 
@@ -514,7 +510,7 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
   // Handle xDS HTTP filters.
   const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
       resolver->current_config_->listener->listener);
-  auto result = XdsRouting::GeneratePerHTTPFilterConfigs(
+  auto result = XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
       static_cast<const GrpcXdsBootstrap&>(resolver->xds_client_->bootstrap())
           .http_filter_registry(),
       hcm.http_filters, *resolver->current_config_->virtual_host, route,
@@ -545,10 +541,9 @@ XdsResolver::RouteConfigData::CreateMethodConfig(
 absl::Status XdsResolver::RouteConfigData::AddRouteEntry(
     XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
     const Duration& default_max_stream_duration) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[xds_resolver " << resolver << "] XdsConfigSelector " << this
-              << ": route: " << route.ToString();
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[xds_resolver " << resolver << "] XdsConfigSelector " << this
+      << ": route: " << route.ToString();
   routes_.emplace_back(route);
   auto* route_entry = &routes_.back();
   auto maybe_add_cluster = [&](absl::string_view cluster_key,
@@ -637,10 +632,8 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
     RefCountedPtr<RouteConfigData> route_config_data)
     : resolver_(std::move(resolver)),
       route_config_data_(std::move(route_config_data)) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[xds_resolver " << resolver_.get()
-              << "] creating XdsConfigSelector " << this;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO) << "[xds_resolver " << resolver_.get()
+                                     << "] creating XdsConfigSelector " << this;
   // Populate filter list.
   const auto& http_filter_registry =
       static_cast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
@@ -660,10 +653,9 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
 }
 
 XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[xds_resolver " << resolver_.get()
-              << "] destroying XdsConfigSelector " << this;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[xds_resolver " << resolver_.get()
+      << "] destroying XdsConfigSelector " << this;
   route_config_data_.reset();
   if (!IsWorkSerializerDispatchEnabled()) {
     resolver_->MaybeRemoveUnusedClusters();
@@ -962,10 +954,9 @@ void XdsResolver::StartLocked() {
     lds_resource_name_ =
         absl::StrReplaceAll(name_template, {{"%s", resource_name_fragment}});
   }
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[xds_resolver " << this << "] Started with lds_resource_name "
-              << lds_resource_name_;
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[xds_resolver " << this << "] Started with lds_resource_name "
+      << lds_resource_name_;
   // Start watch for xDS config.
   dependency_mgr_ = MakeOrphanable<XdsDependencyManager>(
       xds_client_, work_serializer_,
@@ -974,9 +965,8 @@ void XdsResolver::StartLocked() {
 }
 
 void XdsResolver::ShutdownLocked() {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[xds_resolver " << this << "] shutting down";
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[xds_resolver " << this << "] shutting down";
   if (xds_client_ != nullptr) {
     dependency_mgr_.reset();
     grpc_pollset_set_del_pollset_set(xds_client_->interested_parties(),
@@ -985,11 +975,9 @@ void XdsResolver::ShutdownLocked() {
   }
 }
 
-void XdsResolver::OnUpdate(
-    RefCountedPtr<const XdsDependencyManager::XdsConfig> config) {
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[xds_resolver " << this << "] received updated xDS config";
-  }
+void XdsResolver::OnUpdate(RefCountedPtr<const XdsConfig> config) {
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[xds_resolver " << this << "] received updated xDS config";
   if (xds_client_ == nullptr) return;
   current_config_ = std::move(config);
   GenerateResult();
@@ -1053,18 +1041,27 @@ XdsResolver::CreateServiceConfig() {
   }
   std::vector<std::string> config_parts;
   config_parts.push_back(
-      "{\n"
-      "  \"loadBalancingConfig\":[\n"
-      "    { \"xds_cluster_manager_experimental\":{\n"
-      "      \"children\":{\n");
-  config_parts.push_back(absl::StrJoin(clusters, ",\n"));
-  config_parts.push_back(
-      "    }\n"
-      "    } }\n"
-      "  ]\n"
-      "}");
-  std::string json = absl::StrJoin(config_parts, "");
-  return ServiceConfigImpl::Create(args_, json.c_str());
+      absl::StrCat("  \"loadBalancingConfig\":[\n"
+                   "    { \"xds_cluster_manager_experimental\":{\n"
+                   "      \"children\":{\n",
+                   absl::StrJoin(clusters, ",\n"),
+                   "    }\n"
+                   "    } }\n"
+                   "  ]"));
+  auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+      current_config_->listener->listener);
+  auto filter_configs =
+      XdsRouting::GeneratePerHTTPFilterConfigsForServiceConfig(
+          static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+              .http_filter_registry(),
+          hcm.http_filters, args_);
+  if (!filter_configs.ok()) return filter_configs.status();
+  for (const auto& p : filter_configs->per_filter_configs) {
+    config_parts.emplace_back(absl::StrCat(
+        "  \"", p.first, "\": [\n", absl::StrJoin(p.second, ",\n"), "\n  ]"));
+  }
+  std::string json = absl::StrCat("{", absl::StrJoin(config_parts, ",\n"), "}");
+  return ServiceConfigImpl::Create(filter_configs->args, json.c_str());
 }
 
 void XdsResolver::GenerateResult() {
@@ -1086,12 +1083,11 @@ void XdsResolver::GenerateResult() {
   Result result;
   result.addresses.emplace();
   result.service_config = CreateServiceConfig();
-  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    LOG(INFO) << "[xds_resolver " << this << "] generated service config: "
-              << (result.service_config.ok()
-                      ? ((*result.service_config)->json_string())
-                      : result.service_config.status().ToString());
-  }
+  GRPC_TRACE_LOG(xds_resolver, INFO)
+      << "[xds_resolver " << this << "] generated service config: "
+      << (result.service_config.ok()
+              ? ((*result.service_config)->json_string())
+              : result.service_config.status().ToString());
   result.args =
       args_.SetObject(xds_client_.Ref(DEBUG_LOCATION, "xds resolver result"))
           .SetObject(config_selector)

data/src/core/server/server.cc

@@ -1794,8 +1794,8 @@ void grpc_server_register_completion_queue(grpc_server* server,
   CHECK(!reserved);
   auto cq_type = grpc_get_cq_completion_type(cq);
   if (cq_type != GRPC_CQ_NEXT && cq_type != GRPC_CQ_CALLBACK) {
-    LOG(INFO) << "Completion queue of type " << static_cast<int>(cq_type)
-              << " is being registered as a server-completion-queue";
+    VLOG(2) << "Completion queue of type " << static_cast<int>(cq_type)
+            << " is being registered as a server-completion-queue";
     // Ideally we should log an error and abort but ruby-wrapped-language API
     // calls grpc_completion_queue_pluck() on server completion queues
   }