grpc 1.65.2 → 1.66.0.pre3

data/src/core/resolver/dns/native/dns_resolver.cc

@@ -29,7 +29,6 @@
 #include "absl/types/optional.h"
 
 #include <grpc/impl/channel_arg_names.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/backoff/backoff.h"
@@ -92,13 +91,13 @@ NativeClientChannelDNSResolver::NativeClientChannelDNSResolver(
                               GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000)),
                       &dns_resolver_trace) {
   if (GRPC_TRACE_FLAG_ENABLED(dns_resolver)) {
-    gpr_log(GPR_DEBUG, "[dns_resolver=%p] created", this);
+    VLOG(2) << "[dns_resolver=" << this << "] created";
   }
 }
 
 NativeClientChannelDNSResolver::~NativeClientChannelDNSResolver() {
   if (GRPC_TRACE_FLAG_ENABLED(dns_resolver)) {
-    gpr_log(GPR_DEBUG, "[dns_resolver=%p] destroyed", this);
+    VLOG(2) << "[dns_resolver=" << this << "] destroyed";
   }
 }
 
@@ -109,8 +108,8 @@ OrphanablePtr<Orphanable> NativeClientChannelDNSResolver::StartRequest() {
       name_to_resolve(), kDefaultSecurePort, kDefaultDNSRequestTimeout,
       interested_parties(), /*name_server=*/"");
   if (GRPC_TRACE_FLAG_ENABLED(dns_resolver)) {
-    gpr_log(GPR_DEBUG, "[dns_resolver=%p] starting request=%p", this,
-            DNSResolver::HandleToString(dns_request_handle).c_str());
+    VLOG(2) << "[dns_resolver=" << this << "] starting request="
+            << DNSResolver::HandleToString(dns_request_handle);
   }
   return MakeOrphanable<Request>();
 }
@@ -118,8 +117,8 @@ OrphanablePtr<Orphanable> NativeClientChannelDNSResolver::StartRequest() {
 void NativeClientChannelDNSResolver::OnResolved(
     absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
   if (GRPC_TRACE_FLAG_ENABLED(dns_resolver)) {
-    gpr_log(GPR_DEBUG, "[dns_resolver=%p] request complete, status=\"%s\"",
-            this, addresses_or.status().ToString().c_str());
+    VLOG(2) << "[dns_resolver=" << this
+            << "] request complete, status=" << addresses_or.status();
   }
   // Convert result from iomgr DNS API into Resolver::Result.
   Result result;

data/src/core/resolver/endpoint_addresses.h

@@ -40,6 +40,9 @@
 // A channel arg indicating the weight of an address.
 #define GRPC_ARG_ADDRESS_WEIGHT GRPC_ARG_NO_SUBCHANNEL_PREFIX "address.weight"
 
+// Name associated with individual address, if available (e.g., DNS name).
+#define GRPC_ARG_ADDRESS_NAME "grpc.address_name"
+
 namespace grpc_core {
 
 // A list of addresses for a given endpoint with an associated set of channel

data/src/core/resolver/resolver.h

@@ -33,9 +33,6 @@
 #include "src/core/resolver/server_address.h"  // IWYU pragma: keep
 #include "src/core/service_config/service_config.h"
 
-// Name associated with individual address, if available.
-#define GRPC_ARG_ADDRESS_NAME "grpc.address_name"
-
 namespace grpc_core {
 
 /// Interface for name resolution.

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

@@ -19,6 +19,7 @@
 #include <set>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_join.h"
 
 #include <grpc/support/port_platform.h>
@@ -27,6 +28,10 @@
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/load_balancing/xds/xds_channel_args.h"
 #include "src/core/resolver/fake/fake_resolver.h"
+#include "src/core/xds/grpc/xds_cluster_parser.h"
+#include "src/core/xds/grpc/xds_endpoint_parser.h"
+#include "src/core/xds/grpc/xds_listener_parser.h"
+#include "src/core/xds/grpc/xds_route_config_parser.h"
 #include "src/core/xds/grpc/xds_routing.h"
 
 namespace grpc_core {
@@ -360,9 +365,8 @@ XdsDependencyManager::XdsDependencyManager(
       args_(std::move(args)),
       interested_parties_(interested_parties) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO,
-            "[XdsDependencyManager %p] starting watch for listener %s", this,
-            listener_resource_name_.c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] starting watch for listener " << listener_resource_name_;
   }
   auto listener_watcher = MakeRefCounted<ListenerWatcher>(Ref());
   listener_watcher_ = listener_watcher.get();
@@ -372,7 +376,7 @@ XdsDependencyManager::XdsDependencyManager(
 
 void XdsDependencyManager::Orphan() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] shutting down", this);
+    LOG(INFO) << "[XdsDependencyManager " << this << "] shutting down";
   }
   if (listener_watcher_ != nullptr) {
     XdsListenerResourceType::CancelWatch(
@@ -402,11 +406,23 @@ void XdsDependencyManager::Orphan() {
   Unref();
 }
 
+void XdsDependencyManager::RequestReresolution() {
+  for (const auto& p : dns_resolvers_) {
+    p.second.resolver->RequestReresolutionLocked();
+  }
+}
+
+void XdsDependencyManager::ResetBackoff() {
+  for (const auto& p : dns_resolvers_) {
+    p.second.resolver->ResetBackoffLocked();
+  }
+}
+
 void XdsDependencyManager::OnListenerUpdate(
     std::shared_ptr<const XdsListenerResource> listener) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] received Listener update",
-            this);
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] received Listener update";
   }
   if (xds_client_ == nullptr) return;
   const auto* hcm = absl::get_if<XdsListenerResource::HttpConnectionManager>(
@@ -438,10 +454,9 @@ void XdsDependencyManager::OnListenerUpdate(
           // Start watch for the new RDS resource name.
           route_config_name_ = rds_name;
           if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-            gpr_log(
-                GPR_INFO,
-                "[XdsDependencyManager %p] starting watch for route config %s",
-                this, route_config_name_.c_str());
+            LOG(INFO) << "[XdsDependencyManager " << this
+                      << "] starting watch for route config "
+                      << route_config_name_;
           }
           auto watcher =
               MakeRefCounted<RouteConfigWatcher>(Ref(), route_config_name_);
@@ -526,9 +541,9 @@ void XdsDependencyManager::OnRouteConfigUpdate(
     const std::string& name,
     std::shared_ptr<const XdsRouteConfigResource> route_config) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO,
-            "[XdsDependencyManager %p] received RouteConfig update for %s",
-            this, name.empty() ? "<inline>" : name.c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] received RouteConfig update for "
+              << (name.empty() ? "<inline>" : name);
   }
   if (xds_client_ == nullptr) return;
   // Ignore updates for stale names.
