grpc 1.63.0 → 1.65.2

data/src/core/lib/gprpp/validation_errors.h

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H
 #define GRPC_SRC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <map>
@@ -27,6 +25,8 @@
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 // Tracks errors that occur during validation of a data structure (e.g.,
@@ -63,6 +63,9 @@ namespace grpc_core {
 // }
 class ValidationErrors {
  public:
+  // Default maximum number of errors to track per scope.
+  static constexpr size_t kMaxErrorCount = 20;
+
   // Pushes a field name onto the stack at construction and pops it off
   // of the stack at destruction.
   class ScopedField {
@@ -93,6 +96,12 @@ class ValidationErrors {
     ValidationErrors* errors_;
   };
 
+  ValidationErrors() : ValidationErrors(kMaxErrorCount) {}
+
+  // Creates a tracker that collects at most `max_error_count` errors per field.
+  explicit ValidationErrors(size_t max_error_count)
+      : max_error_count_(max_error_count) {}
+
   // Records that we've encountered an error associated with the current
   // field.
   void AddError(absl::string_view error) GPR_ATTRIBUTE_NOINLINE;
@@ -127,6 +136,8 @@ class ValidationErrors {
   // Stack of field names indicating the field that we are currently
   // validating.
   std::vector<std::string> fields_;
+
+  size_t max_error_count_;
 };
 
 }  // namespace grpc_core

data/src/core/lib/gprpp/windows/stat.cc

@@ -22,7 +22,8 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
-#include <grpc/support/log.h>
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/stat.h"
@@ -31,13 +32,13 @@
 namespace grpc_core {
 
 absl::Status GetFileModificationTime(const char* filename, time_t* timestamp) {
-  GPR_ASSERT(filename != nullptr);
-  GPR_ASSERT(timestamp != nullptr);
+  CHECK_NE(filename, nullptr);
+  CHECK_NE(timestamp, nullptr);
   struct _stat buf;
   if (_stat(filename, &buf) != 0) {
     std::string error_msg = StrError(errno);
-    gpr_log(GPR_ERROR, "_stat failed for filename %s with error %s.", filename,
-            error_msg.c_str());
+    LOG(ERROR) << "_stat failed for filename " << filename << " with error "
+               << error_msg;
     return absl::Status(absl::StatusCode::kInternal, error_msg);
   }
   // Last file/directory modification time.

data/src/core/lib/gprpp/windows/thd.cc

@@ -23,6 +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/sync.h>
@@ -101,7 +104,7 @@ class ThreadInternalsWindows
 
   void Join() override {
     DWORD ret = WaitForSingleObject(info_->join_event, INFINITE);
-    GPR_ASSERT(ret == WAIT_OBJECT_0);
+    CHECK(ret == WAIT_OBJECT_0);
     destroy_thread();
   }
 
@@ -121,7 +124,7 @@ class ThreadInternalsWindows
     g_thd_info->body(g_thd_info->arg);
     if (g_thd_info->joinable) {
       BOOL ret = SetEvent(g_thd_info->join_event);
-      GPR_ASSERT(ret);
+      CHECK(ret);
     } else {
       gpr_free(g_thd_info);
     }
@@ -147,12 +150,12 @@ namespace grpc_core {
 
 void Thread::Signal(gpr_thd_id /* tid */, int /* sig */) {
   // TODO(hork): Implement
-  gpr_log(GPR_DEBUG, "Thread signals are not supported on Windows.");
+  VLOG(2) << "Thread signals are not supported on Windows.";
 }
 
 void Thread::Kill(gpr_thd_id /* tid */) {
   // TODO(hork): Implement
-  gpr_log(GPR_DEBUG, "Thread::Kill is not supported on Windows.");
+  VLOG(2) << "Thread::Kill is not supported on Windows.";
 }
 
 Thread::Thread(const char* /* thd_name */, void (*thd_body)(void* arg),

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

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/gprpp/work_serializer.h"
 
 #include <stdint.h>
@@ -29,12 +27,13 @@
 #include <utility>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/log/check.h"
+#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/stats.h"
-#include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -42,11 +41,11 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/telemetry/stats.h"
+#include "src/core/telemetry/stats_data.h"
 
 namespace grpc_core {
 
-DebugOnlyTraceFlag grpc_work_serializer_trace(false, "work_serializer");
-
 //
 // WorkSerializer::WorkSerializerImpl
 //
@@ -108,7 +107,7 @@ class WorkSerializer::LegacyWorkSerializer final : public WorkSerializerImpl {
   // First 16 bits indicate ownership of the WorkSerializer, next 48 bits are
   // queue size (i.e., refs).
   static uint64_t MakeRefPair(uint16_t owners, uint64_t size) {
-    GPR_ASSERT(size >> 48 == 0);
+    CHECK_EQ(size >> 48, 0u);
     return (static_cast<uint64_t>(owners) << 48) + static_cast<int64_t>(size);
   }
   static uint32_t GetOwners(uint64_t ref_pair) {
@@ -137,7 +136,7 @@ class WorkSerializer::LegacyWorkSerializer final : public WorkSerializerImpl {
 
 void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
                                                const DebugLocation& location) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
     gpr_log(GPR_INFO, "WorkSerializer::Run() %p Scheduling callback [%s:%d]",
             this, location.file(), location.line());
   }
@@ -146,13 +145,11 @@ void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
   const uint64_t prev_ref_pair =
       refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
   // The work serializer should not have been orphaned.
-  GPR_DEBUG_ASSERT(GetSize(prev_ref_pair) > 0);
+  DCHECK_GT(GetSize(prev_ref_pair), 0u);
   if (GetOwners(prev_ref_pair) == 0) {
     // We took ownership of the WorkSerializer. Invoke callback and drain queue.
     SetCurrentThread();
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-      gpr_log(GPR_INFO, "  Executing immediately");
-    }
+    GRPC_TRACE_LOG(work_serializer, INFO) << "  Executing immediately";
     callback();
     // Delete the callback while still holding the WorkSerializer, so
     // that any refs being held by the callback via lambda captures will
@@ -160,12 +157,12 @@ void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
     callback = nullptr;
     DrainQueueOwned();
   } else {
-    // Another thread is holding the WorkSerializer, so decrement the ownership
-    // count we just added and queue the callback.
+    // Another thread is holding the WorkSerializer, so decrement the
+    // ownership count we just added and queue the 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(grpc_work_serializer_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
       gpr_log(GPR_INFO, "  Scheduling on queue : item %p", cb_wrapper);
     }
     queue_.Push(&cb_wrapper->mpscq_node);
@@ -176,7 +173,7 @@ 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(grpc_work_serializer_trace)) {
+  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());
@@ -186,15 +183,13 @@ void WorkSerializer::LegacyWorkSerializer::Schedule(
 }
 
 void WorkSerializer::LegacyWorkSerializer::Orphan() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
     gpr_log(GPR_INFO, "WorkSerializer::Orphan() %p", 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) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-      gpr_log(GPR_INFO, "  Destroying");
-    }
+    GRPC_TRACE_LOG(work_serializer, INFO) << "  Destroying";
     delete this;
   }
 }
@@ -202,7 +197,7 @@ 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(grpc_work_serializer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
     gpr_log(GPR_INFO, "WorkSerializer::DrainQueue() %p", this);
   }
   // Attempt to take ownership of the WorkSerializer. Also increment the queue
@@ -214,8 +209,8 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueue() {
     // We took ownership of the WorkSerializer. Drain the queue.
     DrainQueueOwned();
   } else {
-    // Another thread is holding the WorkSerializer, so decrement the ownership
-    // count we just added and queue a no-op callback.
+    // Another thread is holding the WorkSerializer, so decrement the
+    // ownership count we just added and queue a no-op callback.
     refs_.fetch_sub(MakeRefPair(1, 0), std::memory_order_acq_rel);
     CallbackWrapper* cb_wrapper = new CallbackWrapper([]() {}, DEBUG_LOCATION);
     queue_.Push(&cb_wrapper->mpscq_node);
@@ -223,7 +218,7 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueue() {
 }
 
 void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
     gpr_log(GPR_INFO, "WorkSerializer::DrainQueueOwned() %p", this);
   }
   while (true) {
@@ -231,9 +226,7 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
     // It is possible that while draining the queue, the last callback ended
     // up orphaning the work serializer. In that case, delete the object.
     if (GetSize(prev_ref_pair) == 1) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-        gpr_log(GPR_INFO, "  Queue Drained. Destroying");
-      }
+      GRPC_TRACE_LOG(work_serializer, INFO) << "  Queue Drained. Destroying";
       delete this;
       return;
     }
@@ -251,9 +244,7 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
       }
       if (GetSize(expected) == 0) {
         // WorkSerializer got orphaned while this was running
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-          gpr_log(GPR_INFO, "  Queue Drained. Destroying");
-        }
+        GRPC_TRACE_LOG(work_serializer, INFO) << "  Queue Drained. Destroying";
         delete this;
         return;
       }
