grpc 1.63.0 → 1.66.0

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

@@ -29,6 +29,7 @@
 #include <ares.h>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
@@ -37,10 +38,7 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
-#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/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
@@ -49,6 +47,9 @@
 #include "src/core/lib/iomgr/tcp_windows.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
+#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/string.h"
 
 // TODO(apolcyn): remove this hack after fixing upstream.
 // Our grpc/c-ares code on Windows uses the ares_set_socket_functions API,
@@ -136,8 +137,8 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
                          GetName(), shutdown_called_);
     CSliceUnref(read_buf_);
     CSliceUnref(write_buf_);
-    GPR_ASSERT(read_closure_ == nullptr);
-    GPR_ASSERT(write_closure_ == nullptr);
+    CHECK_EQ(read_closure_, nullptr);
+    CHECK_EQ(write_closure_, nullptr);
     if (!shutdown_called_) {
       // This can happen if the socket was never seen by grpc ares wrapper
       // code, i.e. if we never started I/O polling on it.
@@ -157,16 +158,16 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
   }
 
   void RegisterForOnReadableLocked(grpc_closure* read_closure) override {
-    GPR_ASSERT(read_closure_ == nullptr);
+    CHECK_EQ(read_closure_, nullptr);
     read_closure_ = read_closure;
-    GPR_ASSERT(GRPC_SLICE_LENGTH(read_buf_) == 0);
+    CHECK_EQ(GRPC_SLICE_LENGTH(read_buf_), 0);
     CSliceUnref(read_buf_);
-    GPR_ASSERT(!read_buf_has_data_);
+    CHECK(!read_buf_has_data_);
     read_buf_ = GRPC_SLICE_MALLOC(4192);
     if (connect_done_) {
       ContinueRegisterForOnReadableLocked();
     } else {
-      GPR_ASSERT(pending_continue_register_for_on_readable_locked_ == false);
+      CHECK(pending_continue_register_for_on_readable_locked_ == false);
       pending_continue_register_for_on_readable_locked_ = true;
     }
   }
@@ -176,7 +177,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
         "fd:|%s| ContinueRegisterForOnReadableLocked "
         "wsa_connect_error_:%d",
         GetName(), wsa_connect_error_);
-    GPR_ASSERT(connect_done_);
+    CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullReadClosure(GRPC_WSA_ERROR(wsa_connect_error_, "connect"));
       return;
@@ -212,16 +213,16 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
       GRPC_CARES_TRACE_LOG("fd:|%s| RegisterForOnWriteableLocked called",
                            GetName());
     } else {
-      GPR_ASSERT(socket_type_ == SOCK_STREAM);
+      CHECK(socket_type_ == SOCK_STREAM);
       GRPC_CARES_TRACE_LOG(
           "fd:|%s| RegisterForOnWriteableLocked called tcp_write_state_: %d "
           "connect_done_: %d",
           GetName(), tcp_write_state_, connect_done_);
     }
-    GPR_ASSERT(write_closure_ == nullptr);
+    CHECK_EQ(write_closure_, nullptr);
     write_closure_ = write_closure;
     if (!connect_done_) {
-      GPR_ASSERT(!pending_continue_register_for_on_writeable_locked_);
+      CHECK(!pending_continue_register_for_on_writeable_locked_);
       pending_continue_register_for_on_writeable_locked_ = true;
       // Register an async OnTcpConnect callback here rather than when the
       // connect was initiated, since we are now guaranteed to hold a ref of the
@@ -237,7 +238,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
         "fd:|%s| ContinueRegisterForOnWriteableLocked "
         "wsa_connect_error_:%d",
         GetName(), wsa_connect_error_);
-    GPR_ASSERT(connect_done_);
+    CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullWriteClosure(
           GRPC_WSA_ERROR(wsa_connect_error_, "connect"));
