grpc 1.64.0 → 1.68.1

data/src/core/lib/event_engine/ares_resolver.cc

@@ -13,11 +13,11 @@
 // limitations under the License.
 #include "src/core/lib/event_engine/ares_resolver.h"
 
+#include <grpc/support/port_platform.h>
+
 #include <string>
 #include <vector>
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/port.h"
 
 // IWYU pragma: no_include <ares_version.h>
@@ -42,6 +42,7 @@
 #include "src/core/lib/event_engine/nameser.h"  // IWYU pragma: keep
 #endif
 
+#include <grpc/event_engine/event_engine.h>
 #include <string.h>
 
 #include <algorithm>
@@ -53,26 +54,24 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/types/optional.h"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
-
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/time_util.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/util/debug_location.h"
+#include "src/core/util/host_port.h"
+#include "src/core/util/orphanable.h"
+#include "src/core/util/ref_counted_ptr.h"
 #ifdef GRPC_POSIX_SOCKET_ARES_EV_DRIVER
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #endif
@@ -80,10 +79,13 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-grpc_core::TraceFlag grpc_trace_ares_resolver(false, "cares_resolver");
-
 namespace {
 
+// A hard limit on the number of records (A/AAAA or SRV) we may get from a
+// single response. This is to be defensive to prevent a bad DNS response from
+// OOMing the process.
+constexpr int kMaxRecordSize = 65536;
+
 absl::Status AresStatusToAbslStatus(int status, absl::string_view error_msg) {
   switch (status) {
     case ARES_ECANCELLED:
@@ -92,6 +94,8 @@ absl::Status AresStatusToAbslStatus(int status, absl::string_view error_msg) {
       return absl::UnimplementedError(error_msg);
     case ARES_ENOTFOUND:
       return absl::NotFoundError(error_msg);
+    case ARES_ECONNREFUSED:
+      return absl::UnavailableError(error_msg);
     default:
       return absl::UnknownError(error_msg);
   }
@@ -117,7 +121,8 @@ bool IsIpv6LoopbackAvailable() {
 
 absl::Status SetRequestDNSServer(absl::string_view dns_server,
                                  ares_channel* channel) {
-  GRPC_ARES_RESOLVER_TRACE_LOG("Using DNS server %s", dns_server.data());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) Using DNS server " << dns_server;
   grpc_resolved_address addr;
   struct ares_addr_port_node dns_server_addr = {};
   if (grpc_parse_ipv4_hostport(dns_server, &addr, /*log_errors=*/false)) {
@@ -200,7 +205,7 @@ AresResolver::CreateAresResolver(
   ares_channel channel;
   int status = ares_init_options(&channel, &opts, ARES_OPT_FLAGS);
   if (status != ARES_SUCCESS) {
-    gpr_log(GPR_ERROR, "ares_init_options failed, status: %d", status);
+    LOG(ERROR) << "ares_init_options failed, status: " << status;
     return AresStatusToAbslStatus(
         status,
         absl::StrCat("Failed to init c-ares channel: ", ares_strerror(status)));
@@ -221,8 +226,7 @@ AresResolver::AresResolver(
     std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
     std::shared_ptr<EventEngine> event_engine, ares_channel channel)
     : RefCountedDNSResolverInterface(
-          GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver) ? "AresResolver"
-                                                            : nullptr),
+          GRPC_TRACE_FLAG_ENABLED(cares_resolver) ? "AresResolver" : nullptr),
       channel_(channel),
       polled_fd_factory_(std::move(polled_fd_factory)),
       event_engine_(std::move(event_engine)) {
@@ -245,8 +249,9 @@ void AresResolver::Orphan() {
     }
     for (const auto& fd_node : fd_node_list_) {
       if (!fd_node->already_shutdown) {
-        GRPC_ARES_RESOLVER_TRACE_LOG("resolver: %p shutdown fd: %s", this,
-                                     fd_node->polled_fd->GetName());
+        GRPC_TRACE_LOG(cares_resolver, INFO)
+            << "(EventEngine c-ares resolver) resolver: " << this
+            << " shutdown fd: " << fd_node->polled_fd->GetName();
         CHECK(fd_node->polled_fd->ShutdownLocked(
             absl::CancelledError("AresResolver::Orphan")));
         fd_node->already_shutdown = true;
@@ -265,7 +270,7 @@ void AresResolver::LookupHostname(
     event_engine_->Run(
         [callback = std::move(callback),
          status = absl::InvalidArgumentError(absl::StrCat(
-             "Unparseable name: ", name))]() mutable { callback(status); });
+             "Unparsable name: ", name))]() mutable { callback(status); });
     return;
   }
   if (host.empty()) {
@@ -344,7 +349,7 @@ void AresResolver::LookupSRV(
     event_engine_->Run(
         [callback = std::move(callback),
          status = absl::InvalidArgumentError(absl::StrCat(
-             "Unparseable name: ", name))]() mutable { callback(status); });
+             "Unparsable name: ", name))]() mutable { callback(status); });
     return;
   }
   if (host.empty()) {
@@ -379,7 +384,7 @@ void AresResolver::LookupTXT(
     event_engine_->Run(
         [callback = std::move(callback),
          status = absl::InvalidArgumentError(absl::StrCat(
-             "Unparseable name: ", name))]() mutable { callback(status); });
+             "Unparsable name: ", name))]() mutable { callback(status); });
     return;
   }
   if (host.empty()) {
@@ -417,8 +422,9 @@ void AresResolver::CheckSocketsLocked() {
             fd_node_list_.begin(), fd_node_list_.end(),
             [sock = socks[i]](const auto& node) { return node->as == sock; });
         if (iter == fd_node_list_.end()) {
-          GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p new fd: %d", this,
-                                       socks[i]);
+          GRPC_TRACE_LOG(cares_resolver, INFO)
+              << "(EventEngine c-ares resolver) resolver:" << this
+              << " new fd: " << socks[i];
           new_list.push_back(std::make_unique<FdNode>(
               socks[i], polled_fd_factory_->NewGrpcPolledFdLocked(socks[i])));
         } else {
@@ -434,8 +440,9 @@ void AresResolver::CheckSocketsLocked() {
             // to cope with the edge-triggered poller not getting an event if no
             // new data arrives and c-ares hasn't read all the data in the
             // previous ares_process_fd.
-            GRPC_ARES_RESOLVER_TRACE_LOG(
-                "resolver:%p schedule read directly on: %d", this, fd_node->as);
+            GRPC_TRACE_LOG(cares_resolver, INFO)
+                << "(EventEngine c-ares resolver) resolver:" << this
+                << " schedule read directly on: " << fd_node->as;
             event_engine_->Run(
                 [self = Ref(DEBUG_LOCATION, "CheckSocketsLocked"),
                  fd_node]() mutable {
@@ -444,8 +451,9 @@ void AresResolver::CheckSocketsLocked() {
                 });
           } else {
             // Otherwise register with the poller for readable event.
-            GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p notify read on: %d", this,
-                                         fd_node->as);
+            GRPC_TRACE_LOG(cares_resolver, INFO)
+                << "(EventEngine c-ares resolver) resolver:" << this
+                << " notify read on: " << fd_node->as;
             fd_node->polled_fd->RegisterForOnReadableLocked(
                 [self = Ref(DEBUG_LOCATION, "CheckSocketsLocked"),
                  fd_node](absl::Status status) mutable {
@@ -458,8 +466,9 @@ void AresResolver::CheckSocketsLocked() {
         // has not been registered with this socket.
         if (ARES_GETSOCK_WRITABLE(socks_bitmask, i) &&
             !fd_node->writable_registered) {
-          GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p notify write on: %d", this,
-                                       fd_node->as);
+          GRPC_TRACE_LOG(cares_resolver, INFO)
+              << "(EventEngine c-ares resolver) resolver:" << this
+              << " notify write on: " << fd_node->as;
           fd_node->writable_registered = true;
           fd_node->polled_fd->RegisterForOnWriteableLocked(
               [self = Ref(DEBUG_LOCATION, "CheckSocketsLocked"),
@@ -481,14 +490,16 @@ void AresResolver::CheckSocketsLocked() {
   while (!fd_node_list_.empty()) {
     FdNode* fd_node = fd_node_list_.front().get();
     if (!fd_node->already_shutdown) {
-      GRPC_ARES_RESOLVER_TRACE_LOG("resolver: %p shutdown fd: %s", this,
-                                   fd_node->polled_fd->GetName());
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) resolver: " << this
+          << " shutdown fd: " << fd_node->polled_fd->GetName();
       fd_node->already_shutdown =
           fd_node->polled_fd->ShutdownLocked(absl::OkStatus());
     }
     if (!fd_node->readable_registered && !fd_node->writable_registered) {
-      GRPC_ARES_RESOLVER_TRACE_LOG("resolver: %p delete fd: %s", this,
-                                   fd_node->polled_fd->GetName());
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) resolver: " << this
+          << " delete fd: " << fd_node->polled_fd->GetName();
       fd_node_list_.pop_front();
     } else {
       new_list.splice(new_list.end(), fd_node_list_, fd_node_list_.begin());
@@ -502,9 +513,10 @@ void AresResolver::MaybeStartTimerLocked() {
     return;
   }
   // Initialize the backup poll alarm
-  GRPC_ARES_RESOLVER_TRACE_LOG(
-      "request:%p MaybeStartTimerLocked next ares process poll time in %zu ms",
-      this, Milliseconds(kAresBackupPollAlarmDuration));
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) request:" << this
+      << " MaybeStartTimerLocked next ares process poll time in "
+      << Milliseconds(kAresBackupPollAlarmDuration) << " ms";
   ares_backup_poll_alarm_handle_ = event_engine_->RunAfter(
       kAresBackupPollAlarmDuration,
       [self = Ref(DEBUG_LOCATION, "MaybeStartTimerLocked")]() {
@@ -516,8 +528,9 @@ void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
   CHECK(fd_node->readable_registered);
   fd_node->readable_registered = false;
-  GRPC_ARES_RESOLVER_TRACE_LOG("OnReadable: fd: %d; request: %p; status: %s",
-                               fd_node->as, this, status.ToString().c_str());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) OnReadable: fd: " << fd_node->as
+      << "; request: " << this << "; status: " << status;
   if (status.ok() && !shutting_down_) {
     ares_process_fd(channel_, fd_node->as, ARES_SOCKET_BAD);
   } else {
@@ -535,8 +548,9 @@ void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
   CHECK(fd_node->writable_registered);
   fd_node->writable_registered = false;
-  GRPC_ARES_RESOLVER_TRACE_LOG("OnWritable: fd: %d; request:%p; status: %s",
-                               fd_node->as, this, status.ToString().c_str());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) OnWritable: fd: " << fd_node->as
+      << "; request:" << this << "; status: " << status;
   if (status.ok() && !shutting_down_) {
     ares_process_fd(channel_, ARES_SOCKET_BAD, fd_node->as);
   } else {
@@ -561,15 +575,16 @@ void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
 void AresResolver::OnAresBackupPollAlarm() {
   grpc_core::MutexLock lock(&mutex_);
   ares_backup_poll_alarm_handle_.reset();
-  GRPC_ARES_RESOLVER_TRACE_LOG(
-      "request:%p OnAresBackupPollAlarm shutting_down=%d.", this,
-      shutting_down_);
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) request:" << this
+      << " OnAresBackupPollAlarm shutting_down=" << shutting_down_;
   if (!shutting_down_) {
     for (const auto& fd_node : fd_node_list_) {
       if (!fd_node->already_shutdown) {
-        GRPC_ARES_RESOLVER_TRACE_LOG(
-            "request:%p OnAresBackupPollAlarm; ares_process_fd. fd=%s", this,
-            fd_node->polled_fd->GetName());
+        GRPC_TRACE_LOG(cares_resolver, INFO)
+            << "(EventEngine c-ares resolver) request:" << this
+            << " OnAresBackupPollAlarm; ares_process_fd. fd="
+            << fd_node->polled_fd->GetName();
         ares_socket_t as = fd_node->polled_fd->GetWrappedAresSocketLocked();
         ares_process_fd(channel_, as, as);
       }
@@ -589,14 +604,20 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
     std::string error_msg =
         absl::StrFormat("address lookup failed for %s: %s",
                         hostname_qa->query_name, ares_strerror(status));
-    GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p OnHostbynameDoneLocked: %s",
-                                 ares_resolver, error_msg.c_str());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+        << " OnHostbynameDoneLocked: " << error_msg;
     hostname_qa->error_status = AresStatusToAbslStatus(status, error_msg);
   } else {
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "resolver:%p OnHostbynameDoneLocked name=%s ARES_SUCCESS",
-        ares_resolver, hostname_qa->query_name.c_str());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+        << " OnHostbynameDoneLocked name=" << hostname_qa->query_name
+        << " ARES_SUCCESS";
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; i++) {
+      if (hostname_qa->result.size() == kMaxRecordSize) {
+        LOG(ERROR) << "A/AAAA response exceeds maximum record size of 65536";
+        break;
+      }
       switch (hostent->h_addrtype) {
         case AF_INET6: {
           size_t addr_len = sizeof(struct sockaddr_in6);
@@ -610,10 +631,11 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
               reinterpret_cast<const sockaddr*>(&addr), addr_len);
           char output[INET6_ADDRSTRLEN];
           ares_inet_ntop(AF_INET6, &addr.sin6_addr, output, INET6_ADDRSTRLEN);
-          GRPC_ARES_RESOLVER_TRACE_LOG(
-              "resolver:%p c-ares resolver gets a AF_INET6 result: \n"
-              "  addr: %s\n  port: %d\n  sin6_scope_id: %d\n",
-              ares_resolver, output, hostname_qa->port, addr.sin6_scope_id);
+          GRPC_TRACE_LOG(cares_resolver, INFO)
+              << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+              << " c-ares resolver gets a AF_INET6 result: \n  addr: " << output
+              << "\n  port: " << hostname_qa->port
+              << "\n  sin6_scope_id: " << addr.sin6_scope_id;
           break;
         }
         case AF_INET: {
@@ -628,10 +650,10 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
               reinterpret_cast<const sockaddr*>(&addr), addr_len);
           char output[INET_ADDRSTRLEN];
           ares_inet_ntop(AF_INET, &addr.sin_addr, output, INET_ADDRSTRLEN);
-          GRPC_ARES_RESOLVER_TRACE_LOG(
-              "resolver:%p c-ares resolver gets a AF_INET result: \n"
-              "  addr: %s\n  port: %d\n",
-              ares_resolver, output, hostname_qa->port);
+          GRPC_TRACE_LOG(cares_resolver, INFO)
+              << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+              << " c-ares resolver gets a AF_INET result: \n  addr: " << output
+              << "\n  port: " << hostname_qa->port;
           break;
         }
         default:
@@ -679,8 +701,9 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   auto fail = [&](absl::string_view prefix) {
     std::string error_message = absl::StrFormat(
         "%s for %s: %s", prefix, qa->query_name, ares_strerror(status));
-    GRPC_ARES_RESOLVER_TRACE_LOG("OnSRVQueryDoneLocked: %s",
-                                 error_message.c_str());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) OnSRVQueryDoneLocked: "
+        << error_message;
     ares_resolver->event_engine_->Run(
         [callback = std::move(callback),
          status = AresStatusToAbslStatus(status, error_message)]() mutable {
@@ -691,13 +714,14 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
     fail("SRV lookup failed");
     return;
   }
-  GRPC_ARES_RESOLVER_TRACE_LOG(
-      "resolver:%p OnSRVQueryDoneLocked name=%s ARES_SUCCESS", ares_resolver,
-      qa->query_name.c_str());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+      << " OnSRVQueryDoneLocked name=" << qa->query_name << " ARES_SUCCESS";
   struct ares_srv_reply* reply = nullptr;
   status = ares_parse_srv_reply(abuf, alen, &reply);
-  GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p ares_parse_srv_reply: %d",
-                               ares_resolver, status);
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+      << " ares_parse_srv_reply: " << status;
   if (status != ARES_SUCCESS) {
     fail("Failed to parse SRV reply");
     return;
@@ -705,6 +729,10 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   std::vector<EventEngine::DNSResolver::SRVRecord> result;
   for (struct ares_srv_reply* srv_it = reply; srv_it != nullptr;
        srv_it = srv_it->next) {
+    if (result.size() == kMaxRecordSize) {
+      LOG(ERROR) << "SRV response exceeds maximum record size of 65536";
+      break;
+    }
     EventEngine::DNSResolver::SRVRecord record;
     record.host = srv_it->host;
     record.port = srv_it->port;
@@ -734,8 +762,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   auto fail = [&](absl::string_view prefix) {
     std::string error_message = absl::StrFormat(
         "%s for %s: %s", prefix, qa->query_name, ares_strerror(status));
-    GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p OnTXTDoneLocked: %s",
-                                 ares_resolver, error_message.c_str());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+        << " OnTXTDoneLocked: " << error_message;
     ares_resolver->event_engine_->Run(
         [callback = std::move(callback),
          status = AresStatusToAbslStatus(status, error_message)]() mutable {
@@ -746,9 +775,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
     fail("TXT lookup failed");
     return;
   }
-  GRPC_ARES_RESOLVER_TRACE_LOG(
-      "resolver:%p OnTXTDoneLocked name=%s ARES_SUCCESS", ares_resolver,
-      qa->query_name.c_str());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+      << " OnTXTDoneLocked name=" << qa->query_name << " ARES_SUCCESS";
   struct ares_txt_ext* reply = nullptr;
   status = ares_parse_txt_reply_ext(buf, len, &reply);
   if (status != ARES_SUCCESS) {
@@ -765,11 +794,12 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
           std::string(reinterpret_cast<char*>(part->txt), part->length));
     }
   }
-  GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p Got %zu TXT records", ares_resolver,
-                               result.size());
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver)) {
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) resolver:" << ares_resolver << " Got "
+      << result.size() << " TXT records";
+  if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {
     for (const auto& record : result) {
-      gpr_log(GPR_INFO, "%s", record.c_str());
+      LOG(INFO) << record;
     }
   }
   // Clean up.
@@ -790,4 +820,50 @@ void (*event_engine_grpc_ares_test_only_inject_config)(ares_channel* channel) =
 
 bool g_event_engine_grpc_ares_test_only_force_tcp = false;
 
+bool ShouldUseAresDnsResolver() {
+#if defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER) || \
+    defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+  auto resolver_env = grpc_core::ConfigVars::Get().DnsResolver();
+  return resolver_env.empty() || absl::EqualsIgnoreCase(resolver_env, "ares");
+#else   // defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER) ||
+        // defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+  return false;
+#endif  // defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER) ||
+        // defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+}
+
+absl::Status AresInit() {
+  if (ShouldUseAresDnsResolver()) {
+    address_sorting_init();
+    // ares_library_init and ares_library_cleanup are currently no-op except
+    // under Windows. Calling them may cause race conditions when other parts of
+    // the binary calls these functions concurrently.
+#ifdef GPR_WINDOWS
+    int status = ares_library_init(ARES_LIB_INIT_ALL);
+    if (status != ARES_SUCCESS) {
+      return GRPC_ERROR_CREATE(
+          absl::StrCat("ares_library_init failed: ", ares_strerror(status)));
+    }
+#endif  // GPR_WINDOWS
+  }
+  return absl::OkStatus();
+}
+void AresShutdown() {
+  if (ShouldUseAresDnsResolver()) {
+    address_sorting_shutdown();
+    // ares_library_init and ares_library_cleanup are currently no-op except
+    // under Windows. Calling them may cause race conditions when other parts of
+    // the binary calls these functions concurrently.
+#ifdef GPR_WINDOWS
+    ares_library_cleanup();
+#endif  // GPR_WINDOWS
+  }
+}
+
+#else  // GRPC_ARES == 1
+
+bool ShouldUseAresDnsResolver() { return false; }
+absl::Status AresInit() { return absl::OkStatus(); }
+void AresShutdown() {}
+
 #endif  // GRPC_ARES == 1

data/src/core/lib/event_engine/ares_resolver.h

@@ -14,47 +14,35 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H
 
-#include <utility>
-
 #include <grpc/support/port_platform.h>
 
+#include <utility>
+
+#include "absl/status/status.h"
 #include "src/core/lib/debug/trace.h"
 
 #if GRPC_ARES == 1
 
+#include <ares.h>
+#include <grpc/event_engine/event_engine.h>
+
 #include <list>
 #include <memory>
 
-#include <ares.h>
-
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_map.h"
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
-
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/sync.h"
+#include "src/core/util/orphanable.h"
+#include "src/core/util/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-extern grpc_core::TraceFlag grpc_trace_ares_resolver;
-
-#define GRPC_ARES_RESOLVER_TRACE_LOG(format, ...)                              \
-  do {                                                                         \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver)) {                   \
-      gpr_log(GPR_INFO, "(EventEngine c-ares resolver) " format, __VA_ARGS__); \
-    }                                                                          \
-  } while (0)
-
 class AresResolver : public RefCountedDNSResolverInterface {
  public:
   static absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>
@@ -148,4 +136,9 @@ extern void (*event_engine_grpc_ares_test_only_inject_config)(
 extern bool g_event_engine_grpc_ares_test_only_force_tcp;
 
 #endif  // GRPC_ARES == 1
+
+bool ShouldUseAresDnsResolver();
+absl::Status AresInit();
+void AresShutdown();
+
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H

data/src/core/lib/event_engine/cf_engine/cf_engine.cc

@@ -19,20 +19,18 @@
 #ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 
 #include <CoreFoundation/CoreFoundation.h>
-
-#include "absl/log/check.h"
-
 #include <grpc/support/cpu.h>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "src/core/lib/event_engine/cf_engine/cf_engine.h"
 #include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
 #include "src/core/lib/event_engine/cf_engine/dns_service_resolver.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/utils.h"
-#include "src/core/lib/gprpp/crash.h"
+#include "src/core/util/crash.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -44,8 +42,8 @@ struct CFEventEngine::Closure final : public EventEngine::Closure {
   EventEngine::TaskHandle handle;
 
   void Run() override {
-    GRPC_EVENT_ENGINE_TRACE("CFEventEngine:%p executing callback:%s", engine,
-                            HandleToString(handle).c_str());
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "CFEventEngine:" << engine << " executing callback:" << handle;
     {
       grpc_core::MutexLock lock(&engine->task_mu_);
       engine->known_handles_.erase(handle);
@@ -63,11 +61,11 @@ CFEventEngine::CFEventEngine()
 CFEventEngine::~CFEventEngine() {
   {
     grpc_core::MutexLock lock(&task_mu_);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
       for (auto handle : known_handles_) {
-        gpr_log(GPR_ERROR,
-                "CFEventEngine:%p uncleared TaskHandle at shutdown:%s", this,
-                HandleToString(handle).c_str());
+        LOG(ERROR) << "CFEventEngine:" << this
+                   << " uncleared TaskHandle at shutdown:"
+                   << HandleToString(handle);
       }
     }
     CHECK(GPR_LIKELY(known_handles_.empty()));
@@ -145,9 +143,8 @@ bool CFEventEngine::CancelConnectInternal(ConnectionHandle handle,
   grpc_core::MutexLock lock(&conn_mu_);
 
   if (!conn_handles_.contains(handle)) {
-    GRPC_EVENT_ENGINE_TRACE(
-        "Unknown connection handle: %s",
-        HandleToString<EventEngine::ConnectionHandle>(handle).c_str());
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "Unknown connection handle: " << handle;
     return false;
   }
   conn_handles_.erase(handle);
@@ -210,8 +207,8 @@ EventEngine::TaskHandle CFEventEngine::RunAfterInternal(
   grpc_core::MutexLock lock(&task_mu_);
   known_handles_.insert(handle);
   cd->handle = handle;
-  GRPC_EVENT_ENGINE_TRACE("CFEventEngine:%p scheduling callback:%s", this,
-                          HandleToString(handle).c_str());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "CFEventEngine:" << this << " scheduling callback:" << handle;
   timer_manager_.TimerInit(&cd->timer, when_ts, cd);
   return handle;
 }

data/src/core/lib/event_engine/cf_engine/cf_engine.h

@@ -26,8 +26,8 @@
 #include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
-#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/surface/init_internally.h"
+#include "src/core/util/sync.h"
 
 namespace grpc_event_engine {
 namespace experimental {