grpc 1.66.0 → 1.67.0.pre1

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

@@ -360,9 +360,8 @@ 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(fd_refcount)) {
-    VLOG(2) << "FD " << fd << " " << new_fd << " create " << fd_name;
-  }
+  GRPC_TRACE_VLOG(fd_refcount, 2)
+      << "FD " << fd << " " << new_fd << " create " << fd_name;
 #endif
 
   struct epoll_event ev;
@@ -727,9 +726,8 @@ 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(polling)) {
-    LOG(INFO) << "ps: " << ps << " poll got " << r << " events";
-  }
+  GRPC_TRACE_LOG(polling, INFO)
+      << "ps: " << ps << " poll got " << r << " events";
 
   gpr_atm_rel_store(&g_epoll_set.num_events, r);
   gpr_atm_rel_store(&g_epoll_set.cursor, 0);
@@ -746,9 +744,8 @@ 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(polling)) {
-    LOG(INFO) << "PS:" << pollset << " BEGIN_STARTS:" << worker;
-  }
+  GRPC_TRACE_LOG(polling, INFO)
+      << "PS:" << pollset << " BEGIN_STARTS:" << worker;
 
   if (pollset->seen_inactive) {
     // pollset has been observed to be inactive, we need to move back to the
@@ -765,11 +762,10 @@ 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(polling)) {
-      LOG(INFO) << "PS:" << pollset << " BEGIN_REORG:" << worker
-                << " kick_state=" << kick_state_string(worker->state)
-                << " is_reassigning=" << is_reassigning;
-    }
+    GRPC_TRACE_LOG(polling, INFO)
+        << "PS:" << pollset << " BEGIN_REORG:" << worker
+        << " kick_state=" << kick_state_string(worker->state)
+        << " is_reassigning=" << is_reassigning;
     if (pollset->seen_inactive) {
       if (neighborhood != pollset->neighborhood) {
         gpr_mu_unlock(&neighborhood->mu);
@@ -818,11 +814,10 @@ 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(polling)) {
-        LOG(INFO) << "PS:" << pollset << " BEGIN_WAIT:" << worker
-                  << " kick_state=" << kick_state_string(worker->state)
-                  << " shutdown=" << pollset->shutting_down;
-      }
+      GRPC_TRACE_LOG(polling, INFO)
+          << "PS:" << pollset << " BEGIN_WAIT:" << worker
+          << " kick_state=" << kick_state_string(worker->state)
+          << " shutdown=" << pollset->shutting_down;
 
       if (gpr_cv_wait(&worker->cv, &pollset->mu,
                       deadline.as_timespec(GPR_CLOCK_MONOTONIC)) &&
@@ -835,12 +830,11 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
     grpc_core::ExecCtx::Get()->InvalidateNow();
   }
 
-  if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-    LOG(INFO) << "PS:" << pollset << " BEGIN_DONE:" << worker
-              << " kick_state=" << kick_state_string(worker->state)
-              << " shutdown=" << pollset->shutting_down
-              << " kicked_without_poller: " << pollset->kicked_without_poller;
-  }
+  GRPC_TRACE_LOG(polling, INFO)
+      << "PS:" << pollset << " BEGIN_DONE:" << worker
+      << " kick_state=" << kick_state_string(worker->state)
+      << " shutdown=" << pollset->shutting_down
+      << " kicked_without_poller: " << pollset->kicked_without_poller;
 
   // We release pollset lock in this function at a couple of places:
   //   1. Briefly when assigning pollset to a neighborhood
@@ -877,17 +871,15 @@ 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(polling)) {
-                LOG(INFO) << " .. choose next poller to be " << inspect_worker;
-              }
+              GRPC_TRACE_LOG(polling, INFO)
+                  << " .. choose next poller to be " << inspect_worker;
               SET_KICK_STATE(inspect_worker, DESIGNATED_POLLER);
               if (inspect_worker->initialized_cv) {
                 gpr_cv_signal(&inspect_worker->cv);
               }
             } else {
-              if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-                LOG(INFO) << " .. beaten to choose next poller";
-              }
+              GRPC_TRACE_LOG(polling, INFO)
+                  << " .. beaten to choose next poller";
             }
             // even if we didn't win the cas, there's a worker, we can stop
             found_worker = true;
