grpc 1.64.0 → 1.65.0

data/src/core/lib/iomgr/ev_epoll1_linux.cc

@@ -41,6 +41,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
@@ -48,10 +49,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
 
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/debug/stats_data.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/iomgr/block_annotate.h"
@@ -60,6 +57,10 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/lockfree_event.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
+#include "src/core/telemetry/stats.h"
+#include "src/core/telemetry/stats_data.h"
+#include "src/core/util/string.h"
+#include "src/core/util/useful.h"
 
 static grpc_wakeup_fd global_wakeup_fd;
 static bool g_is_shutdown = true;
@@ -100,14 +101,14 @@ static int epoll_create_and_cloexec() {
 #ifdef GRPC_LINUX_EPOLL_CREATE1
   int fd = epoll_create1(EPOLL_CLOEXEC);
   if (fd < 0) {
-    gpr_log(GPR_ERROR, "epoll_create1 unavailable");
+    LOG(ERROR) << "epoll_create1 unavailable";
   }
 #else
   int fd = epoll_create(MAX_EPOLL_EVENTS);
   if (fd < 0) {
-    gpr_log(GPR_ERROR, "epoll_create unavailable");
+    LOG(ERROR) << "epoll_create unavailable";
   } else if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) {
-    gpr_log(GPR_ERROR, "fcntl following epoll_create failed");
+    LOG(ERROR) << "fcntl following epoll_create failed";
     return -1;
   }
 #endif
@@ -361,7 +362,7 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
   grpc_iomgr_register_object(&new_fd->iomgr_object, fd_name.c_str());
   fork_fd_list_add_grpc_fd(new_fd);
 #ifndef NDEBUG
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
+  if (GRPC_TRACE_FLAG_ENABLED(fd_refcount)) {
     gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, new_fd, fd_name.c_str());
   }
 #endif
@@ -730,7 +731,7 @@ static grpc_error_handle do_epoll_wait(grpc_pollset* ps,
 
   if (r < 0) return GRPC_OS_ERROR(errno, "epoll_wait");
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(polling)) {
     gpr_log(GPR_INFO, "ps: %p poll got %d events", ps, r);
   }
 
@@ -749,7 +750,7 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
   worker->schedule_on_end_work = (grpc_closure_list)GRPC_CLOSURE_LIST_INIT;
   pollset->begin_refs++;
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(polling)) {
     gpr_log(GPR_INFO, "PS:%p BEGIN_STARTS:%p", pollset, worker);
   }
 
@@ -768,7 +769,7 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
   retry_lock_neighborhood:
     gpr_mu_lock(&neighborhood->mu);
     gpr_mu_lock(&pollset->mu);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
       gpr_log(GPR_INFO, "PS:%p BEGIN_REORG:%p kick_state=%s is_reassigning=%d",
               pollset, worker, kick_state_string(worker->state),
               is_reassigning);
@@ -821,7 +822,7 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
     worker->initialized_cv = true;
     gpr_cv_init(&worker->cv);
     while (worker->state == UNKICKED && !pollset->shutting_down) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(polling)) {
         gpr_log(GPR_INFO, "PS:%p BEGIN_WAIT:%p kick_state=%s shutdown=%d",
                 pollset, worker, kick_state_string(worker->state),
                 pollset->shutting_down);
@@ -838,7 +839,7 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
     grpc_core::ExecCtx::Get()->InvalidateNow();
   }
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(polling)) {
     gpr_log(GPR_INFO,
             "PS:%p BEGIN_DONE:%p kick_state=%s shutdown=%d "
             "kicked_without_poller: %d",
@@ -881,7 +882,7 @@ static bool check_neighborhood_for_available_poller(
             if (gpr_atm_no_barrier_cas(
                     &g_active_poller, 0,
                     reinterpret_cast<gpr_atm>(inspect_worker))) {
-              if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+              if (GRPC_TRACE_FLAG_ENABLED(polling)) {
                 gpr_log(GPR_INFO, " .. choose next poller to be %p",
                         inspect_worker);
               }
@@ -890,8 +891,8 @@ static bool check_neighborhood_for_available_poller(
                 gpr_cv_signal(&inspect_worker->cv);
               }
             } else {
-              if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-                gpr_log(GPR_INFO, " .. beaten to choose next poller");
+              if (GRPC_TRACE_FLAG_ENABLED(polling)) {
+                LOG(INFO) << " .. beaten to choose next poller";
               }
             }
             // even if we didn't win the cas, there's a worker, we can stop
@@ -908,7 +909,7 @@ static bool check_neighborhood_for_available_poller(
       } while (!found_worker && inspect_worker != inspect->root_worker);
     }
     if (!found_worker) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(polling)) {
         gpr_log(GPR_INFO, " .. mark pollset %p inactive", inspect);
       }
       inspect->seen_inactive = true;
@@ -927,7 +928,7 @@ static bool check_neighborhood_for_available_poller(
 
 static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
                        grpc_pollset_worker** worker_hdl) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(polling)) {
     gpr_log(GPR_INFO, "PS:%p END_WORKER:%p", pollset, worker);
   }
   if (worker_hdl != nullptr) *worker_hdl = nullptr;
