grpc 1.64.0 → 1.65.0.pre1

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

@@ -21,18 +21,17 @@
 #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
@@ -115,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",
@@ -124,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(
@@ -146,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);
   }
   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";
   }
 }
 
@@ -196,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",
@@ -207,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);
         }
@@ -216,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);
@@ -244,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);

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

@@ -44,8 +44,6 @@
 
 namespace grpc_core {
 
-extern DebugOnlyTraceFlag grpc_call_combiner_trace;
-
 class CallCombiner {
  public:
   CallCombiner();
@@ -167,7 +165,7 @@ class CallCombinerClosureList {
       GRPC_CALL_COMBINER_START(call_combiner, closure.closure, closure.error,
                                closure.reason);
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
+    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",

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

@@ -35,8 +35,6 @@
 #include "src/core/lib/iomgr/ev_apple.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-extern grpc_core::TraceFlag grpc_tcp_trace;
-
 GrpcLibraryInitHolder::GrpcLibraryInitHolder() { grpc_init(); }
 
 GrpcLibraryInitHolder::~GrpcLibraryInitHolder() { grpc_shutdown(); }
@@ -65,7 +63,7 @@ void CFStreamHandle::ReadCallback(CFReadStreamRef stream,
   grpc_error_handle error;
   CFErrorRef stream_error;
   CFStreamHandle* handle = static_cast<CFStreamHandle*>(client_callback_info);
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_DEBUG, "CFStream ReadCallback (%p, %p, %lu, %p)", handle,
             stream, type, client_callback_info);
   }
@@ -99,7 +97,7 @@ void CFStreamHandle::WriteCallback(CFWriteStreamRef stream,
   grpc_error_handle error;
   CFErrorRef stream_error;
   CFStreamHandle* handle = static_cast<CFStreamHandle*>(clientCallBackInfo);
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_DEBUG, "CFStream WriteCallback (%p, %p, %lu, %p)", handle,
             stream, type, clientCallBackInfo);
   }
@@ -176,7 +174,7 @@ void CFStreamHandle::Shutdown(grpc_error_handle error) {
 }
 
 void CFStreamHandle::Ref(const char* file, int line, const char* reason) {
-  if (grpc_tcp_trace.enabled()) {
+  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,
@@ -186,7 +184,7 @@ void CFStreamHandle::Ref(const char* file, int line, const char* reason) {
 }
 
 void CFStreamHandle::Unref(const char* file, int line, const char* reason) {
-  if (grpc_tcp_trace.enabled()) {
+  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,

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

@@ -37,8 +37,6 @@
 struct grpc_closure;
 typedef struct grpc_closure grpc_closure;
 
-extern grpc_core::DebugOnlyTraceFlag grpc_trace_closure;
-
 typedef struct grpc_closure_list {
   grpc_closure* head;
   grpc_closure* tail;
@@ -294,7 +292,7 @@ class Closure {
       return;
     }
 #ifndef NDEBUG
-    if (grpc_trace_closure.enabled()) {
+    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());
@@ -303,7 +301,7 @@ class Closure {
 #endif
     closure->cb(closure->cb_arg, error);
 #ifndef NDEBUG
-    if (grpc_trace_closure.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(closure)) {
       gpr_log(GPR_DEBUG, "closure %p finished", closure);
     }
 #endif

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

@@ -34,13 +34,11 @@
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 
-grpc_core::DebugOnlyTraceFlag grpc_combiner_trace(false, "combiner");
-
-#define GRPC_COMBINER_TRACE(fn)          \
-  do {                                   \
-    if (grpc_combiner_trace.enabled()) { \
-      fn;                                \
-    }                                    \
+#define GRPC_COMBINER_TRACE(fn)              \
+  do {                                       \
+    if (GRPC_TRACE_FLAG_ENABLED(combiner)) { \
+      fn;                                    \
+    }                                        \
   } while (0)
 
 #define STATE_UNORPHANED 1
@@ -81,7 +79,7 @@ static void start_destroy(grpc_core::Combiner* lock) {
 
 #ifndef NDEBUG
 #define GRPC_COMBINER_DEBUG_SPAM(op, delta)                                \
-  if (grpc_combiner_trace.enabled()) {                                     \
+  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),                    \

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

@@ -88,6 +88,4 @@ void grpc_combiner_unref(grpc_core::Combiner* lock GRPC_COMBINER_DEBUG_ARGS);
 
 bool grpc_combiner_continue_exec_ctx();
 
-extern grpc_core::DebugOnlyTraceFlag grpc_combiner_trace;
-
 #endif  // GRPC_SRC_CORE_LIB_IOMGR_COMBINER_H

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

@@ -20,8 +20,6 @@
 
 #include <grpc/support/port_platform.h>
 
-grpc_core::TraceFlag grpc_tcp_trace(false, "tcp");
-
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
                         grpc_closure* cb, bool urgent, int min_progress_size) {
   ep->vtable->read(ep, slices, cb, urgent, min_progress_size);
@@ -46,10 +44,6 @@ void grpc_endpoint_delete_from_pollset_set(grpc_endpoint* ep,
   ep->vtable->delete_from_pollset_set(ep, pollset_set);
 }
 
-void grpc_endpoint_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
-  ep->vtable->shutdown(ep, why);
-}
-
 void grpc_endpoint_destroy(grpc_endpoint* ep) { ep->vtable->destroy(ep); }
 
 absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep) {

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

@@ -43,7 +43,6 @@ struct grpc_endpoint_vtable {
   void (*add_to_pollset)(grpc_endpoint* ep, grpc_pollset* pollset);
   void (*add_to_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
   void (*delete_from_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
-  void (*shutdown)(grpc_endpoint* ep, grpc_error_handle why);
   void (*destroy)(grpc_endpoint* ep);
   absl::string_view (*get_peer)(grpc_endpoint* ep);
   absl::string_view (*get_local_address)(grpc_endpoint* ep);
@@ -86,7 +85,6 @@ void grpc_endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
 // Causes any pending and future read/write callbacks to run immediately with
 // success==0
-void grpc_endpoint_shutdown(grpc_endpoint* ep, grpc_error_handle why);
 void grpc_endpoint_destroy(grpc_endpoint* ep);
 
 // Add an endpoint to a pollset or pollset_set, so that when the pollset is

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

@@ -31,7 +31,6 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/cfstream_handle.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -41,8 +40,7 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
-
-extern grpc_core::TraceFlag grpc_tcp_trace;
+#include "src/core/util/string.h"
 
 struct CFStreamEndpoint {
   grpc_endpoint base;
@@ -75,7 +73,7 @@ static void CFStreamFree(CFStreamEndpoint* ep) {
 #define EP_UNREF(ep, reason) CFStreamUnref((ep), (reason), __FILE__, __LINE__)
 static void CFStreamUnref(CFStreamEndpoint* ep, const char* reason,
                           const char* file, int line) {
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&ep->refcount.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "CFStream endpoint unref %p : %s %" PRIdPTR " -> %" PRIdPTR, ep,
@@ -87,7 +85,7 @@ static void CFStreamUnref(CFStreamEndpoint* ep, const char* reason,
 }
 static void CFStreamRef(CFStreamEndpoint* ep, const char* reason,
                         const char* file, int line) {
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&ep->refcount.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "CFStream endpoint ref %p : %s %" PRIdPTR " -> %" PRIdPTR, ep,
@@ -106,17 +104,13 @@ static void CFStreamUnref(CFStreamEndpoint* ep) {
 static void CFStreamRef(CFStreamEndpoint* ep) { gpr_ref(&ep->refcount); }
 #endif
 
-static grpc_error_handle CFStreamAnnotateError(grpc_error_handle src_error,
-                                               CFStreamEndpoint* ep) {
-  return grpc_error_set_str(
-      grpc_error_set_int(src_error, grpc_core::StatusIntProperty::kRpcStatus,
-                         GRPC_STATUS_UNAVAILABLE),
-      grpc_core::StatusStrProperty::kTargetAddress, ep->peer_string);
+static grpc_error_handle CFStreamAnnotateError(grpc_error_handle src_error) {
+  return grpc_error_set_int(src_error, grpc_core::StatusIntProperty::kRpcStatus,
+                            GRPC_STATUS_UNAVAILABLE);
 }
 
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
-      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p call_read_cb %p %p:%p", ep,
             ep->read_cb, ep->read_cb->cb, ep->read_cb->cb_arg);
     size_t i;
@@ -138,7 +132,7 @@ static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
 }
 
 static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p call_write_cb %p %p:%p", ep,
             ep->write_cb, ep->write_cb->cb, ep->write_cb->cb_arg);
     gpr_log(GPR_DEBUG, "write: error=%s",
@@ -170,7 +164,7 @@ static void ReadAction(void* arg, grpc_error_handle error) {
     CFErrorRef stream_error = CFReadStreamCopyError(ep->read_stream);
     if (stream_error != nullptr) {
       error = CFStreamAnnotateError(
-          GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "Read error"), ep);
+          GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "Read error"));
       CFRelease(stream_error);
     } else {
       error = GRPC_ERROR_CREATE("Read error");
@@ -179,8 +173,7 @@ static void ReadAction(void* arg, grpc_error_handle error) {
     EP_UNREF(ep, "read");
   } else if (read_size == 0) {
     grpc_slice_buffer_reset_and_unref(ep->read_slices);
-    CallReadCb(ep,
-               CFStreamAnnotateError(GRPC_ERROR_CREATE("Socket closed"), ep));
+    CallReadCb(ep, CFStreamAnnotateError(GRPC_ERROR_CREATE("Socket closed")));
     EP_UNREF(ep, "read");
   } else {
     if (read_size < static_cast<CFIndex>(len)) {
@@ -209,7 +202,7 @@ static void WriteAction(void* arg, grpc_error_handle error) {
     CFErrorRef stream_error = CFWriteStreamCopyError(ep->write_stream);
     if (stream_error != nullptr) {
       error = CFStreamAnnotateError(
-          GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "write failed."), ep);
+          GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "Write failed"));
       CFRelease(stream_error);
     } else {
       error = GRPC_ERROR_CREATE("write failed.");
@@ -228,8 +221,7 @@ static void WriteAction(void* arg, grpc_error_handle error) {
       EP_UNREF(ep, "write");
     }
 
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
-        gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
       grpc_slice trace_slice = grpc_slice_sub(slice, 0, write_size);
       char* dump = grpc_dump_slice(trace_slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
       gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", ep, ep->peer_string.c_str(),
@@ -245,7 +237,7 @@ 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_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p read (%p, %p) length:%zu", ep_impl,
             slices, cb, slices->length);
   }
@@ -263,7 +255,7 @@ 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_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p write (%p, %p) length:%zu",
             ep_impl, slices, cb, slices->length);
   }
@@ -274,26 +266,13 @@ static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
   ep_impl->stream_sync->NotifyOnWrite(&ep_impl->write_action);
 }
 
-void CFStreamShutdown(grpc_endpoint* ep, grpc_error_handle why) {
+void CFStreamDestroy(grpc_endpoint* ep) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
-  if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown (%s)", ep_impl,
-            grpc_core::StatusToString(why).c_str());
-  }
+  GRPC_TRACE_VLOG(tcp, 2) << "CFStream endpoint:" << ep_impl << " destroy";
   CFReadStreamClose(ep_impl->read_stream);
   CFWriteStreamClose(ep_impl->write_stream);
-  ep_impl->stream_sync->Shutdown(why);
-  if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown DONE (%s)", ep_impl,
-            grpc_core::StatusToString(why).c_str());
-  }
-}
-
-void CFStreamDestroy(grpc_endpoint* ep) {
-  CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
-  if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CFStream endpoint:%p destroy", ep_impl);
-  }
+  ep_impl->stream_sync->Shutdown(absl::UnavailableError("endpoint shutdown"));
+  GRPC_TRACE_VLOG(tcp, 2) << "CFStream endpoint:" << ep_impl << " destroy DONE";
   EP_UNREF(ep_impl, "destroy");
 }
 
@@ -322,7 +301,6 @@ static const grpc_endpoint_vtable vtable = {CFStreamRead,
                                             CFStreamAddToPollset,
                                             CFStreamAddToPollsetSet,
                                             CFStreamDeleteFromPollsetSet,
-                                            CFStreamShutdown,
                                             CFStreamDestroy,
                                             CFStreamGetPeer,
                                             CFStreamGetLocalAddress,
@@ -334,7 +312,7 @@ grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
                                              const char* peer_string,
                                              CFStreamHandle* stream_sync) {
   CFStreamEndpoint* ep_impl = new CFStreamEndpoint;
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_DEBUG,
             "CFStream endpoint:%p create readStream:%p writeStream: %p",
             ep_impl, read_stream, write_stream);

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

@@ -37,13 +37,13 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/event_engine/channel_args_endpoint_config.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/endpoint_pair.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/resource_quota/api.h"
+#include "src/core/util/string.h"
 
 static void create_sockets(int sv[2]) {
   int flags;

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

@@ -26,8 +26,7 @@
 #include <string.h>
 
 #include "absl/log/check.h"
-
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gprpp/crash.h"
@@ -67,13 +66,13 @@ static void create_sockets(SOCKET sv[2]) {
   closesocket(lst_sock);
   grpc_error_handle error = grpc_tcp_prepare_socket(cli_sock);
   if (!error.ok()) {
-    gpr_log(GPR_INFO, "Prepare cli_sock failed with error: %s",
-            grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << "Prepare cli_sock failed with error: "
+              << grpc_core::StatusToString(error);
   }
   error = grpc_tcp_prepare_socket(svr_sock);
   if (!error.ok()) {
-    gpr_log(GPR_INFO, "Prepare svr_sock failed with error: %s",
-            grpc_core::StatusToString(error).c_str());
+    LOG(INFO) << "Prepare svr_sock failed with error: "
+              << grpc_core::StatusToString(error);
   }
 
   sv[1] = cli_sock;

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

@@ -21,6 +21,7 @@
 #include <string.h>
 
 #include "absl/log/check.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/status.h>
@@ -36,13 +37,9 @@
 #endif
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/slice/slice_internal.h"
-
-grpc_core::DebugOnlyTraceFlag grpc_trace_error_refcount(false,
-                                                        "error_refcount");
-grpc_core::DebugOnlyTraceFlag grpc_trace_closure(false, "closure");
+#include "src/core/util/useful.h"
 
 absl::Status grpc_status_create(absl::StatusCode code, absl::string_view msg,
                                 const grpc_core::DebugLocation& location,
@@ -58,15 +55,10 @@ absl::Status grpc_status_create(absl::StatusCode code, absl::string_view msg,
 
 absl::Status grpc_os_error(const grpc_core::DebugLocation& location, int err,
                            const char* call_name) {
-  auto err_string = grpc_core::StrError(err);
-  absl::Status s =
-      StatusCreate(absl::StatusCode::kUnknown, err_string, location, {});
-  grpc_core::StatusSetInt(&s, grpc_core::StatusIntProperty::kErrorNo, err);
-  grpc_core::StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError,
-                          err_string);
-  grpc_core::StatusSetStr(&s, grpc_core::StatusStrProperty::kSyscall,
-                          call_name);
-  return s;
+  return StatusCreate(
+      absl::StatusCode::kUnknown,
+      absl::StrCat(call_name, ": ", grpc_core::StrError(err), " (", err, ")"),
+      location, {});
 }
 
 #ifdef GPR_WINDOWS
@@ -104,15 +96,15 @@ std::string WSAErrorToShortDescription(int err) {
 absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
                             absl::string_view call_name) {
   char* utf8_message = gpr_format_message(err);
-  absl::Status s = StatusCreate(absl::StatusCode::kUnavailable,
-                                WSAErrorToShortDescription(err), location, {});
-  StatusSetInt(&s, grpc_core::StatusIntProperty::kWsaError, err);
-  StatusSetInt(&s, grpc_core::StatusIntProperty::kRpcStatus,
+  absl::Status status = StatusCreate(
+      absl::StatusCode::kUnavailable,
+      absl::StrCat(call_name, ": ", WSAErrorToShortDescription(err), " (",
+                   utf8_message, " -- ", err, ")"),
+      location, {});
+  StatusSetInt(&status, grpc_core::StatusIntProperty::kRpcStatus,
                GRPC_STATUS_UNAVAILABLE);
-  StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError, utf8_message);
-  StatusSetStr(&s, grpc_core::StatusStrProperty::kSyscall, call_name);
   gpr_free(utf8_message);
-  return s;
+  return status;
 }
 #endif
 

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

@@ -32,10 +32,10 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/spinlock.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/util/spinlock.h"
 
 /// Opaque representation of an error.
 

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

@@ -39,12 +39,10 @@
 #include "src/core/lib/gprpp/time_util.h"
 #include "src/core/lib/iomgr/ev_apple.h"
 
-grpc_core::DebugOnlyTraceFlag grpc_apple_polling_trace(false, "apple_polling");
-
 #ifndef NDEBUG
-#define GRPC_POLLING_TRACE(format, ...)                    \
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_apple_polling_trace)) { \
-    gpr_log(GPR_DEBUG, "(polling) " format, __VA_ARGS__);  \
+#define GRPC_POLLING_TRACE(format, ...)                   \
+  if (GRPC_TRACE_FLAG_ENABLED(apple_polling)) {           \
+    gpr_log(GPR_DEBUG, "(polling) " format, __VA_ARGS__); \
   }
 #else
 #define GRPC_POLLING_TRACE(...)