@@ -246,7 +247,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
     if (socket_type_ == SOCK_DGRAM) {
       ScheduleAndNullWriteClosure(absl::OkStatus());
     } else {
-      GPR_ASSERT(socket_type_ == SOCK_STREAM);
+      CHECK(socket_type_ == SOCK_STREAM);
       int wsa_error_code = 0;
       switch (tcp_write_state_) {
         case WRITE_IDLE:
@@ -272,7 +273,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
   bool IsFdStillReadableLocked() override { return read_buf_has_data_; }
 
   void ShutdownLocked(grpc_error_handle /* error */) override {
-    GPR_ASSERT(!shutdown_called_);
+    CHECK(!shutdown_called_);
     shutdown_called_ = true;
     on_shutdown_locked_();
     grpc_winsocket_shutdown(winsocket_);
@@ -308,7 +309,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
     // c-ares overloads this recv_from virtual socket function to receive
     // data on both UDP and TCP sockets, and from is nullptr for TCP.
     if (from != nullptr) {
-      GPR_ASSERT(*from_len <= recv_from_source_addr_len_);
+      CHECK(*from_len <= recv_from_source_addr_len_);
       memcpy(from, &recv_from_source_addr_, recv_from_source_addr_len_);
       *from_len = recv_from_source_addr_len_;
     }
@@ -377,7 +378,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
     // Therefore, the sendv handler for UDP sockets must only attempt
     // to write everything inline.
     GRPC_CARES_TRACE_LOG("fd:|%s| SendVUDP called", GetName());
-    GPR_ASSERT(GRPC_SLICE_LENGTH(write_buf_) == 0);
+    CHECK_EQ(GRPC_SLICE_LENGTH(write_buf_), 0);
     CSliceUnref(write_buf_);
     write_buf_ = FlattenIovec(iov, iov_count);
     DWORD bytes_sent = 0;
@@ -410,7 +411,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
     switch (tcp_write_state_) {
       case WRITE_IDLE:
         tcp_write_state_ = WRITE_REQUESTED;
-        GPR_ASSERT(GRPC_SLICE_LENGTH(write_buf_) == 0);
+        CHECK_EQ(GRPC_SLICE_LENGTH(write_buf_), 0);
         CSliceUnref(write_buf_);
         write_buf_ = FlattenIovec(iov, iov_count);
         wsa_error_ctx->SetWSAError(WSAEWOULDBLOCK);
@@ -426,12 +427,12 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
         // send again. If c-ares still needs to send even more data, we'll get
         // to it eventually.
         grpc_slice currently_attempted = FlattenIovec(iov, iov_count);
-        GPR_ASSERT(GRPC_SLICE_LENGTH(currently_attempted) >=
-                   GRPC_SLICE_LENGTH(write_buf_));
+        CHECK(GRPC_SLICE_LENGTH(currently_attempted) >=
+              GRPC_SLICE_LENGTH(write_buf_));
         ares_ssize_t total_sent = 0;
         for (size_t i = 0; i < GRPC_SLICE_LENGTH(write_buf_); i++) {
-          GPR_ASSERT(GRPC_SLICE_START_PTR(currently_attempted)[i] ==
-                     GRPC_SLICE_START_PTR(write_buf_)[i]);
+          CHECK(GRPC_SLICE_START_PTR(currently_attempted)[i] ==
+                GRPC_SLICE_START_PTR(write_buf_)[i]);
           total_sent++;
         }
         CSliceUnref(currently_attempted);
@@ -456,9 +457,9 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
         GetName(), StatusToString(error).c_str(),
         pending_continue_register_for_on_readable_locked_,
         pending_continue_register_for_on_writeable_locked_);
-    GPR_ASSERT(!connect_done_);
+    CHECK(!connect_done_);
     connect_done_ = true;
-    GPR_ASSERT(wsa_connect_error_ == 0);
+    CHECK_EQ(wsa_connect_error_, 0);
     if (!error.ok() || shutdown_called_) {
       wsa_connect_error_ = WSA_OPERATION_ABORTED;
     } else {
@@ -468,7 +469,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
           WSAGetOverlappedResult(grpc_winsocket_wrapped_socket(winsocket_),
                                  &winsocket_->write_info.overlapped,
                                  &transferred_bytes, FALSE, &flags);
-      GPR_ASSERT(transferred_bytes == 0);
+      CHECK_EQ(transferred_bytes, 0);
       if (!wsa_success) {
         wsa_connect_error_ = WSAGetLastError();
         char* msg = gpr_format_message(wsa_connect_error_);
@@ -502,8 +503,8 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
   int ConnectUDP(WSAErrorContext* wsa_error_ctx, const struct sockaddr* target,
                  ares_socklen_t target_len) {
     GRPC_CARES_TRACE_LOG("fd:%s ConnectUDP", GetName());
-    GPR_ASSERT(!connect_done_);
-    GPR_ASSERT(wsa_connect_error_ == 0);
+    CHECK(!connect_done_);
+    CHECK_EQ(wsa_connect_error_, 0);
     SOCKET s = grpc_winsocket_wrapped_socket(winsocket_);
     int out =
         WSAConnect(s, target, target_len, nullptr, nullptr, nullptr, nullptr);
@@ -639,7 +640,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
 
   void OnIocpWriteableLocked(grpc_error_handle error) {
     GRPC_CARES_TRACE_LOG("OnIocpWriteableInner. fd:|%s|", GetName());
-    GPR_ASSERT(socket_type_ == SOCK_STREAM);
+    CHECK(socket_type_ == SOCK_STREAM);
     if (error.ok()) {
       if (winsocket_->write_info.wsa_error != 0) {
         error = GRPC_WSA_ERROR(winsocket_->write_info.wsa_error,
@@ -651,7 +652,7 @@ class GrpcPolledFdWindows final : public GrpcPolledFd {
             StatusToString(error).c_str());
       }
     }
-    GPR_ASSERT(tcp_write_state_ == WRITE_PENDING);
+    CHECK(tcp_write_state_ == WRITE_PENDING);
     if (error.ok()) {
       tcp_write_state_ = WRITE_WAITING_FOR_VERIFICATION_UPON_RETRY;
       write_buf_ = grpc_slice_sub_no_ref(
@@ -710,7 +711,7 @@ class GrpcPolledFdFactoryWindows final : public GrpcPolledFdFactory {
   GrpcPolledFd* NewGrpcPolledFdLocked(
       ares_socket_t as, grpc_pollset_set* /* driver_pollset_set */) override {
     auto it = sockets_.find(as);
-    GPR_ASSERT(it != sockets_.end());
+    CHECK(it != sockets_.end());
     return it->second;
   }
 
@@ -757,7 +758,7 @@ class GrpcPolledFdFactoryWindows final : public GrpcPolledFdFactory {
     GRPC_CARES_TRACE_LOG(
         "fd:|%s| created with params af:%d type:%d protocol:%d",
         polled_fd->GetName(), af, type, protocol);
-    GPR_ASSERT(self->sockets_.insert({s, polled_fd}).second);
+    CHECK(self->sockets_.insert({s, polled_fd}).second);
     return s;
   }
 
@@ -767,7 +768,7 @@ class GrpcPolledFdFactoryWindows final : public GrpcPolledFdFactory {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    GPR_ASSERT(it != self->sockets_.end());
+    CHECK(it != self->sockets_.end());
     return it->second->Connect(&wsa_error_ctx, target, target_len);
   }
 
@@ -777,7 +778,7 @@ class GrpcPolledFdFactoryWindows final : public GrpcPolledFdFactory {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    GPR_ASSERT(it != self->sockets_.end());
+    CHECK(it != self->sockets_.end());
     return it->second->SendV(&wsa_error_ctx, iov, iovec_count);
   }
 
@@ -788,7 +789,7 @@ class GrpcPolledFdFactoryWindows final : public GrpcPolledFdFactory {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    GPR_ASSERT(it != self->sockets_.end());
+    CHECK(it != self->sockets_.end());
     return it->second->RecvFrom(&wsa_error_ctx, data, data_len, flags, from,
                                 from_len);
   }

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

@@ -16,14 +16,13 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <algorithm>
 #include <vector>
 
 #include "absl/strings/string_view.h"
 
 #include <grpc/impl/channel_arg_names.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -47,22 +46,20 @@
 #include <address_sorting/address_sorting.h>
 #include <ares.h>
 
+#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/str_format.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
-#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/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/time.h"
@@ -71,15 +68,13 @@
 #include "src/core/lib/iomgr/nameser.h"  // IWYU pragma: keep
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/timer.h"
+#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/string.h"
 
 using grpc_core::EndpointAddresses;
 using grpc_core::EndpointAddressesList;
 
-grpc_core::TraceFlag grpc_trace_cares_address_sorting(false,
-                                                      "cares_address_sorting");
-
-grpc_core::TraceFlag grpc_trace_cares_resolver(false, "cares_resolver");
-
 typedef struct fd_node {
   // default constructor exists only for linked list manipulation
   fd_node() : ev_driver(nullptr) {}
@@ -205,7 +200,7 @@ static void grpc_ares_ev_driver_unref(grpc_ares_ev_driver* ev_driver)
   if (gpr_unref(&ev_driver->refs)) {
     GRPC_CARES_TRACE_LOG("request:%p destroy ev_driver %p", ev_driver->request,
                          ev_driver);
-    GPR_ASSERT(ev_driver->fds == nullptr);
+    CHECK_EQ(ev_driver->fds, nullptr);
     ares_destroy(ev_driver->channel);
     grpc_ares_complete_request_locked(ev_driver->request);
     delete ev_driver;
@@ -216,9 +211,9 @@ static void fd_node_destroy_locked(fd_node* fdn)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(&grpc_ares_request::mu) {
   GRPC_CARES_TRACE_LOG("request:%p delete fd: %s", fdn->ev_driver->request,
                        fdn->grpc_polled_fd->GetName());
-  GPR_ASSERT(!fdn->readable_registered);
-  GPR_ASSERT(!fdn->writable_registered);
-  GPR_ASSERT(fdn->already_shutdown);
+  CHECK(!fdn->readable_registered);
+  CHECK(!fdn->writable_registered);
+  CHECK(fdn->already_shutdown);
   delete fdn->grpc_polled_fd;
   delete fdn;
 }
@@ -358,7 +353,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);
-  GPR_ASSERT(fdn->readable_registered);
+  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;
@@ -382,7 +377,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);
-  GPR_ASSERT(fdn->writable_registered);
+  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;
@@ -560,18 +555,17 @@ static void log_address_sorting_list(const grpc_ares_request* r,
                                      const char* input_output_str) {
   for (size_t i = 0; i < addresses.size(); i++) {
     auto addr_str = grpc_sockaddr_to_string(&addresses[i].address(), true);
-    gpr_log(GPR_INFO,
-            "(c-ares resolver) request:%p c-ares address sorting: %s[%" PRIuPTR
-            "]=%s",
-            r, input_output_str, i,
-            addr_str.ok() ? addr_str->c_str()
-                          : addr_str.status().ToString().c_str());
+    LOG(INFO) << "(c-ares resolver) request:" << r
+              << " c-ares address sorting: " << input_output_str << "[" << i
+              << "]="
+              << (addr_str.ok() ? addr_str->c_str()
+                                : addr_str.status().ToString().c_str());
   }
 }
 
 void grpc_cares_wrapper_address_sorting_sort(const grpc_ares_request* r,
                                              EndpointAddressesList* addresses) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_cares_address_sorting)) {
+  if (GRPC_TRACE_FLAG_ENABLED(cares_address_sorting)) {
     log_address_sorting_list(r, *addresses, "input");
   }
   address_sorting_sortable* sortables = static_cast<address_sorting_sortable*>(
@@ -591,7 +585,7 @@ void grpc_cares_wrapper_address_sorting_sort(const grpc_ares_request* r,
   }
   gpr_free(sortables);
   *addresses = std::move(sorted);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_cares_address_sorting)) {
+  if (GRPC_TRACE_FLAG_ENABLED(cares_address_sorting)) {
     log_address_sorting_list(r, *addresses, "output");
   }
 }
@@ -883,14 +877,11 @@ grpc_error_handle grpc_dns_lookup_ares_continued(
   grpc_core::SplitHostPort(name, host, port);
   if (host->empty()) {
     error =
-        grpc_error_set_str(GRPC_ERROR_CREATE("unparseable host:port"),
-                           grpc_core::StatusStrProperty::kTargetAddress, name);
+        GRPC_ERROR_CREATE(absl::StrCat("unparseable host:port \"", name, "\""));
     return error;
   } else if (check_port && port->empty()) {
     if (default_port == nullptr || strlen(default_port) == 0) {
-      error = grpc_error_set_str(GRPC_ERROR_CREATE("no port in name"),
-                                 grpc_core::StatusStrProperty::kTargetAddress,
-                                 name);
+      error = GRPC_ERROR_CREATE(absl::StrCat("no port in name \"", name, "\""));
       return error;
     }
     *port = default_port;
@@ -908,18 +899,14 @@ static bool inner_resolve_as_ip_literal_locked(
     std::unique_ptr<grpc_core::EndpointAddressesList>* addrs, std::string* host,
     std::string* port, std::string* hostport) {
   if (!grpc_core::SplitHostPort(name, host, port)) {
-    gpr_log(GPR_ERROR,
-            "Failed to parse %s to host:port while attempting to resolve as ip "
-            "literal.",
-            name);
+    LOG(ERROR) << "Failed to parse " << name
+               << " to host:port while attempting to resolve as ip literal.";
     return false;
   }
   if (port->empty()) {
     if (default_port == nullptr || strlen(default_port) == 0) {
-      gpr_log(GPR_ERROR,
-              "No port or default port for %s while attempting to resolve as "
-              "ip literal.",
-              name);
+      LOG(ERROR) << "No port or default port for " << name
+                 << " while attempting to resolve as ip literal.";
       return false;
     }
     *port = default_port;
@@ -930,7 +917,7 @@ static bool inner_resolve_as_ip_literal_locked(
                                false /* log errors */) ||
       grpc_parse_ipv6_hostport(hostport->c_str(), &addr,
                                false /* log errors */)) {
-    GPR_ASSERT(*addrs == nullptr);
+    CHECK(*addrs == nullptr);
     *addrs = std::make_unique<EndpointAddressesList>();
     (*addrs)->emplace_back(addr, grpc_core::ChannelArgs());
     return true;
@@ -952,7 +939,7 @@ static bool resolve_as_ip_literal_locked(
 static bool target_matches_localhost_inner(const char* name, std::string* host,
                                            std::string* port) {
   if (!grpc_core::SplitHostPort(name, host, port)) {
-    gpr_log(GPR_ERROR, "Unable to split host and port for name: %s", name);
+    LOG(ERROR) << "Unable to split host and port for name: " << name;
     return false;
   }
   return gpr_stricmp(host->c_str(), "localhost") == 0;
@@ -971,24 +958,20 @@ static bool inner_maybe_resolve_localhost_manually_locked(
     std::string* port) {
   grpc_core::SplitHostPort(name, host, port);
   if (host->empty()) {
-    gpr_log(GPR_ERROR,
-            "Failed to parse %s into host:port during manual localhost "
-            "resolution check.",
-            name);
+    LOG(ERROR) << "Failed to parse " << name
+               << " into host:port during manual localhost resolution check.";
     return false;
   }
   if (port->empty()) {
     if (default_port == nullptr || strlen(default_port) == 0) {
-      gpr_log(GPR_ERROR,
-              "No port or default port for %s during manual localhost "
-              "resolution check.",
-              name);
+      LOG(ERROR) << "No port or default port for " << name
+                 << " during manual localhost resolution check.";
       return false;
     }
     *port = default_port;
   }
   if (gpr_stricmp(host->c_str(), "localhost") == 0) {
-    GPR_ASSERT(*addrs == nullptr);
+    CHECK(*addrs == nullptr);
     *addrs = std::make_unique<grpc_core::EndpointAddressesList>();
     uint16_t numeric_port = grpc_strhtons(port->c_str());
     grpc_resolved_address address;
@@ -1185,7 +1168,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) {
-  GPR_ASSERT(r != nullptr);
+  CHECK_NE(r, nullptr);
   grpc_core::MutexLock lock(&r->mu);
   GRPC_CARES_TRACE_LOG("request:%p grpc_cancel_ares_request ev_driver:%p", r,
                        r->ev_driver);

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
 #define GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <memory>
@@ -28,8 +26,9 @@
 #include <ares.h>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -40,15 +39,11 @@
 
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
-extern grpc_core::TraceFlag grpc_trace_cares_address_sorting;
-
-extern grpc_core::TraceFlag grpc_trace_cares_resolver;
-
-#define GRPC_CARES_TRACE_LOG(format, ...)                           \
-  do {                                                              \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_cares_resolver)) {       \
-      gpr_log(GPR_DEBUG, "(c-ares resolver) " format, __VA_ARGS__); \
-    }                                                               \
+#define GRPC_CARES_TRACE_LOG(format, ...)                                      \
+  do {                                                                         \
+    if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {                             \
+      VLOG(2) << "(c-ares resolver) " << absl::StrFormat(format, __VA_ARGS__); \
+    }                                                                          \
   } while (0)
 
 typedef struct grpc_ares_ev_driver grpc_ares_ev_driver;

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

@@ -21,8 +21,8 @@
 #include "src/core/lib/iomgr/port.h"
 #if GRPC_ARES == 1 && defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER)
 
-#include "src/core/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
+#include "src/core/resolver/dns/c_ares/grpc_ares_wrapper.h"
 
 bool grpc_ares_query_ipv6() { return grpc_ipv6_loopback_available(); }
 

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

@@ -24,11 +24,11 @@
 
 #include <grpc/support/string_util.h>
 
-#include "src/core/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/socket_windows.h"
+#include "src/core/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/resolver/endpoint_addresses.h"
+#include "src/core/util/string.h"
 
 bool grpc_ares_query_ipv6() { return grpc_ipv6_loopback_available(); }
 

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

@@ -11,36 +11,36 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#include <grpc/support/port_platform.h>
-
 #include "src/core/resolver/dns/dns_resolver_plugin.h"
 
 #include <memory>
 
+#include "absl/log/log.h"
 #include "absl/strings/match.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/resolver/dns/c_ares/dns_resolver_ares.h"
-#include "src/core/resolver/dns/event_engine/event_engine_client_channel_resolver.h"
-#include "src/core/resolver/dns/native/dns_resolver.h"
 #include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/resolver/dns/c_ares/dns_resolver_ares.h"
+#include "src/core/resolver/dns/event_engine/event_engine_client_channel_resolver.h"
+#include "src/core/resolver/dns/native/dns_resolver.h"
 #include "src/core/resolver/resolver_factory.h"
 
 namespace grpc_core {
 
 void RegisterDnsResolver(CoreConfiguration::Builder* builder) {
-#ifdef GRPC_IOS_EVENT_ENGINE_CLIENT
-  gpr_log(GPR_DEBUG, "Using EventEngine dns resolver");
+#if GRPC_IOS_EVENT_ENGINE_CLIENT
+  VLOG(2) << "Using EventEngine dns resolver";
   builder->resolver_registry()->RegisterResolverFactory(
       std::make_unique<EventEngineClientChannelDNSResolverFactory>());
   return;
 #endif
 #ifndef GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER
   if (IsEventEngineDnsEnabled()) {
-    gpr_log(GPR_DEBUG, "Using EventEngine dns resolver");
+    VLOG(2) << "Using EventEngine dns resolver";
     builder->resolver_registry()->RegisterResolverFactory(
         std::make_unique<EventEngineClientChannelDNSResolverFactory>());
     return;
@@ -49,14 +49,14 @@ void RegisterDnsResolver(CoreConfiguration::Builder* builder) {
   auto resolver = ConfigVars::Get().DnsResolver();
   // ---- Ares resolver ----
   if (ShouldUseAresDnsResolver(resolver)) {
-    gpr_log(GPR_DEBUG, "Using ares dns resolver");
+    VLOG(2) << "Using ares dns resolver";
     RegisterAresDnsResolver(builder);
     return;
   }
   // ---- Native resolver ----
   if (absl::EqualsIgnoreCase(resolver, "native") ||
       !builder->resolver_registry()->HasResolverFactory("dns")) {
-    gpr_log(GPR_DEBUG, "Using native dns resolver");
+    VLOG(2) << "Using native dns resolver";
     RegisterNativeDnsResolver(builder);
     return;
   }