@@ -903,9 +895,8 @@ static bool check_neighborhood_for_available_poller(
       } while (!found_worker && inspect_worker != inspect->root_worker);
     }
     if (!found_worker) {
-      if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-        LOG(INFO) << " .. mark pollset " << inspect << " inactive";
-      }
+      GRPC_TRACE_LOG(polling, INFO)
+          << " .. mark pollset " << inspect << " inactive";
       inspect->seen_inactive = true;
       if (inspect == neighborhood->active_root) {
         neighborhood->active_root =
@@ -922,9 +913,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(polling)) {
-    LOG(INFO) << "PS:" << pollset << " END_WORKER:" << worker;
-  }
+  GRPC_TRACE_LOG(polling, INFO) << "PS:" << pollset << " END_WORKER:" << worker;
   if (worker_hdl != nullptr) *worker_hdl = nullptr;
   // Make sure we appear kicked
   SET_KICK_STATE(worker, KICKED);
@@ -933,9 +922,8 @@ 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(polling)) {
-        LOG(INFO) << " .. choose next poller to be peer " << worker;
-      }
+      GRPC_TRACE_LOG(polling, INFO)
+          << " .. choose next poller to be peer " << worker;
       CHECK(worker->next->initialized_cv);
       gpr_atm_no_barrier_store(&g_active_poller, (gpr_atm)worker->next);
       SET_KICK_STATE(worker->next, DESIGNATED_POLLER);
@@ -984,9 +972,7 @@ 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(polling)) {
-    LOG(INFO) << " .. remove worker";
-  }
+  GRPC_TRACE_LOG(polling, INFO) << " .. remove worker";
   if (EMPTIED == worker_remove(pollset, worker)) {
     pollset_maybe_finish_shutdown(pollset);
   }
@@ -1075,22 +1061,16 @@ 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(polling)) {
-          LOG(INFO) << " .. kicked_without_poller";
-        }
+        GRPC_TRACE_LOG(polling, INFO) << " .. kicked_without_poller";
         goto done;
       }
       grpc_pollset_worker* next_worker = root_worker->next;
       if (root_worker->state == KICKED) {
-        if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-          LOG(INFO) << " .. already kicked " << root_worker;
-        }
+        GRPC_TRACE_LOG(polling, INFO) << " .. already kicked " << root_worker;
         SET_KICK_STATE(root_worker, KICKED);
         goto done;
       } else if (next_worker->state == KICKED) {
-        if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-          LOG(INFO) << " .. already kicked " << next_worker;
-        }
+        GRPC_TRACE_LOG(polling, INFO) << " .. already kicked " << next_worker;
         SET_KICK_STATE(next_worker, KICKED);
         goto done;
       } else if (root_worker == next_worker &&  // only try and wake up a poller
@@ -1098,37 +1078,30 @@ 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(polling)) {
-          LOG(INFO) << " .. kicked " << root_worker;
-        }
+        GRPC_TRACE_LOG(polling, INFO) << " .. kicked " << 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(polling)) {
-          LOG(INFO) << " .. kicked " << next_worker;
-        }
+        GRPC_TRACE_LOG(polling, INFO) << " .. kicked " << next_worker;
         CHECK(next_worker->initialized_cv);
         SET_KICK_STATE(next_worker, KICKED);
         gpr_cv_signal(&next_worker->cv);
         goto done;
       } else if (next_worker->state == DESIGNATED_POLLER) {
         if (root_worker->state != DESIGNATED_POLLER) {
-          if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-            LOG(INFO) << " .. kicked root non-poller " << root_worker
-                      << " (initialized_cv=" << root_worker->initialized_cv
-                      << ") (poller=" << next_worker << ")";
-          }
+          GRPC_TRACE_LOG(polling, INFO)
+              << " .. kicked root non-poller " << root_worker
+              << " (initialized_cv=" << root_worker->initialized_cv
+              << ") (poller=" << next_worker << ")";
           SET_KICK_STATE(root_worker, KICKED);
           if (root_worker->initialized_cv) {
             gpr_cv_signal(&root_worker->cv);
           }
           goto done;
         } else {
-          if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-            LOG(INFO) << " .. non-root poller " << next_worker
-                      << " (root=" << root_worker << ")";
-          }
+          GRPC_TRACE_LOG(polling, INFO) << " .. non-root poller " << next_worker
+                                        << " (root=" << root_worker << ")";
           SET_KICK_STATE(next_worker, KICKED);
           ret_err = grpc_wakeup_fd_wakeup(&global_wakeup_fd);
           goto done;