@@ -561,10 +576,9 @@ void XdsDependencyManager::OnRouteConfigUpdate(
 
 void XdsDependencyManager::OnError(std::string context, absl::Status status) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO,
-            "[XdsDependencyManager %p] received Listener or RouteConfig "
-            "error: %s %s",
-            this, context.c_str(), status.ToString().c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] received Listener or RouteConfig error: " << context << " "
+              << status;
   }
   if (xds_client_ == nullptr) return;
   if (current_virtual_host_ != nullptr) return;
@@ -573,7 +587,7 @@ void XdsDependencyManager::OnError(std::string context, absl::Status status) {
 
 void XdsDependencyManager::OnResourceDoesNotExist(std::string context) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] %s", this, context.c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this << "] " << context;
   }
   if (xds_client_ == nullptr) return;
   current_virtual_host_ = nullptr;
@@ -584,8 +598,8 @@ void XdsDependencyManager::OnClusterUpdate(
     const std::string& name,
     std::shared_ptr<const XdsClusterResource> cluster) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] received Cluster update: %s",
-            this, name.c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] received Cluster update: " << name;
   }
   if (xds_client_ == nullptr) return;
   auto it = cluster_watchers_.find(name);
@@ -597,8 +611,8 @@ void XdsDependencyManager::OnClusterUpdate(
 void XdsDependencyManager::OnClusterError(const std::string& name,
                                           absl::Status status) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] received Cluster error: %s %s",
-            this, name.c_str(), status.ToString().c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] received Cluster error: " << name << " " << status;
   }
   if (xds_client_ == nullptr) return;
   auto it = cluster_watchers_.find(name);
@@ -612,8 +626,8 @@ void XdsDependencyManager::OnClusterError(const std::string& name,
 
 void XdsDependencyManager::OnClusterDoesNotExist(const std::string& name) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] Cluster does not exist: %s",
