grpc 1.65.2 → 1.66.0.pre3

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

@@ -31,7 +31,6 @@
 #include "absl/log/log.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -43,6 +42,7 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/util/latent_see.h"
 
 namespace grpc_core {
 
@@ -137,8 +137,8 @@ class WorkSerializer::LegacyWorkSerializer final : public WorkSerializerImpl {
 void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
                                                const DebugLocation& location) {
   if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    gpr_log(GPR_INFO, "WorkSerializer::Run() %p Scheduling callback [%s:%d]",
-            this, location.file(), location.line());
+    LOG(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.
@@ -163,7 +163,7 @@ void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
     CallbackWrapper* cb_wrapper =
         new CallbackWrapper(std::move(callback), location);
     if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-      gpr_log(GPR_INFO, "  Scheduling on queue : item %p", cb_wrapper);
+      LOG(INFO) << "  Scheduling on queue : item " << cb_wrapper;
     }
     queue_.Push(&cb_wrapper->mpscq_node);
   }
@@ -174,9 +174,9 @@ void WorkSerializer::LegacyWorkSerializer::Schedule(
   CallbackWrapper* cb_wrapper =
       new CallbackWrapper(std::move(callback), location);
   if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    gpr_log(GPR_INFO,
-            "WorkSerializer::Schedule() %p Scheduling callback %p [%s:%d]",
-            this, cb_wrapper, location.file(), location.line());
+    LOG(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);
@@ -184,7 +184,7 @@ void WorkSerializer::LegacyWorkSerializer::Schedule(
 
 void WorkSerializer::LegacyWorkSerializer::Orphan() {
   if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    gpr_log(GPR_INFO, "WorkSerializer::Orphan() %p", this);
+    LOG(INFO) << "WorkSerializer::Orphan() " << this;
   }
   const uint64_t prev_ref_pair =
       refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
@@ -198,7 +198,7 @@ void WorkSerializer::LegacyWorkSerializer::Orphan() {
 // execute all the scheduled callbacks.
 void WorkSerializer::LegacyWorkSerializer::DrainQueue() {
   if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    gpr_log(GPR_INFO, "WorkSerializer::DrainQueue() %p", this);
+    LOG(INFO) << "WorkSerializer::DrainQueue() " << this;
   }
   // Attempt to take ownership of the WorkSerializer. Also increment the queue
   // size as required by `DrainQueueOwned()`.
@@ -219,7 +219,7 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueue() {
 
 void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
   if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    gpr_log(GPR_INFO, "WorkSerializer::DrainQueueOwned() %p", this);
+    LOG(INFO) << "WorkSerializer::DrainQueueOwned() " << this;
   }
   while (true) {
     auto prev_ref_pair = refs_.fetch_sub(MakeRefPair(0, 1));
@@ -266,9 +266,9 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
           << "  Queue returned nullptr, trying again";
     }
     if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-      gpr_log(GPR_INFO, "  Running item %p : callback scheduled at [%s:%d]",
-              cb_wrapper, cb_wrapper->location.file(),
-              cb_wrapper->location.line());
+      LOG(INFO) << "  Running item " << cb_wrapper
+                << " : callback scheduled at [" << cb_wrapper->location.file()
+                << ":" << cb_wrapper->location.line() << "]";
     }
     cb_wrapper->callback();
     delete cb_wrapper;
@@ -377,6 +377,8 @@ class WorkSerializer::DispatchingWorkSerializer final
   // rate of mutex acquisitions per work item tends towards 1.
   CallbackVector incoming_ ABSL_GUARDED_BY(mu_);
 
+  GPR_NO_UNIQUE_ADDRESS latent_see::Flow flow_;
+
 #ifndef NDEBUG
   static thread_local DispatchingWorkSerializer* running_work_serializer_;
 #endif
@@ -404,8 +406,8 @@ void WorkSerializer::DispatchingWorkSerializer::Orphan() {
 void WorkSerializer::DispatchingWorkSerializer::Run(
     std::function<void()> callback, const DebugLocation& location) {
   if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    gpr_log(GPR_INFO, "WorkSerializer[%p] Scheduling callback [%s:%d]", this,
-            location.file(), location.line());
+    LOG(INFO) << "WorkSerializer[" << this << "] Scheduling callback ["
+              << location.file() << ":" << location.line() << "]";
   }
   global_stats().IncrementWorkSerializerItemsEnqueued();
   MutexLock lock(&mu_);
@@ -428,6 +430,8 @@ void WorkSerializer::DispatchingWorkSerializer::Run(
 
 // Implementation of EventEngine::Closure::Run - our actual work loop
 void WorkSerializer::DispatchingWorkSerializer::Run() {
+  GRPC_LATENT_SEE_PARENT_SCOPE("WorkSerializer::Run");
+  flow_.End();
   // TODO(ctiller): remove these when we can deprecate ExecCtx
   ApplicationCallbackExecCtx app_exec_ctx;
   ExecCtx exec_ctx;
@@ -435,8 +439,8 @@ void WorkSerializer::DispatchingWorkSerializer::Run() {
   // queue since processing_ is stored in reverse order.
   auto& cb = processing_.back();
   if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
-    gpr_log(GPR_INFO, "WorkSerializer[%p] Executing callback [%s:%d]", this,
-            cb.location.file(), cb.location.line());
+    LOG(INFO) << "WorkSerializer[" << this << "] Executing callback ["
+              << cb.location.file() << ":" << cb.location.line() << "]";
   }
   // Run the work item.
   const auto start = std::chrono::steady_clock::now();
@@ -457,6 +461,7 @@ void WorkSerializer::DispatchingWorkSerializer::Run() {
   if (processing_.empty() && !Refill()) return;
   // There's still work in processing_, so schedule ourselves again on
   // EventEngine.
+  flow_.Begin(GRPC_LATENT_SEE_METADATA("WorkSerializer::Link"));
   event_engine_->Run(this);
 }
 

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

@@ -23,7 +23,6 @@
 #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/gprpp/crash.h"
@@ -114,19 +113,15 @@ void CallCombiner::ScheduleClosure(grpc_closure* closure,
 
 void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
                          DEBUG_ARGS const char* reason) {
-  if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-    gpr_log(GPR_INFO,
-            "==> CallCombiner::Start() [%p] closure=%s [" DEBUG_FMT_STR
-            "%s] error=%s",
-            this, closure->DebugString().c_str() DEBUG_FMT_ARGS, reason,
-            StatusToString(error).c_str());
-  }
+  GRPC_TRACE_LOG(call_combiner, INFO) << absl::StrFormat(
+      "==> CallCombiner::Start() [%p] closure=%s [" DEBUG_FMT_STR
+      "%s] error=%s",
+      this, closure->DebugString().c_str() DEBUG_FMT_ARGS, reason,
+      StatusToString(error).c_str());
   size_t prev_size =
       static_cast<size_t>(gpr_atm_full_fetch_add(&size_, (gpr_atm)1));
-  if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-    gpr_log(GPR_INFO, "  size: %" PRIdPTR " -> %" PRIdPTR, prev_size,
-            prev_size + 1);
-  }
+  GRPC_TRACE_LOG(call_combiner, INFO)
+      << "  size: " << prev_size << " -> " << prev_size + 1;
   if (prev_size == 0) {
     GRPC_TRACE_LOG(call_combiner, INFO) << "  EXECUTING IMMEDIATELY";
     // Queue was empty, so execute this closure immediately.
@@ -141,16 +136,13 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
 }
 
 void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
-  if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-    gpr_log(GPR_INFO, "==> CallCombiner::Stop() [%p] [" DEBUG_FMT_STR "%s]",
-            this DEBUG_FMT_ARGS, reason);
-  }
+  GRPC_TRACE_LOG(call_combiner, INFO)
+      << absl::StrFormat("==> CallCombiner::Stop() [%p] [" DEBUG_FMT_STR "%s]",
+                         this DEBUG_FMT_ARGS, reason);
   size_t prev_size =
       static_cast<size_t>(gpr_atm_full_fetch_add(&size_, (gpr_atm)-1));
-  if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-    gpr_log(GPR_INFO, "  size: %" PRIdPTR " -> %" PRIdPTR, prev_size,
-            prev_size - 1);
-  }
+  GRPC_TRACE_LOG(call_combiner, INFO)
+      << "  size: " << prev_size << " -> " << prev_size - 1;
   CHECK_GE(prev_size, 1u);
   if (prev_size > 1) {
     while (true) {
@@ -168,10 +160,9 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
       grpc_error_handle error =
           internal::StatusMoveFromHeapPtr(closure->error_data.error);
       closure->error_data.error = 0;
-      if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-        gpr_log(GPR_INFO, "  EXECUTING FROM QUEUE: closure=%s error=%s",
-                closure->DebugString().c_str(), StatusToString(error).c_str());
-      }
+      GRPC_TRACE_LOG(call_combiner, INFO)
+          << "  EXECUTING FROM QUEUE: closure=" << closure->DebugString()
+          << " error=" << StatusToString(error);
       ScheduleClosure(closure, error);
       break;
     }
@@ -187,31 +178,26 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
     // If error is set, invoke the cancellation closure immediately.
     // Otherwise, store the new closure.
     if (!original_error.ok()) {
-      if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-        gpr_log(GPR_INFO,
-                "call_combiner=%p: scheduling notify_on_cancel callback=%p "
-                "for pre-existing cancellation",
-                this, closure);
-      }
+      GRPC_TRACE_LOG(call_combiner, INFO)
+          << "call_combiner=" << this
+          << ": scheduling notify_on_cancel callback=" << closure
+          << " for pre-existing cancellation";
       ExecCtx::Run(DEBUG_LOCATION, closure, original_error);
       break;
     } else {
       if (gpr_atm_full_cas(&cancel_state_, original_state,
                            reinterpret_cast<gpr_atm>(closure))) {
-        if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-          gpr_log(GPR_INFO, "call_combiner=%p: setting notify_on_cancel=%p",
-                  this, closure);
-        }
+        GRPC_TRACE_LOG(call_combiner, INFO)
+            << "call_combiner=" << this
+            << ": setting notify_on_cancel=" << closure;
         // If we replaced an earlier closure, invoke the original
         // closure with absl::OkStatus().  This allows callers to clean
         // up any resources they may be holding for the callback.
         if (original_state != 0) {
           closure = reinterpret_cast<grpc_closure*>(original_state);
-          if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-            gpr_log(GPR_INFO,
-                    "call_combiner=%p: scheduling old cancel callback=%p", this,
-                    closure);
-          }
+          GRPC_TRACE_LOG(call_combiner, INFO)
+              << "call_combiner=" << this
+              << ": scheduling old cancel callback=" << closure;
           ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
         }
         break;
@@ -235,11 +221,9 @@ void CallCombiner::Cancel(grpc_error_handle error) {
       if (original_state != 0) {
         grpc_closure* notify_on_cancel =
             reinterpret_cast<grpc_closure*>(original_state);
-        if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-          gpr_log(GPR_INFO,
-                  "call_combiner=%p: scheduling notify_on_cancel callback=%p",
-                  this, notify_on_cancel);
-        }
+        GRPC_TRACE_LOG(call_combiner, INFO)
+            << "call_combiner=" << this
+            << ": scheduling notify_on_cancel callback=" << notify_on_cancel;
         ExecCtx::Run(DEBUG_LOCATION, notify_on_cancel, error);
       }
       break;

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

@@ -22,6 +22,7 @@
 #include <stddef.h>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/atm.h>
 #include <grpc/support/port_platform.h>
@@ -166,11 +167,12 @@ class CallCombinerClosureList {
                                closure.reason);
     }
     if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
-      gpr_log(GPR_INFO,
-              "CallCombinerClosureList executing closure while already "
-              "holding call_combiner %p: closure=%s error=%s reason=%s",
-              call_combiner, closures_[0].closure->DebugString().c_str(),
-              StatusToString(closures_[0].error).c_str(), closures_[0].reason);
+      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;
     }
     // This will release the call combiner.
     ExecCtx::Run(DEBUG_LOCATION, closures_[0].closure, closures_[0].error);

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

