grpc 1.66.0 → 1.67.0.pre1

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.h

@@ -93,7 +93,7 @@ class PosixEngineListenerImpl
                   ResolvedAddressToNormalizedString(socket_.addr),
               listener_->poller_->CanTrackErrors())),
           notify_on_accept_(PosixEngineClosure::ToPermanentClosure(
-              [this](absl::Status status) { NotifyOnAccept(status); })){};
+              [this](absl::Status status) { NotifyOnAccept(status); })) {};
     // Start listening for incoming connections on the socket.
     void Start();
     // Internal callback invoked when the socket has incoming connections to
@@ -129,7 +129,7 @@ class PosixEngineListenerImpl
   class ListenerAsyncAcceptors : public ListenerSocketsContainer {
    public:
     explicit ListenerAsyncAcceptors(PosixEngineListenerImpl* listener)
-        : listener_(listener){};
+        : listener_(listener) {};
 
     void UpdateOnAppendCallback(
         PosixListenerWithFdSupport::OnPosixBindNewFdCallback on_append) {

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h

@@ -27,7 +27,6 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/grpc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -164,7 +163,7 @@ class PosixSocketWrapper {
  public:
   explicit PosixSocketWrapper(int fd) : fd_(fd) { CHECK_GT(fd_, 0); }
 
-  PosixSocketWrapper() : fd_(-1){};
+  PosixSocketWrapper() : fd_(-1) {};
 
   ~PosixSocketWrapper() = default;
 

data/src/core/lib/event_engine/posix_engine/timer_manager.cc

@@ -118,17 +118,13 @@ void TimerManager::Shutdown() {
   {
     grpc_core::MutexLock lock(&mu_);
     if (shutdown_) return;
-    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
-      VLOG(2) << "TimerManager::" << this << " shutting down";
-    }
+    GRPC_TRACE_VLOG(timer, 2) << "TimerManager::" << this << " shutting down";
     shutdown_ = true;
     // Wait on the main loop to exit.
     cv_wait_.Signal();
   }
   main_loop_exit_signal_->WaitForNotification();
-  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
-    VLOG(2) << "TimerManager::" << this << " shutdown complete";
-  }
+  GRPC_TRACE_VLOG(timer, 2) << "TimerManager::" << this << " shutdown complete";
 }
 
 TimerManager::~TimerManager() { Shutdown(); }
@@ -144,9 +140,8 @@ void TimerManager::Kick() {
 void TimerManager::RestartPostFork() {
   grpc_core::MutexLock lock(&mu_);
   CHECK(GPR_LIKELY(shutdown_));
-  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
-    VLOG(2) << "TimerManager::" << this << " restarting after shutdown";
-  }
+  GRPC_TRACE_VLOG(timer, 2)
+      << "TimerManager::" << this << " restarting after shutdown";
   shutdown_ = false;
   main_loop_exit_signal_.emplace();
   thread_pool_->Run([this]() { MainLoop(); });

data/src/core/lib/event_engine/posix_engine/traced_buffer_list.cc

@@ -24,7 +24,6 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 

data/src/core/lib/event_engine/resolved_address.cc

@@ -19,7 +19,6 @@
 #include "absl/log/check.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/resolved_address_internal.h"

data/src/core/lib/event_engine/slice.cc

@@ -23,7 +23,6 @@
 
 #include <grpc/event_engine/slice.h>
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/slice/slice_internal.h"

data/src/core/lib/event_engine/thread_pool/thread_count.cc

@@ -23,7 +23,6 @@
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/time.h"

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.cc

@@ -400,9 +400,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
       if (pool_->IsQuiesced()) break;
     } else {
       lifeguard_should_shut_down_->WaitForNotificationWithTimeout(
-          absl::Milliseconds(
-              (backoff_.NextAttemptTime() - grpc_core::Timestamp::Now())
-                  .millis()));
+          absl::Milliseconds(backoff_.NextAttemptDelay().millis()));
     }
     MaybeStartNewThread();
   }