-            this, name.c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] Cluster does not exist: " << name;
   }
   if (xds_client_ == nullptr) return;
   auto it = cluster_watchers_.find(name);
@@ -627,8 +641,8 @@ void XdsDependencyManager::OnEndpointUpdate(
     const std::string& name,
     std::shared_ptr<const XdsEndpointResource> endpoint) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] received Endpoint update: %s",
-            this, name.c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] received Endpoint update: " << name;
   }
   if (xds_client_ == nullptr) return;
   auto it = endpoint_watchers_.find(name);
@@ -659,9 +673,8 @@ void XdsDependencyManager::OnEndpointUpdate(
 void XdsDependencyManager::OnEndpointError(const std::string& name,
                                            absl::Status status) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO,
-            "[XdsDependencyManager %p] received Endpoint error: %s %s", this,
-            name.c_str(), status.ToString().c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] received Endpoint error: " << name << " " << status;
   }
   if (xds_client_ == nullptr) return;
   auto it = endpoint_watchers_.find(name);
@@ -675,8 +688,8 @@ void XdsDependencyManager::OnEndpointError(const std::string& name,
 
 void XdsDependencyManager::OnEndpointDoesNotExist(const std::string& name) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] Endpoint does not exist: %s",
-            this, name.c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] Endpoint does not exist: " << name;
   }
   if (xds_client_ == nullptr) return;
   auto it = endpoint_watchers_.find(name);
@@ -690,8 +703,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)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] received DNS update: %s", this,
-            dns_name.c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] received DNS update: " << dns_name;
   }
   if (xds_client_ == nullptr) return;
   auto it = dns_resolvers_.find(dns_name);
@@ -708,7 +721,11 @@ void XdsDependencyManager::PopulateDnsUpdate(const std::string& dns_name,
   locality.name = MakeRefCounted<XdsLocalityName>("", "", "");
   locality.lb_weight = 1;
   if (result.addresses.ok()) {
-    locality.endpoints = std::move(*result.addresses);
+    for (const auto& address : *result.addresses) {
+      locality.endpoints.emplace_back(
+          address.addresses(),
+          address.args().Set(GRPC_ARG_ADDRESS_NAME, dns_name));
+    }
     dns_state->update.resolution_note = std::move(result.resolution_note);
   } else if (result.resolution_note.empty()) {
     dns_state->update.resolution_note =
@@ -749,9 +766,8 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
   if (state.watcher == nullptr) {
     auto watcher = MakeRefCounted<ClusterWatcher>(Ref(), name);
     if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      gpr_log(GPR_INFO,
-              "[XdsDependencyManager %p] starting watch for cluster %s", this,
-              std::string(name).c_str());
+      LOG(INFO) << "[XdsDependencyManager " << this
+                << "] starting watch for cluster " << name;
     }
     state.watcher = watcher.get();
     XdsClusterResourceType::StartWatch(xds_client_.get(), name,
@@ -777,9 +793,8 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         auto& eds_state = endpoint_watchers_[eds_resource_name];
         if (eds_state.watcher == nullptr) {
           if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-            gpr_log(GPR_INFO,
-                    "[XdsDependencyManager %p] starting watch for endpoint %s",
-                    this, std::string(eds_resource_name).c_str());
+            LOG(INFO) << "[XdsDependencyManager " << this
+                      << "] starting watch for endpoint " << eds_resource_name;
           }
           auto watcher =
               MakeRefCounted<EndpointWatcher>(Ref(), eds_resource_name);
@@ -806,9 +821,8 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
         auto& dns_state = dns_resolvers_[logical_dns.hostname];
         if (dns_state.resolver == nullptr) {
           if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-            gpr_log(GPR_INFO,
-                    "[XdsDependencyManager %p] starting DNS resolver for %s",
-                    this, logical_dns.hostname.c_str());
+            LOG(INFO) << "[XdsDependencyManager " << this
+                      << "] starting DNS resolver for " << logical_dns.hostname;
           }
           auto* fake_resolver_response_generator = args_.GetPointer<
               FakeResolverResponseGenerator>(
@@ -974,9 +988,8 @@ void XdsDependencyManager::MaybeReportUpdate() {
       continue;
     }
     if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      gpr_log(GPR_INFO,
-              "[XdsDependencyManager %p] cancelling watch for cluster %s", this,
-              cluster_name.c_str());
+      LOG(INFO) << "[XdsDependencyManager " << this
+                << "] cancelling watch for cluster " << cluster_name;
     }
     XdsClusterResourceType::CancelWatch(xds_client_.get(), cluster_name,
                                         it->second.watcher,
@@ -993,9 +1006,8 @@ void XdsDependencyManager::MaybeReportUpdate() {
       continue;
     }
     if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      gpr_log(GPR_INFO,
-              "[XdsDependencyManager %p] cancelling watch for EDS resource %s",
-              this, eds_resource_name.c_str());
+      LOG(INFO) << "[XdsDependencyManager " << this
+                << "] cancelling watch for EDS resource " << eds_resource_name;
     }
     XdsEndpointResourceType::CancelWatch(xds_client_.get(), eds_resource_name,
                                          it->second.watcher,
@@ -1011,24 +1023,22 @@ void XdsDependencyManager::MaybeReportUpdate() {
       continue;
     }
     if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      gpr_log(GPR_INFO,
-              "[XdsDependencyManager %p] shutting down DNS resolver for %s",
-              this, dns_name.c_str());
+      LOG(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)) {
-      gpr_log(GPR_INFO,
-              "[XdsDependencyManager %p] missing data -- NOT returning config",
-              this);
+      LOG(INFO) << "[XdsDependencyManager " << this
+                << "] missing data -- NOT returning config";
     }
     return;
   }
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[XdsDependencyManager %p] returning config: %s", this,
-            config->ToString().c_str());
+    LOG(INFO) << "[XdsDependencyManager " << this
+              << "] returning config: " << config->ToString();
   }
   watcher_->OnUpdate(std::move(config));
 }

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