@@ -938,7 +939,7 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
   if (gpr_atm_no_barrier_load(&g_active_poller) ==
       reinterpret_cast<gpr_atm>(worker)) {
     if (worker->next != worker && worker->next->state == UNKICKED) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(polling)) {
         gpr_log(GPR_INFO, " .. choose next poller to be peer %p", worker);
       }
       CHECK(worker->next->initialized_cv);
@@ -989,8 +990,8 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
   if (worker->initialized_cv) {
     gpr_cv_destroy(&worker->cv);
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-    gpr_log(GPR_INFO, " .. remove worker");
+  if (GRPC_TRACE_FLAG_ENABLED(polling)) {
+    LOG(INFO) << " .. remove worker";
   }
   if (EMPTIED == worker_remove(pollset, worker)) {
     pollset_maybe_finish_shutdown(pollset);
@@ -1055,7 +1056,7 @@ static grpc_error_handle pollset_work(grpc_pollset* ps,
 static grpc_error_handle pollset_kick(grpc_pollset* pollset,
                                       grpc_pollset_worker* specific_worker) {
   grpc_error_handle ret_err;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(polling)) {
     std::vector<std::string> log;
     log.push_back(absl::StrFormat(
         "PS:%p KICK:%p curps=%p curworker=%p root=%p", pollset, specific_worker,
@@ -1080,20 +1081,20 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
       grpc_pollset_worker* root_worker = pollset->root_worker;
       if (root_worker == nullptr) {
         pollset->kicked_without_poller = true;
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-          gpr_log(GPR_INFO, " .. kicked_without_poller");
+        if (GRPC_TRACE_FLAG_ENABLED(polling)) {
+          LOG(INFO) << " .. kicked_without_poller";
         }
         goto done;
       }
       grpc_pollset_worker* next_worker = root_worker->next;
       if (root_worker->state == KICKED) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(polling)) {
           gpr_log(GPR_INFO, " .. already kicked %p", root_worker);
         }
         SET_KICK_STATE(root_worker, KICKED);
         goto done;
       } else if (next_worker->state == KICKED) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(polling)) {
           gpr_log(GPR_INFO, " .. already kicked %p", next_worker);
         }
         SET_KICK_STATE(next_worker, KICKED);
@@ -1103,14 +1104,14 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
                  root_worker ==
                      reinterpret_cast<grpc_pollset_worker*>(
                          gpr_atm_no_barrier_load(&g_active_poller))) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(polling)) {
           gpr_log(GPR_INFO, " .. kicked %p", root_worker);
         }
         SET_KICK_STATE(root_worker, KICKED);
         ret_err = grpc_wakeup_fd_wakeup(&global_wakeup_fd);
         goto done;
       } else if (next_worker->state == UNKICKED) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(polling)) {
           gpr_log(GPR_INFO, " .. kicked %p", next_worker);
         }
         CHECK(next_worker->initialized_cv);
@@ -1119,7 +1120,7 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
         goto done;
       } else if (next_worker->state == DESIGNATED_POLLER) {
         if (root_worker->state != DESIGNATED_POLLER) {
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+          if (GRPC_TRACE_FLAG_ENABLED(polling)) {
             gpr_log(
                 GPR_INFO,
                 " .. kicked root non-poller %p (initialized_cv=%d) (poller=%p)",
@@ -1131,7 +1132,7 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
           }
           goto done;
         } else {
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+          if (GRPC_TRACE_FLAG_ENABLED(polling)) {
             gpr_log(GPR_INFO, " .. non-root poller %p (root=%p)", next_worker,
                     root_worker);
           }
@@ -1145,8 +1146,8 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
         goto done;
       }
     } else {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-        gpr_log(GPR_INFO, " .. kicked while waking up");
+      if (GRPC_TRACE_FLAG_ENABLED(polling)) {
+        LOG(INFO) << " .. kicked while waking up";
       }
       goto done;
     }
@@ -1155,12 +1156,12 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
   }
 
   if (specific_worker->state == KICKED) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-      gpr_log(GPR_INFO, " .. specific worker already kicked");