@@ -556,8 +554,8 @@ bool WorkStealingThreadPool::ThreadState::Step() {
     // No closures were retrieved from anywhere.
     // Quit the thread if the pool has been shut down.
     if (pool_->IsShutdown()) break;
-    bool timed_out = pool_->work_signal()->WaitWithTimeout(
-        backoff_.NextAttemptTime() - grpc_core::Timestamp::Now());
+    bool timed_out =
+        pool_->work_signal()->WaitWithTimeout(backoff_.NextAttemptDelay());
     if (pool_->IsForking() || pool_->IsShutdown()) break;
     // Quit a thread if the pool has more than it requires, and this thread
     // has been idle long enough.

data/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc

@@ -82,7 +82,7 @@ grpc_slice FlattenIovec(const struct iovec* iov, int iov_count) {
 // instantiated at the top of the virtual socket function callstack.
 class WSAErrorContext {
  public:
-  explicit WSAErrorContext(){};
+  explicit WSAErrorContext() {};
 
   ~WSAErrorContext() {
     if (error_ != 0) {
@@ -128,9 +128,9 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         event_engine_(event_engine) {}
 
   ~GrpcPolledFdWindows() override {
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "fd:|%s| ~GrpcPolledFdWindows shutdown_called_: %d ", GetName(),
-        shutdown_called_);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:|" << GetName()
+        << "| ~GrpcPolledFdWindows shutdown_called_: " << shutdown_called_;
     grpc_core::CSliceUnref(read_buf_);
     grpc_core::CSliceUnref(write_buf_);
     CHECK(read_closure_ == nullptr);
@@ -158,14 +158,16 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   void RegisterForOnWriteableLocked(
       absl::AnyInvocable<void(absl::Status)> write_closure) override {
     if (socket_type_ == SOCK_DGRAM) {
-      GRPC_ARES_RESOLVER_TRACE_LOG(
-          "fd:|%s| RegisterForOnWriteableLocked called", GetName());
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) fd:|" << GetName()
+          << "| RegisterForOnWriteableLocked called";
     } else {
       CHECK(socket_type_ == SOCK_STREAM);
-      GRPC_ARES_RESOLVER_TRACE_LOG(
-          "fd:|%s| RegisterForOnWriteableLocked called tcp_write_state_: %d "
-          "connect_done_: %d",
-          GetName(), tcp_write_state_, connect_done_);
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) fd:|" << GetName()
+          << "| RegisterForOnWriteableLocked called tcp_write_state_: "
+          << static_cast<int>(tcp_write_state_)
+          << " connect_done_: " << connect_done_;
     }
     CHECK(write_closure_ == nullptr);
     write_closure_ = std::move(write_closure);
@@ -184,7 +186,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     if (!absl::IsCancelled(error)) {
       return false;
     }
-    GRPC_ARES_RESOLVER_TRACE_LOG("fd:|%s| ShutdownLocked", GetName());
+    GRPC_TRACE_LOG(cares_resolver, INFO) << "(EventEngine c-ares resolver) fd:|"
+                                         << GetName() << "| ShutdownLocked";
     shutdown_called_ = true;
     // The socket is disconnected and closed here since this is an external
     // cancel request, e.g. a timeout. c-ares shouldn't do anything on the
@@ -203,10 +206,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   ares_ssize_t RecvFrom(WSAErrorContext* wsa_error_ctx, void* data,
                         ares_socket_t data_len, int /* flags */,
                         struct sockaddr* from, ares_socklen_t* from_len) {
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "fd:|%s| RecvFrom called read_buf_has_data:%d Current read buf "
-        "length:|%d|",
-        GetName(), read_buf_has_data_, GRPC_SLICE_LENGTH(read_buf_));
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:" << GetName()
+        << " RecvFrom called read_buf_has_data:" << read_buf_has_data_
+        << " Current read buf length:" << GRPC_SLICE_LENGTH(read_buf_);
     if (!read_buf_has_data_) {
       wsa_error_ctx->SetWSAError(WSAEWOULDBLOCK);
       return -1;
@@ -233,9 +236,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
 
   ares_ssize_t SendV(WSAErrorContext* wsa_error_ctx, const struct iovec* iov,
                      int iov_count) {
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "fd:|%s| SendV called connect_done_:%d wsa_connect_error_:%d",
-        GetName(), connect_done_, wsa_connect_error_);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:|" << GetName()
+        << "| SendV called connect_done_:" << connect_done_
+        << " wsa_connect_error_:" << wsa_connect_error_;
     if (!connect_done_) {
       wsa_error_ctx->SetWSAError(WSAEWOULDBLOCK);
       return -1;
@@ -288,10 +292,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   }
 
   void ContinueRegisterForOnReadableLocked() {
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "fd:|%s| ContinueRegisterForOnReadableLocked "
-        "wsa_connect_error_:%d",
-        GetName(), wsa_connect_error_);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:|" << GetName()
+        << "| ContinueRegisterForOnReadableLocked wsa_connect_error_:"
+        << wsa_connect_error_;
     CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullReadClosure(GRPC_WSA_ERROR(wsa_connect_error_, "connect"));
@@ -309,11 +313,11 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
                     winsocket_->read_info()->overlapped(), nullptr) != 0) {
       int wsa_last_error = WSAGetLastError();
       char* msg = gpr_format_message(wsa_last_error);
-      GRPC_ARES_RESOLVER_TRACE_LOG(
-          "fd:|%s| ContinueRegisterForOnReadableLocked WSARecvFrom error "
-          "code:|%d| "
-          "msg:|%s|",
-          GetName(), wsa_last_error, msg);
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) fd:" << GetName()
+          << " ContinueRegisterForOnReadableLocked WSARecvFrom error "
+             "code:"
+          << wsa_last_error << " msg:" << msg;
       gpr_free(msg);
       if (wsa_last_error != WSA_IO_PENDING) {
         winsocket_->UnregisterReadCallback();
@@ -325,10 +329,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   }
 
   void ContinueRegisterForOnWriteableLocked() {
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "fd:|%s| ContinueRegisterForOnWriteableLocked "
-        "wsa_connect_error_:%d",
-        GetName(), wsa_connect_error_);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:|" << GetName()
+        << "| ContinueRegisterForOnWriteableLocked wsa_connect_error_:"
+        << wsa_connect_error_;
     CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullWriteClosure(
@@ -372,12 +376,12 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     int out = WSASend(winsocket_->raw_socket(), &buf, 1, bytes_sent_ptr, flags,
                       overlapped, nullptr);
     *wsa_error_code = WSAGetLastError();
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "fd:|%s| SendWriteBuf WSASend buf.len:%d *bytes_sent_ptr:%d "
-        "overlapped:%p "
-        "return:%d *wsa_error_code:%d",
-        GetName(), buf.len, bytes_sent_ptr != nullptr ? *bytes_sent_ptr : 0,
-        overlapped, out, *wsa_error_code);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:" << GetName()
+        << " SendWriteBuf WSASend buf.len:" << buf.len << " *bytes_sent_ptr:"
+        << (bytes_sent_ptr != nullptr ? *bytes_sent_ptr : 0)
+        << " overlapped:" << overlapped << " return:" << out
+        << " *wsa_error_code:" << *wsa_error_code;
     return out;
   }
 
@@ -386,7 +390,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     // c-ares doesn't handle retryable errors on writes of UDP sockets.
     // Therefore, the sendv handler for UDP sockets must only attempt
     // to write everything inline.
-    GRPC_ARES_RESOLVER_TRACE_LOG("fd:|%s| SendVUDP called", GetName());
+    GRPC_TRACE_LOG(cares_resolver, INFO) << "(EventEngine c-ares resolver) fd:|"
+                                         << GetName() << "| SendVUDP called";
     CHECK_EQ(GRPC_SLICE_LENGTH(write_buf_), 0);
     grpc_core::CSliceUnref(write_buf_);
     write_buf_ = FlattenIovec(iov, iov_count);
@@ -397,9 +402,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       write_buf_ = grpc_empty_slice();
       wsa_error_ctx->SetWSAError(wsa_error_code);
       char* msg = gpr_format_message(wsa_error_code);
-      GRPC_ARES_RESOLVER_TRACE_LOG(
-          "fd:|%s| SendVUDP SendWriteBuf error code:%d msg:|%s|", GetName(),
-          wsa_error_code, msg);
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) fd:|" << GetName()
+          << "| SendVUDP SendWriteBuf error code:" << wsa_error_code << " msg:|"
+          << msg << "|";
       gpr_free(msg);
       return -1;
     }