@@ -24,6 +24,8 @@
 #ifdef GRPC_CFSTREAM
 #import <CoreFoundation/CoreFoundation.h>
 
+#include "absl/log/log.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/sync.h>
@@ -64,8 +66,8 @@ void CFStreamHandle::ReadCallback(CFReadStreamRef stream,
   CFErrorRef stream_error;
   CFStreamHandle* handle = static_cast<CFStreamHandle*>(client_callback_info);
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_DEBUG, "CFStream ReadCallback (%p, %p, %lu, %p)", handle,
-            stream, type, client_callback_info);
+    VLOG(2) << "CFStream ReadCallback (" << handle << ", " << stream << ", "
+            << type << ", " << client_callback_info << ")";
   }
   switch (type) {
     case kCFStreamEventOpenCompleted:
@@ -98,8 +100,8 @@ void CFStreamHandle::WriteCallback(CFWriteStreamRef stream,
   CFErrorRef stream_error;
   CFStreamHandle* handle = static_cast<CFStreamHandle*>(clientCallBackInfo);
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
-    gpr_log(GPR_DEBUG, "CFStream WriteCallback (%p, %p, %lu, %p)", handle,
-            stream, type, clientCallBackInfo);
+    VLOG(2) << "CFStream WriteCallback (" << handle << ", " << stream << ", "
+            << type << ", " << clientCallBackInfo << ")";
   }
   switch (type) {
     case kCFStreamEventOpenCompleted:
@@ -176,9 +178,8 @@ void CFStreamHandle::Shutdown(grpc_error_handle error) {
 void CFStreamHandle::Ref(const char* file, int line, const char* reason) {
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&refcount_.count);
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "CFStream Handle ref %p : %s %" PRIdPTR " -> %" PRIdPTR, this,
-            reason, val, val + 1);
+    VLOG(2).AtLocation(file, line) << "CFStream Handle ref " << this << " : "
+                                   << reason << " " << val << " -> " << val + 1;
   }
   gpr_ref(&refcount_);
 }