@@ -271,11 +262,10 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
                 queue_.PopAndCheckEnd(&empty_unused))) == nullptr) {
       // This can happen due to a race condition within the mpscq
       // implementation or because of a race with Run()/Schedule().
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-        gpr_log(GPR_INFO, "  Queue returned nullptr, trying again");
-      }
+      GRPC_TRACE_LOG(work_serializer, INFO)
+          << "  Queue returned nullptr, trying again";
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+    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());
@@ -291,9 +281,9 @@ void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
 
 // DispatchingWorkSerializer: executes callbacks one at a time on EventEngine.
 // One at a time guarantees that fixed size thread pools in EventEngine
-// implementations are not starved of threads by long running work serializers.
-// We implement EventEngine::Closure directly to avoid allocating once per
-// callback in the queue when scheduling.
+// implementations are not starved of threads by long running work
+// serializers. We implement EventEngine::Closure directly to avoid allocating
+// once per callback in the queue when scheduling.
 class WorkSerializer::DispatchingWorkSerializer final
     : public WorkSerializerImpl,
       public grpc_event_engine::experimental::EventEngine::Closure {
@@ -306,7 +296,8 @@ class WorkSerializer::DispatchingWorkSerializer final
            const DebugLocation& location) override;
   void Schedule(std::function<void()> callback,
                 const DebugLocation& location) override {
-    // We always dispatch to event engine, so Schedule and Run share semantics.
+    // We always dispatch to event engine, so Schedule and Run share
+    // semantics.
     Run(callback, location);
   }
   void DrainQueue() override {}