@@ -415,8 +421,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     // out in the background, and making further send progress in general, will
     // happen as long as c-ares continues to show interest in writeability on
     // this fd.
-    GRPC_ARES_RESOLVER_TRACE_LOG("fd:|%s| SendVTCP called tcp_write_state_:%d",
-                                 GetName(), tcp_write_state_);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:|" << GetName()
+        << "| SendVTCP called tcp_write_state_:"
+        << static_cast<int>(tcp_write_state_);
     switch (tcp_write_state_) {
       case WRITE_IDLE:
         tcp_write_state_ = WRITE_REQUESTED;
@@ -453,12 +461,12 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
 
   void OnTcpConnect() {
     grpc_core::MutexLock lock(mu_);
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "fd:%s InnerOnTcpConnectLocked "
-        "pending_register_for_readable:%d"
-        " pending_register_for_writeable:%d",
-        GetName(), pending_continue_register_for_on_readable_locked_,
-        pending_continue_register_for_on_writeable_locked_);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:" << GetName()
+        << " InnerOnTcpConnectLocked pending_register_for_readable:"
+        << pending_continue_register_for_on_readable_locked_
+        << " pending_register_for_writeable:"
+        << pending_continue_register_for_on_writeable_locked_;
     CHECK(!connect_done_);
     connect_done_ = true;
     CHECK_EQ(wsa_connect_error_, 0);
@@ -474,10 +482,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       if (!wsa_success) {
         wsa_connect_error_ = WSAGetLastError();
         char* msg = gpr_format_message(wsa_connect_error_);
-        GRPC_ARES_RESOLVER_TRACE_LOG(
-            "fd:%s InnerOnTcpConnectLocked WSA overlapped result code:%d "
-            "msg:|%s|",
-            GetName(), wsa_connect_error_, msg);
+        GRPC_TRACE_LOG(cares_resolver, INFO)
+            << "(EventEngine c-ares resolver) fd:" << GetName()
+            << " InnerOnTcpConnectLocked WSA overlapped result code:"
+            << wsa_connect_error_ << " msg:|" << msg << "|";
         gpr_free(msg);
       }
     }
