grpc 1.65.2 → 1.66.0.pre3

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

@@ -19,9 +19,9 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
@@ -33,10 +33,10 @@ static void exec_ctx_run(grpc_closure* closure) {
 #ifndef NDEBUG
   closure->scheduled = false;
   if (GRPC_TRACE_FLAG_ENABLED(closure)) {
-    gpr_log(GPR_DEBUG, "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) << "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 =
@@ -45,7 +45,7 @@ static void exec_ctx_run(grpc_closure* closure) {
   closure->cb(closure->cb_arg, std::move(error));
 #ifndef NDEBUG
   if (GRPC_TRACE_FLAG_ENABLED(closure)) {
-    gpr_log(GPR_DEBUG, "closure %p finished", closure);
+    VLOG(2) << "closure " << closure << " finished";
   }
 #endif
 }

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

@@ -21,6 +21,8 @@
 #include <string.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
@@ -28,6 +30,7 @@
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
+#include "src/core/lib/debug/trace_impl.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -36,11 +39,11 @@
 
 #define MAX_DEPTH 2
 
-#define EXECUTOR_TRACE(format, ...)                       \
-  do {                                                    \
-    if (GRPC_TRACE_FLAG_ENABLED(executor)) {              \
-      gpr_log(GPR_INFO, "EXECUTOR " format, __VA_ARGS__); \
-    }                                                     \
+#define EXECUTOR_TRACE(format, ...)                                     \
+  do {                                                                  \
+    if (GRPC_TRACE_FLAG_ENABLED(executor)) {                            \
+      LOG(INFO) << "EXECUTOR " << absl::StrFormat(format, __VA_ARGS__); \
+    }                                                                   \
   } while (0)
 
 namespace grpc_core {

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

@@ -19,8 +19,8 @@
 #include "src/core/lib/iomgr/lockfree_event.h"
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -96,9 +96,8 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
     // referencing it.
     gpr_atm curr = gpr_atm_acq_load(&state_);
     if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-      gpr_log(GPR_DEBUG,
-              "LockfreeEvent::NotifyOn: %p curr=%" PRIxPTR " closure=%p", this,
-              curr, closure);
+      VLOG(2) << "LockfreeEvent::NotifyOn: " << this << " curr=" << curr
+              << " closure=" << closure;
     }
     switch (curr) {
       case kClosureNotReady: {
@@ -165,9 +164,8 @@ bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
   while (true) {
     gpr_atm curr = gpr_atm_no_barrier_load(&state_);
     if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-      gpr_log(GPR_DEBUG,
-              "LockfreeEvent::SetShutdown: %p curr=%" PRIxPTR " err=%s",
-              &state_, curr, StatusToString(shutdown_error).c_str());
+      VLOG(2) << "LockfreeEvent::SetShutdown: " << &state_ << " curr=" << curr
+              << " err=" << StatusToString(shutdown_error);
     }
     switch (curr) {
       case kClosureReady:
@@ -215,8 +213,7 @@ void LockfreeEvent::SetReady() {
     gpr_atm curr = gpr_atm_no_barrier_load(&state_);
 
     if (GRPC_TRACE_FLAG_ENABLED(polling)) {
-      gpr_log(GPR_DEBUG, "LockfreeEvent::SetReady: %p curr=%" PRIxPTR, &state_,
-              curr);
+      VLOG(2) << "LockfreeEvent::SetReady: " << &state_ << " curr=" << curr;
     }
 
     switch (curr) {

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

@@ -49,7 +49,6 @@
 
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -391,13 +390,13 @@ grpc_error_handle grpc_set_socket_tcp_user_timeout(
             << " ms";
         if (0 != setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout,
                             sizeof(timeout))) {
-          gpr_log(GPR_ERROR, "setsockopt(TCP_USER_TIMEOUT) %s",
-                  grpc_core::StrError(errno).c_str());
+          LOG(ERROR) << "setsockopt(TCP_USER_TIMEOUT) "
+                     << grpc_core::StrError(errno);
           return absl::OkStatus();
         }
         if (0 != getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) {
-          gpr_log(GPR_ERROR, "getsockopt(TCP_USER_TIMEOUT) %s",
-                  grpc_core::StrError(errno).c_str());
+          LOG(ERROR) << "getsockopt(TCP_USER_TIMEOUT) "
+                     << grpc_core::StrError(errno);
           return absl::OkStatus();
         }
         if (newval != timeout) {
@@ -481,14 +480,15 @@ static int create_socket(grpc_socket_factory* factory, int domain, int type,
                 : socket(domain, type, protocol);
   if (res < 0 && errno == EMFILE) {
     int saved_errno = errno;
-    GRPC_LOG_EVERY_N_SEC(
-        10, GPR_ERROR,
-        "socket(%d, %d, %d) returned %d with error: |%s|. This process "
-        "might not have a sufficient file descriptor limit for the number "
-        "of connections grpc wants to open (which is generally a function of "
-        "the number of grpc channels, the lb policy of each channel, and the "
-        "number of backends each channel is load balancing across).",
-        domain, type, protocol, res, grpc_core::StrError(errno).c_str());
+    LOG_EVERY_N_SEC(ERROR, 10)
+        << "socket(" << domain << ", " << type << ", " << protocol
+        << ") returned " << res << " with error: |"
+        << grpc_core::StrError(errno)
+        << "|. This process might not have a sufficient file descriptor limit "
+           "for the number of connections grpc wants to open (which is "
+           "generally a function of the number of grpc channels, the lb policy "
+           "of each channel, and the number of backends each channel is load "
+           "balancing across).";
     errno = saved_errno;
   }
   return res;

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

@@ -27,9 +27,10 @@
 #include <netinet/in.h>
 #include <string.h>
 
+#include "absl/log/log.h"
+
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -78,8 +79,8 @@ static void CFStreamConnectCleanup(CFStreamConnect* connect) {
 static void OnAlarm(void* arg, grpc_error_handle error) {
   CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnAlarm, error:%s", connect,
-            grpc_core::StatusToString(error).c_str());
+    VLOG(2) << "CLIENT_CONNECT :" << connect
+            << " OnAlarm, error:" << grpc_core::StatusToString(error);
   }
   gpr_mu_lock(&connect->mu);
   grpc_closure* closure = connect->closure;
@@ -99,8 +100,8 @@ static void OnAlarm(void* arg, grpc_error_handle error) {
 static void OnOpen(void* arg, grpc_error_handle error) {
   CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnOpen, error:%s", connect,
-            grpc_core::StatusToString(error).c_str());
+    VLOG(2) << "CLIENT_CONNECT :" << connect
+            << " OnOpen, error:" << grpc_core::StatusToString(error);
   }
   gpr_mu_lock(&connect->mu);
   grpc_timer_cancel(&connect->alarm);
@@ -173,8 +174,8 @@ static int64_t CFStreamClientConnect(
   gpr_mu_init(&connect->mu);
 
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %p, %s: asynchronously connecting",
-            connect, connect->addr_name.c_str());
+    VLOG(2) << "CLIENT_CONNECT: " << connect << ", " << connect->addr_name
+            << ": asynchronously connecting";
   }
 
   CFReadStreamRef read_stream;

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

@@ -34,7 +34,6 @@
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -143,8 +142,8 @@ static void tc_on_alarm(void* acp, grpc_error_handle error) {
   int done;
   async_connect* ac = static_cast<async_connect*>(acp);
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s",
-            ac->addr_str.c_str(), grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << "CLIENT_CONNECT: " << ac->addr_str
+              << ": on_alarm: error=" << grpc_core::StatusToString(error);
   }
   gpr_mu_lock(&ac->mu);
   if (ac->fd != nullptr) {
@@ -182,8 +181,8 @@ static void on_writable(void* acp, grpc_error_handle error) {
   grpc_fd* fd;
 
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_writable: error=%s",
-            ac->addr_str.c_str(), grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << "CLIENT_CONNECT: " << ac->addr_str
+              << ": on_writable: error=" << grpc_core::StatusToString(error);
   }
 
   gpr_mu_lock(&ac->mu);
@@ -383,8 +382,8 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   ac->options = options;
 
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: asynchronously connecting fd %p",
-            ac->addr_str.c_str(), fdobj);
+    LOG(INFO) << "CLIENT_CONNECT: " << ac->addr_str
+              << ": asynchronously connecting fd " << fdobj;
   }
 
   int shard_number = connection_id % (*g_connection_shards).size();

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

@@ -50,7 +50,6 @@
 
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
@@ -594,9 +593,9 @@ void LogCommonIOErrors(absl::string_view prefix, int error_no) {
       return;
     default:
       grpc_core::global_stats().IncrementUncommonIoErrorCount();
-      GRPC_LOG_EVERY_N_SEC(1, GPR_ERROR, "%s encountered uncommon error: %s",
-                           prefix.data(),
-                           grpc_core::StrError(error_no).c_str());
+      LOG_EVERY_N_SEC(ERROR, 1)
+          << prefix.data()
+          << " encountered uncommon error: " << grpc_core::StrError(error_no);
       return;
   }
 }
@@ -620,7 +619,7 @@ 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)) {
-    gpr_log(GPR_INFO, "BACKUP_POLLER:%p destroy", p);
+    LOG(INFO) << "BACKUP_POLLER:" << p << " destroy";
   }
   grpc_pollset_destroy(BACKUP_POLLER_POLLSET(p));
   gpr_free(p);
@@ -629,7 +628,7 @@ static void done_poller(void* bp, grpc_error_handle /*error_ignored*/) {
 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)) {
-    gpr_log(GPR_INFO, "BACKUP_POLLER:%p run", p);
+    LOG(INFO) << "BACKUP_POLLER:" << p << " run";
   }
   gpr_mu_lock(p->pollset_mu);
   grpc_core::Timestamp deadline =
@@ -646,7 +645,7 @@ static void run_poller(void* bp, grpc_error_handle /*error_ignored*/) {
     g_uncovered_notifications_pending = 0;
     g_backup_poller_mu->Unlock();
     if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      gpr_log(GPR_INFO, "BACKUP_POLLER:%p shutdown", p);
+      LOG(INFO) << "BACKUP_POLLER:" << p << " shutdown";
     }
     grpc_pollset_shutdown(BACKUP_POLLER_POLLSET(p),
                           GRPC_CLOSURE_INIT(&p->run_poller, done_poller, p,
@@ -654,7 +653,7 @@ static void run_poller(void* bp, grpc_error_handle /*error_ignored*/) {
   } else {
     g_backup_poller_mu->Unlock();
     if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      gpr_log(GPR_INFO, "BACKUP_POLLER:%p reschedule", p);
+      LOG(INFO) << "BACKUP_POLLER:" << p << " reschedule";
     }
     grpc_core::Executor::Run(&p->run_poller, absl::OkStatus(),
                              grpc_core::ExecutorType::DEFAULT,
@@ -671,8 +670,8 @@ static void drop_uncovered(grpc_tcp* /*tcp*/) {
   g_backup_poller_mu->Unlock();
   CHECK_GT(old_count, 1);
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_INFO, "BACKUP_POLLER:%p uncover cnt %d->%d", p, old_count,
-            old_count - 1);
+    LOG(INFO) << "BACKUP_POLLER:" << p << " uncover cnt " << old_count << "->"
+              << old_count - 1;
   }
 }
 
@@ -695,7 +694,7 @@ static void cover_self(grpc_tcp* tcp) {
     grpc_pollset_init(BACKUP_POLLER_POLLSET(p), &p->pollset_mu);
     g_backup_poller_mu->Unlock();
     if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      gpr_log(GPR_INFO, "BACKUP_POLLER:%p create", p);
+      LOG(INFO) << "BACKUP_POLLER:" << p << " create";
     }
     grpc_core::Executor::Run(
         GRPC_CLOSURE_INIT(&p->run_poller, run_poller, p, nullptr),
@@ -707,22 +706,22 @@ static void cover_self(grpc_tcp* tcp) {
     g_backup_poller_mu->Unlock();
   }
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_INFO, "BACKUP_POLLER:%p add %p cnt %d->%d", p, tcp,
-            old_count - 1, old_count);
+    LOG(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)) {
-    gpr_log(GPR_INFO, "TCP:%p notify_on_read", tcp);
+    LOG(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)) {
-    gpr_log(GPR_INFO, "TCP:%p notify_on_write", tcp);
+    LOG(INFO) << "TCP:" << tcp << " notify_on_write";
   }
   if (!grpc_event_engine_run_in_background()) {
     cover_self(tcp);
@@ -733,8 +732,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)) {
-    gpr_log(GPR_INFO, "TCP:%p got_write: %s", arg,
-            grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << "TCP:" << arg
+              << " got_write: " << grpc_core::StatusToString(error);
   }
   drop_uncovered(static_cast<grpc_tcp*>(arg));
   tcp_handle_write(arg, error);
@@ -853,10 +852,11 @@ static void tcp_trace_read(grpc_tcp* tcp, grpc_error_handle error)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(tcp->read_mu) {
   grpc_closure* cb = tcp->read_cb;
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_INFO, "TCP:%p call_cb %p %p:%p", tcp, cb, cb->cb, cb->cb_arg);
+    LOG(INFO) << "TCP:" << tcp << " call_cb " << cb << " " << cb->cb << ":"
+              << cb->cb_arg;
     size_t i;
-    gpr_log(GPR_INFO, "READ %p (peer=%s) error=%s", tcp,
-            tcp->peer_string.c_str(), grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << "READ " << tcp << " (peer=" << tcp->peer_string
+              << ") error=" << grpc_core::StatusToString(error);
     if (ABSL_VLOG_IS_ON(2)) {
       for (i = 0; i < tcp->incoming_buffer->count; i++) {
         char* dump = grpc_dump_slice(tcp->incoming_buffer->slices[i],
@@ -904,10 +904,8 @@ static void update_rcvlowat(grpc_tcp* tcp)
   }
   if (setsockopt(tcp->fd, SOL_SOCKET, SO_RCVLOWAT, &remaining,
                  sizeof(remaining)) != 0) {
-    gpr_log(GPR_ERROR, "%s",
-            absl::StrCat("Cannot set SO_RCVLOWAT on fd=", tcp->fd,
-                         " err=", grpc_core::StrError(errno).c_str())
-                .c_str());
+    LOG(ERROR) << "Cannot set SO_RCVLOWAT on fd=" << tcp->fd
+               << " err=" << grpc_core::StrError(errno);
     return;
   }
   tcp->set_rcvlowat = remaining;
@@ -918,7 +916,7 @@ static void update_rcvlowat(grpc_tcp* tcp)
 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)) {
-    gpr_log(GPR_INFO, "TCP:%p do_read", tcp);
+    LOG(INFO) << "TCP:" << tcp << " do_read";
   }
   struct msghdr msg;
   struct iovec iov[MAX_READ_IOVEC];
@@ -1131,8 +1129,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)) {
-    gpr_log(GPR_INFO, "TCP:%p got_read: %s", tcp,
-            grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << "TCP:" << tcp
+              << " got_read: " << grpc_core::StatusToString(error);
   }
   tcp->read_mu.Lock();
   grpc_error_handle tcp_read_error;
@@ -1472,9 +1470,8 @@ static bool process_errors(grpc_tcp* tcp) {
         // Got a control message that is not a timestamp or zerocopy. Don't know
         // how to handle this.
         if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-          gpr_log(GPR_INFO,
-                  "unknown control message cmsg_level:%d cmsg_type:%d",
-                  cmsg->cmsg_level, cmsg->cmsg_type);
+          LOG(INFO) << "unknown control message cmsg_level:" << cmsg->cmsg_level
+                    << " cmsg_type:" << cmsg->cmsg_type;
         }
         return processed_err;
       }
@@ -1489,8 +1486,7 @@ 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)) {
-    gpr_log(GPR_INFO, "TCP:%p got_error: %s", tcp,
-            grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << "TCP:" << tcp << " got_error: " << error;
   }
 
   if (!error.ok() ||
@@ -1848,7 +1844,7 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
     size_t i;
 
     for (i = 0; i < buf->count; i++) {
-      gpr_log(GPR_INFO, "WRITE %p (peer=%s)", tcp, tcp->peer_string.c_str());
+      LOG(INFO) << "WRITE " << tcp << " (peer=" << tcp->peer_string << ")";
       if (ABSL_VLOG_IS_ON(2)) {
         char* data =
             grpc_dump_slice(buf->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
@@ -2031,7 +2027,7 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   if (setsockopt(tcp->fd, SOL_TCP, TCP_INQ, &one, sizeof(one)) == 0) {
     tcp->inq_capable = true;
   } else {
-    gpr_log(GPR_DEBUG, "cannot set inq fd=%d errno=%d", tcp->fd, errno);
+    VLOG(2) << "cannot set inq fd=" << tcp->fd << " errno=" << errno;
     tcp->inq_capable = false;
   }
 #else

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

@@ -44,6 +44,7 @@
 #include <string>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
@@ -51,7 +52,6 @@
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
@@ -165,22 +165,21 @@ static grpc_error_handle CreateEventEngineListener(
                       ->GetWrappedFd();
               if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
                               &(addr.len)) < 0) {
-                gpr_log(GPR_ERROR, "Failed getpeername: %s",
-                        grpc_core::StrError(errno).c_str());
+                LOG(ERROR) << "Failed getpeername: "
+                           << grpc_core::StrError(errno);
                 close(fd);
                 return;
               }
               (void)grpc_set_socket_no_sigpipe_if_possible(fd);
               auto addr_uri = grpc_sockaddr_to_uri(&addr);
               if (!addr_uri.ok()) {
-                gpr_log(GPR_ERROR, "Invalid address: %s",
-                        addr_uri.status().ToString().c_str());
+                LOG(ERROR) << "Invalid address: "
+                           << addr_uri.status().ToString();
                 return;
               }
               if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-                gpr_log(GPR_INFO,
-                        "SERVER_CONNECT: incoming external connection: %s",
-                        addr_uri->c_str());
+                LOG(INFO) << "SERVER_CONNECT: incoming external connection: "
+                          << addr_uri->c_str();
               }
             }
             read_notifier_pollset =
@@ -395,8 +394,7 @@ static void on_read(void* arg, grpc_error_handle err) {
       // This is not a performant code path, but if an fd limit has been
       // reached, the system is likely in an unhappy state regardless.
       if (errno == EMFILE) {
-        GRPC_LOG_EVERY_N_SEC(1, GPR_ERROR, "%s",
-                             "File descriptor limit reached. Retrying.");
+        LOG_EVERY_N_SEC(ERROR, 1) << "File descriptor limit reached. Retrying.";
         grpc_fd_notify_on_read(sp->emfd, &sp->read_closure);
         if (gpr_atm_full_xchg(&sp->retry_timer_armed, true)) return;
         grpc_timer_init(&sp->retry_timer,
@@ -410,8 +408,7 @@ static void on_read(void* arg, grpc_error_handle err) {
       }
       gpr_mu_lock(&sp->server->mu);
       if (!sp->server->shutdown_listeners) {
-        gpr_log(GPR_ERROR, "Failed accept4: %s",
-                grpc_core::StrError(errno).c_str());
+        LOG(ERROR) << "Failed accept4: " << grpc_core::StrError(errno);
       } else {
         // if we have shutdown listeners, accept4 could fail, and we
         // needn't notify users
@@ -440,13 +437,11 @@ static void on_read(void* arg, grpc_error_handle err) {
       if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
                       &(addr.len)) < 0) {
         auto listener_addr_uri = grpc_sockaddr_to_uri(&sp->addr);
-        gpr_log(
-            GPR_ERROR,
-            "Failed getpeername: %s. Dropping the connection, and continuing "
-            "to listen on %s:%d.",
-            grpc_core::StrError(errno).c_str(),
-            listener_addr_uri.ok() ? listener_addr_uri->c_str() : "<unknown>",
-            sp->port);
+        LOG(ERROR) << "Failed getpeername: " << grpc_core::StrError(errno)
+                   << ". Dropping the connection, and continuing to listen on "
+                   << (listener_addr_uri.ok() ? *listener_addr_uri
+                                              : "<unknown>")
+                   << ":" << sp->port;
         close(fd);
         continue;
       }
@@ -462,13 +457,11 @@ static void on_read(void* arg, grpc_error_handle err) {
 
     auto addr_uri = grpc_sockaddr_to_uri(&addr);
     if (!addr_uri.ok()) {
-      gpr_log(GPR_ERROR, "Invalid address: %s",
-              addr_uri.status().ToString().c_str());
+      LOG(ERROR) << "Invalid address: " << addr_uri.status();
       goto error;
     }
     if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      gpr_log(GPR_INFO, "SERVER_CONNECT: incoming connection: %s",
-              addr_uri->c_str());
+      LOG(INFO) << "SERVER_CONNECT: incoming connection: " << *addr_uri;
     }
 
     std::string name = absl::StrCat("tcp-server-connection:", addr_uri.value());
@@ -913,21 +906,19 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
 
     if (getpeername(fd, reinterpret_cast<struct sockaddr*>(addr.addr),
                     &(addr.len)) < 0) {
-      gpr_log(GPR_ERROR, "Failed getpeername: %s",
-              grpc_core::StrError(errno).c_str());
+      LOG(ERROR) << "Failed getpeername: " << grpc_core::StrError(errno);
       close(fd);
       return;
     }
     (void)grpc_set_socket_no_sigpipe_if_possible(fd);
     auto addr_uri = grpc_sockaddr_to_uri(&addr);
     if (!addr_uri.ok()) {
-      gpr_log(GPR_ERROR, "Invalid address: %s",
-              addr_uri.status().ToString().c_str());
+      LOG(ERROR) << "Invalid address: " << addr_uri.status();
       return;
     }
     if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-      gpr_log(GPR_INFO, "SERVER_CONNECT: incoming external connection: %s",
-              addr_uri->c_str());
+      LOG(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);

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

@@ -29,8 +29,6 @@
 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/log_windows.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -142,9 +140,8 @@ static void tcp_unref(grpc_tcp* tcp, const char* reason, const char* file,
                       int line) {
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&tcp->refcount.count);
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "TCP unref %p : %s %" PRIdPTR " -> %" PRIdPTR, tcp, reason, val,
-            val - 1);
+    VLOG(2).AtLocation(file, line) << "TCP unref " << tcp << " : " << reason
+                                   << " " << val << " -> " << val - 1;
   }
   if (gpr_unref(&tcp->refcount)) {
     tcp_free(tcp);
@@ -155,9 +152,8 @@ static void tcp_ref(grpc_tcp* tcp, const char* reason, const char* file,
                     int line) {
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&tcp->refcount.count);
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "TCP   ref %p : %s %" PRIdPTR " -> %" PRIdPTR, tcp, reason, val,
-            val + 1);
+    VLOG(2).AtLocation(file, line) << "TCP   ref " << tcp << " : " << reason
+                                   << " " << val << " -> " << val + 1;
   }
   gpr_ref(&tcp->refcount);
 }
@@ -181,7 +177,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
   grpc_winsocket_callback_info* info = &socket->read_info;
 
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_INFO, "TCP:%p on_read", tcp);
+    LOG(INFO) << "TCP:" << tcp << " on_read";
   }
 
   if (error.ok()) {
@@ -213,7 +209,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
         }
       } else {
         if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-          gpr_log(GPR_INFO, "TCP:%p unref read_slice", tcp);
+          LOG(INFO) << "TCP:" << tcp << " unref read_slice";
         }
         grpc_slice_buffer_reset_and_unref(tcp->read_slices);
         error = grpc_error_set_int(
@@ -244,7 +240,7 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
   size_t i;
 
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_INFO, "TCP:%p win_read", tcp);
+    LOG(INFO) << "TCP:" << tcp << " win_read";
   }
 
   if (tcp->shutting_down) {
@@ -315,7 +311,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
   grpc_closure* cb;
 
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_INFO, "TCP:%p on_write", tcp);
+    LOG(INFO) << "TCP:" << tcp << " on_write";
   }
 
   gpr_mu_lock(&tcp->mu);