@@ -1139,9 +1112,7 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
         goto done;
       }
     } else {
-      if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-        LOG(INFO) << " .. kicked while waking up";
-      }
+      GRPC_TRACE_LOG(polling, INFO) << " .. kicked while waking up";
       goto done;
     }
 
@@ -1149,36 +1120,27 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
   }
 
   if (specific_worker->state == KICKED) {
-    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-      LOG(INFO) << " .. specific worker already kicked";
-    }
+    GRPC_TRACE_LOG(polling, INFO) << " .. specific worker already kicked";
     goto done;
   } else if (g_current_thread_worker == specific_worker) {
-    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-      LOG(INFO) << " .. mark " << specific_worker << " kicked";
-    }
+    GRPC_TRACE_LOG(polling, INFO)
+        << " .. mark " << specific_worker << " kicked";
     SET_KICK_STATE(specific_worker, KICKED);
     goto done;
   } else if (specific_worker ==
              reinterpret_cast<grpc_pollset_worker*>(
                  gpr_atm_no_barrier_load(&g_active_poller))) {
-    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-      LOG(INFO) << " .. kick active poller";
-    }
+    GRPC_TRACE_LOG(polling, 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(polling)) {
-      LOG(INFO) << " .. kick waiting worker";
-    }
+    GRPC_TRACE_LOG(polling, INFO) << " .. kick waiting worker";
     SET_KICK_STATE(specific_worker, KICKED);
     gpr_cv_signal(&specific_worker->cv);
     goto done;
   } else {
-    if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-      LOG(INFO) << " .. kick non-waiting worker";
-    }
+    GRPC_TRACE_LOG(polling, INFO) << " .. kick non-waiting worker";
     SET_KICK_STATE(specific_worker, KICKED);
     goto done;
   }

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

@@ -332,12 +332,11 @@ 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(fd_refcount)) {
-    VLOG(2) << "FD " << fd->fd << " " << fd << "   ref " << n << " "
-            << gpr_atm_no_barrier_load(&fd->refst) << " -> "
-            << gpr_atm_no_barrier_load(&fd->refst) + n << " [" << reason << "; "
-            << file << ":" << line << "]";
-  }
+  GRPC_TRACE_VLOG(fd_refcount, 2)
+      << "FD " << fd->fd << " " << fd << "   ref " << n << " "
+      << gpr_atm_no_barrier_load(&fd->refst) << " -> "
+      << gpr_atm_no_barrier_load(&fd->refst) + n << " [" << reason << "; "
+      << file << ":" << line << "]";
 #else
 #define REF_BY(fd, n, reason) \
   do {                        \
@@ -357,12 +356,11 @@ 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(fd_refcount)) {
-    VLOG(2) << "FD " << fd->fd << " " << fd << " unref " << n << " "
-            << gpr_atm_no_barrier_load(&fd->refst) << " -> "
-            << gpr_atm_no_barrier_load(&fd->refst) - n << " [" << reason << "; "
-            << file << ":" << line << "]";
-  }
+  GRPC_TRACE_VLOG(fd_refcount, 2)
+      << "FD " << fd->fd << " " << fd << " unref " << n << " "
+      << gpr_atm_no_barrier_load(&fd->refst) << " -> "
+      << gpr_atm_no_barrier_load(&fd->refst) - n << " [" << reason << "; "
+      << file << ":" << line << "]";
 #else
 static void unref_by(grpc_fd* fd, int n) {
 #endif
@@ -1028,9 +1026,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(polling)) {
-        LOG(INFO) << pollset << " poll=" << r;
-      }
+      GRPC_TRACE_LOG(polling, INFO) << pollset << " poll=" << r;
 
       if (r < 0) {
         if (errno != EINTR) {
@@ -1052,9 +1048,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
         }
       } else {
         if (pfds[0].revents & POLLIN_CHECK) {
-          if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-            LOG(INFO) << pollset << ": got_wakeup";
-          }
+          GRPC_TRACE_LOG(polling, INFO) << pollset << ": got_wakeup";
           work_combine_error(
               &error, grpc_wakeup_fd_consume_wakeup(&worker.wakeup_fd->fd));
         }