@@ -491,7 +499,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
 
   int ConnectUDP(WSAErrorContext* wsa_error_ctx, const struct sockaddr* target,
                  ares_socklen_t target_len) {
-    GRPC_ARES_RESOLVER_TRACE_LOG("fd:%s ConnectUDP", GetName());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:" << GetName() << " ConnectUDP";
     CHECK(!connect_done_);
     CHECK_EQ(wsa_connect_error_, 0);
     SOCKET s = winsocket_->raw_socket();
@@ -501,8 +510,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     wsa_error_ctx->SetWSAError(wsa_connect_error_);
     connect_done_ = true;
     char* msg = gpr_format_message(wsa_connect_error_);
-    GRPC_ARES_RESOLVER_TRACE_LOG("fd:%s WSAConnect error code:|%d| msg:|%s|",
-                                 GetName(), wsa_connect_error_, msg);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:" << GetName()
+        << " WSAConnect error code:|" << wsa_connect_error_ << "| msg:|" << msg
+        << "|";
     gpr_free(msg);
     // c-ares expects a posix-style connect API
     return out == 0 ? 0 : -1;
@@ -510,7 +521,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
 
   int ConnectTCP(WSAErrorContext* wsa_error_ctx, const struct sockaddr* target,
                  ares_socklen_t target_len) {
-    GRPC_ARES_RESOLVER_TRACE_LOG("fd:%s ConnectTCP", GetName());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:" << GetName() << " ConnectTCP";
     LPFN_CONNECTEX ConnectEx;
     GUID guid = WSAID_CONNECTEX;
     DWORD ioctl_num_bytes;
@@ -521,10 +533,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       int wsa_last_error = WSAGetLastError();
       wsa_error_ctx->SetWSAError(wsa_last_error);
       char* msg = gpr_format_message(wsa_last_error);
-      GRPC_ARES_RESOLVER_TRACE_LOG(
-          "fd:%s WSAIoctl(SIO_GET_EXTENSION_FUNCTION_POINTER) error code:%d "
-          "msg:|%s|",
-          GetName(), wsa_last_error, msg);
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) fd:" << GetName()
+          << " WSAIoctl(SIO_GET_EXTENSION_FUNCTION_POINTER) error code:"
+          << wsa_last_error << " msg:|" << msg << "|";
       gpr_free(msg);
       connect_done_ = true;
       wsa_connect_error_ = wsa_last_error;
@@ -544,8 +556,9 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       int wsa_last_error = WSAGetLastError();
       wsa_error_ctx->SetWSAError(wsa_last_error);
       char* msg = gpr_format_message(wsa_last_error);
-      GRPC_ARES_RESOLVER_TRACE_LOG("fd:%s bind error code:%d msg:|%s|",
-                                   GetName(), wsa_last_error, msg);
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) fd:" << GetName()
+          << " bind error code:" << wsa_last_error << " msg:|" << msg << "|";
       gpr_free(msg);
       connect_done_ = true;
       wsa_connect_error_ = wsa_last_error;
