grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -47,7 +47,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -64,6 +63,7 @@
 #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/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/string.h"
 #include "src/core/util/time.h"
@@ -215,7 +215,7 @@ static void grpc_ares_ev_driver_unref(grpc_ares_ev_driver* ev_driver)
     GRPC_TRACE_VLOG(cares_resolver, 2)
         << "(c-ares resolver) request:" << ev_driver->request
         << " destroy ev_driver " << ev_driver;
-    CHECK_EQ(ev_driver->fds, nullptr);
+    GRPC_CHECK_EQ(ev_driver->fds, nullptr);
     ares_destroy(ev_driver->channel);
     grpc_ares_complete_request_locked(ev_driver->request);
     delete ev_driver;
@@ -227,9 +227,9 @@ static void fd_node_destroy_locked(fd_node* fdn)
   GRPC_TRACE_VLOG(cares_resolver, 2)
       << "(c-ares resolver) request:" << fdn->ev_driver->request
       << " delete fd: " << fdn->grpc_polled_fd->GetName();
-  CHECK(!fdn->readable_registered);
-  CHECK(!fdn->writable_registered);
-  CHECK(fdn->already_shutdown);
+  GRPC_CHECK(!fdn->readable_registered);
+  GRPC_CHECK(!fdn->writable_registered);
+  GRPC_CHECK(fdn->already_shutdown);
   delete fdn->grpc_polled_fd;
   delete fdn;
 }
