grpc 1.63.0 → 1.65.2

data/src/core/resolver/polling_resolver.cc

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/resolver/polling_resolver.h"
 
 #include <inttypes.h>
@@ -25,12 +23,14 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -38,9 +38,9 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/uri/uri_parser.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/service_config/service_config.h"
-#include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 
@@ -60,13 +60,13 @@ PollingResolver::PollingResolver(ResolverArgs args,
       min_time_between_resolutions_(min_time_between_resolutions),
       backoff_(backoff_options) {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] created", this);
+    LOG(INFO) << "[polling resolver " << this << "] created";
   }
 }
 
 PollingResolver::~PollingResolver() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] destroying", this);
+    LOG(INFO) << "[polling resolver " << this << "] destroying";
   }
 }
 
@@ -97,7 +97,7 @@ void PollingResolver::ResetBackoffLocked() {
 
 void PollingResolver::ShutdownLocked() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] shutting down", this);
+    LOG(INFO) << "[polling resolver " << this << "] shutting down";
   }
   shutdown_ = true;
   MaybeCancelNextResolutionTimer();
@@ -119,9 +119,8 @@ void PollingResolver::ScheduleNextResolutionTimer(const Duration& timeout) {
 
 void PollingResolver::OnNextResolutionLocked() {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO,
-            "[polling resolver %p] re-resolution timer fired: shutdown_=%d",
-            this, shutdown_);
+    LOG(INFO) << "[polling resolver " << this
+              << "] re-resolution timer fired: shutdown_=" << shutdown_;
   }
   // If we haven't been cancelled nor shutdown, then start resolving.
   if (next_resolution_timer_handle_.has_value() && !shutdown_) {
@@ -133,8 +132,8 @@ void PollingResolver::OnNextResolutionLocked() {
 void PollingResolver::MaybeCancelNextResolutionTimer() {
   if (next_resolution_timer_handle_.has_value()) {
     if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-      gpr_log(GPR_INFO, "[polling resolver %p] cancel re-resolution timer",
-              this);
+      LOG(INFO) << "[polling resolver " << this
+                << "] cancel re-resolution timer";
     }
     channel_args_.GetObject<EventEngine>()->Cancel(
         *next_resolution_timer_handle_);
@@ -151,28 +150,26 @@ void PollingResolver::OnRequestComplete(Result result) {
 
 void PollingResolver::OnRequestCompleteLocked(Result result) {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] request complete", this);
+    LOG(INFO) << "[polling resolver " << this << "] request complete";
   }
   request_.reset();
   if (!shutdown_) {
     if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-      gpr_log(GPR_INFO,
-              "[polling resolver %p] returning result: "
-              "addresses=%s, service_config=%s, resolution_note=%s",
-              this,
-              result.addresses.ok()
+      LOG(INFO)
+          << "[polling resolver " << this << "] returning result: addresses="
+          << (result.addresses.ok()
                   ? absl::StrCat("<", result.addresses->size(), " addresses>")
-                        .c_str()
-                  : result.addresses.status().ToString().c_str(),
-              result.service_config.ok()
+                  : result.addresses.status().ToString())
+          << ", service_config="
+          << (result.service_config.ok()
                   ? (*result.service_config == nullptr
                          ? "<null>"
                          : std::string((*result.service_config)->json_string())
                                .c_str())
-                  : result.service_config.status().ToString().c_str(),
-              result.resolution_note.c_str());
+                  : result.service_config.status().ToString())
+          << ", resolution_note=" << result.resolution_note;
     }
-    GPR_ASSERT(result.result_health_callback == nullptr);
+    CHECK(result.result_health_callback == nullptr);
     result.result_health_callback =
         [self = RefAsSubclass<PollingResolver>(
              DEBUG_LOCATION, "result_health_callback")](absl::Status status) {
@@ -186,8 +183,8 @@ void PollingResolver::OnRequestCompleteLocked(Result result) {
 
 void PollingResolver::GetResultStatus(absl::Status status) {
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-    gpr_log(GPR_INFO, "[polling resolver %p] result status from channel: %s",
-            this, status.ToString().c_str());
+    LOG(INFO) << "[polling resolver " << this
+              << "] result status from channel: " << status;
   }
   if (status.ok()) {
     // Reset backoff state so that we start from the beginning when the
@@ -207,13 +204,13 @@ void PollingResolver::GetResultStatus(absl::Status status) {
     ExecCtx::Get()->InvalidateNow();
     const Timestamp next_try = backoff_.NextAttemptTime();
     const Duration timeout = next_try - Timestamp::Now();
-    GPR_ASSERT(!next_resolution_timer_handle_.has_value());
+    CHECK(!next_resolution_timer_handle_.has_value());
     if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
       if (timeout > Duration::Zero()) {
-        gpr_log(GPR_INFO, "[polling resolver %p] retrying in %" PRId64 " ms",
-                this, timeout.millis());
+        LOG(INFO) << "[polling resolver " << this << "] retrying in "
+                  << timeout.millis() << " ms";
       } else {
-        gpr_log(GPR_INFO, "[polling resolver %p] retrying immediately", this);
+        LOG(INFO) << "[polling resolver " << this << "] retrying immediately";
       }
     }
     ScheduleNextResolutionTimer(timeout);
@@ -241,12 +238,11 @@ void PollingResolver::MaybeStartResolvingLocked() {
       if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
         const Duration last_resolution_ago =
             Timestamp::Now() - *last_resolution_timestamp_;
-        gpr_log(GPR_INFO,
-                "[polling resolver %p] in cooldown from last resolution "
-                "(from %" PRId64 " ms ago); will resolve again in %" PRId64
-                " ms",
-                this, last_resolution_ago.millis(),
-                time_until_next_resolution.millis());
+        LOG(INFO) << "[polling resolver " << this
+                  << "] in cooldown from last resolution (from "
+                  << last_resolution_ago.millis()
+                  << " ms ago); will resolve again in "
+                  << time_until_next_resolution.millis() << " ms";
       }
       ScheduleNextResolutionTimer(time_until_next_resolution);
       return;
@@ -260,11 +256,10 @@ void PollingResolver::StartResolvingLocked() {
   last_resolution_timestamp_ = Timestamp::Now();
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
     if (request_ != nullptr) {
-      gpr_log(GPR_INFO,
-              "[polling resolver %p] starting resolution, request_=%p", this,
-              request_.get());
+      LOG(INFO) << "[polling resolver " << this
+                << "] starting resolution, request_=" << request_.get();
     } else {
-      gpr_log(GPR_INFO, "[polling resolver %p] StartRequest failed", this);
+      LOG(INFO) << "[polling resolver " << this << "] StartRequest failed";
     }
   }
 }

data/src/core/resolver/polling_resolver.h

@@ -17,8 +17,6 @@
 #ifndef GRPC_SRC_CORE_RESOLVER_POLLING_RESOLVER_H
 #define GRPC_SRC_CORE_RESOLVER_POLLING_RESOLVER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <string>
 
@@ -26,6 +24,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"

data/src/core/resolver/resolver.cc

@@ -16,12 +16,9 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/resolver/resolver.h"
 
-grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount(false,
-                                                           "resolver_refcount");
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
@@ -30,8 +27,7 @@ namespace grpc_core {
 //
 
 Resolver::Resolver()
-    : InternallyRefCounted(GRPC_TRACE_FLAG_ENABLED(grpc_trace_resolver_refcount)
-                               ? "Resolver"
-                               : nullptr) {}
+    : InternallyRefCounted(
+          GRPC_TRACE_FLAG_ENABLED(resolver_refcount) ? "Resolver" : nullptr) {}
 
 }  // namespace grpc_core

data/src/core/resolver/resolver.h

@@ -17,14 +17,14 @@
 #ifndef GRPC_SRC_CORE_RESOLVER_RESOLVER_H
 #define GRPC_SRC_CORE_RESOLVER_RESOLVER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <functional>
 #include <string>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/orphanable.h"
@@ -33,8 +33,6 @@
 #include "src/core/resolver/server_address.h"  // IWYU pragma: keep
 #include "src/core/service_config/service_config.h"
 
-extern grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount;
-
 // Name associated with individual address, if available.
 #define GRPC_ARG_ADDRESS_NAME "grpc.address_name"
 

data/src/core/resolver/resolver_factory.h

@@ -17,19 +17,19 @@
 #ifndef GRPC_SRC_CORE_RESOLVER_RESOLVER_FACTORY_H
 #define GRPC_SRC_CORE_RESOLVER_RESOLVER_FACTORY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <string>
 
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/resolver/resolver.h"
 #include "src/core/lib/uri/uri_parser.h"
+#include "src/core/resolver/resolver.h"
 
 namespace grpc_core {
 

data/src/core/resolver/resolver_registry.cc

@@ -14,17 +14,17 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/resolver/resolver_registry.h"
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
@@ -51,9 +51,9 @@ bool IsLowerCase(absl::string_view str) {
 
 void ResolverRegistry::Builder::RegisterResolverFactory(
     std::unique_ptr<ResolverFactory> factory) {
-  GPR_ASSERT(IsLowerCase(factory->scheme()));
+  CHECK(IsLowerCase(factory->scheme()));
   auto p = state_.factories.emplace(factory->scheme(), std::move(factory));
-  GPR_ASSERT(p.second);
+  CHECK(p.second);
 }
 
 bool ResolverRegistry::Builder::HasResolverFactory(
@@ -131,7 +131,7 @@ ResolverFactory* ResolverRegistry::LookupResolverFactory(
 // point to the parsed URI.
 ResolverFactory* ResolverRegistry::FindResolverFactory(
     absl::string_view target, URI* uri, std::string* canonical_target) const {
-  GPR_ASSERT(uri != nullptr);
+  CHECK_NE(uri, nullptr);
   absl::StatusOr<URI> tmp_uri = URI::Parse(target);
   ResolverFactory* factory =
       tmp_uri.ok() ? LookupResolverFactory(tmp_uri->scheme()) : nullptr;
@@ -147,15 +147,13 @@ ResolverFactory* ResolverRegistry::FindResolverFactory(
     return factory;
   }
   if (!tmp_uri.ok() || !tmp_uri2.ok()) {
-    gpr_log(GPR_ERROR, "%s",
-            absl::StrFormat("Error parsing URI(s). '%s':%s; '%s':%s", target,
-                            tmp_uri.status().ToString(), *canonical_target,
-                            tmp_uri2.status().ToString())
-                .c_str());
+    LOG(ERROR) << "Error parsing URI(s). '" << target
+               << "':" << tmp_uri.status() << "; '" << *canonical_target
+               << "':" << tmp_uri2.status();
     return nullptr;
   }
-  gpr_log(GPR_ERROR, "Don't know how to resolve '%s' or '%s'.",
-          std::string(target).c_str(), canonical_target->c_str());
+  LOG(ERROR) << "Don't know how to resolve '" << target << "' or '"
+             << *canonical_target << "'.";
   return nullptr;
 }
 

data/src/core/resolver/resolver_registry.h

@@ -17,8 +17,6 @@
 #ifndef GRPC_SRC_CORE_RESOLVER_RESOLVER_REGISTRY_H
 #define GRPC_SRC_CORE_RESOLVER_RESOLVER_REGISTRY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <map>
 #include <memory>
 #include <string>
@@ -26,12 +24,14 @@
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/uri/uri_parser.h"
 #include "src/core/resolver/resolver.h"
 #include "src/core/resolver/resolver_factory.h"
-#include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 

data/src/core/resolver/sockaddr/sockaddr_resolver.cc

@@ -14,18 +14,17 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -33,10 +32,10 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/uri/uri_parser.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/resolver/resolver.h"
 #include "src/core/resolver/resolver_factory.h"
-#include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 
@@ -77,8 +76,8 @@ bool ParseUri(const URI& uri,
               bool parse(const URI& uri, grpc_resolved_address* dst),
               EndpointAddressesList* addresses) {
   if (!uri.authority().empty()) {
-    gpr_log(GPR_ERROR, "authority-based URIs not supported by the %s scheme",
-            uri.scheme().c_str());
+    LOG(ERROR) << "authority-based URIs not supported by the " << uri.scheme()
+               << " scheme";
     return false;
   }
   // Construct addresses.

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

@@ -14,20 +14,20 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/resolver/xds/xds_dependency_manager.h"
 
 #include <set>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_join.h"
 
-#include "src/core/ext/xds/xds_routing.h"
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/config/core_configuration.h"
 #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/resolver/xds/xds_resolver_trace.h"
+#include "src/core/xds/grpc/xds_routing.h"
 
 namespace grpc_core {
 
@@ -359,7 +359,7 @@ XdsDependencyManager::XdsDependencyManager(
       listener_resource_name_(std::move(listener_resource_name)),
       args_(std::move(args)),
       interested_parties_(interested_parties) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO,
             "[XdsDependencyManager %p] starting watch for listener %s", this,
             listener_resource_name_.c_str());
@@ -371,7 +371,7 @@ XdsDependencyManager::XdsDependencyManager(
 }
 
 void XdsDependencyManager::Orphan() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO, "[XdsDependencyManager %p] shutting down", this);
   }
   if (listener_watcher_ != nullptr) {
@@ -404,7 +404,7 @@ void XdsDependencyManager::Orphan() {
 
 void XdsDependencyManager::OnListenerUpdate(
     std::shared_ptr<const XdsListenerResource> listener) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO, "[XdsDependencyManager %p] received Listener update",
             this);
   }
@@ -437,7 +437,7 @@ void XdsDependencyManager::OnListenerUpdate(
           }
           // Start watch for the new RDS resource name.
           route_config_name_ = rds_name;
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+          if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
             gpr_log(
                 GPR_INFO,
                 "[XdsDependencyManager %p] starting watch for route config %s",
@@ -525,7 +525,7 @@ 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(grpc_xds_resolver_trace)) {
+  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());
@@ -560,7 +560,7 @@ void XdsDependencyManager::OnRouteConfigUpdate(
 }
 
 void XdsDependencyManager::OnError(std::string context, absl::Status status) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO,
             "[XdsDependencyManager %p] received Listener or RouteConfig "
             "error: %s %s",
@@ -572,7 +572,7 @@ void XdsDependencyManager::OnError(std::string context, absl::Status status) {
 }
 
 void XdsDependencyManager::OnResourceDoesNotExist(std::string context) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO, "[XdsDependencyManager %p] %s", this, context.c_str());
   }
   if (xds_client_ == nullptr) return;
@@ -583,7 +583,7 @@ void XdsDependencyManager::OnResourceDoesNotExist(std::string context) {
 void XdsDependencyManager::OnClusterUpdate(
     const std::string& name,
     std::shared_ptr<const XdsClusterResource> cluster) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO, "[XdsDependencyManager %p] received Cluster update: %s",
             this, name.c_str());
   }
@@ -596,7 +596,7 @@ void XdsDependencyManager::OnClusterUpdate(
 
 void XdsDependencyManager::OnClusterError(const std::string& name,
                                           absl::Status status) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  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());
   }
@@ -611,7 +611,7 @@ void XdsDependencyManager::OnClusterError(const std::string& name,
 }
 
 void XdsDependencyManager::OnClusterDoesNotExist(const std::string& name) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO, "[XdsDependencyManager %p] Cluster does not exist: %s",
             this, name.c_str());
   }
@@ -626,7 +626,7 @@ 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(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO, "[XdsDependencyManager %p] received Endpoint update: %s",
             this, name.c_str());
   }
@@ -658,7 +658,7 @@ void XdsDependencyManager::OnEndpointUpdate(
 
 void XdsDependencyManager::OnEndpointError(const std::string& name,
                                            absl::Status status) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  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());
@@ -674,7 +674,7 @@ void XdsDependencyManager::OnEndpointError(const std::string& name,
 }
 
 void XdsDependencyManager::OnEndpointDoesNotExist(const std::string& name) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO, "[XdsDependencyManager %p] Endpoint does not exist: %s",
             this, name.c_str());
   }