+    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
+      LOG(INFO) << " .. specific worker already kicked";
     }
     goto done;
   } else if (g_current_thread_worker == specific_worker) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
       gpr_log(GPR_INFO, " .. mark %p kicked", specific_worker);
     }
     SET_KICK_STATE(specific_worker, KICKED);
@@ -1168,22 +1169,22 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
   } else if (specific_worker ==
              reinterpret_cast<grpc_pollset_worker*>(
                  gpr_atm_no_barrier_load(&g_active_poller))) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-      gpr_log(GPR_INFO, " .. kick active poller");
+    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
+      LOG(INFO) << " .. kick active poller";
     }
     SET_KICK_STATE(specific_worker, KICKED);
     ret_err = grpc_wakeup_fd_wakeup(&global_wakeup_fd);
     goto done;
   } else if (specific_worker->initialized_cv) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-      gpr_log(GPR_INFO, " .. kick waiting worker");
+    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
+      LOG(INFO) << " .. kick waiting worker";
     }
     SET_KICK_STATE(specific_worker, KICKED);
     gpr_cv_signal(&specific_worker->cv);
     goto done;
   } else {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-      gpr_log(GPR_INFO, " .. kick non-waiting worker");
+    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
+      LOG(INFO) << " .. kick non-waiting worker";
     }
     SET_KICK_STATE(specific_worker, KICKED);
     goto done;
