grpc 1.64.0 → 1.65.2

data/src/core/lib/event_engine/posix_engine/posix_engine_listener_utils.cc

@@ -23,12 +23,12 @@
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_replace.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
@@ -120,10 +120,8 @@ int InitMaxAcceptQueueSize() {
   max_accept_queue_size = n;
 
   if (max_accept_queue_size < MIN_SAFE_ACCEPT_QUEUE_SIZE) {
-    gpr_log(GPR_INFO,
-            "Suspiciously small accept queue (%d) will probably lead to "
-            "connection drops",
-            max_accept_queue_size);
+    LOG(INFO) << "Suspiciously small accept queue (" << max_accept_queue_size
+              << ") will probably lead to connection drops";
   }
   return max_accept_queue_size;
 }
@@ -156,7 +154,7 @@ absl::Status PrepareSocket(const PosixTcpOptions& options,
 #ifdef GRPC_LINUX_ERRQUEUE
   if (!socket.sock.SetSocketZeroCopy().ok()) {
     // it's not fatal, so just log it.
-    gpr_log(GPR_DEBUG, "Node does not support SO_ZEROCOPY, continuing.");
+    VLOG(2) << "Node does not support SO_ZEROCOPY, continuing.";
   } else {
     socket.zero_copy_enabled = true;
   }
@@ -179,8 +177,8 @@ absl::Status PrepareSocket(const PosixTcpOptions& options,
   if (bind(fd, socket.addr.address(), socket.addr.size()) < 0) {
     auto sockaddr_str = ResolvedAddressToString(socket.addr);
     if (!sockaddr_str.ok()) {
-      gpr_log(GPR_ERROR, "Could not convert sockaddr to string: %s",
-              sockaddr_str.status().ToString().c_str());
+      LOG(ERROR) << "Could not convert sockaddr to string: "
+                 << sockaddr_str.status();
       sockaddr_str = "<unparsable>";
     }
     sockaddr_str = absl::StrReplaceAll(*sockaddr_str, {{"\0", "@"}});
@@ -244,7 +242,7 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     auto result = GetUnusedPort();
     GRPC_RETURN_IF_ERROR(result.status());
     requested_port = *result;
-    gpr_log(GPR_DEBUG, "Picked unused port %d", requested_port);
+    VLOG(2) << "Picked unused port " << requested_port;
   }
   if (getifaddrs(&ifa) != 0 || ifa == nullptr) {
     return absl::FailedPreconditionError(
@@ -276,14 +274,14 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     addr = EventEngine::ResolvedAddress(ifa_it->ifa_addr, len);
     ResolvedAddressSetPort(addr, requested_port);
     std::string addr_str = *ResolvedAddressToString(addr);
-    gpr_log(GPR_DEBUG,
-            "Adding local addr from interface %s flags 0x%x to server: %s",
-            ifa_name, ifa_it->ifa_flags, addr_str.c_str());
+    VLOG(2) << absl::StrFormat(
+        "Adding local addr from interface %s flags 0x%x to server: %s",
+        ifa_name, ifa_it->ifa_flags, addr_str.c_str());
     // We could have multiple interfaces with the same address (e.g.,
     // bonding), so look for duplicates.
     if (listener_sockets.Find(addr).ok()) {
-      gpr_log(GPR_DEBUG, "Skipping duplicate addr %s on interface %s",
-              addr_str.c_str(), ifa_name);
+      VLOG(2) << "Skipping duplicate addr " << addr_str << " on interface "
+              << ifa_name;
       continue;
     }
     auto result = CreateAndPrepareListenerSocket(options, addr);
@@ -347,16 +345,14 @@ absl::StatusOr<int> ListenerContainerAddWildcardAddresses(
   }
   if (assigned_port > 0) {
     if (!v6_sock.ok()) {
-      gpr_log(GPR_INFO,
-              "Failed to add :: listener, the environment may not support "
-              "IPv6: %s",
-              v6_sock.status().ToString().c_str());
+      VLOG(2) << "Failed to add :: listener, the environment may not support "
+                 "IPv6: "
+              << v6_sock.status();
     }
     if (!v4_sock.ok()) {
-      gpr_log(GPR_INFO,
-              "Failed to add 0.0.0.0 listener, "
-              "the environment may not support IPv4: %s",
-              v4_sock.status().ToString().c_str());
+      VLOG(2) << "Failed to add 0.0.0.0 listener, "
+                 "the environment may not support IPv4: "
+              << v4_sock.status();
     }
     return assigned_port;
   } else {

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.cc

@@ -27,10 +27,10 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/port.h"
+#include "src/core/util/useful.h"
 
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 #include <arpa/inet.h>  // IWYU pragma: keep
@@ -49,10 +49,9 @@
 #include <cstring>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/strerror.h"
@@ -628,32 +627,34 @@ void PosixSocketWrapper::TrySetSocketTcpUserTimeout(
     // if it is available.
     if (g_socket_supports_tcp_user_timeout.load() == 0) {
       if (0 != getsockopt(fd_, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) {
-        gpr_log(GPR_INFO,
-                "TCP_USER_TIMEOUT is not available. TCP_USER_TIMEOUT won't "
-                "be used thereafter");
+        // This log is intentionally not protected behind a flag, so that users
+        // know that TCP_USER_TIMEOUT is not being used.
+        GRPC_TRACE_LOG(tcp, INFO)
+            << "TCP_USER_TIMEOUT is not available. TCP_USER_TIMEOUT "
+               "won't be used thereafter";
         g_socket_supports_tcp_user_timeout.store(-1);
       } else {
-        gpr_log(GPR_INFO,
-                "TCP_USER_TIMEOUT is available. TCP_USER_TIMEOUT will be "
-                "used thereafter");
+        GRPC_TRACE_LOG(tcp, INFO)
+            << "TCP_USER_TIMEOUT is available. TCP_USER_TIMEOUT will be "
+               "used thereafter";
         g_socket_supports_tcp_user_timeout.store(1);
       }
     }
     if (g_socket_supports_tcp_user_timeout.load() > 0) {
       if (0 != setsockopt(fd_, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout,
                           sizeof(timeout))) {
-        gpr_log(GPR_ERROR, "setsockopt(TCP_USER_TIMEOUT) %s",
-                grpc_core::StrError(errno).c_str());
+        LOG(ERROR) << "setsockopt(TCP_USER_TIMEOUT) "
+                   << grpc_core::StrError(errno);
         return;
       }
       if (0 != getsockopt(fd_, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) {
-        gpr_log(GPR_ERROR, "getsockopt(TCP_USER_TIMEOUT) %s",
-                grpc_core::StrError(errno).c_str());
+        LOG(ERROR) << "getsockopt(TCP_USER_TIMEOUT) "
+                   << grpc_core::StrError(errno);
         return;
       }
       if (newval != timeout) {
         // Do not fail on failing to set TCP_USER_TIMEOUT
-        gpr_log(GPR_ERROR, "Failed to set TCP_USER_TIMEOUT");
+        LOG(ERROR) << "Failed to set TCP_USER_TIMEOUT";
         return;
       }
     }
@@ -684,7 +685,8 @@ bool PosixSocketWrapper::IsIpv6LoopbackAvailable() {
     int fd = socket(AF_INET6, SOCK_STREAM, 0);
     bool loopback_available = false;
     if (fd < 0) {
-      gpr_log(GPR_INFO, "Disabling AF_INET6 sockets because socket() failed.");
+      GRPC_TRACE_LOG(tcp, INFO)
+          << "Disabling AF_INET6 sockets because socket() failed.";
     } else {
       sockaddr_in6 addr;
       memset(&addr, 0, sizeof(addr));
@@ -693,8 +695,8 @@ bool PosixSocketWrapper::IsIpv6LoopbackAvailable() {
       if (bind(fd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) == 0) {
         loopback_available = true;
       } else {
-        gpr_log(GPR_INFO,
-                "Disabling AF_INET6 sockets because ::1 is not available.");
+        GRPC_TRACE_LOG(tcp, INFO)
+            << "Disabling AF_INET6 sockets because ::1 is not available.";
       }
       close(fd);
     }

data/src/core/lib/event_engine/posix_engine/timer.cc

@@ -27,8 +27,8 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/posix_engine/timer_heap.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/posix_engine/timer_manager.cc

@@ -36,8 +36,6 @@ static thread_local bool g_timer_thread;
 namespace grpc_event_engine {
 namespace experimental {
 
-grpc_core::DebugOnlyTraceFlag grpc_event_engine_timer_trace(false, "timer");
-
 void TimerManager::RunSomeTimers(
     std::vector<experimental::EventEngine::Closure*> timers) {
   for (auto* timer : timers) {
@@ -101,7 +99,7 @@ grpc_core::Timestamp TimerManager::Host::Now() {
 
 void TimerManager::TimerInit(Timer* timer, grpc_core::Timestamp deadline,
                              experimental::EventEngine::Closure* closure) {
-  if (grpc_event_engine_timer_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     grpc_core::MutexLock lock(&mu_);
     if (shutdown_) {
       gpr_log(GPR_ERROR,
@@ -121,7 +119,7 @@ void TimerManager::Shutdown() {
   {
     grpc_core::MutexLock lock(&mu_);
     if (shutdown_) return;
-    if (grpc_event_engine_timer_trace.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
       gpr_log(GPR_DEBUG, "TimerManager::%p shutting down", this);
     }
     shutdown_ = true;
@@ -129,7 +127,7 @@ void TimerManager::Shutdown() {
     cv_wait_.Signal();
   }
   main_loop_exit_signal_->WaitForNotification();
-  if (grpc_event_engine_timer_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     gpr_log(GPR_DEBUG, "TimerManager::%p shutdown complete", this);
   }
 }
@@ -147,7 +145,7 @@ void TimerManager::Kick() {
 void TimerManager::RestartPostFork() {
   grpc_core::MutexLock lock(&mu_);
   CHECK(GPR_LIKELY(shutdown_));
-  if (grpc_event_engine_timer_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     gpr_log(GPR_DEBUG, "TimerManager::%p restarting after shutdown", this);
   }
   shutdown_ = false;

data/src/core/lib/event_engine/posix_engine/traced_buffer_list.cc

@@ -22,6 +22,7 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
@@ -48,7 +49,7 @@ void FillGprFromTimestamp(gpr_timespec* gts, const struct timespec* ts) {
 
 void DefaultTimestampsCallback(void* /*arg*/, Timestamps* /*ts*/,
                                absl::Status /*shudown_err*/) {
-  gpr_log(GPR_DEBUG, "Timestamps callback has not been registered");
+  VLOG(2) << "Timestamps callback has not been registered";
 }
 
 // The saved callback function that will be invoked when we get all the

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

@@ -30,7 +30,7 @@ bool UseEventEngineClient() {
   return grpc_core::IsEventEngineClientEnabled();
 #elif defined(GPR_WINDOWS) && !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
   return grpc_core::IsEventEngineClientEnabled();
-#elif defined(GRPC_IOS_EVENT_ENGINE_CLIENT)
+#elif GRPC_IOS_EVENT_ENGINE_CLIENT
   return true;
 #else
   return false;

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

@@ -54,12 +54,11 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/resolved_address.h"
@@ -286,8 +285,8 @@ int ResolvedAddressGetPort(const EventEngine::ResolvedAddress& resolved_addr) {
       return 1;
 #endif
     default:
-      gpr_log(GPR_ERROR, "Unknown socket family %d in ResolvedAddressGetPort",
-              addr->sa_family);
+      LOG(ERROR) << "Unknown socket family " << addr->sa_family
+                 << " in ResolvedAddressGetPort";
       abort();
   }
 }
@@ -309,8 +308,8 @@ void ResolvedAddressSetPort(EventEngine::ResolvedAddress& resolved_addr,
           htons(static_cast<uint16_t>(port));
       return;
     default:
-      gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",
-              addr->sa_family);
+      LOG(ERROR) << "Unknown socket family " << addr->sa_family
+                 << " in grpc_sockaddr_set_port";
       abort();
   }
 }
@@ -446,8 +445,7 @@ absl::StatusOr<EventEngine::ResolvedAddress> URIToResolvedAddress(
   grpc_resolved_address addr;
   absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Parse(address_str);
   if (!uri.ok()) {
-    gpr_log(GPR_ERROR, "Failed to parse URI. Error: %s",
-            uri.status().ToString().c_str());
+    LOG(ERROR) << "Failed to parse URI. Error: " << uri.status();
   }
   GRPC_RETURN_IF_ERROR(uri.status());
   CHECK(grpc_parse_uri(*uri, &addr));

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

@@ -29,4 +29,4 @@ class ThreadLocal {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_LOCAL_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_LOCAL_H

data/src/core/lib/event_engine/thread_pool/thread_count.h

@@ -26,9 +26,9 @@
 #include <grpc/support/cpu.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.cc

@@ -27,15 +27,16 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/thd_id.h>
 
 #include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/debug/trace_impl.h"
 #include "src/core/lib/event_engine/common_closures.h"
 #include "src/core/lib/event_engine/thread_local.h"
 #include "src/core/lib/event_engine/trace.h"
@@ -156,11 +157,10 @@ std::atomic<size_t> g_reported_dump_count{0};
 void DumpSignalHandler(int /* sig */) {
   const auto trace = grpc_core::GetCurrentStackTrace();
   if (!trace.has_value()) {
-    gpr_log(GPR_ERROR, "DumpStack::%" PRIdPTR ": Stack trace not available",
-            gpr_thd_currentid());
+    LOG(ERROR) << "DumpStack::" << gpr_thd_currentid()
+               << ": Stack trace not available";
   } else {
-    gpr_log(GPR_ERROR, "DumpStack::%" PRIdPTR ": %s", gpr_thd_currentid(),
-            trace->c_str());
+    LOG(ERROR) << "DumpStack::" << gpr_thd_currentid() << ": " << trace.value();
   }
   g_reported_dump_count.fetch_add(1);
   grpc_core::Thread::Kill(gpr_thd_currentid());
@@ -227,18 +227,19 @@ void WorkStealingThreadPool::PostforkChild() { pool_->Postfork(); }
 
 WorkStealingThreadPool::WorkStealingThreadPoolImpl::WorkStealingThreadPoolImpl(
     size_t reserve_threads)
-    : reserve_threads_(reserve_threads), queue_(this), lifeguard_(this) {}
+    : reserve_threads_(reserve_threads), queue_(this) {}
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Start() {
   for (size_t i = 0; i < reserve_threads_; i++) {
     StartThread();
   }
-  lifeguard_.Start();
+  grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
+  lifeguard_ = std::make_unique<Lifeguard>(this);
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Run(
     EventEngine::Closure* closure) {
-  DCHECK(quiesced_.load(std::memory_order_relaxed) == false);
+  CHECK(!IsQuiesced());
   if (g_local_queue != nullptr && g_local_queue->owner() == this) {
     g_local_queue->Add(closure);
   } else {
@@ -266,7 +267,6 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::StartThread() {
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Quiesce() {
-  gpr_log(GPR_INFO, "WorkStealingThreadPoolImpl::Quiesce");
   SetShutdown(true);
   // Wait until all threads have exited.
   // Note that if this is a threadpool thread then we won't exit this thread
@@ -283,7 +283,8 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Quiesce() {
   }
   CHECK(queue_.Empty());
   quiesced_.store(true, std::memory_order_relaxed);
-  lifeguard_.BlockUntilShutdownAndReset();
+  grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
+  lifeguard_.reset();
 }
 
 bool WorkStealingThreadPool::WorkStealingThreadPoolImpl::SetThrottled(
@@ -317,7 +318,8 @@ bool WorkStealingThreadPool::WorkStealingThreadPoolImpl::IsQuiesced() {
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::PrepareFork() {
-  gpr_log(GPR_INFO, "WorkStealingThreadPoolImpl::PrepareFork");
+  LOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(event_engine))
+      << "WorkStealingThreadPoolImpl::PrepareFork";
   SetForking(true);
   work_signal_.SignalAll();
   auto threads_were_shut_down = living_thread_count_.BlockUntilThreadCount(
@@ -325,7 +327,8 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::PrepareFork() {
   if (!threads_were_shut_down.ok() && g_log_verbose_failures) {
     DumpStacksAndCrash();
   }
-  lifeguard_.BlockUntilShutdownAndReset();
+  grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
+  lifeguard_.reset();
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Postfork() {
@@ -347,10 +350,9 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::UntrackThread(
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::DumpStacksAndCrash() {
   grpc_core::MutexLock lock(&thd_set_mu_);
-  gpr_log(GPR_ERROR,
-          "Pool did not quiesce in time, gRPC will not shut down cleanly. "
-          "Dumping all %zu thread stacks.",
-          thds_.size());
+  LOG(ERROR) << "Pool did not quiesce in time, gRPC will not shut down "
+                "cleanly. Dumping all "
+             << thds_.size() << " thread stacks.";
   for (const auto tid : thds_) {
     grpc_core::Thread::Signal(tid, kDumpStackSignal);
   }
@@ -374,9 +376,7 @@ WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::Lifeguard(
                    .set_max_backoff(kLifeguardMaxSleepBetweenChecks)
                    .set_multiplier(1.3)),
       lifeguard_should_shut_down_(std::make_unique<grpc_core::Notification>()),
-      lifeguard_is_shut_down_(std::make_unique<grpc_core::Notification>()) {}
-
-void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::Start() {
+      lifeguard_is_shut_down_(std::make_unique<grpc_core::Notification>()) {
   // lifeguard_running_ is set early to avoid a quiesce race while the
   // lifeguard is still starting up.
   lifeguard_running_.store(true);
@@ -411,8 +411,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
   lifeguard_is_shut_down_->Notify();
 }
 
-void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
-    BlockUntilShutdownAndReset() {
+WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::~Lifeguard() {
   lifeguard_should_shut_down_->Notify();
   while (lifeguard_running_.load(std::memory_order_relaxed)) {
     GRPC_LOG_EVERY_N_SEC_DELAYED(kBlockingQuiesceLogRateSeconds, GPR_DEBUG,

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h

@@ -155,11 +155,7 @@ class WorkStealingThreadPool final : public ThreadPool {
     class Lifeguard {
      public:
       explicit Lifeguard(WorkStealingThreadPoolImpl* pool);
-      // Start the lifeguard thread.
-      void Start();
-      // Block until the lifeguard thread is shut down.
-      // Afterwards, reset the lifeguard state so it can start again cleanly.
-      void BlockUntilShutdownAndReset();
+      ~Lifeguard();
 
      private:
       // The main body of the lifeguard thread.
@@ -194,7 +190,8 @@ class WorkStealingThreadPool final : public ThreadPool {
     // at a time.
     std::atomic<bool> throttled_{false};
     WorkSignal work_signal_;
-    Lifeguard lifeguard_;
+    grpc_core::Mutex lifeguard_ptr_mu_;
+    std::unique_ptr<Lifeguard> lifeguard_ ABSL_GUARDED_BY(lifeguard_ptr_mu_);
     // Set of threads for verbose failure debugging
     grpc_core::Mutex thd_set_mu_;
     absl::flat_hash_set<gpr_thd_id> thds_ ABSL_GUARDED_BY(thd_set_mu_);

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

@@ -85,7 +85,9 @@ bool ThreadyEventEngine::IsWorkerThread() {
 absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
 ThreadyEventEngine::GetDNSResolver(
     const DNSResolver::ResolverOptions& options) {
-  return std::make_unique<ThreadyDNSResolver>(*impl_->GetDNSResolver(options));
+  return std::make_unique<ThreadyDNSResolver>(
+      *impl_->GetDNSResolver(options),
+      std::static_pointer_cast<ThreadyEventEngine>(shared_from_this()));
 }
 
 void ThreadyEventEngine::Run(Closure* closure) {
@@ -116,10 +118,10 @@ void ThreadyEventEngine::ThreadyDNSResolver::LookupHostname(
     LookupHostnameCallback on_resolve, absl::string_view name,
     absl::string_view default_port) {
   return impl_->LookupHostname(
-      [this, on_resolve = std::move(on_resolve)](
+      [engine = engine_, on_resolve = std::move(on_resolve)](
           absl::StatusOr<std::vector<ResolvedAddress>> addresses) mutable {
-        engine_->Asynchronously([on_resolve = std::move(on_resolve),
-                                 addresses = std::move(addresses)]() mutable {
+        engine->Asynchronously([on_resolve = std::move(on_resolve),
+                                addresses = std::move(addresses)]() mutable {
           on_resolve(std::move(addresses));
         });
       },
@@ -129,13 +131,12 @@ void ThreadyEventEngine::ThreadyDNSResolver::LookupHostname(
 void ThreadyEventEngine::ThreadyDNSResolver::LookupSRV(
     LookupSRVCallback on_resolve, absl::string_view name) {
   return impl_->LookupSRV(
-      [this, on_resolve = std::move(on_resolve)](
+      [engine = engine_, on_resolve = std::move(on_resolve)](
           absl::StatusOr<std::vector<SRVRecord>> records) mutable {
-        return engine_->Asynchronously(
-            [on_resolve = std::move(on_resolve),
-             records = std::move(records)]() mutable {
-              on_resolve(std::move(records));
-            });
+        return engine->Asynchronously([on_resolve = std::move(on_resolve),
+                                       records = std::move(records)]() mutable {
+          on_resolve(std::move(records));
+        });
       },
       name);
 }
@@ -143,10 +144,10 @@ void ThreadyEventEngine::ThreadyDNSResolver::LookupSRV(
 void ThreadyEventEngine::ThreadyDNSResolver::LookupTXT(
     LookupTXTCallback on_resolve, absl::string_view name) {
   return impl_->LookupTXT(
-      [this, on_resolve = std::move(on_resolve)](
+      [engine = engine_, on_resolve = std::move(on_resolve)](
           absl::StatusOr<std::vector<std::string>> record) mutable {
-        return engine_->Asynchronously([on_resolve = std::move(on_resolve),
-                                        record = std::move(record)]() mutable {
+        return engine->Asynchronously([on_resolve = std::move(on_resolve),
+                                       record = std::move(record)]() mutable {
           on_resolve(std::move(record));
         });
       },

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

@@ -77,8 +77,9 @@ class ThreadyEventEngine final : public EventEngine {
  private:
   class ThreadyDNSResolver final : public DNSResolver {
    public:
-    explicit ThreadyDNSResolver(std::unique_ptr<DNSResolver> impl)
-        : impl_(std::move(impl)) {}
+    ThreadyDNSResolver(std::unique_ptr<DNSResolver> impl,
+                       std::shared_ptr<ThreadyEventEngine> engine)
+        : impl_(std::move(impl)), engine_(std::move(engine)) {}
     void LookupHostname(LookupHostnameCallback on_resolve,
                         absl::string_view name,
                         absl::string_view default_port) override;
@@ -89,7 +90,7 @@ class ThreadyEventEngine final : public EventEngine {
 
    private:
     std::unique_ptr<DNSResolver> impl_;
-    ThreadyEventEngine* engine_;
+    std::shared_ptr<ThreadyEventEngine> engine_;
   };
 
   void Asynchronously(absl::AnyInvocable<void()> fn);

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

@@ -19,30 +19,19 @@
 
 #include "src/core/lib/debug/trace.h"
 
-extern grpc_core::TraceFlag grpc_event_engine_trace;
-extern grpc_core::TraceFlag grpc_event_engine_dns_trace;
-extern grpc_core::TraceFlag grpc_event_engine_endpoint_data_trace;
-extern grpc_core::TraceFlag grpc_event_engine_poller_trace;
-extern grpc_core::TraceFlag grpc_event_engine_endpoint_trace;
-
 #define GRPC_EVENT_ENGINE_TRACE(format, ...)                   \
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {      \
-    gpr_log(GPR_DEBUG, "(event_engine) " format, __VA_ARGS__); \
+  if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {                 \
+    gpr_log(GPR_ERROR, "(event_engine) " format, __VA_ARGS__); \
   }
 
 #define GRPC_EVENT_ENGINE_ENDPOINT_TRACE(format, ...)                   \
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_endpoint_trace)) {      \
-    gpr_log(GPR_DEBUG, "(event_engine endpoint) " format, __VA_ARGS__); \
+  if (GRPC_TRACE_FLAG_ENABLED(event_engine_endpoint)) {                 \
+    gpr_log(GPR_ERROR, "(event_engine endpoint) " format, __VA_ARGS__); \
   }
 
 #define GRPC_EVENT_ENGINE_POLLER_TRACE(format, ...)                   \
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_poller_trace)) {      \
-    gpr_log(GPR_DEBUG, "(event_engine poller) " format, __VA_ARGS__); \
-  }
-
-#define GRPC_EVENT_ENGINE_DNS_TRACE(format, ...)                   \
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_dns_trace)) {      \
-    gpr_log(GPR_DEBUG, "(event_engine dns) " format, __VA_ARGS__); \
+  if (GRPC_TRACE_FLAG_ENABLED(event_engine_poller)) {                 \
+    gpr_log(GPR_ERROR, "(event_engine poller) " format, __VA_ARGS__); \
   }
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_TRACE_H

data/src/core/lib/event_engine/windows/iocp.h

@@ -32,7 +32,7 @@ namespace experimental {
 class IOCP final : public Poller {
  public:
   explicit IOCP(ThreadPool* thread_pool) noexcept;
-  ~IOCP();
+  ~IOCP() override;
   // Not copyable
   IOCP(const IOCP&) = delete;
   IOCP& operator=(const IOCP&) = delete;