@@ -689,7 +689,7 @@ void XdsDependencyManager::OnEndpointDoesNotExist(const std::string& name) {
 
 void XdsDependencyManager::OnDnsResult(const std::string& dns_name,
                                        Resolver::Result result) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO, "[XdsDependencyManager %p] received DNS update: %s", this,
             dns_name.c_str());
   }
@@ -729,7 +729,7 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
     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) GPR_ASSERT(leaf_clusters != nullptr);
+  if (depth > 0) CHECK_NE(leaf_clusters, nullptr);
   if (depth == kMaxXdsAggregateClusterRecursionDepth) {
     *leaf_clusters =
         absl::UnavailableError("aggregate cluster graph exceeds max depth");
@@ -748,7 +748,7 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
   // Create a new watcher if needed.
   if (state.watcher == nullptr) {
     auto watcher = MakeRefCounted<ClusterWatcher>(Ref(), name);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
       gpr_log(GPR_INFO,
               "[XdsDependencyManager %p] starting watch for cluster %s", this,
               std::string(name).c_str());
@@ -776,7 +776,7 @@ 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(grpc_xds_resolver_trace)) {
+          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());
@@ -805,7 +805,7 @@ 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(grpc_xds_resolver_trace)) {
+          if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
             gpr_log(GPR_INFO,
                     "[XdsDependencyManager %p] starting DNS resolver for %s",
                     this, logical_dns.hostname.c_str());
@@ -973,7 +973,7 @@ void XdsDependencyManager::MaybeReportUpdate() {
       ++it;
       continue;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
       gpr_log(GPR_INFO,
               "[XdsDependencyManager %p] cancelling watch for cluster %s", this,
               cluster_name.c_str());
@@ -992,7 +992,7 @@ void XdsDependencyManager::MaybeReportUpdate() {
       ++it;
       continue;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    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());
@@ -1010,7 +1010,7 @@ void XdsDependencyManager::MaybeReportUpdate() {
       ++it;
       continue;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
       gpr_log(GPR_INFO,
               "[XdsDependencyManager %p] shutting down DNS resolver for %s",
               this, dns_name.c_str());
@@ -1019,14 +1019,14 @@ void XdsDependencyManager::MaybeReportUpdate() {
   }
   // If we have all the data we need, then send an update.
   if (!have_all_resources) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
       gpr_log(GPR_INFO,
               "[XdsDependencyManager %p] missing data -- NOT returning config",
               this);
     }
     return;
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_resolver)) {
     gpr_log(GPR_INFO, "[XdsDependencyManager %p] returning config: %s", this,
             config->ToString().c_str());
   }

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

@@ -17,19 +17,19 @@
 #ifndef GRPC_SRC_CORE_RESOLVER_XDS_XDS_DEPENDENCY_MANAGER_H
 #define GRPC_SRC_CORE_RESOLVER_XDS_XDS_DEPENDENCY_MANAGER_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/strings/string_view.h"
 
-#include "src/core/ext/xds/xds_client_grpc.h"
-#include "src/core/ext/xds/xds_cluster.h"
-#include "src/core/ext/xds/xds_endpoint.h"
-#include "src/core/ext/xds/xds_listener.h"
-#include "src/core/ext/xds/xds_route_config.h"
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/resolver/resolver.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"
+#include "src/core/xds/grpc/xds_listener.h"
+#include "src/core/xds/grpc/xds_route_config.h"
 
 namespace grpc_core {