@@ -186,9 +187,8 @@ void CFStreamHandle::Ref(const char* file, int line, const char* reason) {
 void CFStreamHandle::Unref(const char* file, int line, const char* reason) {
   if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&refcount_.count);
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "CFStream Handle unref %p : %s %" PRIdPTR " -> %" PRIdPTR, this,
-            reason, val, val - 1);
+    VLOG(2).AtLocation(file, line) << "CFStream Handle unref " << this << " : "
+                                   << reason << " " << val << " -> " << val - 1;
   }
   if (gpr_unref(&refcount_)) {
     delete this;

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

@@ -23,9 +23,9 @@
 #include <stdbool.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -293,16 +293,16 @@ class Closure {
     }
 #ifndef NDEBUG
     if (GRPC_TRACE_FLAG_ENABLED(closure)) {
-      gpr_log(GPR_DEBUG, "running closure %p: created [%s:%d]: run [%s:%d]",
-              closure, closure->file_created, closure->line_created,
-              location.file(), location.line());
+      VLOG(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)) {
-      gpr_log(GPR_DEBUG, "closure %p finished", closure);
+      VLOG(2) << "closure " << closure << " finished";
     }
 #endif
   }

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

@@ -23,9 +23,9 @@
 #include <string.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/experiments/experiments.h"
