grpc 1.65.2 → 1.66.0.pre3

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

@@ -25,6 +25,7 @@
 #import <CoreFoundation/CoreFoundation.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
@@ -75,9 +76,8 @@ static void CFStreamUnref(CFStreamEndpoint* ep, const char* reason,
                           const char* file, int line) {
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&ep->refcount.count);
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "CFStream endpoint unref %p : %s %" PRIdPTR " -> %" PRIdPTR, ep,
-            reason, val, val - 1);
+    VLOG(2) << "CFStream endpoint unref " << ep << " : " << reason << " " << val
+            << " -> " << val - 1;
   }
   if (gpr_unref(&ep->refcount)) {
     CFStreamFree(ep);
@@ -87,9 +87,8 @@ static void CFStreamRef(CFStreamEndpoint* ep, const char* reason,
                         const char* file, int line) {
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&ep->refcount.count);
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "CFStream endpoint ref %p : %s %" PRIdPTR " -> %" PRIdPTR, ep,
-            reason, val, val + 1);
+    VLOG(2) << "CFStream endpoint ref " << ep << " : " << reason << " " << val
+            << " -> " << val + 1;
   }
   gpr_ref(&ep->refcount);
 }
@@ -111,17 +110,15 @@ static grpc_error_handle CFStreamAnnotateError(grpc_error_handle src_error) {
 
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p call_read_cb %p %p:%p", ep,
-            ep->read_cb, ep->read_cb->cb, ep->read_cb->cb_arg);
+    VLOG(2) << "CFStream endpoint:" << ep << " call_read_cb " << ep->read_cb
+            << " " << ep->read_cb->cb << ":" << ep->read_cb->cb_arg;
     size_t i;
-    gpr_log(GPR_DEBUG, "read: error=%s",
-            grpc_core::StatusToString(error).c_str());
+    VLOG(2) << "read: error=" << grpc_core::StatusToString(error);
 
     for (i = 0; i < ep->read_slices->count; i++) {
       char* dump = grpc_dump_slice(ep->read_slices->slices[i],
                                    GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_DEBUG, "READ %p (peer=%s): %s", ep, ep->peer_string.c_str(),
-              dump);
+      VLOG(2) << "READ " << ep << " (peer=" << ep->peer_string << "): " << dump;
       gpr_free(dump);
     }
   }
@@ -133,10 +130,9 @@ static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
 
 static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p call_write_cb %p %p:%p", ep,
-            ep->write_cb, ep->write_cb->cb, ep->write_cb->cb_arg);
-    gpr_log(GPR_DEBUG, "write: error=%s",
-            grpc_core::StatusToString(error).c_str());
+    VLOG(2) << "CFStream endpoint:" << ep << " call_write_cb " << ep->write_cb
+            << " " << ep->write_cb->cb << ":" << ep->write_cb->cb_arg;
+    VLOG(2) << "write: error=" << grpc_core::StatusToString(error);
   }
   grpc_closure* cb = ep->write_cb;
   ep->write_cb = nullptr;
@@ -224,8 +220,8 @@ static void WriteAction(void* arg, grpc_error_handle error) {
     if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
       grpc_slice trace_slice = grpc_slice_sub(slice, 0, write_size);
       char* dump = grpc_dump_slice(trace_slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", ep, ep->peer_string.c_str(),
-              dump);
+      VLOG(2) << "WRITE " << ep << " (peer=" << ep->peer_string
+              << "): " << dump;
       gpr_free(dump);
       grpc_core::CSliceUnref(trace_slice);
     }