@@ -356,11 +347,11 @@ class WorkSerializer::DispatchingWorkSerializer final
   // separated from incoming cache lines.
 
   // Callbacks that are currently being processed.
-  // Only accessed by: a Run() call going from not-running to running, or a work
-  // item being executed in EventEngine -- ie this does not need a mutex because
-  // all access is serialized.
-  // Stored in reverse execution order so that callbacks can be `pop_back()`'d
-  // on completion to free up any resources they hold.
+  // Only accessed by: a Run() call going from not-running to running, or a
+  // work item being executed in EventEngine -- ie this does not need a mutex
+  // because all access is serialized. Stored in reverse execution order so
+  // that callbacks can be `pop_back()`'d on completion to free up any
+  // resources they hold.
   CallbackVector processing_;
   // EventEngine instance upon which we'll do our work.
   const std::shared_ptr<grpc_event_engine::experimental::EventEngine>
@@ -374,16 +365,16 @@ class WorkSerializer::DispatchingWorkSerializer final
   //   on an idle WorkSerializer, and transitions back to false after the last
   //   callback scheduled is completed and the WorkSerializer is again idle.
   // - orphaned_ transitions to true once upon Orphan being called.
-  // When orphaned_ is true and running_ is false, the DispatchingWorkSerializer
-  // instance is deleted.
+  // When orphaned_ is true and running_ is false, the
+  // DispatchingWorkSerializer instance is deleted.
   bool running_ ABSL_GUARDED_BY(mu_) = false;
   bool orphaned_ ABSL_GUARDED_BY(mu_) = false;
   Mutex mu_;
-  // Queued callbacks. New work items land here, and when processing_ is drained
-  // we move this entire queue into processing_ and work on draining it again.
-  // In low traffic scenarios this gives two mutex acquisitions per work item,
-  // but as load increases we get some natural batching and the rate of mutex
-  // acquisitions per work item tends towards 1.
+  // Queued callbacks. New work items land here, and when processing_ is
+  // drained we move this entire queue into processing_ and work on draining
+  // it again. In low traffic scenarios this gives two mutex acquisitions per
+  // work item, but as load increases we get some natural batching and the
+  // rate of mutex acquisitions per work item tends towards 1.
   CallbackVector incoming_ ABSL_GUARDED_BY(mu_);
 
 #ifndef NDEBUG
