grpc 1.64.0 → 1.65.0.pre1

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

@@ -60,30 +60,16 @@ const absl::string_view kChildrenPropertyUrl = TYPE_URL(TYPE_CHILDREN_TAG);
 
 const char* GetStatusIntPropertyUrl(StatusIntProperty key) {
   switch (key) {
-    case StatusIntProperty::kErrorNo:
-      return TYPE_URL(TYPE_INT_TAG "errno");
     case StatusIntProperty::kFileLine:
       return TYPE_URL(TYPE_INT_TAG "file_line");
     case StatusIntProperty::kStreamId:
       return TYPE_URL(TYPE_INT_TAG "stream_id");
     case StatusIntProperty::kRpcStatus:
       return TYPE_URL(TYPE_INT_TAG "grpc_status");
-    case StatusIntProperty::kOffset:
-      return TYPE_URL(TYPE_INT_TAG "offset");
-    case StatusIntProperty::kIndex:
-      return TYPE_URL(TYPE_INT_TAG "index");
-    case StatusIntProperty::kSize:
-      return TYPE_URL(TYPE_INT_TAG "size");
     case StatusIntProperty::kHttp2Error:
       return TYPE_URL(TYPE_INT_TAG "http2_error");
-    case StatusIntProperty::kTsiCode:
-      return TYPE_URL(TYPE_INT_TAG "tsi_code");
-    case StatusIntProperty::kWsaError:
-      return TYPE_URL(TYPE_INT_TAG "wsa_error");
     case StatusIntProperty::kFd:
       return TYPE_URL(TYPE_INT_TAG "fd");
-    case StatusIntProperty::kHttpStatus:
-      return TYPE_URL(TYPE_INT_TAG "http_status");
     case StatusIntProperty::kOccurredDuringWrite:
       return TYPE_URL(TYPE_INT_TAG "occurred_during_write");
     case StatusIntProperty::ChannelConnectivityState:
@@ -100,24 +86,8 @@ const char* GetStatusStrPropertyUrl(StatusStrProperty key) {
       return TYPE_URL(TYPE_STR_TAG "description");
     case StatusStrProperty::kFile:
       return TYPE_URL(TYPE_STR_TAG "file");
-    case StatusStrProperty::kOsError:
-      return TYPE_URL(TYPE_STR_TAG "os_error");
-    case StatusStrProperty::kSyscall:
-      return TYPE_URL(TYPE_STR_TAG "syscall");
-    case StatusStrProperty::kTargetAddress:
-      return TYPE_URL(TYPE_STR_TAG "target_address");
     case StatusStrProperty::kGrpcMessage:
       return TYPE_URL(TYPE_STR_TAG "grpc_message");
-    case StatusStrProperty::kRawBytes:
-      return TYPE_URL(TYPE_STR_TAG "raw_bytes");
-    case StatusStrProperty::kTsiError:
-      return TYPE_URL(TYPE_STR_TAG "tsi_error");
-    case StatusStrProperty::kFilename:
-      return TYPE_URL(TYPE_STR_TAG "filename");
-    case StatusStrProperty::kKey:
-      return TYPE_URL(TYPE_STR_TAG "key");
-    case StatusStrProperty::kValue:
-      return TYPE_URL(TYPE_STR_TAG "value");
   }
   GPR_UNREACHABLE_CODE(return "unknown");
 }
@@ -348,6 +318,17 @@ std::string StatusToString(const absl::Status& status) {
                      : absl::StrCat(head, " {", absl::StrJoin(kvs, ", "), "}");
 }
 
+absl::Status AddMessagePrefix(absl::string_view prefix, absl::Status status) {
+  absl::Status new_status(status.code(),
+                          absl::StrCat(prefix, ": ", status.message()));
+  // TODO(roth): Remove this once we elimiate all status attributes.
+  status.ForEachPayload(
+      [&](absl::string_view type_url, const absl::Cord& payload) {
+        new_status.SetPayload(type_url, payload);
+      });
+  return new_status;
+}
+
 namespace internal {
 
 google_rpc_Status* StatusToProto(const absl::Status& status, upb_Arena* arena) {

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

@@ -48,8 +48,6 @@ namespace grpc_core {
 
 /// This enum should have the same value of grpc_error_ints
 enum class StatusIntProperty {
-  /// 'errno' from the operating system
-  kErrorNo,
   /// __LINE__ from the call site creating the error
   kFileLine,
   /// stream identifier: for errors that are associated with an individual
@@ -58,23 +56,10 @@ enum class StatusIntProperty {
   /// grpc status code representing this error
   // TODO(veblush): Remove this after grpc_error is replaced with absl::Status
   kRpcStatus,
-  /// offset into some binary blob (usually represented by
-  /// RAW_BYTES) where the error occurred
-  kOffset,
-  /// context sensitive index associated with the error
-  kIndex,
-  /// context sensitive size associated with the error
-  kSize,
   /// http2 error code associated with the error (see the HTTP2 RFC)
   kHttp2Error,
-  /// TSI status code associated with the error
-  kTsiCode,
-  /// WSAGetLastError() reported when this error occurred
-  kWsaError,
   /// File descriptor associated with this error
   kFd,
-  /// HTTP status (i.e. 404)
-  kHttpStatus,
   /// chttp2: did the error occur while a write was in progress
   kOccurredDuringWrite,
   /// channel connectivity state associated with the error
@@ -89,24 +74,8 @@ enum class StatusStrProperty {
   kDescription,
   /// source file in which this error occurred
   kFile,
-  /// operating system description of this error
-  kOsError,
-  /// syscall that generated this error
-  kSyscall,
   /// peer that we were trying to communicate when this error occurred
-  kTargetAddress,
-  /// grpc status message associated with this error
   kGrpcMessage,
-  /// hex dump (or similar) with the data that generated this error
-  kRawBytes,
-  /// tsi error string associated with this error
-  kTsiError,
-  /// filename that we were trying to read/write when this error occurred
-  kFilename,
-  /// key associated with the error
-  kKey,
-  /// value associated with the error
-  kValue,
 };
 
 /// This enum should have the same value of grpc_error_times
@@ -158,6 +127,9 @@ GRPC_MUST_USE_RESULT std::vector<absl::Status> StatusGetChildren(
 ///   CANCELLATION:SampleMessage {errno:'2021', line:'54', children:[ABORTED]}
 GRPC_MUST_USE_RESULT std::string StatusToString(const absl::Status& status);
 
+/// Adds prefix to the message of status.
+absl::Status AddMessagePrefix(absl::string_view prefix, absl::Status status);
+
 namespace internal {
 
 /// Builds a upb message, google_rpc_Status from a status

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

@@ -21,9 +21,9 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
@@ -60,9 +60,8 @@ GPR_ATTRIBUTE_NOINLINE std::pair<int64_t, gpr_cycle_counter> InitTime() {
     if (process_epoch_seconds > 1) {
       break;
     }
-    gpr_log(GPR_INFO,
-            "gpr_now(GPR_CLOCK_MONOTONIC) returns a very small number: "
-            "sleeping for 100ms");
+    LOG(INFO) << "gpr_now(GPR_CLOCK_MONOTONIC) returns a very small number: "
+                 "sleeping for 100ms";
     gpr_sleep_until(gpr_time_add(now, gpr_time_from_millis(100, GPR_TIMESPAN)));
   }
 

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

@@ -24,11 +24,12 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/time_precise.h"
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/util/time_precise.h"
+#include "src/core/util/useful.h"
 
 #define GRPC_LOG_EVERY_N_SEC(n, severity, format, ...)          \
   do {                                                          \

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

@@ -23,7 +23,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/util/useful.h"
 
 // Provides a type name that is unique by instance rather than by
 // string content.  This is useful in cases where there are different

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

@@ -14,8 +14,11 @@
 
 #include "src/core/lib/gprpp/validation_errors.h"
 
+#include <inttypes.h>
+
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
@@ -34,7 +37,13 @@ void ValidationErrors::PushField(absl::string_view ext) {
 void ValidationErrors::PopField() { fields_.pop_back(); }
 
 void ValidationErrors::AddError(absl::string_view error) {
-  field_errors_[absl::StrJoin(fields_, "")].emplace_back(error);
+  auto key = absl::StrJoin(fields_, "");
+  if (field_errors_[key].size() >= max_error_count_) {
+    VLOG(2) << "Ignoring validation error: too many errors found ("
+            << max_error_count_ << ")";
+    return;
+  }
+  field_errors_[key].emplace_back(error);
 }
 
 bool ValidationErrors::FieldHasErrors() const {

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

@@ -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

@@ -23,8 +23,7 @@
 #include <sys/types.h>
 
 #include "absl/log/check.h"
-
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
 
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/stat.h"
@@ -38,8 +37,8 @@ absl::Status GetFileModificationTime(const char* filename, time_t* timestamp) {
   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

@@ -24,6 +24,7 @@
 #include <string.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -149,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

@@ -28,13 +28,12 @@
 
 #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
 //
@@ -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());
   }
@@ -150,9 +149,7 @@ void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
   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,15 +403,15 @@ 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;
@@ -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/iomgr/buffer_list.cc

@@ -18,6 +18,8 @@
 
 #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>
@@ -42,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
@@ -321,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