@@ -561,8 +574,10 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       int wsa_last_error = WSAGetLastError();
       wsa_error_ctx->SetWSAError(wsa_last_error);
       char* msg = gpr_format_message(wsa_last_error);
-      GRPC_ARES_RESOLVER_TRACE_LOG("fd:%s ConnectEx error code:%d msg:|%s|",
-                                   GetName(), wsa_last_error, msg);
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) fd:" << GetName()
+          << " ConnectEx error code:" << wsa_last_error << " msg:|" << msg
+          << "|";
       gpr_free(msg);
       if (wsa_last_error == WSA_IO_PENDING) {
         // c-ares only understands WSAEINPROGRESS and EWOULDBLOCK error codes on
@@ -597,11 +612,12 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       if (winsocket_->read_info()->result().wsa_error != WSAEMSGSIZE) {
         error = GRPC_WSA_ERROR(winsocket_->read_info()->result().wsa_error,
                                "OnIocpReadableInner");
-        GRPC_ARES_RESOLVER_TRACE_LOG(
-            "fd:|%s| OnIocpReadableInner winsocket_->read_info.wsa_error "
-            "code:|%d| msg:|%s|",
-            GetName(), winsocket_->read_info()->result().wsa_error,
-            grpc_core::StatusToString(error).c_str());
+        GRPC_TRACE_LOG(cares_resolver, INFO)
+            << "(EventEngine c-ares resolver) fd:|" << GetName()
+            << "| OnIocpReadableInner winsocket_->read_info.wsa_error "
+               "code:|"
+            << winsocket_->read_info()->result().wsa_error << "| msg:|"
+            << grpc_core::StatusToString(error) << "|";
       }
     }
     if (error.ok()) {
@@ -612,34 +628,40 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       grpc_core::CSliceUnref(read_buf_);
       read_buf_ = grpc_empty_slice();
     }
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "fd:|%s| OnIocpReadable finishing. read buf length now:|%d|", GetName(),
-        GRPC_SLICE_LENGTH(read_buf_));
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:|" << GetName()
+        << "| OnIocpReadable finishing. read buf length now:|"
+        << GRPC_SLICE_LENGTH(read_buf_) << "|";
     ScheduleAndNullReadClosure(error);
   }
 
   void OnIocpWriteable() {
     grpc_core::MutexLock lock(mu_);
-    GRPC_ARES_RESOLVER_TRACE_LOG("OnIocpWriteableInner. fd:|%s|", GetName());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) OnIocpWriteableInner. fd:|"
+        << GetName() << "|";
     CHECK(socket_type_ == SOCK_STREAM);
     absl::Status error;
     if (winsocket_->write_info()->result().wsa_error != 0) {
       error = GRPC_WSA_ERROR(winsocket_->write_info()->result().wsa_error,
                              "OnIocpWriteableInner");
-      GRPC_ARES_RESOLVER_TRACE_LOG(
-          "fd:|%s| OnIocpWriteableInner. winsocket_->write_info.wsa_error "
-          "code:|%d| msg:|%s|",
-          GetName(), winsocket_->write_info()->result().wsa_error,
-          grpc_core::StatusToString(error).c_str());
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) fd:|" << GetName()
+          << "| OnIocpWriteableInner. winsocket_->write_info.wsa_error "
+             "code:|"
+          << winsocket_->write_info()->result().wsa_error << "| msg:|"
+          << grpc_core::StatusToString(error) << "|";
     }
     CHECK(tcp_write_state_ == WRITE_PENDING);
     if (error.ok()) {
       tcp_write_state_ = WRITE_WAITING_FOR_VERIFICATION_UPON_RETRY;
       write_buf_ = grpc_slice_sub_no_ref(
           write_buf_, 0, winsocket_->write_info()->result().bytes_transferred);
-      GRPC_ARES_RESOLVER_TRACE_LOG(
-          "fd:|%s| OnIocpWriteableInner. bytes transferred:%d", GetName(),
-          winsocket_->write_info()->result().bytes_transferred);
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) fd:|" << GetName()
+          << "| OnIocpWriteableInner. bytes transferred:"
+          << winsocket_->write_info()->result().bytes_transferred;
+
     } else {
       grpc_core::CSliceUnref(write_buf_);
       write_buf_ = grpc_empty_slice();
@@ -686,8 +708,10 @@ class CustomSockFuncs {
  public:
   static ares_socket_t Socket(int af, int type, int protocol, void* user_data) {
     if (type != SOCK_DGRAM && type != SOCK_STREAM) {
-      GRPC_ARES_RESOLVER_TRACE_LOG("Socket called with invalid socket type:%d",
-                                   type);
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) Socket called with invalid socket "
+             "type:"
+          << type;
       return INVALID_SOCKET;
     }
     GrpcPolledFdFactoryWindows* self =
@@ -695,24 +719,26 @@ class CustomSockFuncs {
     SOCKET s = WSASocket(af, type, protocol, nullptr, 0,
                          IOCP::GetDefaultSocketFlags());
     if (s == INVALID_SOCKET) {
-      GRPC_ARES_RESOLVER_TRACE_LOG(
-          "WSASocket failed with params af:%d type:%d protocol:%d", af, type,
-          protocol);
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) WSASocket failed with params af:"
+          << af << " type:" << type << " protocol:" << protocol;
       return INVALID_SOCKET;
     }
     if (type == SOCK_STREAM) {
       absl::Status error = PrepareSocket(s);
       if (!error.ok()) {
-        GRPC_ARES_RESOLVER_TRACE_LOG("WSAIoctl failed with error: %s",
-                                     grpc_core::StatusToString(error).c_str());
+        GRPC_TRACE_LOG(cares_resolver, INFO)
+            << "(EventEngine c-ares resolver) WSAIoctl failed with error: "
+            << grpc_core::StatusToString(error);
         return INVALID_SOCKET;
       }
     }
     auto polled_fd = std::make_unique<GrpcPolledFdWindows>(
         self->iocp_->Watch(s), self->mu_, af, type, self->event_engine_);
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "fd:|%s| created with params af:%d type:%d protocol:%d",
-        polled_fd->GetName(), af, type, protocol);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) fd:" << polled_fd->GetName()
+        << " created with params af:" << af << " type:" << type
+        << " protocol:" << protocol;
     CHECK(self->sockets_.insert({s, std::move(polled_fd)}).second);
     return s;
   }