@@ -412,20 +403,20 @@ void WorkSerializer::DispatchingWorkSerializer::Orphan() {
 // Implementation of WorkSerializerImpl::Run
 void WorkSerializer::DispatchingWorkSerializer::Run(
     std::function<void()> callback, const DebugLocation& location) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
     gpr_log(GPR_INFO, "WorkSerializer[%p] Scheduling callback [%s:%d]", this,
             location.file(), location.line());
   }
   global_stats().IncrementWorkSerializerItemsEnqueued();
   MutexLock lock(&mu_);
   if (!running_) {
-    // If we were previously idle, insert this callback directly into the empty
-    // processing_ list and start running.
+    // If we were previously idle, insert this callback directly into the
+    // empty processing_ list and start running.
     running_ = true;
     running_start_time_ = std::chrono::steady_clock::now();
     items_processed_during_run_ = 0;
     time_running_items_ = std::chrono::steady_clock::duration();
-    GPR_ASSERT(processing_.empty());
+    CHECK(processing_.empty());
     processing_.emplace_back(std::move(callback), location);
     event_engine_->Run(this);
   } else {
@@ -440,10 +431,10 @@ void WorkSerializer::DispatchingWorkSerializer::Run() {
   // TODO(ctiller): remove these when we can deprecate ExecCtx
   ApplicationCallbackExecCtx app_exec_ctx;
   ExecCtx exec_ctx;
-  // Grab the last element of processing_ - which is the next item in our queue
-  // since processing_ is stored in reverse order.
+  // 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(grpc_work_serializer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
     gpr_log(GPR_INFO, "WorkSerializer[%p] Executing callback [%s:%d]", this,
             cb.location.file(), cb.location.line());
   }
@@ -451,9 +442,9 @@ void WorkSerializer::DispatchingWorkSerializer::Run() {
   const auto start = std::chrono::steady_clock::now();
   SetCurrentThread();
   cb.callback();
-  // pop_back here destroys the callback - freeing any resources it might hold.
-  // We do so before clearing the current thread in case the callback destructor
-  // wants to check that it's in the WorkSerializer too.
+  // pop_back here destroys the callback - freeing any resources it might
+  // hold. We do so before clearing the current thread in case the callback
+  // destructor wants to check that it's in the WorkSerializer too.
   processing_.pop_back();
   ClearCurrentThread();
   global_stats().IncrementWorkSerializerItemsDequeued();
@@ -507,8 +498,8 @@ bool WorkSerializer::DispatchingWorkSerializer::Refill() {
     case RefillResult::kRefilled:
       // Reverse processing_ so that we can pop_back() items in the correct
       // order. (note that this is mostly pointer swaps inside the
-      // std::function's, so should be relatively cheap even for longer lists).
-      // Do so here so we're outside of the RefillInner lock.
+      // std::function's, so should be relatively cheap even for longer
+      // lists). Do so here so we're outside of the RefillInner lock.
       std::reverse(processing_.begin(), processing_.end());
       return true;
     case RefillResult::kFinished:

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

@@ -17,14 +17,13 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_WORK_SERIALIZER_H
 #define GRPC_SRC_CORE_LIB_GPRPP_WORK_SERIALIZER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <functional>
 #include <memory>
 
 #include "absl/base/thread_annotations.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"

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

@@ -16,11 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/buffer_list.h"
 
+#include "absl/log/log.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -43,7 +44,7 @@ void FillGprFromTimestamp(gpr_timespec* gts, const struct timespec* ts) {
 
 void DefaultTimestampsCallback(void* /*arg*/, Timestamps* /*ts*/,
                                absl::Status /*shudown_err*/) {
-  gpr_log(GPR_DEBUG, "Timestamps callback has not been registered");
+  VLOG(2) << "Timestamps callback has not been registered";
 }
 
 // The saved callback function that will be invoked when we get all the
@@ -322,7 +323,7 @@ void grpc_tcp_set_write_timestamps_callback(
   // Can't comment out the name because some compilers and formatters don't
   // like the sequence */* , which would arise from */*fn*/.
   (void)fn;
-  gpr_log(GPR_DEBUG, "Timestamps callback is not enabled for this platform");
+  VLOG(2) << "Timestamps callback is not enabled for this platform";
 }
 }  // namespace grpc_core
 

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

@@ -19,10 +19,9 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_BUFFER_LIST_H
 #define GRPC_SRC_CORE_LIB_IOMGR_BUFFER_LIST_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/sync.h"

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

@@ -16,22 +16,22 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/call_combiner.h"
 
 #include <inttypes.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/stats.h"
-#include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/telemetry/stats.h"
+#include "src/core/telemetry/stats_data.h"
 
 namespace grpc_core {
 
-DebugOnlyTraceFlag grpc_call_combiner_trace(false, "call_combiner");
-
 namespace {
 
 // grpc_error LSB can be used
@@ -87,7 +87,7 @@ void CallCombiner::TsanClosure(void* arg, grpc_error_handle error) {
   if (lock != nullptr) {
     TSAN_ANNOTATE_RWLOCK_RELEASED(&lock->taken, true);
     bool prev = true;
-    GPR_ASSERT(lock->taken.compare_exchange_strong(prev, false));
+    CHECK(lock->taken.compare_exchange_strong(prev, false));
   }
 }
 #endif
@@ -114,7 +114,7 @@ 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(grpc_call_combiner_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
     gpr_log(GPR_INFO,
             "==> CallCombiner::Start() [%p] closure=%s [" DEBUG_FMT_STR
             "%s] error=%s",
@@ -123,20 +123,16 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
   }
   size_t prev_size =
       static_cast<size_t>(gpr_atm_full_fetch_add(&size_, (gpr_atm)1));
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
     gpr_log(GPR_INFO, "  size: %" PRIdPTR " -> %" PRIdPTR, prev_size,
             prev_size + 1);
   }
   if (prev_size == 0) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
-      gpr_log(GPR_INFO, "  EXECUTING IMMEDIATELY");
-    }
+    GRPC_TRACE_LOG(call_combiner, INFO) << "  EXECUTING IMMEDIATELY";
     // Queue was empty, so execute this closure immediately.
     ScheduleClosure(closure, error);
   } else {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
-      gpr_log(GPR_INFO, "  QUEUING");
-    }
+    GRPC_TRACE_LOG(call_combiner, INFO) << "  QUEUING";
     // Queue was not empty, so add closure to queue.
     closure->error_data.error = internal::StatusAllocHeapPtr(error);
     queue_.Push(
@@ -145,45 +141,41 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
 }
 
 void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
     gpr_log(GPR_INFO, "==> 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(grpc_call_combiner_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
     gpr_log(GPR_INFO, "  size: %" PRIdPTR " -> %" PRIdPTR, prev_size,
             prev_size - 1);
   }
-  GPR_ASSERT(prev_size >= 1);
+  CHECK_GE(prev_size, 1u);
   if (prev_size > 1) {
     while (true) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
-        gpr_log(GPR_INFO, "  checking queue");
-      }
+      GRPC_TRACE_LOG(call_combiner, INFO) << "  checking queue";
       bool empty;
       grpc_closure* closure =
           reinterpret_cast<grpc_closure*>(queue_.PopAndCheckEnd(&empty));
       if (closure == nullptr) {
         // This can happen either due to a race condition within the mpscq
         // code or because of a race with Start().
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
-          gpr_log(GPR_INFO, "  queue returned no result; checking again");
-        }
+        GRPC_TRACE_LOG(call_combiner, INFO)
+            << "  queue returned no result; checking again";
         continue;
       }
       grpc_error_handle error =
           internal::StatusMoveFromHeapPtr(closure->error_data.error);
       closure->error_data.error = 0;
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
+      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());
       }
       ScheduleClosure(closure, error);
       break;
     }
-  } else if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
-    gpr_log(GPR_INFO, "  queue empty");
+    GRPC_TRACE_LOG(call_combiner, INFO) << "  queue empty";
   }
 }
 
@@ -195,7 +187,7 @@ 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(grpc_call_combiner_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
         gpr_log(GPR_INFO,
                 "call_combiner=%p: scheduling notify_on_cancel callback=%p "
                 "for pre-existing cancellation",
@@ -206,7 +198,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
     } else {
       if (gpr_atm_full_cas(&cancel_state_, original_state,
                            reinterpret_cast<gpr_atm>(closure))) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
           gpr_log(GPR_INFO, "call_combiner=%p: setting notify_on_cancel=%p",
                   this, closure);
         }
@@ -215,7 +207,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
         // 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(grpc_call_combiner_trace)) {
+          if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
             gpr_log(GPR_INFO,
                     "call_combiner=%p: scheduling old cancel callback=%p", this,
                     closure);
@@ -243,7 +235,7 @@ 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(grpc_call_combiner_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(call_combiner)) {
           gpr_log(GPR_INFO,
                   "call_combiner=%p: scheduling notify_on_cancel callback=%p",
                   this, notify_on_cancel);