@@ -34,13 +34,6 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 
-#define GRPC_COMBINER_TRACE(fn)              \
-  do {                                       \
-    if (GRPC_TRACE_FLAG_ENABLED(combiner)) { \
-      fn;                                    \
-    }                                        \
-  } while (0)
-
 #define STATE_UNORPHANED 1
 #define STATE_ELEM_COUNT_LOW_BIT 2
 
@@ -58,32 +51,33 @@ grpc_core::Combiner* grpc_combiner_create(
   gpr_ref_init(&lock->refs, 1);
   gpr_atm_no_barrier_store(&lock->state, STATE_UNORPHANED);
   grpc_closure_list_init(&lock->final_list);
-  GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p create", lock));
+  GRPC_TRACE_LOG(combiner, INFO) << "C:" << lock << " create";
   return lock;
 }
 
 static void really_destroy(grpc_core::Combiner* lock) {
-  GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p really_destroy", lock));
+  GRPC_TRACE_LOG(combiner, INFO) << "C:" << lock << " really_destroy";
   CHECK_EQ(gpr_atm_no_barrier_load(&lock->state), 0);
   delete lock;
 }
 
 static void start_destroy(grpc_core::Combiner* lock) {
   gpr_atm old_state = gpr_atm_full_fetch_add(&lock->state, -STATE_UNORPHANED);
-  GRPC_COMBINER_TRACE(gpr_log(
-      GPR_INFO, "C:%p really_destroy old_state=%" PRIdPTR, lock, old_state));
+  GRPC_TRACE_LOG(combiner, INFO)
+      << "C:" << lock << " really_destroy old_state=" << old_state;
   if (old_state == 1) {
     really_destroy(lock);
   }
 }
 
 #ifndef NDEBUG