@@ -1066,12 +1060,11 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
             }
             fd_end_poll(&watchers[i], 0, 0);
           } else {
-            if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-              LOG(INFO) << pollset << " got_event: " << pfds[i].fd
-                        << " r:" << ((pfds[i].revents & POLLIN_CHECK) != 0)
-                        << " w:" << ((pfds[i].revents & POLLOUT_CHECK) != 0)
-                        << " [" << pfds[i].revents << "]";
-            }
+            GRPC_TRACE_LOG(polling, INFO)
+                << pollset << " got_event: " << pfds[i].fd
+                << " r:" << ((pfds[i].revents & POLLIN_CHECK) != 0)
+                << " w:" << ((pfds[i].revents & POLLOUT_CHECK) != 0) << " ["
+                << pfds[i].revents << "]";
             // This is a mitigation to prevent poll() from spinning on a
             //* POLLHUP https://github.com/grpc/grpc/pull/13665
             //

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

@@ -30,7 +30,6 @@
 #include "absl/strings/str_split.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/config/config_vars.h"
@@ -42,18 +41,6 @@
 #include "src/core/lib/iomgr/internal_errqueue.h"
 #include "src/core/util/useful.h"
 
-// Traces fd create/close operations
-
-// Polling API trace only enabled in debug builds
-#ifndef NDEBUG
-#define GRPC_POLLING_API_TRACE(format, ...)                                \
-  if (GRPC_TRACE_FLAG_ENABLED(polling_api)) {                              \
-    LOG(INFO) << "(polling-api) " << absl::StrFormat(format, __VA_ARGS__); \
-  }
-#else
-#define GRPC_POLLING_API_TRACE(...)
-#endif  // NDEBUG
-
 /// Default poll() function - a pointer so that it can be overridden by some
 /// tests
 #ifndef GPR_AIX
@@ -165,8 +152,10 @@ bool grpc_event_engine_run_in_background(void) {
 }
 
 grpc_fd* grpc_fd_create(int fd, const char* name, bool track_err) {
-  GRPC_POLLING_API_TRACE("fd_create(%d, %s, %d)", fd, name, track_err);
-  GRPC_FD_TRACE("fd_create(%d, %s, %d)", fd, name, track_err);
+  GRPC_TRACE_DLOG(polling_api, INFO) << "(polling-api) fd_create(" << fd << ", "
+                                     << name << ", " << track_err << ")";
+  GRPC_TRACE_LOG(fd_trace, INFO) << "(fd-trace) fd_create(" << fd << ", "
+                                 << name << ", " << track_err << ")";
   return g_event_engine->fd_create(
       fd, name, track_err && grpc_event_engine_can_track_errors());
 }
