grpc 1.66.0.pre5 → 1.67.0.pre1

data/src/core/lib/gprpp/work_serializer.cc

@@ -136,10 +136,9 @@ class WorkSerializer::LegacyWorkSerializer final : public WorkSerializerImpl {
 
 void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
                                                const DebugLocation& location) {
-  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    LOG(INFO) << "WorkSerializer::Run() " << this << " Scheduling callback ["
-              << location.file() << ":" << location.line() << "]";
-  }
+  GRPC_TRACE_LOG(work_serializer, INFO)
+      << "WorkSerializer::Run() " << this << " Scheduling callback ["
+      << location.file() << ":" << location.line() << "]";
   // Increment queue size for the new callback and owner count to attempt to
   // take ownership of the WorkSerializer.
   const uint64_t prev_ref_pair =
@@ -162,9 +161,8 @@ void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
     refs_.fetch_sub(MakeRefPair(1, 0), std::memory_order_acq_rel);
     CallbackWrapper* cb_wrapper =
         new CallbackWrapper(std::move(callback), location);
-    if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-      LOG(INFO) << "  Scheduling on queue : item " << cb_wrapper;
-    }
+    GRPC_TRACE_LOG(work_serializer, INFO)
+        << "  Scheduling on queue : item " << cb_wrapper;
     queue_.Push(&cb_wrapper->mpscq_node);
   }
 }
@@ -173,19 +171,15 @@ void WorkSerializer::LegacyWorkSerializer::Schedule(
     std::function<void()> callback, const DebugLocation& location) {
   CallbackWrapper* cb_wrapper =
       new CallbackWrapper(std::move(callback), location);
-  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    LOG(INFO) << "WorkSerializer::Schedule() " << this
-              << " Scheduling callback " << cb_wrapper << " ["
-              << location.file() << ":" << location.line() << "]";
-  }
+  GRPC_TRACE_LOG(work_serializer, INFO)
+      << "WorkSerializer::Schedule() " << this << " Scheduling callback "
+      << cb_wrapper << " [" << location.file() << ":" << location.line() << "]";
   refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_acq_rel);
   queue_.Push(&cb_wrapper->mpscq_node);
 }
 
 void WorkSerializer::LegacyWorkSerializer::Orphan() {
-  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    LOG(INFO) << "WorkSerializer::Orphan() " << this;
-  }
+  GRPC_TRACE_LOG(work_serializer, INFO) << "WorkSerializer::Orphan() " << this;
   const uint64_t prev_ref_pair =
       refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
   if (GetOwners(prev_ref_pair) == 0 && GetSize(prev_ref_pair) == 1) {
@@ -197,9 +191,8 @@ void WorkSerializer::LegacyWorkSerializer::Orphan() {
 // The thread that calls this loans itself to the work serializer so as to
 // execute all the scheduled callbacks.
 void WorkSerializer::LegacyWorkSerializer::DrainQueue() {
-  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    LOG(INFO) << "WorkSerializer::DrainQueue() " << this;
-  }
+  GRPC_TRACE_LOG(work_serializer, INFO)
+      << "WorkSerializer::DrainQueue() " << this;
   // Attempt to take ownership of the WorkSerializer. Also increment the queue
   // size as required by `DrainQueueOwned()`.
   const uint64_t prev_ref_pair =
@@ -218,9 +211,8 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueue() {
 }
 
 void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
-  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    LOG(INFO) << "WorkSerializer::DrainQueueOwned() " << this;
-  }
+  GRPC_TRACE_LOG(work_serializer, INFO)
+      << "WorkSerializer::DrainQueueOwned() " << this;
   while (true) {
     auto prev_ref_pair = refs_.fetch_sub(MakeRefPair(0, 1));
     // It is possible that while draining the queue, the last callback ended
@@ -265,11 +257,10 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
       GRPC_TRACE_LOG(work_serializer, INFO)
           << "  Queue returned nullptr, trying again";
     }
-    if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-      LOG(INFO) << "  Running item " << cb_wrapper
-                << " : callback scheduled at [" << cb_wrapper->location.file()
-                << ":" << cb_wrapper->location.line() << "]";
-    }
+    GRPC_TRACE_LOG(work_serializer, INFO)
+        << "  Running item " << cb_wrapper << " : callback scheduled at ["
+        << cb_wrapper->location.file() << ":" << cb_wrapper->location.line()
+        << "]";
     cb_wrapper->callback();
     delete cb_wrapper;
   }