@@ -369,7 +369,7 @@ static void on_ares_backup_poll_alarm(void* arg, grpc_error_handle error) {
 static void on_readable(void* arg, grpc_error_handle error) {
   fd_node* fdn = static_cast<fd_node*>(arg);
   grpc_core::MutexLock lock(&fdn->ev_driver->request->mu);
-  CHECK(fdn->readable_registered);
+  GRPC_CHECK(fdn->readable_registered);
   grpc_ares_ev_driver* ev_driver = fdn->ev_driver;
   const ares_socket_t as = fdn->grpc_polled_fd->GetWrappedAresSocketLocked();
   fdn->readable_registered = false;
@@ -394,7 +394,7 @@ static void on_readable(void* arg, grpc_error_handle error) {
 static void on_writable(void* arg, grpc_error_handle error) {
   fd_node* fdn = static_cast<fd_node*>(arg);
   grpc_core::MutexLock lock(&fdn->ev_driver->request->mu);
-  CHECK(fdn->writable_registered);
+  GRPC_CHECK(fdn->writable_registered);
   grpc_ares_ev_driver* ev_driver = fdn->ev_driver;
   const ares_socket_t as = fdn->grpc_polled_fd->GetWrappedAresSocketLocked();
   fdn->writable_registered = false;
@@ -949,7 +949,7 @@ static bool inner_resolve_as_ip_literal_locked(
                                false /* log errors */) ||
       grpc_parse_ipv6_hostport(hostport->c_str(), &addr,
                                false /* log errors */)) {
-    CHECK(*addrs == nullptr);
+    GRPC_CHECK(*addrs == nullptr);
     *addrs = std::make_unique<EndpointAddressesList>();
     (*addrs)->emplace_back(addr, grpc_core::ChannelArgs());
     return true;
@@ -1003,7 +1003,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     *port = default_port;
   }
   if (gpr_stricmp(host->c_str(), "localhost") == 0) {
-    CHECK(*addrs == nullptr);
+    GRPC_CHECK(*addrs == nullptr);
     *addrs = std::make_unique<grpc_core::EndpointAddressesList>();
     uint16_t numeric_port = grpc_strhtons(port->c_str());
     grpc_resolved_address address;
@@ -1202,7 +1202,7 @@ grpc_ares_request* (*grpc_dns_lookup_txt_ares)(
     int query_timeout_ms) = grpc_dns_lookup_txt_ares_impl;
 
 static void grpc_cancel_ares_request_impl(grpc_ares_request* r) {
-  CHECK_NE(r, nullptr);
+  GRPC_CHECK_NE(r, nullptr);
   grpc_core::MutexLock lock(&r->mu);
   GRPC_TRACE_VLOG(cares_resolver, 2)
       << "(c-ares resolver) request:" << r

data/src/core/resolver/dns/dns_resolver_plugin.cc

@@ -36,14 +36,17 @@ void RegisterDnsResolver(CoreConfiguration::Builder* builder) {
       std::make_unique<EventEngineClientChannelDNSResolverFactory>());
   return;
 #endif
-#ifndef GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER
-  if (IsEventEngineDnsEnabled()) {
+#ifdef GRPC_PYTHON_BUILD
+  bool use_ee = IsEventEnginePollerForPythonEnabled();
+#else   // GRPC_PYTHON_BUILD
+  bool use_ee = true;
+#endif  // GRPC_PYTHON_BUILD
+  if (use_ee && IsEventEngineDnsEnabled()) {
     VLOG(2) << "Using EventEngine dns resolver";
     builder->resolver_registry()->RegisterResolverFactory(
         std::make_unique<EventEngineClientChannelDNSResolverFactory>());
     return;
   }
-#endif
   auto resolver = ConfigVars::Get().DnsResolver();
   // ---- Ares resolver ----
   if (ShouldUseAresDnsResolver(resolver)) {

data/src/core/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -29,7 +29,6 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/cleanup/cleanup.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -51,6 +50,7 @@
 #include "src/core/service_config/service_config_impl.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
@@ -421,7 +421,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     // Make sure field destroys before cleanup.
     ValidationErrors::ScopedField field(&errors_, "txt lookup");
     if (orphaned_) return;
-    CHECK(is_txt_inflight_);
+    GRPC_CHECK(is_txt_inflight_);
     is_txt_inflight_ = false;
     if (!service_config.ok()) {
       errors_.AddError(service_config.status().message());

data/src/core/resolver/endpoint_addresses.cc

@@ -25,13 +25,13 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/useful.h"
 
 // IWYU pragma: no_include <sys/socket.h>
@@ -45,7 +45,7 @@ EndpointAddresses::EndpointAddresses(const grpc_resolved_address& address,
 EndpointAddresses::EndpointAddresses(
     std::vector<grpc_resolved_address> addresses, const ChannelArgs& args)
     : addresses_(std::move(addresses)), args_(args) {
-  CHECK(!addresses_.empty());
+  GRPC_CHECK(!addresses_.empty());
 }
 
 EndpointAddresses::EndpointAddresses(const EndpointAddresses& other)
@@ -108,7 +108,7 @@ bool EndpointAddressSet::operator==(const EndpointAddressSet& other) const {
   if (addresses_.size() != other.addresses_.size()) return false;
   auto other_it = other.addresses_.begin();
   for (auto it = addresses_.begin(); it != addresses_.end(); ++it) {
-    CHECK(other_it != other.addresses_.end());
+    GRPC_CHECK(other_it != other.addresses_.end());
     if (it->len != other_it->len ||
         memcmp(it->addr, other_it->addr, it->len) != 0) {
       return false;

data/src/core/resolver/endpoint_addresses.h

@@ -42,6 +42,9 @@
 // Name associated with individual address, if available (e.g., DNS name).
 #define GRPC_ARG_ADDRESS_NAME "grpc.address_name"
 
+// Backend service name associated with the addresses.
+#define GRPC_ARG_BACKEND_SERVICE "grpc.internal.backend_service"
+
 namespace grpc_core {
 
 // A list of addresses for a given endpoint with an associated set of channel

data/src/core/resolver/fake/fake_resolver.cc

@@ -25,12 +25,12 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/strings/string_view.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/resolver/resolver_factory.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/uri.h"
 #include "src/core/util/useful.h"
@@ -94,7 +94,7 @@ void FakeResolver::StartLocked() {
 
 void FakeResolver::RequestReresolutionLocked() {
   // Re-resolution can't happen until after we return an initial result.
-  CHECK(response_generator_ != nullptr);
+  GRPC_CHECK(response_generator_ != nullptr);
   response_generator_->ReresolutionRequested();
 }
 

data/src/core/resolver/google_c2p/google_c2p_resolver.cc

@@ -25,7 +25,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -42,6 +41,7 @@
 #include "src/core/util/debug_location.h"
 #include "src/core/util/env.h"
 #include "src/core/util/gcp_metadata_query.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/orphanable.h"
@@ -71,6 +71,7 @@ class GoogleCloud2ProdResolver final : public Resolver {
   void ZoneQueryDone(std::string zone);
   void IPv6QueryDone(bool ipv6_supported);
   void StartXdsResolver();
+  std::shared_ptr<GrpcXdsBootstrap> ConstructBootstrap() const;
 
   ResourceQuotaRefPtr resource_quota_;
   std::shared_ptr<WorkSerializer> work_serializer_;
@@ -80,11 +81,12 @@ class GoogleCloud2ProdResolver final : public Resolver {
   std::string metadata_server_name_ = "metadata.google.internal.";
   bool shutdown_ = false;
 
-  OrphanablePtr<GcpMetadataQuery> zone_query_;
-  std::optional<std::string> zone_;
+  // Used to hold state between ctor and StartLocked().
+  std::string xds_uri_;
+  ChannelArgs args_;
 
-  OrphanablePtr<GcpMetadataQuery> ipv6_query_;
-  std::optional<bool> supports_ipv6_;
+  OrphanablePtr<GcpMetadataQuery> zone_query_;
+  std::string zone_;
 };
 
 //
@@ -99,13 +101,13 @@ bool XdsBootstrapConfigured() {
 GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
     : resource_quota_(args.args.GetObjectRef<ResourceQuota>()),
       work_serializer_(std::move(args.work_serializer)),
-      pollent_(grpc_polling_entity_create_from_pollset_set(args.pollset_set)) {
+      pollent_(grpc_polling_entity_create_from_pollset_set(args.pollset_set)),
+      args_(std::move(args.args)) {
   absl::string_view name_to_resolve = absl::StripPrefix(args.uri.path(), "/");
   // If we're not running on GCP, we can't use DirectPath, so delegate
   // to the DNS resolver.
   const bool test_only_pretend_running_on_gcp =
-      args.args
-          .GetBool("grpc.testing.google_c2p_resolver_pretend_running_on_gcp")
+      args_.GetBool("grpc.testing.google_c2p_resolver_pretend_running_on_gcp")
           .value_or(false);
   const bool running_on_gcp =
       test_only_pretend_running_on_gcp || grpc_alts_is_running_on_gcp();
@@ -120,28 +122,27 @@ GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
     using_dns_ = true;
     child_resolver_ =
         CoreConfiguration::Get().resolver_registry().CreateResolver(
-            absl::StrCat("dns:", name_to_resolve), args.args, args.pollset_set,
+            absl::StrCat("dns:", name_to_resolve), args_, args.pollset_set,
             work_serializer_, std::move(args.result_handler));
-    CHECK(child_resolver_ != nullptr);
+    GRPC_CHECK(child_resolver_ != nullptr);
     return;
   }
   // Maybe override metadata server name for testing
   std::optional<std::string> test_only_metadata_server_override =
-      args.args.GetOwnedString(
+      args_.GetOwnedString(
           "grpc.testing.google_c2p_resolver_metadata_server_override");
   if (test_only_metadata_server_override.has_value() &&
       !test_only_metadata_server_override->empty()) {
     metadata_server_name_ = std::move(*test_only_metadata_server_override);
   }
   // Create xds resolver.
-  std::string xds_uri =
-      federation_enabled
-          ? absl::StrCat("xds://", kC2PAuthority, "/", name_to_resolve)
-          : absl::StrCat("xds:", name_to_resolve);
+  xds_uri_ = federation_enabled
+                 ? absl::StrCat("xds://", kC2PAuthority, "/", name_to_resolve)
+                 : absl::StrCat("xds:", name_to_resolve);
   child_resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(
-      xds_uri, args.args, args.pollset_set, work_serializer_,
+      xds_uri_, args_, args.pollset_set, work_serializer_,
       std::move(args.result_handler));
-  CHECK(child_resolver_ != nullptr);
+  GRPC_CHECK(child_resolver_ != nullptr);
 }
 
 void GoogleCloud2ProdResolver::StartLocked() {
@@ -162,22 +163,6 @@ void GoogleCloud2ProdResolver::StartLocked() {
         });
       },
       Duration::Seconds(10));
-  ipv6_query_ = MakeOrphanable<GcpMetadataQuery>(
-      metadata_server_name_, std::string(GcpMetadataQuery::kIPv6Attribute),
-      &pollent_,
-      [resolver = RefAsSubclass<GoogleCloud2ProdResolver>()](
-          std::string /* attribute */,
-          absl::StatusOr<std::string> result) mutable {
-        resolver->work_serializer_->Run(
-            [resolver, result = std::move(result)]() {
-              // Check that the payload is non-empty in order to work around
-              // the fact that there are buggy implementations of metadata
-              // servers in the wild, which can in some cases return 200
-              // plus an empty result when they should have returned 404.
-              resolver->IPv6QueryDone(result.ok() && !result->empty());
-            });
-      },
-      Duration::Seconds(10));
 }
 
 void GoogleCloud2ProdResolver::RequestReresolutionLocked() {
@@ -195,26 +180,17 @@ void GoogleCloud2ProdResolver::ResetBackoffLocked() {
 void GoogleCloud2ProdResolver::ShutdownLocked() {
   shutdown_ = true;
   zone_query_.reset();
-  ipv6_query_.reset();
   child_resolver_.reset();
 }
 
 void GoogleCloud2ProdResolver::ZoneQueryDone(std::string zone) {
   zone_query_.reset();
   zone_ = std::move(zone);
-  if (supports_ipv6_.has_value()) StartXdsResolver();
-}
-
-void GoogleCloud2ProdResolver::IPv6QueryDone(bool ipv6_supported) {
-  ipv6_query_.reset();
-  supports_ipv6_ = ipv6_supported;
-  if (zone_.has_value()) StartXdsResolver();
+  StartXdsResolver();
 }
 
-void GoogleCloud2ProdResolver::StartXdsResolver() {
-  if (shutdown_) {
-    return;
-  }
+std::shared_ptr<GrpcXdsBootstrap> GoogleCloud2ProdResolver::ConstructBootstrap()
+    const {
   // Construct bootstrap JSON.
   std::random_device rd;
   std::mt19937 mt(rd());
@@ -222,16 +198,15 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
   Json::Object node = {
       {"id", Json::FromString(absl::StrCat("C2P-", dist(mt)))},
   };
-  if (!zone_->empty()) {
+  if (!zone_.empty()) {
     node["locality"] = Json::FromObject({
-        {"zone", Json::FromString(*zone_)},
+        {"zone", Json::FromString(zone_)},
     });
   };
-  if (*supports_ipv6_) {
-    node["metadata"] = Json::FromObject({
-        {"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", Json::FromBool(true)},
-    });
-  }
+  // Enable dualstack endpoints from TD
+  node["metadata"] = Json::FromObject({
+      {"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", Json::FromBool(true)},
+  });
   // Allow the TD server uri to be overridden for testing purposes.
   auto override_server =
       GetEnv("GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI");
@@ -262,8 +237,20 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
        })},
       {"node", Json::FromObject(std::move(node))},
   });
-  // Inject bootstrap JSON as fallback config.
-  internal::SetXdsFallbackBootstrapConfig(JsonDump(bootstrap).c_str());
+  return GrpcXdsBootstrap::Create(JsonDump(bootstrap)).value();
+}
+
+void GoogleCloud2ProdResolver::StartXdsResolver() {
+  if (shutdown_) return;
+  // Create XdsClient here with a custom bootstrap for C2P.  When the
+  // xds resolver calls GrpcXdsClient::GetOrCreate(), it will get back
+  // the same instance rather than creating one with the normal
+  // bootstrap config from env vars.
+  static NoDestruct<std::shared_ptr<GrpcXdsBootstrap>> bootstrap(
+      ConstructBootstrap());
+  auto xds_client = GrpcXdsClient::GetOrCreate(
+      xds_uri_, args_, "google-c2p resolver", *bootstrap);
+  args_ = ChannelArgs();  // Don't need the args anymore.
   // Now start xDS resolver.
   child_resolver_->StartLocked();
 }

data/src/core/resolver/polling_resolver.cc

@@ -24,7 +24,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -36,6 +35,7 @@
 #include "src/core/service_config/service_config.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/uri.h"
 #include "src/core/util/work_serializer.h"
@@ -164,7 +164,7 @@ void PollingResolver::OnRequestCompleteLocked(Result result) {
                   : result.service_config.status().ToString())
           << ", resolution_note=" << result.resolution_note;
     }
-    CHECK(result.result_health_callback == nullptr);
+    GRPC_CHECK(result.result_health_callback == nullptr);
     result.result_health_callback =
         [self = RefAsSubclass<PollingResolver>(
              DEBUG_LOCATION, "result_health_callback")](absl::Status status) {
@@ -194,7 +194,7 @@ void PollingResolver::GetResultStatus(absl::Status status) {
   } else {
     // Set up for retry.
     const Duration delay = backoff_.NextAttemptDelay();
-    CHECK(!next_resolution_timer_handle_.has_value());
+    GRPC_CHECK(!next_resolution_timer_handle_.has_value());
     if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
       LOG(INFO) << "[polling resolver " << this << "] retrying in "
                 << delay.millis() << " ms";

data/src/core/resolver/resolver_registry.cc

@@ -18,13 +18,13 @@
 
 #include <grpc/support/port_platform.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 "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -51,10 +51,11 @@ bool IsLowerCase(absl::string_view str) {
 
 void ResolverRegistry::Builder::RegisterResolverFactory(
     std::unique_ptr<ResolverFactory> factory) {
-  CHECK(IsLowerCase(factory->scheme())) << factory->scheme();
+  GRPC_CHECK(IsLowerCase(factory->scheme())) << factory->scheme();
   auto [_, inserted] =
       state_.factories.try_emplace(factory->scheme(), std::move(factory));
-  CHECK(inserted) << "scheme " << factory->scheme() << " already registered";
+  GRPC_CHECK(inserted) << "scheme " << factory->scheme()
+                       << " already registered";
 }
 
 bool ResolverRegistry::Builder::HasResolverFactory(
@@ -132,7 +133,7 @@ ResolverFactory* ResolverRegistry::LookupResolverFactory(
 // point to the parsed URI.
 ResolverFactory* ResolverRegistry::FindResolverFactory(
     absl::string_view target, URI* uri, std::string* canonical_target) const {
-  CHECK_NE(uri, nullptr);
+  GRPC_CHECK_NE(uri, nullptr);
   absl::StatusOr<URI> tmp_uri = URI::Parse(target);
   ResolverFactory* factory =
       tmp_uri.ok() ? LookupResolverFactory(tmp_uri->scheme()) : nullptr;

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

@@ -18,12 +18,12 @@
 
 #include <set>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_join.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/load_balancing/xds/xds_channel_args.h"
 #include "src/core/resolver/fake/fake_resolver.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
 #include "src/core/xds/grpc/xds_cluster_parser.h"
 #include "src/core/xds/grpc/xds_endpoint_parser.h"
@@ -608,9 +608,9 @@ void XdsDependencyManager::PopulateDnsUpdate(const std::string& dns_name,
     std::vector<grpc_resolved_address> addresses;
     ChannelArgs address_args = result.addresses->front().args();
     for (const auto& address : *result.addresses) {
-      CHECK_EQ(address.addresses().size(), 1UL);
+      GRPC_CHECK_EQ(address.addresses().size(), 1UL);
       addresses.emplace_back(address.addresses().front());
-      CHECK_EQ(address_args, address.args());
+      GRPC_CHECK_EQ(address_args, address.args());
     }
     locality.endpoints.emplace_back(
         std::move(addresses),
@@ -659,8 +659,8 @@ bool XdsDependencyManager::PopulateClusterConfigMap(
     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);
+    GRPC_CHECK_NE(leaf_clusters, nullptr);
+    GRPC_CHECK_NE(resolution_notes, nullptr);
   }
   if (depth == kMaxXdsAggregateClusterRecursionDepth) {
     *leaf_clusters =

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

@@ -32,7 +32,6 @@
 #include <variant>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
@@ -75,6 +74,7 @@
 #include "src/core/service_config/service_config_impl.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/dual_ref_counted.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
@@ -627,7 +627,7 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
     const XdsHttpFilterImpl* filter_impl =
         http_filter_registry.GetFilterForType(
             http_filter.config.config_proto_type_name);
-    CHECK_NE(filter_impl, nullptr);
+    GRPC_CHECK_NE(filter_impl, nullptr);
     // Add filter to list.
     filters_.push_back(filter_impl);
   }
@@ -667,7 +667,7 @@ std::optional<uint64_t> HeaderHashHelper(
 absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
     GetCallConfigArgs args) {
   Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
-  CHECK_NE(path, nullptr);
+  GRPC_CHECK_NE(path, nullptr);
   auto* entry = route_config_data_->GetRouteForRequest(path->as_string_view(),
                                                        args.initial_metadata);
   if (entry == nullptr) {
@@ -715,7 +715,7 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
           }
         }
         if (index == 0) index = start_index;
-        CHECK(entry->weighted_cluster_state[index].range_end > key);
+        GRPC_CHECK(entry->weighted_cluster_state[index].range_end > key);
         cluster_name = absl::StrCat(
             "cluster:", entry->weighted_cluster_state[index].cluster);
         method_config = entry->weighted_cluster_state[index].method_config;
@@ -729,7 +729,7 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
         method_config = entry->method_config;
       });
   auto cluster = route_config_data_->FindClusterRef(cluster_name);
-  CHECK(cluster != nullptr);
+  GRPC_CHECK(cluster != nullptr);
   // Generate a hash.
   std::optional<uint64_t> hash;
   for (const auto& hash_policy : route_action->hash_policies) {
@@ -781,7 +781,7 @@ void XdsResolver::XdsConfigSelector::AddFilters(
     Blackboard* new_blackboard) {
   const auto& hcm =
       std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
-  CHECK_EQ(filters_.size(), hcm.http_filters.size());
+  GRPC_CHECK_EQ(filters_.size(), hcm.http_filters.size());
   for (size_t i = 0; i < filters_.size(); ++i) {
     auto* filter = filters_[i];
     filter->AddFilter(builder);
@@ -796,7 +796,7 @@ XdsResolver::XdsConfigSelector::GetFilters(const Blackboard* old_blackboard,
                                            Blackboard* new_blackboard) {
   const auto& hcm =
       std::get<XdsListenerResource::HttpConnectionManager>(listener_->listener);
-  CHECK_EQ(filters_.size(), hcm.http_filters.size());
+  GRPC_CHECK_EQ(filters_.size(), hcm.http_filters.size());
   std::vector<const grpc_channel_filter*> filters;
   for (size_t i = 0; i < filters_.size(); ++i) {
     auto* filter = filters_[i];
@@ -863,7 +863,7 @@ void XdsResolver::ClusterSelectionFilter::Call::OnClientInitialMetadata(
     ClientMetadata&) {
   auto* service_config_call_data =
       GetContext<ClientChannelServiceConfigCallData>();
-  CHECK_NE(service_config_call_data, nullptr);
+  GRPC_CHECK_NE(service_config_call_data, nullptr);
   auto* route_state_attribute = static_cast<XdsRouteStateAttributeImpl*>(
       service_config_call_data->GetCallAttribute<XdsRouteStateAttribute>());
   auto* cluster_name_attribute =
@@ -1068,7 +1068,7 @@ void XdsResolver::GenerateErrorResult(std::string error) {
   Result result;
   result.addresses.emplace();
   result.service_config = ServiceConfigImpl::Create(args_, "{}");
-  CHECK(result.service_config.ok());
+  GRPC_CHECK(result.service_config.ok());
   result.resolution_note = std::move(error);
   result.args = args_;
   result_handler_->ReportResult(std::move(result));