@@ -149,6 +149,10 @@ class XdsDependencyManager final : public RefCounted<XdsDependencyManager>,
   RefCountedPtr<ClusterSubscription> GetClusterSubscription(
       absl::string_view cluster_name);
 
+  void RequestReresolution();
+
+  void ResetBackoff();
+
   static absl::string_view ChannelArgName() {
     return GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_dependency_manager";
   }

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

@@ -27,6 +27,7 @@
 #include <vector>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
@@ -45,7 +46,6 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/client_channel/client_channel_internal.h"
@@ -86,7 +86,7 @@
 #include "src/core/service_config/service_config_impl.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
 #include "src/core/xds/grpc/xds_client_grpc.h"
-#include "src/core/xds/grpc/xds_http_filters.h"
+#include "src/core/xds/grpc/xds_http_filter.h"
 #include "src/core/xds/grpc/xds_listener.h"
 #include "src/core/xds/grpc/xds_route_config.h"
 #include "src/core/xds/grpc/xds_routing.h"
@@ -111,16 +111,15 @@ class XdsResolver final : public Resolver {
         data_plane_authority_(std::move(data_plane_authority)),
         channel_id_(absl::Uniform<uint64_t>(absl::BitGen())) {
     if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-      gpr_log(
-          GPR_INFO,
-          "[xds_resolver %p] created for URI %s; data plane authority is %s",
-          this, uri_.ToString().c_str(), data_plane_authority_.c_str());
+      LOG(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)) {
-      gpr_log(GPR_INFO, "[xds_resolver %p] destroyed", this);
+      LOG(INFO) << "[xds_resolver " << this << "] destroyed";
     }
   }
 