@@ -1311,7 +1312,7 @@ static void reset_event_manager_on_fork() {
 static bool init_epoll1_linux() {
   if (!g_is_shutdown) return true;
   if (!grpc_has_wakeup_fd()) {
-    gpr_log(GPR_ERROR, "Skipping epoll1 because of no wakeup fd.");
+    LOG(ERROR) << "Skipping epoll1 because of no wakeup fd.";
     return false;
   }
 

data/src/core/lib/iomgr/ev_poll_posix.cc

@@ -34,21 +34,22 @@
 #include <string>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/debug/stats_data.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
+#include "src/core/telemetry/stats.h"
+#include "src/core/telemetry/stats_data.h"
+#include "src/core/util/useful.h"
 
 #define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1)
 
@@ -266,19 +267,29 @@ struct grpc_pollset_set {
 //
 
 static void fork_fd_list_remove_node(grpc_fork_fd_list* node) {
+  gpr_mu_lock(&fork_fd_list_mu);
+  if (fork_fd_list_head == node) {
+    fork_fd_list_head = node->next;
+  }
+  if (node->prev != nullptr) {
+    node->prev->next = node->next;
+  }
+  if (node->next != nullptr) {
+    node->next->prev = node->prev;
+  }
+  gpr_free(node);
+  gpr_mu_unlock(&fork_fd_list_mu);
+}
+
+static void fork_fd_list_remove_grpc_fd(grpc_fd* fd) {
   if (track_fds_for_fork) {
-    gpr_mu_lock(&fork_fd_list_mu);
-    if (fork_fd_list_head == node) {
-      fork_fd_list_head = node->next;
-    }
-    if (node->prev != nullptr) {
-      node->prev->next = node->next;
-    }
-    if (node->next != nullptr) {
-      node->next->prev = node->prev;
-    }
-    gpr_free(node);
-    gpr_mu_unlock(&fork_fd_list_mu);
+    fork_fd_list_remove_node(fd->fork_fd_list);
+  }
+}
+
+static void fork_fd_list_remove_wakeup_fd(grpc_cached_wakeup_fd* fd) {
+  if (track_fds_for_fork) {
+    fork_fd_list_remove_node(fd->fork_fd_list);
   }
 }
 
@@ -322,7 +333,7 @@ static void fork_fd_list_add_wakeup_fd(grpc_cached_wakeup_fd* fd) {
 #define UNREF_BY(fd, n, reason) unref_by(fd, n, reason, __FILE__, __LINE__)
 static void ref_by(grpc_fd* fd, int n, const char* reason, const char* file,
                    int line) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
+  if (GRPC_TRACE_FLAG_ENABLED(fd_refcount)) {
     gpr_log(GPR_DEBUG,
             "FD %d %p   ref %d %" PRIdPTR " -> %" PRIdPTR " [%s; %s:%d]",
             fd->fd, fd, n, gpr_atm_no_barrier_load(&fd->refst),
@@ -347,7 +358,7 @@ static void ref_by(grpc_fd* fd, int n) {
 #ifndef NDEBUG
 static void unref_by(grpc_fd* fd, int n, const char* reason, const char* file,
                      int line) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
+  if (GRPC_TRACE_FLAG_ENABLED(fd_refcount)) {
     gpr_log(GPR_DEBUG,
             "FD %d %p unref %d %" PRIdPTR " -> %" PRIdPTR " [%s; %s:%d]",
             fd->fd, fd, n, gpr_atm_no_barrier_load(&fd->refst),
@@ -360,7 +371,7 @@ static void unref_by(grpc_fd* fd, int n) {
   if (old == n) {
     gpr_mu_destroy(&fd->mu);
     grpc_iomgr_unregister_object(&fd->iomgr_object);
-    fork_fd_list_remove_node(fd->fork_fd_list);
+    fork_fd_list_remove_grpc_fd(fd);
     if (fd->shutdown) {
     }
     fd->shutdown_error.~Status();
@@ -582,9 +593,8 @@ static void fd_notify_on_write(grpc_fd* fd, grpc_closure* closure) {
 }
 
 static void fd_notify_on_error(grpc_fd* /*fd*/, grpc_closure* closure) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-    gpr_log(GPR_ERROR, "Polling engine does not support tracking errors.");
-  }
+  GRPC_TRACE_LOG(polling, ERROR)
+      << "Polling engine does not support tracking errors.";
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, absl::CancelledError());
 }
 
@@ -601,9 +611,8 @@ static void fd_set_writable(grpc_fd* fd) {
 }
 
 static void fd_set_error(grpc_fd* /*fd*/) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-    gpr_log(GPR_ERROR, "Polling engine does not support tracking errors.");
-  }
+  GRPC_TRACE_LOG(polling, ERROR)
+      << "Polling engine does not support tracking errors.";
 }
 
 static uint32_t fd_begin_poll(grpc_fd* fd, grpc_pollset* pollset,
@@ -859,7 +868,7 @@ static void pollset_destroy(grpc_pollset* pollset) {
   CHECK(!pollset_has_workers(pollset));
   while (pollset->local_wakeup_cache) {
     grpc_cached_wakeup_fd* next = pollset->local_wakeup_cache->next;
-    fork_fd_list_remove_node(pollset->local_wakeup_cache->fork_fd_list);
+    fork_fd_list_remove_wakeup_fd(pollset->local_wakeup_cache);
     grpc_wakeup_fd_destroy(&pollset->local_wakeup_cache->fd);
     gpr_free(pollset->local_wakeup_cache);
     pollset->local_wakeup_cache = next;
@@ -1020,7 +1029,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
       r = grpc_poll_function(pfds, pfd_count, timeout);
       GRPC_SCHEDULING_END_BLOCKING_REGION;
 
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(polling)) {
         gpr_log(GPR_INFO, "%p poll=%d", pollset, r);
       }
 
@@ -1044,7 +1053,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
         }
       } else {
         if (pfds[0].revents & POLLIN_CHECK) {
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+          if (GRPC_TRACE_FLAG_ENABLED(polling)) {
             gpr_log(GPR_INFO, "%p: got_wakeup", pollset);
           }
           work_combine_error(
@@ -1058,7 +1067,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
             }
             fd_end_poll(&watchers[i], 0, 0);
           } else {
-            if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
+            if (GRPC_TRACE_FLAG_ENABLED(polling)) {
               gpr_log(GPR_INFO, "%p got_event: %d r:%d w:%d [%d]", pollset,
                       pfds[i].fd, (pfds[i].revents & POLLIN_CHECK) != 0,
                       (pfds[i].revents & POLLOUT_CHECK) != 0, pfds[i].revents);
@@ -1397,7 +1406,7 @@ const grpc_event_engine_vtable grpc_ev_poll_posix = {
     // check_engine_available =
     [](bool) {
       if (!grpc_has_wakeup_fd()) {
-        gpr_log(GPR_ERROR, "Skipping poll because of no wakeup fd.");
+        LOG(ERROR) << "Skipping poll because of no wakeup fd.";
         return false;
       }
       if (!GRPC_LOG_IF_ERROR("pollset_global_init", pollset_global_init())) {

data/src/core/lib/iomgr/ev_posix.cc

@@ -25,6 +25,7 @@
 
 #include <string.h>
 
+#include "absl/log/log.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
 
@@ -34,25 +35,19 @@
 
 #include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
-
-grpc_core::DebugOnlyTraceFlag grpc_polling_trace(
-    false, "polling");  // Disabled by default
+#include "src/core/util/useful.h"
 
 // Traces fd create/close operations
-grpc_core::DebugOnlyTraceFlag grpc_fd_trace(false, "fd_trace");
-grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount(false, "fd_refcount");
-grpc_core::DebugOnlyTraceFlag grpc_polling_api_trace(false, "polling_api");
 
 // Polling API trace only enabled in debug builds
 #ifndef NDEBUG
 #define GRPC_POLLING_API_TRACE(format, ...)                  \
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_api_trace)) {     \
+  if (GRPC_TRACE_FLAG_ENABLED(polling_api)) {                \
     gpr_log(GPR_INFO, "(polling-api) " format, __VA_ARGS__); \
   }
 #else
@@ -109,7 +104,7 @@ static void try_engine(absl::string_view engine) {
     if (g_vtables[i] != nullptr && is(engine, g_vtables[i]->name) &&
         g_vtables[i]->check_engine_available(engine == g_vtables[i]->name)) {
       g_event_engine = g_vtables[i];
-      gpr_log(GPR_DEBUG, "Using polling engine: %s", g_event_engine->name);
+      VLOG(2) << "Using polling engine: " << g_event_engine->name;
       return;
     }
   }
@@ -339,4 +334,8 @@ void grpc_shutdown_background_closure(void) {
   g_event_engine->shutdown_background_closure();
 }
 
+#else  // GRPC_POSIX_SOCKET_EV
+
+const char* grpc_get_poll_strategy_name() { return ""; }
+
 #endif  // GRPC_POSIX_SOCKET_EV

data/src/core/lib/iomgr/ev_posix.h

@@ -19,6 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_EV_POSIX_H
 #define GRPC_SRC_CORE_LIB_IOMGR_EV_POSIX_H
 
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_EV
+
 #include <poll.h>
 
 #include <grpc/support/port_platform.h>
@@ -29,11 +33,8 @@
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
-extern grpc_core::DebugOnlyTraceFlag grpc_fd_trace;       // Disabled by default
-extern grpc_core::DebugOnlyTraceFlag grpc_polling_trace;  // Disabled by default
-
 #define GRPC_FD_TRACE(format, ...)                        \
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_fd_trace)) {           \
+  if (GRPC_TRACE_FLAG_ENABLED(fd_trace)) {                \
     gpr_log(GPR_INFO, "(fd-trace) " format, __VA_ARGS__); \
   }
 
@@ -99,9 +100,6 @@ void grpc_register_event_engine_factory(const grpc_event_engine_vtable* vtable,
 void grpc_event_engine_init(void);
 void grpc_event_engine_shutdown(void);
 
-// Return the name of the poll strategy
-const char* grpc_get_poll_strategy_name();
-
 // Returns true if polling engine can track errors separately, false otherwise.
 // If this is true, fd can be created with track_err set. After this, error
 // events will be reported using fd_notify_on_error. If it is not set, errors
@@ -207,4 +205,9 @@ void grpc_shutdown_background_closure();
 typedef int (*grpc_poll_function_type)(struct pollfd*, nfds_t, int);
 extern grpc_poll_function_type grpc_poll_function;
 
+#endif  // GRPC_POSIX_SOCKET_EV
+
+// Return the name of the poll strategy
+const char* grpc_get_poll_strategy_name();
+
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_EV_POSIX_H

data/src/core/lib/iomgr/event_engine_shims/closure.cc

@@ -34,7 +34,7 @@ void RunEventEngineClosure(grpc_closure* closure, grpc_error_handle error) {
   grpc_core::ExecCtx exec_ctx;
 #ifndef NDEBUG
   closure->scheduled = false;
-  if (grpc_trace_closure.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(closure)) {
     gpr_log(GPR_DEBUG,
             "EventEngine: running closure %p: created [%s:%d]: %s [%s:%d]",
             closure, closure->file_created, closure->line_created,
@@ -44,7 +44,7 @@ void RunEventEngineClosure(grpc_closure* closure, grpc_error_handle error) {
 #endif
   closure->cb(closure->cb_arg, error);
 #ifndef NDEBUG
-  if (grpc_trace_closure.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(closure)) {
     gpr_log(GPR_DEBUG, "EventEngine: closure %p finished", closure);
   }
 #endif