@@ -177,22 +166,29 @@ int grpc_fd_wrapped_fd(grpc_fd* fd) {
 
 void grpc_fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
                     const char* reason) {
-  GRPC_POLLING_API_TRACE("fd_orphan(%d, %p, %p, %s)", grpc_fd_wrapped_fd(fd),
-                         on_done, release_fd, reason);
-  GRPC_FD_TRACE("grpc_fd_orphan, fd:%d closed", grpc_fd_wrapped_fd(fd));
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) fd_orphan(" << grpc_fd_wrapped_fd(fd) << ", " << on_done
+      << ", " << release_fd << ", " << reason << ")";
+  GRPC_TRACE_LOG(fd_trace, INFO)
+      << "(fd-trace) grpc_fd_orphan, fd:" << grpc_fd_wrapped_fd(fd)
+      << " closed";
 
   g_event_engine->fd_orphan(fd, on_done, release_fd, reason);
 }
 
 void grpc_fd_set_pre_allocated(grpc_fd* fd) {
-  GRPC_POLLING_API_TRACE("fd_set_pre_allocated(%d)", grpc_fd_wrapped_fd(fd));
-  GRPC_FD_TRACE("fd_set_pre_allocated(%d)", grpc_fd_wrapped_fd(fd));
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) fd_set_pre_allocated(" << grpc_fd_wrapped_fd(fd) << ")";
+  GRPC_TRACE_LOG(fd_trace, INFO)
+      << "(fd-trace) fd_set_pre_allocated(" << grpc_fd_wrapped_fd(fd) << ")";
   g_event_engine->fd_set_pre_allocated(fd);
 }
 
 void grpc_fd_shutdown(grpc_fd* fd, grpc_error_handle why) {
-  GRPC_POLLING_API_TRACE("fd_shutdown(%d)", grpc_fd_wrapped_fd(fd));
-  GRPC_FD_TRACE("fd_shutdown(%d)", grpc_fd_wrapped_fd(fd));
+  GRPC_TRACE_LOG(polling_api, INFO)
+      << "(polling-api) fd_shutdown(" << grpc_fd_wrapped_fd(fd) << ")";
+  GRPC_TRACE_LOG(fd_trace, INFO)
+      << "(fd-trace) fd_shutdown(" << grpc_fd_wrapped_fd(fd) << ")";
   g_event_engine->fd_shutdown(fd, why);
 }
 
@@ -221,41 +217,48 @@ void grpc_fd_set_error(grpc_fd* fd) { g_event_engine->fd_set_error(fd); }
 static size_t pollset_size(void) { return g_event_engine->pollset_size; }
 
 static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
-  GRPC_POLLING_API_TRACE("pollset_init(%p)", pollset);
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_init(" << pollset << ")";
   g_event_engine->pollset_init(pollset, mu);
 }
 
 static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