@@ -128,8 +127,13 @@ class XdsResolver final : public Resolver {
 
   void ShutdownLocked() override;
 
+  void RequestReresolutionLocked() override {
+    if (dependency_mgr_ != nullptr) dependency_mgr_->RequestReresolution();
+  }
+
   void ResetBackoffLocked() override {
     if (xds_client_ != nullptr) xds_client_->ResetBackoff();
+    if (dependency_mgr_ != nullptr) dependency_mgr_->ResetBackoff();
   }
 
  private:
@@ -270,7 +274,10 @@ class XdsResolver final : public Resolver {
                       RefCountedPtr<RouteConfigData> route_config_data);
     ~XdsConfigSelector() override;
 
-    const char* name() const override { return "XdsConfigSelector"; }
+    UniqueTypeName name() const override {
+      static UniqueTypeName::Factory kFactory("XdsConfigSelector");
+      return kFactory.Create();
+    }
 
     bool Equals(const ConfigSelector* other) const override {
       const auto* other_xds = static_cast<const XdsConfigSelector*>(other);
@@ -281,14 +288,14 @@ class XdsResolver final : public Resolver {
 
     absl::Status GetCallConfig(GetCallConfigArgs args) override;
 
-    std::vector<const grpc_channel_filter*> GetFilters() override {
-      return filters_;
-    }
+    void AddFilters(InterceptionChainBuilder& builder) override;
+
+    std::vector<const grpc_channel_filter*> GetFilters() override;
 
    private:
     RefCountedPtr<XdsResolver> resolver_;
     RefCountedPtr<RouteConfigData> route_config_data_;
-    std::vector<const grpc_channel_filter*> filters_;
+    std::vector<const XdsHttpFilterImpl*> filters_;
   };
 
   class XdsRouteStateAttributeImpl final : public XdsRouteStateAttribute {
@@ -305,6 +312,10 @@ class XdsResolver final : public Resolver {
 
     bool HasClusterForRoute(absl::string_view cluster_name) const override;
 
+    const XdsRouteConfigResource::Route& route() const override {
+      return route_->route;
+    }
+
    private:
     RefCountedPtr<RouteConfigData> route_config_data_;
     RouteConfigData::RouteEntry* route_;
@@ -315,6 +326,8 @@ class XdsResolver final : public Resolver {
    public:
     const static grpc_channel_filter kFilter;
 
+    static absl::string_view TypeName() { return "cluster_selection_filter"; }
+
     static absl::StatusOr<std::unique_ptr<ClusterSelectionFilter>> Create(
         const ChannelArgs& /* unused */,
         ChannelFilter::Args /* filter_args */) {
@@ -533,8 +546,8 @@ absl::Status XdsResolver::RouteConfigData::AddRouteEntry(
     XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
     const Duration& default_max_stream_duration) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] XdsConfigSelector %p: route: %s",
-            resolver, this, route.ToString().c_str());
+    LOG(INFO) << "[xds_resolver " << resolver << "] XdsConfigSelector " << this
+              << ": route: " << route.ToString();
   }
   routes_.emplace_back(route);
   auto* route_entry = &routes_.back();
@@ -625,8 +638,8 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
     : resolver_(std::move(resolver)),
       route_config_data_(std::move(route_config_data)) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] creating XdsConfigSelector %p",
-            resolver_.get(), this);
+    LOG(INFO) << "[xds_resolver " << resolver_.get()
+              << "] creating XdsConfigSelector " << this;
   }
   // Populate filter list.
   const auto& http_filter_registry =
@@ -641,18 +654,15 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
         http_filter_registry.GetFilterForType(
             http_filter.config.config_proto_type_name);
     CHECK_NE(filter_impl, nullptr);
-    // Add C-core filter to list.
-    if (filter_impl->channel_filter() != nullptr) {
-      filters_.push_back(filter_impl->channel_filter());
-    }
+    // Add filter to list.
+    filters_.push_back(filter_impl);
   }
-  filters_.push_back(&ClusterSelectionFilter::kFilter);
 }
 
 XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] destroying XdsConfigSelector %p",
-            resolver_.get(), this);
+    LOG(INFO) << "[xds_resolver " << resolver_.get()
+              << "] destroying XdsConfigSelector " << this;
   }
   route_config_data_.reset();
   if (!IsWorkSerializerDispatchEnabled()) {
@@ -799,6 +809,26 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
   return absl::OkStatus();
 }
 
+void XdsResolver::XdsConfigSelector::AddFilters(
+    InterceptionChainBuilder& builder) {
+  for (const XdsHttpFilterImpl* filter : filters_) {
+    filter->AddFilter(builder);
+  }
+  builder.Add<ClusterSelectionFilter>();
+}
+
+std::vector<const grpc_channel_filter*>
+XdsResolver::XdsConfigSelector::GetFilters() {
+  std::vector<const grpc_channel_filter*> filters;
+  for (const XdsHttpFilterImpl* filter : filters_) {
+    if (filter->channel_filter() != nullptr) {
+      filters.push_back(filter->channel_filter());
+    }
+  }
+  filters.push_back(&ClusterSelectionFilter::kFilter);
+  return filters;
+}
+
 //
 // XdsResolver::XdsRouteStateAttributeImpl
 //