-#define GRPC_COMBINER_DEBUG_SPAM(op, delta)                                \
-  if (GRPC_TRACE_FLAG_ENABLED(combiner)) {                                 \
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,                            \
-            "C:%p %s %" PRIdPTR " --> %" PRIdPTR " %s", 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)                            \
+  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;                                                     \
   }
 #else
 #define GRPC_COMBINER_DEBUG_SPAM(op, delta)
@@ -128,9 +122,8 @@ static void push_first_on_exec_ctx(grpc_core::Combiner* lock) {
 static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* cl,
                           grpc_error_handle error) {
   gpr_atm last = gpr_atm_full_fetch_add(&lock->state, STATE_ELEM_COUNT_LOW_BIT);
-  GRPC_COMBINER_TRACE(gpr_log(GPR_INFO,
-                              "C:%p grpc_combiner_execute c=%p last=%" PRIdPTR,
-                              lock, cl, last));
+  GRPC_TRACE_LOG(combiner, INFO)
+      << "C:" << lock << " grpc_combiner_execute c=" << cl << " last=" << last;
   if (last == 1) {
     gpr_atm_no_barrier_store(
         &lock->initiating_exec_ctx_or_null,
@@ -169,7 +162,7 @@ static void queue_offload(grpc_core::Combiner* lock) {
   // Make the combiner look uncontended by storing a non-null value here, so
   // that we don't immediately offload again.
   gpr_atm_no_barrier_store(&lock->initiating_exec_ctx_or_null, 1);
-  GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p queue_offload", lock));
+  GRPC_TRACE_LOG(combiner, INFO) << "C:" << lock << " queue_offload";
   lock->event_engine->Run([lock] {
     grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
     grpc_core::ExecCtx exec_ctx(0);
@@ -188,14 +181,11 @@ bool grpc_combiner_continue_exec_ctx() {
   bool contended =
       gpr_atm_no_barrier_load(&lock->initiating_exec_ctx_or_null) == 0;
 
-  GRPC_COMBINER_TRACE(gpr_log(GPR_INFO,
-                              "C:%p grpc_combiner_continue_exec_ctx "
-                              "contended=%d "
-                              "exec_ctx_ready_to_finish=%d "
-                              "time_to_execute_final_list=%d",
-                              lock, contended,
-                              grpc_core::ExecCtx::Get()->IsReadyToFinish(),
-                              lock->time_to_execute_final_list));
+  GRPC_TRACE_LOG(combiner, INFO)
+      << "C:" << lock << " grpc_combiner_continue_exec_ctx "
+      << "contended=" << contended << " exec_ctx_ready_to_finish="
+      << grpc_core::ExecCtx::Get()->IsReadyToFinish()
+      << " time_to_execute_final_list=" << lock->time_to_execute_final_list;
 
   // offload only if both (1) the combiner is contended and has more than one
   // closure to execute, and (2) the current execution context needs to finish
@@ -212,8 +202,9 @@ bool grpc_combiner_continue_exec_ctx() {
       // priority
       (gpr_atm_acq_load(&lock->state) >> 1) > 1) {
     grpc_core::MultiProducerSingleConsumerQueue::Node* n = lock->queue.Pop();
-    GRPC_COMBINER_TRACE(
-        gpr_log(GPR_INFO, "C:%p maybe_finish_one n=%p", lock, n));
+    GRPC_TRACE_LOG(combiner, INFO)
+        << "C:" << lock << " maybe_finish_one n=" << n;
+
     if (n == nullptr) {
       // queue is in an inconsistent state: use this as a cue that we should
       // go off and do something else for a while (and come back later)
@@ -234,8 +225,8 @@ bool grpc_combiner_continue_exec_ctx() {
     grpc_closure_list_init(&lock->final_list);
     int loops = 0;
     while (c != nullptr) {
-      GRPC_COMBINER_TRACE(
-          gpr_log(GPR_INFO, "C:%p execute_final[%d] c=%p", lock, loops, c));
+      GRPC_TRACE_LOG(combiner, INFO)
+          << "C:" << lock << " execute_final[" << loops << "] c=" << c;
       grpc_closure* next = c->next_data.next;
 #ifndef NDEBUG
       c->scheduled = false;
@@ -252,8 +243,8 @@ bool grpc_combiner_continue_exec_ctx() {
   lock->time_to_execute_final_list = false;
   gpr_atm old_state =
       gpr_atm_full_fetch_add(&lock->state, -STATE_ELEM_COUNT_LOW_BIT);
-  GRPC_COMBINER_TRACE(
-      gpr_log(GPR_INFO, "C:%p finish old_state=%" PRIdPTR, lock, old_state));
+  GRPC_TRACE_LOG(combiner, INFO)
+      << "C:" << lock << " finish old_state=" << old_state;
 // Define a macro to ease readability of the following switch statement.
 #define OLD_STATE_WAS(orphaned, elem_count) \
   (((orphaned) ? 0 : STATE_UNORPHANED) |    \
@@ -294,9 +285,9 @@ static void combiner_finally_exec(grpc_core::Combiner* lock,
                                   grpc_closure* closure,
                                   grpc_error_handle error) {
   CHECK_NE(lock, nullptr);
-  GRPC_COMBINER_TRACE(gpr_log(
-      GPR_INFO, "C:%p grpc_combiner_execute_finally c=%p; ac=%p", lock, closure,
-      grpc_core::ExecCtx::Get()->combiner_data()->active_combiner));
+  GRPC_TRACE_LOG(combiner, INFO)
+      << "C:" << lock << " grpc_combiner_execute_finally c=" << closure
+      << "; ac=" << grpc_core::ExecCtx::Get()->combiner_data()->active_combiner;
   if (grpc_core::ExecCtx::Get()->combiner_data()->active_combiner != lock) {
     // Using error_data.scratch to store the combiner so that it can be accessed
     // in enqueue_finally.

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

@@ -101,6 +101,8 @@ bool grpc_endpoint_can_track_err(grpc_endpoint* ep);
 
 struct grpc_endpoint {
   const grpc_endpoint_vtable* vtable;
+
+  void Orphan() { grpc_endpoint_destroy(this); }
 };
 
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_ENDPOINT_H