grpc 1.66.0 → 1.67.0.pre1

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

@@ -618,18 +618,14 @@ static void tcp_drop_uncovered_then_handle_write(void* arg /* grpc_tcp */,
 
 static void done_poller(void* bp, grpc_error_handle /*error_ignored*/) {
   backup_poller* p = static_cast<backup_poller*>(bp);
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "BACKUP_POLLER:" << p << " destroy";
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " destroy";
   grpc_pollset_destroy(BACKUP_POLLER_POLLSET(p));
   gpr_free(p);
 }
 
 static void run_poller(void* bp, grpc_error_handle /*error_ignored*/) {
   backup_poller* p = static_cast<backup_poller*>(bp);
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "BACKUP_POLLER:" << p << " run";
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " run";
   gpr_mu_lock(p->pollset_mu);
   grpc_core::Timestamp deadline =
       grpc_core::Timestamp::Now() + grpc_core::Duration::Seconds(10);
@@ -644,17 +640,13 @@ static void run_poller(void* bp, grpc_error_handle /*error_ignored*/) {
     g_backup_poller = nullptr;
     g_uncovered_notifications_pending = 0;
     g_backup_poller_mu->Unlock();
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(INFO) << "BACKUP_POLLER:" << p << " shutdown";
-    }
+    GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " shutdown";
     grpc_pollset_shutdown(BACKUP_POLLER_POLLSET(p),
                           GRPC_CLOSURE_INIT(&p->run_poller, done_poller, p,
                                             grpc_schedule_on_exec_ctx));
   } else {
     g_backup_poller_mu->Unlock();
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(INFO) << "BACKUP_POLLER:" << p << " reschedule";
-    }
+    GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " reschedule";
     grpc_core::Executor::Run(&p->run_poller, absl::OkStatus(),
                              grpc_core::ExecutorType::DEFAULT,
                              grpc_core::ExecutorJobType::LONG);
@@ -669,10 +661,8 @@ static void drop_uncovered(grpc_tcp* /*tcp*/) {
   old_count = g_uncovered_notifications_pending--;
   g_backup_poller_mu->Unlock();
   CHECK_GT(old_count, 1);
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "BACKUP_POLLER:" << p << " uncover cnt " << old_count << "->"
-              << old_count - 1;
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " uncover cnt "
+                            << old_count << "->" << old_count - 1;
 }
 
 // gRPC API considers a Write operation to be done the moment it clears ‘flow
@@ -693,9 +683,7 @@ static void cover_self(grpc_tcp* tcp) {
     g_backup_poller = p;
     grpc_pollset_init(BACKUP_POLLER_POLLSET(p), &p->pollset_mu);
     g_backup_poller_mu->Unlock();
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(INFO) << "BACKUP_POLLER:" << p << " create";
-    }
+    GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " create";
     grpc_core::Executor::Run(
         GRPC_CLOSURE_INIT(&p->run_poller, run_poller, p, nullptr),
         absl::OkStatus(), grpc_core::ExecutorType::DEFAULT,
@@ -705,24 +693,18 @@ static void cover_self(grpc_tcp* tcp) {
     p = g_backup_poller;
     g_backup_poller_mu->Unlock();
   }
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "BACKUP_POLLER:" << p << " add " << tcp << " cnt "
-              << old_count - 1 << "->" << old_count;
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " add " << tcp
+                            << " cnt " << old_count - 1 << "->" << old_count;
   grpc_pollset_add_fd(BACKUP_POLLER_POLLSET(p), tcp->em_fd);
 }
 
 static void notify_on_read(grpc_tcp* tcp) {
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "TCP:" << tcp << " notify_on_read";
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "TCP:" << tcp << " notify_on_read";
   grpc_fd_notify_on_read(tcp->em_fd, &tcp->read_done_closure);
 }
 
 static void notify_on_write(grpc_tcp* tcp) {
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "TCP:" << tcp << " notify_on_write";
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "TCP:" << tcp << " notify_on_write";
   if (!grpc_event_engine_run_in_background()) {
     cover_self(tcp);
   }
@@ -731,10 +713,8 @@ static void notify_on_write(grpc_tcp* tcp) {
 
 static void tcp_drop_uncovered_then_handle_write(void* arg,
                                                  grpc_error_handle error) {
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "TCP:" << arg
-              << " got_write: " << grpc_core::StatusToString(error);
-  }
+  GRPC_TRACE_LOG(tcp, INFO)
+      << "TCP:" << arg << " got_write: " << grpc_core::StatusToString(error);
   drop_uncovered(static_cast<grpc_tcp*>(arg));
   tcp_handle_write(arg, error);
 }
@@ -821,9 +801,8 @@ static void tcp_destroy(grpc_endpoint* ep) {
 
 static void perform_reclamation(grpc_tcp* tcp)
     ABSL_LOCKS_EXCLUDED(tcp->read_mu) {
-  if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-    LOG(INFO) << "TCP: benign reclamation to free memory";
-  }
+  GRPC_TRACE_LOG(resource_quota, INFO)
+      << "TCP: benign reclamation to free memory";
   tcp->read_mu.Lock();
   if (tcp->incoming_buffer != nullptr) {
     grpc_slice_buffer_reset_and_unref(tcp->incoming_buffer);
@@ -915,9 +894,8 @@ static void update_rcvlowat(grpc_tcp* tcp)
 #define MAX_READ_IOVEC 64
 static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(tcp->read_mu) {
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "TCP:" << tcp << " do_read";
-  }
+  GRPC_LATENT_SEE_INNER_SCOPE("tcp_do_read");
+  GRPC_TRACE_LOG(tcp, INFO) << "TCP:" << tcp << " do_read";
   struct msghdr msg;
   struct iovec iov[MAX_READ_IOVEC];
   ssize_t read_bytes;
@@ -1128,10 +1106,8 @@ static void maybe_make_read_slices(grpc_tcp* tcp)
 
 static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
   grpc_tcp* tcp = static_cast<grpc_tcp*>(arg);
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "TCP:" << tcp
-              << " got_read: " << grpc_core::StatusToString(error);
-  }
+  GRPC_TRACE_LOG(tcp, INFO)
+      << "TCP:" << tcp << " got_read: " << grpc_core::StatusToString(error);
   tcp->read_mu.Lock();
   grpc_error_handle tcp_read_error;
   if (GPR_LIKELY(error.ok()) && tcp->memory_owner.is_valid()) {
@@ -1211,6 +1187,7 @@ static void tcp_read(grpc_endpoint* ep, grpc_slice_buffer* incoming_buffer,
 // of bytes sent.
 ssize_t tcp_send(int fd, const struct msghdr* msg, int* saved_errno,
                  int additional_flags = 0) {
+  GRPC_LATENT_SEE_INNER_SCOPE("tcp_send");
   ssize_t sent_length;
   do {
     // TODO(klempner): Cork if this is a partial write
@@ -1278,9 +1255,8 @@ static bool tcp_write_with_timestamps(grpc_tcp* tcp, struct msghdr* msg,
     uint32_t opt = grpc_core::kTimestampingSocketOptions;
     if (setsockopt(tcp->fd, SOL_SOCKET, SO_TIMESTAMPING,
                    static_cast<void*>(&opt), sizeof(opt)) != 0) {
-      if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-        LOG(ERROR) << "Failed to set timestamping options on the socket.";
-      }
+      GRPC_TRACE_LOG(tcp, ERROR)
+          << "Failed to set timestamping options on the socket.";
       return false;
     }
     tcp->bytes_counter = -1;
@@ -1364,9 +1340,7 @@ struct cmsghdr* process_timestamp(grpc_tcp* tcp, msghdr* msg,
   auto next_cmsg = CMSG_NXTHDR(msg, cmsg);
   cmsghdr* opt_stats = nullptr;
   if (next_cmsg == nullptr) {
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(ERROR) << "Received timestamp without extended error";
-    }
+    GRPC_TRACE_LOG(tcp, ERROR) << "Received timestamp without extended error";
     return cmsg;
   }
 
@@ -1376,9 +1350,7 @@ struct cmsghdr* process_timestamp(grpc_tcp* tcp, msghdr* msg,
     opt_stats = next_cmsg;
     next_cmsg = CMSG_NXTHDR(msg, opt_stats);
     if (next_cmsg == nullptr) {
-      if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-        LOG(ERROR) << "Received timestamp without extended error";
-      }
+      GRPC_TRACE_LOG(tcp, ERROR) << "Received timestamp without extended error";
       return opt_stats;
     }
   }
@@ -1386,9 +1358,7 @@ struct cmsghdr* process_timestamp(grpc_tcp* tcp, msghdr* msg,
   if (!(next_cmsg->cmsg_level == SOL_IP || next_cmsg->cmsg_level == SOL_IPV6) ||
       !(next_cmsg->cmsg_type == IP_RECVERR ||
         next_cmsg->cmsg_type == IPV6_RECVERR)) {
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(ERROR) << "Unexpected control message";
-    }
+    GRPC_TRACE_LOG(tcp, ERROR) << "Unexpected control message";
     return cmsg;
   }
 
@@ -1408,6 +1378,7 @@ struct cmsghdr* process_timestamp(grpc_tcp* tcp, msghdr* msg,
 /// messages from the queue.
 ///
 static bool process_errors(grpc_tcp* tcp) {
+  GRPC_LATENT_SEE_INNER_SCOPE("process_errors");
   bool processed_err = false;
   struct iovec iov;
   iov.iov_base = nullptr;
@@ -1469,10 +1440,9 @@ static bool process_errors(grpc_tcp* tcp) {
       } else {
         // Got a control message that is not a timestamp or zerocopy. Don't know
         // how to handle this.
-        if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-          LOG(INFO) << "unknown control message cmsg_level:" << cmsg->cmsg_level
-                    << " cmsg_type:" << cmsg->cmsg_type;
-        }
+        GRPC_TRACE_LOG(tcp, INFO)
+            << "unknown control message cmsg_level:" << cmsg->cmsg_level
+            << " cmsg_type:" << cmsg->cmsg_type;
         return processed_err;
       }
     }
@@ -1485,9 +1455,7 @@ static bool process_errors(grpc_tcp* tcp) {
 static void tcp_handle_error(void* arg /* grpc_tcp */,
                              grpc_error_handle error) {
   grpc_tcp* tcp = static_cast<grpc_tcp*>(arg);
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "TCP:" << tcp << " got_error: " << error;
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "TCP:" << tcp << " got_error: " << error;
 
   if (!error.ok() ||
       static_cast<bool>(gpr_atm_acq_load(&tcp->stop_error_notification))) {
@@ -1815,9 +1783,7 @@ static void tcp_handle_write(void* arg /* grpc_tcp */,
           ? tcp_flush_zerocopy(tcp, tcp->current_zerocopy_send, &error)
           : tcp_flush(tcp, &error);
   if (!flush_result) {
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(INFO) << "write: delayed";
-    }
+    GRPC_TRACE_LOG(tcp, INFO) << "write: delayed";
     notify_on_write(tcp);
     // tcp_flush does not populate error if it has returned false.
     DCHECK(error.ok());
@@ -1886,9 +1852,7 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
     TCP_REF(tcp, "write");
     tcp->write_cb = cb;
     tcp->current_zerocopy_send = zerocopy_send_record;
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(INFO) << "write: delayed";
-    }
+    GRPC_TRACE_LOG(tcp, INFO) << "write: delayed";
     notify_on_write(tcp);
   } else {
     GRPC_TRACE_LOG(tcp, INFO) << "write: " << grpc_core::StatusToString(error);

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

@@ -177,10 +177,9 @@ static grpc_error_handle CreateEventEngineListener(
                            << addr_uri.status().ToString();
                 return;
               }
-              if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-                LOG(INFO) << "SERVER_CONNECT: incoming external connection: "
-                          << addr_uri->c_str();
-              }
+              GRPC_TRACE_LOG(tcp, INFO) << "SERVER_CONNECT: incoming external "
+                                           "connection: "
+                                        << addr_uri->c_str();
             }
             read_notifier_pollset =
                 (*(s->pollsets))[static_cast<size_t>(
@@ -460,9 +459,8 @@ static void on_read(void* arg, grpc_error_handle err) {
       LOG(ERROR) << "Invalid address: " << addr_uri.status();
       goto error;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(INFO) << "SERVER_CONNECT: incoming connection: " << *addr_uri;
-    }
+    GRPC_TRACE_LOG(tcp, INFO)
+        << "SERVER_CONNECT: incoming connection: " << *addr_uri;
 
     std::string name = absl::StrCat("tcp-server-connection:", addr_uri.value());
     grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
@@ -916,10 +914,8 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
       LOG(ERROR) << "Invalid address: " << addr_uri.status();
       return;
     }
-    if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      LOG(INFO) << "SERVER_CONNECT: incoming external connection: "
-                << *addr_uri;
-    }
+    GRPC_TRACE_LOG(tcp, INFO)
+        << "SERVER_CONNECT: incoming external connection: " << *addr_uri;
     std::string name = absl::StrCat("tcp-server-connection:", addr_uri.value());
     grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
     read_notifier_pollset =

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

@@ -176,9 +176,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->read_info;
 
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "TCP:" << tcp << " on_read";
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "TCP:" << tcp << " on_read";
 
   if (error.ok()) {
     if (info->wsa_error != 0 && !tcp->shutting_down) {
@@ -208,9 +206,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
           }
         }
       } else {
-        if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-          LOG(INFO) << "TCP:" << tcp << " unref read_slice";
-        }
+        GRPC_TRACE_LOG(tcp, INFO) << "TCP:" << tcp << " unref read_slice";
         grpc_slice_buffer_reset_and_unref(tcp->read_slices);
         error = grpc_error_set_int(
             tcp->shutting_down ? GRPC_ERROR_CREATE("TCP stream shutting down")
@@ -239,9 +235,7 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
   WSABUF buffers[MAX_WSABUF_COUNT];
   size_t i;
 
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "TCP:" << tcp << " win_read";
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "TCP:" << tcp << " win_read";
 
   if (tcp->shutting_down) {
     grpc_core::ExecCtx::Run(
@@ -310,9 +304,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
   grpc_winsocket_callback_info* info = &handle->write_info;
   grpc_closure* cb;
 
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    LOG(INFO) << "TCP:" << tcp << " on_write";
-  }
+  GRPC_TRACE_LOG(tcp, INFO) << "TCP:" << tcp << " on_write";
 
   gpr_mu_lock(&tcp->mu);
   cb = tcp->write_cb;

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

@@ -334,12 +334,11 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
   timer->hash_table_next = nullptr;
 #endif
 
-  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
-    VLOG(2) << "TIMER " << timer << ": SET "
-            << deadline.milliseconds_after_process_epoch() << " now "
-            << grpc_core::Timestamp::Now().milliseconds_after_process_epoch()
-            << " call " << closure << "[" << closure->cb << "]";
-  }
+  GRPC_TRACE_VLOG(timer, 2)
+      << "TIMER " << timer << ": SET "
+      << deadline.milliseconds_after_process_epoch() << " now "
+      << grpc_core::Timestamp::Now().milliseconds_after_process_epoch()
+      << " call " << closure << "[" << closure->cb << "]";
 
   if (!g_shared_mutables.initialized) {
     timer->pending = false;
@@ -370,12 +369,11 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
     timer->heap_index = INVALID_HEAP_INDEX;
     list_join(&shard->list, timer);
   }
-  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
-    VLOG(2) << "  .. add to shard " << (shard - g_shards)
-            << " with queue_deadline_cap="
-            << shard->queue_deadline_cap.milliseconds_after_process_epoch()
-            << " => is_first_timer=" << (is_first_timer ? "true" : "false");
-  }
+  GRPC_TRACE_VLOG(timer, 2)
+      << "  .. add to shard " << (shard - g_shards)
+      << " with queue_deadline_cap="
+      << shard->queue_deadline_cap.milliseconds_after_process_epoch()
+      << " => is_first_timer=" << (is_first_timer ? "true" : "false");
   gpr_mu_unlock(&shard->mu);
 
   // Deadline may have decreased, we need to adjust the main queue.  Note
@@ -391,10 +389,9 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
   // grpc_timer_check.
   if (is_first_timer) {
     gpr_mu_lock(&g_shared_mutables.mu);
-    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
-      VLOG(2) << "  .. old shard min_deadline="
-              << shard->min_deadline.milliseconds_after_process_epoch();
-    }
+    GRPC_TRACE_VLOG(timer, 2)
+        << "  .. old shard min_deadline="
+        << shard->min_deadline.milliseconds_after_process_epoch();
     if (deadline < shard->min_deadline) {
       grpc_core::Timestamp old_min_deadline = g_shard_queue[0]->min_deadline;
       shard->min_deadline = deadline;
@@ -433,10 +430,9 @@ static void timer_cancel(grpc_timer* timer) {
 
   timer_shard* shard = &g_shards[grpc_core::HashPointer(timer, g_num_shards)];
   gpr_mu_lock(&shard->mu);
-  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
-    VLOG(2) << "TIMER " << timer
-            << ": CANCEL pending=" << (timer->pending ? "true" : "false");
-  }
+  GRPC_TRACE_VLOG(timer, 2)
+      << "TIMER " << timer
+      << ": CANCEL pending=" << (timer->pending ? "true" : "false");
 
   if (timer->pending) {
     REMOVE_FROM_HASH_TABLE(timer);
@@ -474,11 +470,9 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
       std::max(now, shard->queue_deadline_cap) +
       grpc_core::Duration::FromSecondsAsDouble(deadline_delta);
 
-  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
-    VLOG(2) << "  .. shard[" << (shard - g_shards)
-            << "]->queue_deadline_cap --> "
-            << shard->queue_deadline_cap.milliseconds_after_process_epoch();
-  }
+  GRPC_TRACE_VLOG(timer_check, 2)
+      << "  .. shard[" << (shard - g_shards) << "]->queue_deadline_cap --> "
+      << shard->queue_deadline_cap.milliseconds_after_process_epoch();
   for (timer = shard->list.next; timer != &shard->list; timer = next) {
     next = timer->next;
     auto timer_deadline =
@@ -486,11 +480,9 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
             timer->deadline);
 
     if (timer_deadline < shard->queue_deadline_cap) {
-      if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
-        VLOG(2) << "  .. add timer with deadline "
-                << timer_deadline.milliseconds_after_process_epoch()
-                << " to heap";
-      }
+      GRPC_TRACE_VLOG(timer_check, 2)
+          << "  .. add timer with deadline "
+          << timer_deadline.milliseconds_after_process_epoch() << " to heap";
       list_remove(timer);
       grpc_timer_heap_add(&shard->heap, timer);
     }
@@ -504,10 +496,9 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
 static grpc_timer* pop_one(timer_shard* shard, grpc_core::Timestamp now) {
   grpc_timer* timer;
   for (;;) {
-    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
-      VLOG(2) << "  .. shard[" << (shard - g_shards) << "]: heap_empty="
-              << (grpc_timer_heap_is_empty(&shard->heap) ? "true" : "false");
-    }
+    GRPC_TRACE_VLOG(timer_check, 2)
+        << "  .. shard[" << (shard - g_shards) << "]: heap_empty="
+        << (grpc_timer_heap_is_empty(&shard->heap) ? "true" : "false");
     if (grpc_timer_heap_is_empty(&shard->heap)) {
       if (now < shard->queue_deadline_cap) return nullptr;
       if (!refill_heap(shard, now)) return nullptr;
@@ -516,16 +507,13 @@ static grpc_timer* pop_one(timer_shard* shard, grpc_core::Timestamp now) {
     auto timer_deadline =
         grpc_core::Timestamp::FromMillisecondsAfterProcessEpoch(
             timer->deadline);
-    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
-      VLOG(2) << "  .. check top timer deadline="
-              << timer_deadline.milliseconds_after_process_epoch()
-              << " now=" << now.milliseconds_after_process_epoch();
-    }
+    GRPC_TRACE_VLOG(timer_check, 2)
+        << "  .. check top timer deadline="
+        << timer_deadline.milliseconds_after_process_epoch()
+        << " now=" << now.milliseconds_after_process_epoch();
     if (timer_deadline > now) return nullptr;
-    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
-      VLOG(2) << "TIMER " << timer << ": FIRE "
-              << (now - timer_deadline).millis() << "ms late";
-    }
+    GRPC_TRACE_VLOG(timer, 2) << "TIMER " << timer << ": FIRE "
+                              << (now - timer_deadline).millis() << "ms late";
     timer->pending = false;
     grpc_timer_heap_pop(&shard->heap);
     return timer;
@@ -546,9 +534,8 @@ static size_t pop_timers(timer_shard* shard, grpc_core::Timestamp now,
   }
   *new_min_deadline = compute_min_deadline(shard);
   gpr_mu_unlock(&shard->mu);
-  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
-    VLOG(2) << "  .. shard[" << (shard - g_shards) << "] popped " << n;
-  }
+  GRPC_TRACE_VLOG(timer_check, 2)
+      << "  .. shard[" << (shard - g_shards) << "] popped " << n;
   return n;
 }
 
@@ -584,12 +571,10 @@ static grpc_timer_check_result run_some_expired_timers(
     gpr_mu_lock(&g_shared_mutables.mu);
     result = GRPC_TIMERS_CHECKED_AND_EMPTY;
 
-    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
-      VLOG(2)
-          << "  .. shard[" << (g_shard_queue[0] - g_shards)
-          << "]->min_deadline = "
-          << g_shard_queue[0]->min_deadline.milliseconds_after_process_epoch();
-    }
+    GRPC_TRACE_VLOG(timer_check, 2)
+        << "  .. shard[" << (g_shard_queue[0] - g_shards)
+        << "]->min_deadline = "
+        << g_shard_queue[0]->min_deadline.milliseconds_after_process_epoch();
 
     while (g_shard_queue[0]->min_deadline < now ||
            (now != grpc_core::Timestamp::InfFuture() &&
@@ -603,14 +588,12 @@ static grpc_timer_check_result run_some_expired_timers(
         result = GRPC_TIMERS_FIRED;
       }
 
-      if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
-        VLOG(2)
-            << "  .. result --> " << result << ", shard["
-            << (g_shard_queue[0] - g_shards) << "]->min_deadline "
-            << g_shard_queue[0]->min_deadline.milliseconds_after_process_epoch()
-            << " --> " << new_min_deadline.milliseconds_after_process_epoch()
-            << ", now=" << now.milliseconds_after_process_epoch();
-      }
+      GRPC_TRACE_VLOG(timer_check, 2)
+          << "  .. result --> " << result << ", shard["
+          << (g_shard_queue[0] - g_shards) << "]->min_deadline "
+          << g_shard_queue[0]->min_deadline.milliseconds_after_process_epoch()
+          << " --> " << new_min_deadline.milliseconds_after_process_epoch()
+          << ", now=" << now.milliseconds_after_process_epoch();
 
       // An grpc_timer_init() on the shard could intervene here, adding a new
       // timer that is earlier than new_min_deadline.  However,
@@ -660,11 +643,9 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
     if (next != nullptr) {
       *next = std::min(*next, min_timer);
     }
-    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
-      VLOG(2) << "TIMER CHECK SKIP: now="
-              << now.milliseconds_after_process_epoch()
-              << " min_timer=" << min_timer.milliseconds_after_process_epoch();
-    }
+    GRPC_TRACE_VLOG(timer_check, 2)
+        << "TIMER CHECK SKIP: now=" << now.milliseconds_after_process_epoch()
+        << " min_timer=" << min_timer.milliseconds_after_process_epoch();
     return GRPC_TIMERS_CHECKED_AND_EMPTY;
   }
 

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

@@ -195,11 +195,10 @@ static bool wait_until(grpc_core::Timestamp next) {
 
     gpr_cv_wait(&g_cv_wait, &g_mu, next.as_timespec(GPR_CLOCK_MONOTONIC));
 
-    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
-      LOG(INFO) << "wait ended: was_timed:"
-                << (my_timed_waiter_generation == g_timed_waiter_generation)
-                << " kicked:" << g_kicked;
-    }
+    GRPC_TRACE_LOG(timer_check, INFO)
+        << "wait ended: was_timed:"
+        << (my_timed_waiter_generation == g_timed_waiter_generation)
+        << " kicked:" << g_kicked;
     // if this was the timed waiter, then we need to check timers, and flag
     // that there's now no timed waiter... we'll look for a replacement if
     // there's work to do after checking timers (code above)

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

@@ -37,7 +37,6 @@
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/gprpp/crash.h"

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

@@ -26,8 +26,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/gprpp/crash.h"
 
 void grpc_create_socketpair_if_unix(int /* sv */[2]) {

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

@@ -28,7 +28,6 @@
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/gprpp/crash.h"

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

@@ -26,8 +26,6 @@
 #include <sys/eventfd.h>
 #include <unistd.h>
 
-#include <grpc/support/log.h>
-
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"

data/src/core/lib/promise/activity.h

@@ -29,7 +29,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"

data/src/core/lib/promise/context.h

@@ -20,7 +20,6 @@
 #include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/down_cast.h"