@@ -846,8 +876,7 @@ XdsResolver::XdsRouteStateAttributeImpl::LockAndGetCluster(
 
 const grpc_channel_filter XdsResolver::ClusterSelectionFilter::kFilter =
     MakePromiseBasedFilter<ClusterSelectionFilter, FilterEndpoint::kClient,
-                           kFilterExaminesServerInitialMetadata>(
-        "cluster_selection_filter");
+                           kFilterExaminesServerInitialMetadata>();
 
 void XdsResolver::ClusterSelectionFilter::Call::OnClientInitialMetadata(
     ClientMetadata&) {
@@ -876,10 +905,9 @@ void XdsResolver::StartLocked() {
   auto xds_client =
       GrpcXdsClient::GetOrCreate(uri_.ToString(), args_, "xds resolver");
   if (!xds_client.ok()) {
-    gpr_log(GPR_ERROR,
-            "Failed to create xds client -- channel will remain in "
-            "TRANSIENT_FAILURE: %s",
-            xds_client.status().ToString().c_str());
+    LOG(ERROR) << "Failed to create xds client -- channel will remain in "
+                  "TRANSIENT_FAILURE: "
+               << xds_client.status();
     absl::Status status = absl::UnavailableError(absl::StrCat(
         "Failed to create XdsClient: ", xds_client.status().message()));
     Result result;
@@ -935,8 +963,8 @@ void XdsResolver::StartLocked() {
         absl::StrReplaceAll(name_template, {{"%s", resource_name_fragment}});
   }
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] Started with lds_resource_name %s.",
-            this, lds_resource_name_.c_str());
+    LOG(INFO) << "[xds_resolver " << this << "] Started with lds_resource_name "
+              << lds_resource_name_;
   }
   // Start watch for xDS config.
   dependency_mgr_ = MakeOrphanable<XdsDependencyManager>(
@@ -947,7 +975,7 @@ void XdsResolver::StartLocked() {
 
 void XdsResolver::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] shutting down", this);
+    LOG(INFO) << "[xds_resolver " << this << "] shutting down";
   }
   if (xds_client_ != nullptr) {
     dependency_mgr_.reset();
@@ -960,7 +988,7 @@ void XdsResolver::ShutdownLocked() {
 void XdsResolver::OnUpdate(
     RefCountedPtr<const XdsDependencyManager::XdsConfig> config) {
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] received updated xDS config", this);
+    LOG(INFO) << "[xds_resolver " << this << "] received updated xDS config";
   }
   if (xds_client_ == nullptr) return;
   current_config_ = std::move(config);
@@ -968,8 +996,9 @@ void XdsResolver::OnUpdate(
 }
 
 void XdsResolver::OnError(absl::string_view context, absl::Status status) {
-  gpr_log(GPR_ERROR, "[xds_resolver %p] received error from XdsClient: %s: %s",
-          this, std::string(context).c_str(), status.ToString().c_str());
+  LOG(ERROR) << "[xds_resolver " << this
+             << "] received error from XdsClient: " << context << ": "
+             << status;
   if (xds_client_ == nullptr) return;
   status =
       absl::UnavailableError(absl::StrCat(context, ": ", status.ToString()));
@@ -982,10 +1011,9 @@ void XdsResolver::OnError(absl::string_view context, absl::Status status) {
 }
 
 void XdsResolver::OnResourceDoesNotExist(std::string context) {
-  gpr_log(GPR_ERROR,
-          "[xds_resolver %p] LDS/RDS resource does not exist -- clearing "
-          "update and returning empty service config",
-          this);
+  LOG(ERROR) << "[xds_resolver " << this
+             << "] LDS/RDS resource does not exist -- clearing "
+                "update and returning empty service config";
   if (xds_client_ == nullptr) return;
   current_config_.reset();
   Result result;
@@ -1059,10 +1087,10 @@ void XdsResolver::GenerateResult() {
   result.addresses.emplace();
   result.service_config = CreateServiceConfig();
   if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] generated service config: %s", this,
-            result.service_config.ok()
-                ? std::string((*result.service_config)->json_string()).c_str()
-                : result.service_config.status().ToString().c_str());
+    LOG(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"))
@@ -1096,8 +1124,7 @@ class XdsResolverFactory final : public ResolverFactory {
 
   bool IsValidUri(const URI& uri) const override {
     if (uri.path().empty() || uri.path().back() == '/') {
-      gpr_log(GPR_ERROR,
-              "URI path does not contain valid data plane authority");
+      LOG(ERROR) << "URI path does not contain valid data plane authority";
       return false;
     }
     return true;