@@ -238,8 +234,8 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
                          int /*min_progress_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p read (%p, %p) length:%zu", ep_impl,
-            slices, cb, slices->length);
+    VLOG(2) << "CFStream endpoint:" << ep_impl << " read (" << slices << ", "
+            << cb << ") length:" << slices->length;
   }
   CHECK_EQ(ep_impl->read_cb, nullptr);
   ep_impl->read_cb = cb;
@@ -256,8 +252,8 @@ static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
                           int /*max_frame_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p write (%p, %p) length:%zu",
-            ep_impl, slices, cb, slices->length);
+    VLOG(2) << "CFStream endpoint:" << ep_impl << " write (" << slices << ", "
+            << cb << ") length:" << slices->length;
   }
   CHECK_EQ(ep_impl->write_cb, nullptr);
   ep_impl->write_cb = cb;
@@ -313,9 +309,9 @@ grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
                                              CFStreamHandle* stream_sync) {
   CFStreamEndpoint* ep_impl = new CFStreamEndpoint;
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_DEBUG,
-            "CFStream endpoint:%p create readStream:%p writeStream: %p",
-            ep_impl, read_stream, write_stream);
+    VLOG(2) << "CFStream endpoint:" << ep_impl
+            << " create readStream:" << read_stream
+            << " writeStream: " << write_stream;
   }
   ep_impl->base.vtable = &vtable;
   gpr_ref_init(&ep_impl->refcount, 1);

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

@@ -21,12 +21,12 @@
 #include <string.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
@@ -221,7 +221,7 @@ grpc_error_handle grpc_error_add_child(grpc_error_handle src,
 bool grpc_log_error(const char* what, grpc_error_handle error, const char* file,
                     int line) {
   DCHECK(!error.ok());
-  gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "%s: %s", what,
-          grpc_core::StatusToString(error).c_str());
+  LOG(ERROR).AtLocation(file, line)
+      << what << ": " << grpc_core::StatusToString(error);
   return false;
 }

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

@@ -40,9 +40,9 @@
 #include "src/core/lib/iomgr/ev_apple.h"
 
 #ifndef NDEBUG
-#define GRPC_POLLING_TRACE(format, ...)                   \
-  if (GRPC_TRACE_FLAG_ENABLED(apple_polling)) {           \
-    gpr_log(GPR_DEBUG, "(polling) " format, __VA_ARGS__); \
+#define GRPC_POLLING_TRACE(format, ...)                              \
+  if (GRPC_TRACE_FLAG_ENABLED(apple_polling)) {                      \
+    VLOG(2) << "(polling) " << absl::StrFormat(format, __VA_ARGS__); \
   }
 #else
 #define GRPC_POLLING_TRACE(...)

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

@@ -16,9 +16,6 @@
 //
 //
 
-#include "absl/log/check.h"
-
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -41,6 +38,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -363,7 +361,7 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
   fork_fd_list_add_grpc_fd(new_fd);
 #ifndef NDEBUG
   if (GRPC_TRACE_FLAG_ENABLED(fd_refcount)) {
-    gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, new_fd, fd_name.c_str());
+    VLOG(2) << "FD " << fd << " " << new_fd << " create " << fd_name;
   }
 #endif
 
@@ -377,8 +375,7 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
   ev.data.ptr = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(new_fd) |
                                         (track_err ? 1 : 0));
   if (epoll_ctl(g_epoll_set.epfd, EPOLL_CTL_ADD, fd, &ev) != 0) {
-    gpr_log(GPR_ERROR, "epoll_ctl failed: %s",
-            grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "epoll_ctl failed: " << grpc_core::StrError(errno);
   }
 
   return new_fd;
@@ -401,8 +398,7 @@ static void fd_shutdown_internal(grpc_fd* fd, grpc_error_handle why,
       epoll_event phony_event;
       if (epoll_ctl(g_epoll_set.epfd, EPOLL_CTL_DEL, fd->fd, &phony_event) !=
           0) {
-        gpr_log(GPR_ERROR, "epoll_ctl failed: %s",
-                grpc_core::StrError(errno).c_str());
+        LOG(ERROR) << "epoll_ctl failed: " << grpc_core::StrError(errno);
       }
     }
     fd->write_closure->SetShutdown(why);
@@ -732,7 +728,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(polling)) {
-    gpr_log(GPR_INFO, "ps: %p poll got %d events", ps, r);
+    LOG(INFO) << "ps: " << ps << " poll got " << r << " events";
   }
 
   gpr_atm_rel_store(&g_epoll_set.num_events, r);
@@ -751,7 +747,7 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
   pollset->begin_refs++;
 
   if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-    gpr_log(GPR_INFO, "PS:%p BEGIN_STARTS:%p", pollset, worker);
+    LOG(INFO) << "PS:" << pollset << " BEGIN_STARTS:" << worker;
   }
 
   if (pollset->seen_inactive) {
@@ -770,9 +766,9 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
     gpr_mu_lock(&neighborhood->mu);
     gpr_mu_lock(&pollset->mu);
     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);
+      LOG(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) {
@@ -823,9 +819,9 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
     gpr_cv_init(&worker->cv);
     while (worker->state == UNKICKED && !pollset->shutting_down) {
       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);
+        LOG(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,
@@ -840,11 +836,10 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
   }
 
   if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-    gpr_log(GPR_INFO,
-            "PS:%p BEGIN_DONE:%p kick_state=%s shutdown=%d "
-            "kicked_without_poller: %d",
-            pollset, worker, kick_state_string(worker->state),
-            pollset->shutting_down, pollset->kicked_without_poller);
+    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;
   }
 
   // We release pollset lock in this function at a couple of places:
@@ -883,8 +878,7 @@ static bool check_neighborhood_for_available_poller(
                     &g_active_poller, 0,
                     reinterpret_cast<gpr_atm>(inspect_worker))) {
               if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-                gpr_log(GPR_INFO, " .. choose next poller to be %p",
-                        inspect_worker);
+                LOG(INFO) << " .. choose next poller to be " << inspect_worker;
               }
               SET_KICK_STATE(inspect_worker, DESIGNATED_POLLER);
               if (inspect_worker->initialized_cv) {
@@ -910,7 +904,7 @@ static bool check_neighborhood_for_available_poller(
     }
     if (!found_worker) {
       if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-        gpr_log(GPR_INFO, " .. mark pollset %p inactive", inspect);
+        LOG(INFO) << " .. mark pollset " << inspect << " inactive";
       }
       inspect->seen_inactive = true;
       if (inspect == neighborhood->active_root) {
@@ -929,7 +923,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)) {
-    gpr_log(GPR_INFO, "PS:%p END_WORKER:%p", pollset, worker);
+    LOG(INFO) << "PS:" << pollset << " END_WORKER:" << worker;
   }
   if (worker_hdl != nullptr) *worker_hdl = nullptr;
   // Make sure we appear kicked
@@ -940,7 +934,7 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
       reinterpret_cast<gpr_atm>(worker)) {
     if (worker->next != worker && worker->next->state == UNKICKED) {
       if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-        gpr_log(GPR_INFO, " .. choose next poller to be peer %p", worker);
+        LOG(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);
@@ -1073,7 +1067,7 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
       log.push_back(absl::StrFormat(" worker_kick_state=%s",
                                     kick_state_string(specific_worker->state)));
     }
-    gpr_log(GPR_DEBUG, "%s", absl::StrJoin(log, "").c_str());
+    VLOG(2) << absl::StrJoin(log, "");
   }
 
   if (specific_worker == nullptr) {
@@ -1089,13 +1083,13 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
       grpc_pollset_worker* next_worker = root_worker->next;
       if (root_worker->state == KICKED) {
         if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-          gpr_log(GPR_INFO, " .. already kicked %p", root_worker);
+          LOG(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)) {
-          gpr_log(GPR_INFO, " .. already kicked %p", next_worker);
+          LOG(INFO) << " .. already kicked " << next_worker;
         }
         SET_KICK_STATE(next_worker, KICKED);
         goto done;
@@ -1105,14 +1099,14 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
                      reinterpret_cast<grpc_pollset_worker*>(
                          gpr_atm_no_barrier_load(&g_active_poller))) {
         if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-          gpr_log(GPR_INFO, " .. kicked %p", root_worker);
+          LOG(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)) {
-          gpr_log(GPR_INFO, " .. kicked %p", next_worker);
+          LOG(INFO) << " .. kicked " << next_worker;
         }
         CHECK(next_worker->initialized_cv);
         SET_KICK_STATE(next_worker, KICKED);
@@ -1121,10 +1115,9 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
       } else if (next_worker->state == DESIGNATED_POLLER) {
         if (root_worker->state != DESIGNATED_POLLER) {
           if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-            gpr_log(
-                GPR_INFO,
-                " .. kicked root non-poller %p (initialized_cv=%d) (poller=%p)",
-                root_worker, root_worker->initialized_cv, next_worker);
+            LOG(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) {
@@ -1133,8 +1126,8 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
           goto done;
         } else {
           if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-            gpr_log(GPR_INFO, " .. non-root poller %p (root=%p)", next_worker,
-                    root_worker);
+            LOG(INFO) << " .. non-root poller " << next_worker
+                      << " (root=" << root_worker << ")";
           }
           SET_KICK_STATE(next_worker, KICKED);
           ret_err = grpc_wakeup_fd_wakeup(&global_wakeup_fd);
@@ -1162,7 +1155,7 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
     goto done;
   } else if (g_current_thread_worker == specific_worker) {
     if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-      gpr_log(GPR_INFO, " .. mark %p kicked", specific_worker);
+      LOG(INFO) << " .. mark " << specific_worker << " kicked";
     }
     SET_KICK_STATE(specific_worker, KICKED);
     goto done;

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

@@ -39,7 +39,6 @@
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/thd.h"
@@ -334,10 +333,10 @@ static void fork_fd_list_add_wakeup_fd(grpc_cached_wakeup_fd* fd) {
 static void ref_by(grpc_fd* fd, int n, const char* reason, const char* file,
                    int line) {
   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),
-            gpr_atm_no_barrier_load(&fd->refst) + n, reason, file, line);
+    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 << "]";
   }
 #else
 #define REF_BY(fd, n, reason) \
@@ -359,10 +358,10 @@ static void ref_by(grpc_fd* fd, int n) {
 static void unref_by(grpc_fd* fd, int n, const char* reason, const char* file,
                      int line) {
   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),
-            gpr_atm_no_barrier_load(&fd->refst) - n, reason, file, line);
+    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 << "]";
   }
 #else
 static void unref_by(grpc_fd* fd, int n) {
@@ -1030,7 +1029,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
       GRPC_SCHEDULING_END_BLOCKING_REGION;
 
       if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-        gpr_log(GPR_INFO, "%p poll=%d", pollset, r);
+        LOG(INFO) << pollset << " poll=" << r;
       }
 
       if (r < 0) {
@@ -1054,7 +1053,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
       } else {
         if (pfds[0].revents & POLLIN_CHECK) {
           if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-            gpr_log(GPR_INFO, "%p: got_wakeup", pollset);
+            LOG(INFO) << pollset << ": got_wakeup";
           }
           work_combine_error(
               &error, grpc_wakeup_fd_consume_wakeup(&worker.wakeup_fd->fd));
@@ -1068,9 +1067,10 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
             fd_end_poll(&watchers[i], 0, 0);
           } else {
             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);
+              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 << "]";
             }
             // 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

@@ -46,9 +46,9 @@
 
 // Polling API trace only enabled in debug builds
 #ifndef NDEBUG
-#define GRPC_POLLING_API_TRACE(format, ...)                  \
-  if (GRPC_TRACE_FLAG_ENABLED(polling_api)) {                \
-    gpr_log(GPR_INFO, "(polling-api) " format, __VA_ARGS__); \
+#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(...)
@@ -104,7 +104,8 @@ 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];
-      VLOG(2) << "Using polling engine: " << g_event_engine->name;
+      GRPC_TRACE_VLOG(polling_api, 2)
+          << "Using polling engine: " << g_event_engine->name;
       return;
     }
   }

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

@@ -33,9 +33,9 @@
 #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)) {                \
-    gpr_log(GPR_INFO, "(fd-trace) " format, __VA_ARGS__); \
+#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;

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

@@ -14,6 +14,7 @@
 #include "src/core/lib/iomgr/event_engine_shims/closure.h"
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 
 #include <grpc/event_engine/event_engine.h>
@@ -35,17 +36,16 @@ void RunEventEngineClosure(grpc_closure* closure, grpc_error_handle error) {
 #ifndef NDEBUG
   closure->scheduled = false;
   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,
-            closure->run ? "run" : "scheduled", closure->file_initiated,
-            closure->line_initiated);
+    VLOG(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)) {
-    gpr_log(GPR_DEBUG, "EventEngine: closure %p finished", closure);
+    VLOG(2) << "EventEngine: closure " << closure << " finished";
   }
 #endif
 }

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

@@ -28,16 +28,14 @@
 #include <grpc/impl/codegen/slice.h>
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/extensions/can_track_errors.h"
 #include "src/core/lib/event_engine/extensions/supports_fd.h"
 #include "src/core/lib/event_engine/query_extensions.h"
-#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/gprpp/construct_destruct.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -121,8 +119,7 @@ class EventEngineEndpointWrapper {
     read_buffer->~SliceBuffer();
     if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
       size_t i;
-      gpr_log(GPR_INFO, "TCP: %p READ error=%s", eeep_->wrapper,
-              status.ToString().c_str());
+      LOG(INFO) << "TCP: " << eeep_->wrapper << " READ error=" << status;
       if (ABSL_VLOG_IS_ON(2)) {
         for (i = 0; i < pending_read_buffer_->count; i++) {
           char* dump = grpc_dump_slice(pending_read_buffer_->slices[i],
@@ -152,8 +149,7 @@ class EventEngineEndpointWrapper {
     Ref();
     if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
       size_t i;
-      gpr_log(GPR_INFO, "TCP: %p WRITE (peer=%s)", this,
-              std::string(PeerAddress()).c_str());
+      LOG(INFO) << "TCP: " << this << " WRITE (peer=" << PeerAddress() << ")";
       if (ABSL_VLOG_IS_ON(2)) {
         for (i = 0; i < slices->count; i++) {
           char* dump =
@@ -178,8 +174,8 @@ class EventEngineEndpointWrapper {
     auto* write_buffer = reinterpret_cast<SliceBuffer*>(&eeep_->write_buffer);
     write_buffer->~SliceBuffer();
     if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      gpr_log(GPR_INFO, "TCP: %p WRITE (peer=%s) error=%s", this,
-              std::string(PeerAddress()).c_str(), status.ToString().c_str());
+      LOG(INFO) << "TCP: " << this << " WRITE (peer=" << PeerAddress()
+                << ") error=" << status;
     }
     grpc_closure* cb = pending_write_cb_;
     pending_write_cb_ = nullptr;
@@ -353,7 +349,8 @@ void EndpointDestroy(grpc_endpoint* ep) {
   auto* eeep =
       reinterpret_cast<EventEngineEndpointWrapper::grpc_event_engine_endpoint*>(
           ep);
-  GRPC_EVENT_ENGINE_TRACE("EventEngine::Endpoint %p Destroy", eeep->wrapper);
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "EventEngine::Endpoint::" << eeep->wrapper << " EndpointDestroy";
   eeep->wrapper->TriggerShutdown(nullptr);
   eeep->wrapper->Unref();
 }
@@ -411,7 +408,8 @@ EventEngineEndpointWrapper::EventEngineEndpointWrapper(
   } else {
     fd_ = -1;
   }
-  GRPC_EVENT_ENGINE_TRACE("EventEngine::Endpoint %p Create", eeep_->wrapper);
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "EventEngine::Endpoint " << eeep_->wrapper << " Create";
 }
 
 }  // namespace

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

@@ -15,17 +15,15 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
@@ -64,8 +62,8 @@ int64_t event_engine_tcp_client_connect(
         } else {
           *endpoint = nullptr;
         }
-        GRPC_EVENT_ENGINE_TRACE("EventEngine::Connect Status: %s",
-                                ep.status().ToString().c_str());
+        GRPC_TRACE_LOG(event_engine, INFO)
+            << "EventEngine::Connect Status: " << ep.status();
         grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_connect,
                                 absl_status_to_grpc_error(conn_status));
       },
@@ -75,15 +73,14 @@ int64_t event_engine_tcp_client_connect(
           : grpc_event_engine::experimental::MemoryAllocator(),
       std::max(grpc_core::Duration::Milliseconds(1),
                deadline - grpc_core::Timestamp::Now()));
-  GRPC_EVENT_ENGINE_TRACE("EventEngine::Connect Peer: %s, handle: %" PRId64,
-                          (*addr_uri).c_str(),
-                          static_cast<int64_t>(handle.keys[0]));
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "EventEngine::Connect Peer: " << *addr_uri << ", handle: " << handle;
   return handle.keys[0];
 }
 
 bool event_engine_tcp_client_cancel_connect(int64_t connection_handle) {
-  GRPC_EVENT_ENGINE_TRACE("EventEngine::CancelConnect handle: %" PRId64,
-                          connection_handle);
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "EventEngine::CancelConnect handle: " << connection_handle;
   return GetDefaultEventEngine()->CancelConnect(
       {static_cast<intptr_t>(connection_handle), 0});
 }