-  GRPC_POLLING_API_TRACE("pollset_shutdown(%p)", pollset);
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_shutdown(" << pollset << ")";
   g_event_engine->pollset_shutdown(pollset, closure);
 }
 
 static void pollset_destroy(grpc_pollset* pollset) {
-  GRPC_POLLING_API_TRACE("pollset_destroy(%p)", pollset);
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_destroy(" << pollset << ")";
   g_event_engine->pollset_destroy(pollset);
 }
 
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker,
                                       grpc_core::Timestamp deadline) {
-  GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") begin", pollset,
-                         deadline.milliseconds_after_process_epoch());
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_work(" << pollset << ", "
+      << deadline.milliseconds_after_process_epoch() << ") begin";
   grpc_error_handle err =
       g_event_engine->pollset_work(pollset, worker, deadline);
-  GRPC_POLLING_API_TRACE("pollset_work(%p, %" PRId64 ") end", pollset,
-                         deadline.milliseconds_after_process_epoch());
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_work(" << pollset << ", "
+      << deadline.milliseconds_after_process_epoch() << ") end";
   return err;
 }
 
 static grpc_error_handle pollset_kick(grpc_pollset* pollset,
                                       grpc_pollset_worker* specific_worker) {
-  GRPC_POLLING_API_TRACE("pollset_kick(%p, %p)", pollset, specific_worker);
+  GRPC_TRACE_DLOG(polling_api, INFO) << "(polling-api) pollset_kick(" << pollset
+                                     << ", " << specific_worker << ")";
   return g_event_engine->pollset_kick(pollset, specific_worker);
 }
 
 void grpc_pollset_add_fd(grpc_pollset* pollset, struct grpc_fd* fd) {
-  GRPC_POLLING_API_TRACE("pollset_add_fd(%p, %d)", pollset,
-                         grpc_fd_wrapped_fd(fd));
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_add_fd(" << pollset << ", "
+      << grpc_fd_wrapped_fd(fd) << ")";
   g_event_engine->pollset_add_fd(pollset, fd);
 }
 
@@ -270,38 +273,44 @@ grpc_pollset_vtable grpc_posix_pollset_vtable = {
 
 static grpc_pollset_set* pollset_set_create(void) {
   grpc_pollset_set* pss = g_event_engine->pollset_set_create();
-  GRPC_POLLING_API_TRACE("pollset_set_create(%p)", pss);
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_set_create(" << pss << ")";
   return pss;
 }
 
 static void pollset_set_destroy(grpc_pollset_set* pollset_set) {
-  GRPC_POLLING_API_TRACE("pollset_set_destroy(%p)", pollset_set);
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_set_destroy(" << pollset_set << ")";
   g_event_engine->pollset_set_destroy(pollset_set);
 }
 
 static void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
                                     grpc_pollset* pollset) {
-  GRPC_POLLING_API_TRACE("pollset_set_add_pollset(%p, %p)", pollset_set,
-                         pollset);
+  GRPC_TRACE_DLOG(polling_api, INFO) << "(polling-api) pollset_set_add_pollset("
+                                     << pollset_set << ", " << pollset << ")";
   g_event_engine->pollset_set_add_pollset(pollset_set, pollset);
 }
 
 static void pollset_set_del_pollset(grpc_pollset_set* pollset_set,
                                     grpc_pollset* pollset) {
-  GRPC_POLLING_API_TRACE("pollset_set_del_pollset(%p, %p)", pollset_set,
-                         pollset);
+  GRPC_TRACE_DLOG(polling_api, INFO) << "(polling-api) pollset_set_del_pollset("
+                                     << pollset_set << ", " << pollset << ")";
   g_event_engine->pollset_set_del_pollset(pollset_set, pollset);
 }
 
 static void pollset_set_add_pollset_set(grpc_pollset_set* bag,
                                         grpc_pollset_set* item) {
-  GRPC_POLLING_API_TRACE("pollset_set_add_pollset_set(%p, %p)", bag, item);
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_set_add_pollset_set(" << bag << ", " << item
+      << ")";
   g_event_engine->pollset_set_add_pollset_set(bag, item);
 }
 
 static void pollset_set_del_pollset_set(grpc_pollset_set* bag,
                                         grpc_pollset_set* item) {
-  GRPC_POLLING_API_TRACE("pollset_set_del_pollset_set(%p, %p)", bag, item);
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_set_del_pollset_set(" << bag << ", " << item
+      << ")";
   g_event_engine->pollset_set_del_pollset_set(bag, item);
 }
 
@@ -311,14 +320,16 @@ grpc_pollset_set_vtable grpc_posix_pollset_set_vtable = {
     pollset_set_add_pollset_set, pollset_set_del_pollset_set};
 
 void grpc_pollset_set_add_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
-  GRPC_POLLING_API_TRACE("pollset_set_add_fd(%p, %d)", pollset_set,
-                         grpc_fd_wrapped_fd(fd));
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_set_add_fd(" << pollset_set << ", "
+      << grpc_fd_wrapped_fd(fd) << ")";
   g_event_engine->pollset_set_add_fd(pollset_set, fd);
 }
 
 void grpc_pollset_set_del_fd(grpc_pollset_set* pollset_set, grpc_fd* fd) {
-  GRPC_POLLING_API_TRACE("pollset_set_del_fd(%p, %d)", pollset_set,
-                         grpc_fd_wrapped_fd(fd));
+  GRPC_TRACE_DLOG(polling_api, INFO)
+      << "(polling-api) pollset_set_del_fd(" << pollset_set << ", "
+      << grpc_fd_wrapped_fd(fd) << ")";
   g_event_engine->pollset_set_del_fd(pollset_set, fd);
 }
 

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

@@ -33,11 +33,6 @@
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 
-#define GRPC_FD_TRACE(format, ...)                                      \
-  if (GRPC_TRACE_FLAG_ENABLED(fd_trace)) {                              \
-    LOG(INFO) << "(fd-trace) " << absl::StrFormat(format, __VA_ARGS__); \
-  }
-
 typedef struct grpc_fd grpc_fd;
 
 typedef struct grpc_event_engine_vtable {

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

@@ -35,18 +35,16 @@ void RunEventEngineClosure(grpc_closure* closure, grpc_error_handle error) {
   grpc_core::ExecCtx exec_ctx;
 #ifndef NDEBUG
   closure->scheduled = false;
-  if (GRPC_TRACE_FLAG_ENABLED(closure)) {
-    VLOG(2) << "EventEngine: running closure " << closure << ": created ["
-            << closure->file_created << ":" << closure->line_created
-            << "]: " << (closure->run ? "run" : "scheduled") << " ["
-            << closure->file_initiated << ":" << closure->line_initiated << "]";
-  }
+  GRPC_TRACE_VLOG(closure, 2)
+      << "EventEngine: running closure " << closure << ": created ["
+      << closure->file_created << ":" << closure->line_created
+      << "]: " << (closure->run ? "run" : "scheduled") << " ["
+      << closure->file_initiated << ":" << closure->line_initiated << "]";
 #endif
   closure->cb(closure->cb_arg, error);
 #ifndef NDEBUG
-  if (GRPC_TRACE_FLAG_ENABLED(closure)) {
-    VLOG(2) << "EventEngine: closure " << closure << " finished";
-  }
+  GRPC_TRACE_VLOG(closure, 2)
+      << "EventEngine: closure " << closure << " finished";
 #endif
 }
 

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

@@ -173,10 +173,9 @@ class EventEngineEndpointWrapper {
   void FinishPendingWrite(absl::Status status) {
     auto* write_buffer = reinterpret_cast<SliceBuffer*>(&eeep_->write_buffer);
     write_buffer->~SliceBuffer();
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(INFO) << "TCP: " << this << " WRITE (peer=" << PeerAddress()
-                << ") error=" << status;
-    }
+    GRPC_TRACE_LOG(tcp, INFO)
+        << "TCP: " << this << " WRITE (peer=" << PeerAddress()
+        << ") error=" << status;
     grpc_closure* cb = pending_write_cb_;
     pending_write_cb_ = nullptr;
     if (grpc_core::ExecCtx::Get() == nullptr) {

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

@@ -32,21 +32,18 @@
 static void exec_ctx_run(grpc_closure* closure) {
 #ifndef NDEBUG
   closure->scheduled = false;
-  if (GRPC_TRACE_FLAG_ENABLED(closure)) {
-    VLOG(2) << "running closure " << closure << ": created ["
-            << closure->file_created << ":" << closure->line_created
-            << "]: " << (closure->run ? "run" : "scheduled") << " ["
-            << closure->file_initiated << ":" << closure->line_initiated << "]";
-  }
+  GRPC_TRACE_VLOG(closure, 2)
+      << "running closure " << closure << ": created [" << closure->file_created
+      << ":" << closure->line_created
+      << "]: " << (closure->run ? "run" : "scheduled") << " ["
+      << closure->file_initiated << ":" << closure->line_initiated << "]";
 #endif
   grpc_error_handle error =
       grpc_core::internal::StatusMoveFromHeapPtr(closure->error_data.error);
   closure->error_data.error = 0;
   closure->cb(closure->cb_arg, std::move(error));
 #ifndef NDEBUG
-  if (GRPC_TRACE_FLAG_ENABLED(closure)) {
-    VLOG(2) << "closure " << closure << " finished";
-  }
+  GRPC_TRACE_VLOG(closure, 2) << "closure " << closure << " finished";
 #endif
 }