@@ -750,7 +776,9 @@ class CustomSockFuncs {
   }
 
   static int CloseSocket(SOCKET s, void*) {
-    GRPC_ARES_RESOLVER_TRACE_LOG("c-ares socket: %d CloseSocket", s);
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) c-ares socket: " << s
+        << " CloseSocket";
     return 0;
   }
 };

data/src/core/lib/experiments/config.cc

@@ -220,6 +220,8 @@ bool IsTestExperimentEnabled(size_t experiment_id) {
   return (*g_test_experiments)[experiment_id];
 }
 
+#define GRPC_EXPERIMENT_LOG VLOG(2)
+
 void PrintExperimentsList() {
   std::map<std::string, std::string> experiment_status;
   std::set<std::string> defaulted_on_experiments;
@@ -254,20 +256,20 @@ void PrintExperimentsList() {
   }
   if (experiment_status.empty()) {
     if (!defaulted_on_experiments.empty()) {
-      VLOG(2) << "gRPC experiments enabled: "
-              << absl::StrJoin(defaulted_on_experiments, ", ");
+      GRPC_EXPERIMENT_LOG << "gRPC experiments enabled: "
+                          << absl::StrJoin(defaulted_on_experiments, ", ");
     }
   } else {
     if (defaulted_on_experiments.empty()) {
-      VLOG(2) << "gRPC experiments: "
-              << absl::StrJoin(experiment_status, ", ",
-                               absl::PairFormatter(":"));
+      GRPC_EXPERIMENT_LOG << "gRPC experiments: "
+                          << absl::StrJoin(experiment_status, ", ",
+                                           absl::PairFormatter(":"));
     } else {
-      VLOG(2) << "gRPC experiments: "
-              << absl::StrJoin(experiment_status, ", ",
-                               absl::PairFormatter(":"))
-              << "; default-enabled: "
-              << absl::StrJoin(defaulted_on_experiments, ", ");
+      GRPC_EXPERIMENT_LOG << "gRPC experiments: "
+                          << absl::StrJoin(experiment_status, ", ",
+                                           absl::PairFormatter(":"))
+                          << "; default-enabled: "
+                          << absl::StrJoin(defaulted_on_experiments, ", ");
     }
   }
 }