@@ -405,10 +396,9 @@ void WorkSerializer::DispatchingWorkSerializer::Orphan() {
 // Implementation of WorkSerializerImpl::Run
 void WorkSerializer::DispatchingWorkSerializer::Run(
     std::function<void()> callback, const DebugLocation& location) {
-  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    LOG(INFO) << "WorkSerializer[" << this << "] Scheduling callback ["
-              << location.file() << ":" << location.line() << "]";
-  }
+  GRPC_TRACE_LOG(work_serializer, INFO)
+      << "WorkSerializer[" << this << "] Scheduling callback ["
+      << location.file() << ":" << location.line() << "]";
   global_stats().IncrementWorkSerializerItemsEnqueued();
   MutexLock lock(&mu_);
   if (!running_) {
@@ -438,10 +428,9 @@ void WorkSerializer::DispatchingWorkSerializer::Run() {
   // Grab the last element of processing_ - which is the next item in our
   // queue since processing_ is stored in reverse order.
   auto& cb = processing_.back();
-  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    LOG(INFO) << "WorkSerializer[" << this << "] Executing callback ["
-              << cb.location.file() << ":" << cb.location.line() << "]";
-  }
+  GRPC_TRACE_LOG(work_serializer, INFO)
+      << "WorkSerializer[" << this << "] Executing callback ["
+      << cb.location.file() << ":" << cb.location.line() << "]";
   // Run the work item.
   const auto start = std::chrono::steady_clock::now();
   SetCurrentThread();

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

@@ -20,7 +20,6 @@
 
 #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/iomgr/call_combiner.h

@@ -166,14 +166,12 @@ class CallCombinerClosureList {
       GRPC_CALL_COMBINER_START(call_combiner, closure.closure, closure.error,
                                closure.reason);
     }
-    if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-      LOG(INFO) << "CallCombinerClosureList executing closure while already "
-                   "holding call_combiner "
-                << call_combiner
-                << ": closure=" << closures_[0].closure->DebugString()
-                << " error=" << StatusToString(closures_[0].error)
-                << " reason=" << closures_[0].reason;
-    }
+    GRPC_TRACE_LOG(call_combiner, INFO)
+        << "CallCombinerClosureList executing closure while already "
+           "holding call_combiner "
+        << call_combiner << ": closure=" << closures_[0].closure->DebugString()
+        << " error=" << StatusToString(closures_[0].error)
+        << " reason=" << closures_[0].reason;
     // This will release the call combiner.
     ExecCtx::Run(DEBUG_LOCATION, closures_[0].closure, closures_[0].error);
     closures_.clear();

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

@@ -65,10 +65,9 @@ void CFStreamHandle::ReadCallback(CFReadStreamRef stream,
   grpc_error_handle error;
   CFErrorRef stream_error;
   CFStreamHandle* handle = static_cast<CFStreamHandle*>(client_callback_info);
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    VLOG(2) << "CFStream ReadCallback (" << handle << ", " << stream << ", "
-            << type << ", " << client_callback_info << ")";
-  }
+  GRPC_TRACE_VLOG(tcp, 2) << "CFStream ReadCallback (" << handle << ", "
+                          << stream << ", " << type << ", "
+                          << client_callback_info << ")";
   switch (type) {
     case kCFStreamEventOpenCompleted:
       handle->open_event_.SetReady();
@@ -99,10 +98,9 @@ void CFStreamHandle::WriteCallback(CFWriteStreamRef stream,
   grpc_error_handle error;
   CFErrorRef stream_error;
   CFStreamHandle* handle = static_cast<CFStreamHandle*>(clientCallBackInfo);
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    VLOG(2) << "CFStream WriteCallback (" << handle << ", " << stream << ", "
-            << type << ", " << clientCallBackInfo << ")";
-  }
+  GRPC_TRACE_VLOG(tcp, 2) << "CFStream WriteCallback (" << handle << ", "
+                          << stream << ", " << type << ", "
+                          << clientCallBackInfo << ")";
   switch (type) {
     case kCFStreamEventOpenCompleted:
       handle->open_event_.SetReady();

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

@@ -292,18 +292,15 @@ class Closure {
       return;
     }
 #ifndef NDEBUG
-    if (GRPC_TRACE_FLAG_ENABLED(closure)) {
-      VLOG(2) << "running closure " << closure << ": created ["
-              << closure->file_created << ":" << closure->line_created
-              << "]: run [" << location.file() << ":" << location.line() << "]";
-    }
+    GRPC_TRACE_VLOG(closure, 2)
+        << "running closure " << closure << ": created ["
+        << closure->file_created << ":" << closure->line_created << "]: run ["
+        << location.file() << ":" << location.line() << "]";
     CHECK_NE(closure->cb, nullptr);
 #endif
     closure->cb(closure->cb_arg, error);
 #ifndef NDEBUG
-    if (GRPC_TRACE_FLAG_ENABLED(closure)) {
-      VLOG(2) << "closure " << closure << " finished";
-    }
+    GRPC_TRACE_VLOG(closure, 2) << "closure " << closure << " finished";
 #endif
   }
 };

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

@@ -71,14 +71,12 @@ static void start_destroy(grpc_core::Combiner* lock) {
 }
 
 #ifndef NDEBUG
-#define GRPC_COMBINER_DEBUG_SPAM(op, delta)                            \
-  if (GRPC_TRACE_FLAG_ENABLED(combiner)) {                             \
-    VLOG(2).AtLocation(file, line)                                     \
-        << "C:" << lock << " " << (op) << " "                          \
-        << gpr_atm_no_barrier_load(&lock->refs.count) << " --> "       \
-        << gpr_atm_no_barrier_load(&lock->refs.count) + (delta) << " " \
-        << reason;                                                     \
-  }
+#define GRPC_COMBINER_DEBUG_SPAM(op, delta)                          \
+  GRPC_TRACE_VLOG(combiner, 2).AtLocation(file, line)                \
+      << "C:" << lock << " " << (op) << " "                          \
+      << gpr_atm_no_barrier_load(&lock->refs.count) << " --> "       \
+      << gpr_atm_no_barrier_load(&lock->refs.count) + (delta) << " " \
+      << reason;
 #else
 #define GRPC_COMBINER_DEBUG_SPAM(op, delta)
 #endif

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

@@ -76,8 +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);
-    VLOG(2) << "CFStream endpoint unref " << ep << " : " << reason << " " << val
-            << " -> " << val - 1;
+    VLOG(2).AtLocation(file, line) << "CFStream endpoint unref " << ep << " : "
+                                   << reason << " " << val << " -> " << val - 1;
   }
   if (gpr_unref(&ep->refcount)) {
     CFStreamFree(ep);
@@ -87,8 +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);
-    VLOG(2) << "CFStream endpoint ref " << ep << " : " << reason << " " << val
-            << " -> " << val + 1;
+    VLOG(2).AtLocation(file, line) << "CFStream endpoint ref " << ep << " : "
+                                   << reason << " " << val << " -> " << val + 1;
   }
   gpr_ref(&ep->refcount);
 }
@@ -129,11 +129,10 @@ static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
 }
 
 static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    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_TRACE_VLOG(tcp, 2) << "CFStream endpoint:" << ep << " call_write_cb "
+                          << ep->write_cb << " " << ep->write_cb->cb << ":"
+                          << ep->write_cb->cb_arg << "write: error="
+                          << grpc_core::StatusToString(error);
   grpc_closure* cb = ep->write_cb;
   ep->write_cb = nullptr;
   ep->write_slices = nullptr;
@@ -233,10 +232,9 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
                          grpc_closure* cb, bool /*urgent*/,
                          int /*min_progress_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    VLOG(2) << "CFStream endpoint:" << ep_impl << " read (" << slices << ", "
-            << cb << ") length:" << slices->length;
-  }
+  GRPC_TRACE_VLOG(tcp, 2) << "CFStream endpoint:" << ep_impl << " read ("
+                          << slices << ", " << cb
+                          << ") length:" << slices->length;
   CHECK_EQ(ep_impl->read_cb, nullptr);
   ep_impl->read_cb = cb;
   ep_impl->read_slices = slices;
@@ -251,10 +249,9 @@ static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
                           grpc_closure* cb, void* /*arg*/,
                           int /*max_frame_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    VLOG(2) << "CFStream endpoint:" << ep_impl << " write (" << slices << ", "
-            << cb << ") length:" << slices->length;
-  }
+  GRPC_TRACE_VLOG(tcp, 2) << "CFStream endpoint:" << ep_impl << " write ("
+                          << slices << ", " << cb
+                          << ") length:" << slices->length;
   CHECK_EQ(ep_impl->write_cb, nullptr);
   ep_impl->write_cb = cb;
   ep_impl->write_slices = slices;
@@ -308,11 +305,9 @@ grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
                                              const char* peer_string,
                                              CFStreamHandle* stream_sync) {
   CFStreamEndpoint* ep_impl = new CFStreamEndpoint;
-  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    VLOG(2) << "CFStream endpoint:" << ep_impl
-            << " create readStream:" << read_stream
-            << " writeStream: " << write_stream;
-  }
+  GRPC_TRACE_VLOG(tcp, 2) << "CFStream endpoint:" << ep_impl
+                          << " create readStream:" << read_stream
+                          << " writeStream: " << write_stream;
   ep_impl->base.vtable = &vtable;
   gpr_ref_init(&ep_impl->refcount, 1);
   ep_impl->read_stream = read_stream;

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

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

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

@@ -27,7 +27,6 @@
 
 #include <grpc/slice.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 

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

@@ -39,15 +39,6 @@
 #include "src/core/lib/gprpp/time_util.h"
 #include "src/core/lib/iomgr/ev_apple.h"
 
-#ifndef NDEBUG
-#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(...)
-#endif  // NDEBUG
-
 #define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1)
 
 struct GlobalRunLoopContext {
@@ -117,7 +108,8 @@ static void grpc_apple_register_write_stream_queue(
 /// the global run loop thread gGlobalRunLoopThread.
 static void grpc_apple_register_read_stream_run_loop(
     CFReadStreamRef read_stream, dispatch_queue_t /*dispatch_queue*/) {
-  GRPC_POLLING_TRACE("Register read stream: %p", read_stream);
+  GRPC_TRACE_VLOG(apple_polling, 2)
+      << "(polling) Register read stream: " << read_stream;
   grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
   CFReadStreamScheduleWithRunLoop(read_stream, gGlobalRunLoopContext->run_loop,
                                   kCFRunLoopDefaultMode);
@@ -130,7 +122,8 @@ static void grpc_apple_register_read_stream_run_loop(
 /// by the global run loop thread gGlobalRunLoopThread.
 static void grpc_apple_register_write_stream_run_loop(
     CFWriteStreamRef write_stream, dispatch_queue_t /*dispatch_queue*/) {
-  GRPC_POLLING_TRACE("Register write stream: %p", write_stream);
+  GRPC_TRACE_VLOG(apple_polling, 2)
+      << "(polling) Register write stream: " << write_stream;
   grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
   CFWriteStreamScheduleWithRunLoop(
       write_stream, gGlobalRunLoopContext->run_loop, kCFRunLoopDefaultMode);
@@ -220,9 +213,9 @@ static void pollset_global_shutdown(void) {
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker,
                                       grpc_core::Timestamp deadline) {
-  GRPC_POLLING_TRACE("pollset work: %p, worker: %p, deadline: %" PRIu64,
-                     pollset, worker,
-                     deadline.milliseconds_after_process_epoch());
+  GRPC_TRACE_VLOG(apple_polling, 2)
+      << "(polling) pollset work: " << pollset << ", worker: " << worker
+      << ", deadline: " << deadline.milliseconds_after_process_epoch();
   GrpcApplePollset* apple_pollset =
       reinterpret_cast<GrpcApplePollset*>(pollset);
   GrpcAppleWorker actual_worker;
@@ -276,7 +269,8 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
   GrpcApplePollset* apple_pollset =
       reinterpret_cast<GrpcApplePollset*>(pollset);
 
-  GRPC_POLLING_TRACE("pollset kick: %p, worker:%p", pollset, specific_worker);
+  GRPC_TRACE_VLOG(apple_polling, 2) << "(polling) pollset kick: " << pollset
+                                    << ", worker:" << specific_worker;
 
   if (specific_worker == nullptr) {
     if (apple_pollset->workers.empty()) {
@@ -299,7 +293,7 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
 }
 
 static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
-  GRPC_POLLING_TRACE("pollset init: %p", pollset);
+  GRPC_TRACE_VLOG(apple_polling, 2) << "(polling) pollset init: " << pollset;
   GrpcApplePollset* apple_pollset = new (pollset) GrpcApplePollset();
   *mu = grpc_core::GetUnderlyingGprMu(&apple_pollset->mu);
 }
@@ -307,7 +301,8 @@ static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
 /// The caller must acquire the lock GrpcApplePollset.mu before calling this
 /// function.
 static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
-  GRPC_POLLING_TRACE("pollset shutdown: %p", pollset);
+  GRPC_TRACE_VLOG(apple_polling, 2)
+      << "(polling) pollset shutdown: " << pollset;
 
   GrpcApplePollset* apple_pollset =
       reinterpret_cast<GrpcApplePollset*>(pollset);
@@ -323,7 +318,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
 }
 
 static void pollset_destroy(grpc_pollset* pollset) {
-  GRPC_POLLING_TRACE("pollset destroy: %p", pollset);
+  GRPC_TRACE_VLOG(apple_polling, 2) << "(polling) pollset destroy: " << pollset;
   GrpcApplePollset* apple_pollset =
       reinterpret_cast<GrpcApplePollset*>(pollset);
   apple_pollset->~GrpcApplePollset();