grpc 1.63.0 → 1.66.0

data/src/core/lib/debug/trace_impl.h

@@ -0,0 +1,119 @@
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_DEBUG_TRACE_IMPL_H
+#define GRPC_SRC_CORE_LIB_DEBUG_TRACE_IMPL_H
+
+#include <atomic>
+#include <map>
+#include <string>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/log/log.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/support/port_platform.h>
+
+#ifdef _WIN32
+#undef ERROR
+#endif
+
+void grpc_tracer_init();
+void grpc_tracer_shutdown(void);
+
+namespace grpc_core {
+bool ParseTracers(absl::string_view tracers);
+class SavedTraceFlags;
+
+class TraceFlag;
+
+namespace testing {
+void grpc_tracer_enable_flag(TraceFlag* flag);
+}
+
+class TraceFlag {
+ public:
+  TraceFlag(bool default_enabled, const char* name);
+  // TraceFlag needs to be trivially destructible since it is used as global
+  // variable.
+  ~TraceFlag() = default;
+
+  const char* name() const { return name_; }
+
+// Use the symbol GRPC_USE_TRACERS to determine if tracers will be enabled in
+// opt builds (tracers are always on in dbg builds). The default in OSS is for
+// tracers to be on since we support binary distributions of gRPC for the
+// wrapped language (wr don't want to force recompilation to get tracing).
+// Internally, however, for performance reasons, we compile them out by
+// default, since internal build systems make recompiling trivial.
+//
+// Prefer GRPC_TRACE_FLAG_ENABLED() macro instead of using enabled() directly.
+#define GRPC_USE_TRACERS  // tracers on by default in OSS
+#if defined(GRPC_USE_TRACERS) || !defined(NDEBUG)
+  bool enabled() { return value_.load(std::memory_order_relaxed); }
+#else
+  bool enabled() { return false; }
+#endif  // defined(GRPC_USE_TRACERS) || !defined(NDEBUG)
+
+ private:
+  friend void testing::grpc_tracer_enable_flag(TraceFlag* flag);
+  friend bool ParseTracers(absl::string_view tracers);
+  friend SavedTraceFlags;
+
+  void set_enabled(bool enabled) {
+    value_.store(enabled, std::memory_order_relaxed);
+  }
+
+  TraceFlag* next_tracer_;
+  const char* const name_;
+  std::atomic<bool> value_;
+};
+
+#define GRPC_TRACE_FLAG_ENABLED_OBJ(obj) GPR_UNLIKELY((obj).enabled())
+#define GRPC_TRACE_FLAG_ENABLED(tracer) \
+  GPR_UNLIKELY((grpc_core::tracer##_trace).enabled())
+#define GRPC_TRACE_LOG(tracer, level) \
+  LOG_IF(level, GRPC_TRACE_FLAG_ENABLED(tracer))
+#define GRPC_TRACE_VLOG(tracer, level) \
+  if (GRPC_TRACE_FLAG_ENABLED(tracer)) VLOG(level)
+
+#ifndef NDEBUG
+typedef TraceFlag DebugOnlyTraceFlag;
+#else
+class DebugOnlyTraceFlag {
+ public:
+  constexpr DebugOnlyTraceFlag(bool /*default_enabled*/, const char* /*name*/) {
+  }
+  constexpr bool enabled() const { return false; }
+  constexpr const char* name() const { return "DebugOnlyTraceFlag"; }
+
+ private:
+  void set_enabled(bool /*enabled*/) {}
+};
+#endif
+
+class SavedTraceFlags {
+ public:
+  SavedTraceFlags();
+  void Restore();
+
+ private:
+  std::map<std::string, std::pair<bool, TraceFlag*>> values_;
+};
+
+const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags();
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_DEBUG_TRACE_IMPL_H

data/src/core/lib/event_engine/ares_resolver.cc

@@ -11,13 +11,13 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/event_engine/ares_resolver.h"
 
 #include <string>
 #include <vector>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/port.h"
 
 // IWYU pragma: no_include <ares_version.h>
@@ -52,6 +52,8 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -63,6 +65,7 @@
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/time_util.h"
@@ -79,8 +82,6 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-grpc_core::TraceFlag grpc_trace_ares_resolver(false, "cares_resolver");
-
 namespace {
 
 absl::Status AresStatusToAbslStatus(int status, absl::string_view error_msg) {
@@ -199,7 +200,7 @@ AresResolver::CreateAresResolver(
   ares_channel channel;
   int status = ares_init_options(&channel, &opts, ARES_OPT_FLAGS);
   if (status != ARES_SUCCESS) {
-    gpr_log(GPR_ERROR, "ares_init_options failed, status: %d", status);
+    LOG(ERROR) << "ares_init_options failed, status: " << status;
     return AresStatusToAbslStatus(
         status,
         absl::StrCat("Failed to init c-ares channel: ", ares_strerror(status)));
@@ -220,8 +221,7 @@ AresResolver::AresResolver(
     std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
     std::shared_ptr<EventEngine> event_engine, ares_channel channel)
     : RefCountedDNSResolverInterface(
-          GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver) ? "AresResolver"
-                                                            : nullptr),
+          GRPC_TRACE_FLAG_ENABLED(cares_resolver) ? "AresResolver" : nullptr),
       channel_(channel),
       polled_fd_factory_(std::move(polled_fd_factory)),
       event_engine_(std::move(event_engine)) {
@@ -229,8 +229,8 @@ AresResolver::AresResolver(
 }
 
 AresResolver::~AresResolver() {
-  GPR_ASSERT(fd_node_list_.empty());
-  GPR_ASSERT(callback_map_.empty());
+  CHECK(fd_node_list_.empty());
+  CHECK(callback_map_.empty());
   ares_destroy(channel_);
 }
 
@@ -246,7 +246,7 @@ void AresResolver::Orphan() {
       if (!fd_node->already_shutdown) {
         GRPC_ARES_RESOLVER_TRACE_LOG("resolver: %p shutdown fd: %s", this,
                                      fd_node->polled_fd->GetName());
-        GPR_ASSERT(fd_node->polled_fd->ShutdownLocked(
+        CHECK(fd_node->polled_fd->ShutdownLocked(
             absl::CancelledError("AresResolver::Orphan")));
         fd_node->already_shutdown = true;
       }
@@ -513,7 +513,7 @@ void AresResolver::MaybeStartTimerLocked() {
 
 void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
-  GPR_ASSERT(fd_node->readable_registered);
+  CHECK(fd_node->readable_registered);
   fd_node->readable_registered = false;
   GRPC_ARES_RESOLVER_TRACE_LOG("OnReadable: fd: %d; request: %p; status: %s",
                                fd_node->as, this, status.ToString().c_str());
@@ -532,7 +532,7 @@ void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
 
 void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
-  GPR_ASSERT(fd_node->writable_registered);
+  CHECK(fd_node->writable_registered);
   fd_node->writable_registered = false;
   GRPC_ARES_RESOLVER_TRACE_LOG("OnWritable: fd: %d; request:%p; status: %s",
                                fd_node->as, this, status.ToString().c_str());
@@ -582,7 +582,7 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
                                           int /*timeouts*/,
                                           struct hostent* hostent) {
   auto* hostname_qa = static_cast<HostnameQueryArg*>(arg);
-  GPR_ASSERT(hostname_qa->pending_requests-- > 0);
+  CHECK_GT(hostname_qa->pending_requests--, 0);
   auto* ares_resolver = hostname_qa->ares_resolver;
   if (status != ARES_SUCCESS) {
     std::string error_msg =
@@ -643,9 +643,9 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
   if (hostname_qa->pending_requests == 0) {
     auto nh =
         ares_resolver->callback_map_.extract(hostname_qa->callback_map_id);
-    GPR_ASSERT(!nh.empty());
-    GPR_ASSERT(absl::holds_alternative<
-               EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
+    CHECK(!nh.empty());
+    CHECK(absl::holds_alternative<
+          EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
     auto callback = absl::get<EventEngine::DNSResolver::LookupHostnameCallback>(
         std::move(nh.mapped()));
     if (!hostname_qa->result.empty() || hostname_qa->error_status.ok()) {
@@ -670,10 +670,9 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   std::unique_ptr<QueryArg> qa(static_cast<QueryArg*>(arg));
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
-  GPR_ASSERT(!nh.empty());
-  GPR_ASSERT(
-      absl::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
-          nh.mapped()));
+  CHECK(!nh.empty());
+  CHECK(absl::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
+      nh.mapped()));
   auto callback = absl::get<EventEngine::DNSResolver::LookupSRVCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {
@@ -726,10 +725,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   std::unique_ptr<QueryArg> qa(static_cast<QueryArg*>(arg));
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
-  GPR_ASSERT(!nh.empty());
-  GPR_ASSERT(
-      absl::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
-          nh.mapped()));
+  CHECK(!nh.empty());
+  CHECK(absl::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
+      nh.mapped()));
   auto callback = absl::get<EventEngine::DNSResolver::LookupTXTCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {
@@ -768,9 +766,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   }
   GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p Got %zu TXT records", ares_resolver,
                                result.size());
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver)) {
+  if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {
     for (const auto& record : result) {
-      gpr_log(GPR_INFO, "%s", record.c_str());
+      LOG(INFO) << record;
     }
   }
   // Clean up.
@@ -791,4 +789,50 @@ void (*event_engine_grpc_ares_test_only_inject_config)(ares_channel* channel) =
 
 bool g_event_engine_grpc_ares_test_only_force_tcp = false;
 
+bool ShouldUseAresDnsResolver() {
+#if defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER) || \
+    defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+  auto resolver_env = grpc_core::ConfigVars::Get().DnsResolver();
+  return resolver_env.empty() || absl::EqualsIgnoreCase(resolver_env, "ares");
+#else   // defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER) ||
+        // defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+  return false;
+#endif  // defined(GRPC_POSIX_SOCKET_ARES_EV_DRIVER) ||
+        // defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
+}
+
+absl::Status AresInit() {
+  if (ShouldUseAresDnsResolver()) {
+    address_sorting_init();
+    // ares_library_init and ares_library_cleanup are currently no-op except
+    // under Windows. Calling them may cause race conditions when other parts of
+    // the binary calls these functions concurrently.
+#ifdef GPR_WINDOWS
+    int status = ares_library_init(ARES_LIB_INIT_ALL);
+    if (status != ARES_SUCCESS) {
+      return GRPC_ERROR_CREATE(
+          absl::StrCat("ares_library_init failed: ", ares_strerror(status)));
+    }
+#endif  // GPR_WINDOWS
+  }
+  return absl::OkStatus();
+}
+void AresShutdown() {
+  if (ShouldUseAresDnsResolver()) {
+    address_sorting_shutdown();
+    // ares_library_init and ares_library_cleanup are currently no-op except
+    // under Windows. Calling them may cause race conditions when other parts of
+    // the binary calls these functions concurrently.
+#ifdef GPR_WINDOWS
+    ares_library_cleanup();
+#endif  // GPR_WINDOWS
+  }
+}
+
+#else  // GRPC_ARES == 1
+
+bool ShouldUseAresDnsResolver() { return false; }
+absl::Status AresInit() { return absl::OkStatus(); }
+void AresShutdown() {}
+
 #endif  // GRPC_ARES == 1

data/src/core/lib/event_engine/ares_resolver.h

@@ -14,10 +14,12 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <utility>
 
+#include "absl/status/status.h"
+
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/debug/trace.h"
 
 #if GRPC_ARES == 1
@@ -29,7 +31,6 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_map.h"
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -46,13 +47,12 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-extern grpc_core::TraceFlag grpc_trace_ares_resolver;
-
-#define GRPC_ARES_RESOLVER_TRACE_LOG(format, ...)                              \
-  do {                                                                         \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver)) {                   \
-      gpr_log(GPR_INFO, "(EventEngine c-ares resolver) " format, __VA_ARGS__); \
-    }                                                                          \
+#define GRPC_ARES_RESOLVER_TRACE_LOG(format, ...)        \
+  do {                                                   \
+    if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {       \
+      LOG(INFO) << "(EventEngine c-ares resolver) "      \
+                << absl::StrFormat(format, __VA_ARGS__); \
+    }                                                    \
   } while (0)
 
 class AresResolver : public RefCountedDNSResolverInterface {
@@ -148,4 +148,9 @@ extern void (*event_engine_grpc_ares_test_only_inject_config)(
 extern bool g_event_engine_grpc_ares_test_only_force_tcp;
 
 #endif  // GRPC_ARES == 1
+
+bool ShouldUseAresDnsResolver();
+absl::Status AresInit();
+void AresShutdown();
+
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_ARES_RESOLVER_H

data/src/core/lib/event_engine/cf_engine/cf_engine.cc

@@ -20,6 +20,9 @@
 
 #include <CoreFoundation/CoreFoundation.h>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+
 #include <grpc/support/cpu.h>
 
 #include "src/core/lib/event_engine/cf_engine/cf_engine.h"
@@ -28,7 +31,6 @@
 #include "src/core/lib/event_engine/posix_engine/timer_manager.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/gprpp/crash.h"
 
@@ -42,8 +44,8 @@ struct CFEventEngine::Closure final : public EventEngine::Closure {
   EventEngine::TaskHandle handle;
 
   void Run() override {
-    GRPC_EVENT_ENGINE_TRACE("CFEventEngine:%p executing callback:%s", engine,
-                            HandleToString(handle).c_str());
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "CFEventEngine:" << engine << " executing callback:" << handle;
     {
       grpc_core::MutexLock lock(&engine->task_mu_);
       engine->known_handles_.erase(handle);
@@ -61,14 +63,14 @@ CFEventEngine::CFEventEngine()
 CFEventEngine::~CFEventEngine() {
   {
     grpc_core::MutexLock lock(&task_mu_);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
       for (auto handle : known_handles_) {
-        gpr_log(GPR_ERROR,
-                "CFEventEngine:%p uncleared TaskHandle at shutdown:%s", this,
-                HandleToString(handle).c_str());
+        LOG(ERROR) << "CFEventEngine:" << this
+                   << " uncleared TaskHandle at shutdown:"
+                   << HandleToString(handle);
       }
     }
-    GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+    CHECK(GPR_LIKELY(known_handles_.empty()));
     timer_manager_.Shutdown();
   }
   thread_pool_->Quiesce();
@@ -143,9 +145,8 @@ bool CFEventEngine::CancelConnectInternal(ConnectionHandle handle,
   grpc_core::MutexLock lock(&conn_mu_);
 
   if (!conn_handles_.contains(handle)) {
-    GRPC_EVENT_ENGINE_TRACE(
-        "Unknown connection handle: %s",
-        HandleToString<EventEngine::ConnectionHandle>(handle).c_str());
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "Unknown connection handle: " << handle;
     return false;
   }
   conn_handles_.erase(handle);
@@ -208,8 +209,8 @@ EventEngine::TaskHandle CFEventEngine::RunAfterInternal(
   grpc_core::MutexLock lock(&task_mu_);
   known_handles_.insert(handle);
   cd->handle = handle;
-  GRPC_EVENT_ENGINE_TRACE("CFEventEngine:%p scheduling callback:%s", this,
-                          HandleToString(handle).c_str());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "CFEventEngine:" << this << " scheduling callback:" << handle;
   timer_manager_.TimerInit(&cd->timer, when_ts, cd);
   return handle;
 }

data/src/core/lib/event_engine/cf_engine/cfstream_endpoint.cc

@@ -23,7 +23,6 @@
 #include "absl/strings/str_format.h"
 
 #include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/gprpp/strerror.h"
 
 namespace grpc_event_engine {
@@ -68,9 +67,9 @@ absl::StatusOr<EventEngine::ResolvedAddress> CFReadStreamLocallAddress(
 }  // namespace
 
 bool CFStreamEndpointImpl::CancelConnect(absl::Status status) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
-      "CFStreamEndpointImpl::CancelConnect: status: %s, this: %p",
-      status.ToString().c_str(), this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::CancelConnect: status: " << status
+      << ", this: " << this;
 
   return open_event_.SetShutdown(std::move(status));
 }
@@ -85,8 +84,8 @@ void CFStreamEndpointImpl::Connect(
     return;
   }
 
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::Connect: %s",
-                                   addr_uri.value().c_str());
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::Connect: " << addr_uri.value();
 
   peer_address_ = std::move(addr);
   auto host_port = ResolvedAddressToNormalizedString(peer_address_);
@@ -96,8 +95,8 @@ void CFStreamEndpointImpl::Connect(
   }
 
   peer_address_string_ = host_port.value();
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
-      "CFStreamEndpointImpl::Connect, host_port: %s", host_port->c_str());
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::Connect, host_port: " << peer_address_string_;
 
   std::string host_string;
   std::string port_string;
@@ -163,8 +162,9 @@ void CFStreamEndpointImpl::Connect(
     void* client_callback_info) {
   auto self = static_cast<CFStreamEndpointImpl*>(client_callback_info);
 
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
-      "CFStreamEndpointImpl::ReadCallback, type: %lu, this: %p", type, self);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::ReadCallback, type: " << type
+      << ", this: " << self;
 
   switch (type) {
     case kCFStreamEventOpenCompleted:
@@ -177,8 +177,8 @@ void CFStreamEndpointImpl::Connect(
       break;
     case kCFStreamEventErrorOccurred: {
       auto status = CFErrorToStatus(CFReadStreamCopyError(stream));
-      GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStream Read error: %s",
-                                       status.ToString().c_str());
+      GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+          << "CFStream Read error: " << status;
 
       self->open_event_.SetShutdown(status);
       self->read_event_.SetShutdown(status);
@@ -194,8 +194,9 @@ void CFStreamEndpointImpl::WriteCallback(CFWriteStreamRef stream,
                                          CFStreamEventType type,
                                          void* client_callback_info) {
   auto self = static_cast<CFStreamEndpointImpl*>(client_callback_info);
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE(
-      "CFStreamEndpointImpl::WriteCallback, type: %lu, this: %p", type, self);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::WriteCallback, type: " << type
+      << ", this: " << self;
 
   switch (type) {
     case kCFStreamEventOpenCompleted:
@@ -208,8 +209,8 @@ void CFStreamEndpointImpl::WriteCallback(CFWriteStreamRef stream,
       break;
     case kCFStreamEventErrorOccurred: {
       auto status = CFErrorToStatus(CFWriteStreamCopyError(stream));
-      GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStream Write error: %s",
-                                       status.ToString().c_str());
+      GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+          << "CFStream Write error: " << status;
 
       self->open_event_.SetShutdown(status);
       self->read_event_.SetShutdown(status);
@@ -239,8 +240,8 @@ CFStreamEndpointImpl::~CFStreamEndpointImpl() {
 }
 
 void CFStreamEndpointImpl::Shutdown() {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::Shutdown: this: %p",
-                                   this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::Shutdown: this: " << this;
 
   auto shutdownStatus =
       absl::Status(absl::StatusCode::kUnknown,
@@ -249,9 +250,9 @@ void CFStreamEndpointImpl::Shutdown() {
   read_event_.SetShutdown(shutdownStatus);
   write_event_.SetShutdown(shutdownStatus);
 
-  CFReadStreamSetClient(cf_read_stream_, kCFStreamEventNone, nullptr, nullptr);
-  CFWriteStreamSetClient(cf_write_stream_, kCFStreamEventNone, nullptr,
-                         nullptr);
+  CFReadStreamSetDispatchQueue(cf_read_stream_, nullptr);
+  CFWriteStreamSetDispatchQueue(cf_write_stream_, nullptr);
+
   CFReadStreamClose(cf_read_stream_);
   CFWriteStreamClose(cf_write_stream_);
 }
@@ -259,8 +260,8 @@ void CFStreamEndpointImpl::Shutdown() {
 bool CFStreamEndpointImpl::Read(
     absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
     const EventEngine::Endpoint::ReadArgs* /* args */) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::Read, this: %p",
-                                   this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::Read, this: " << this;
 
   read_event_.NotifyOn(new PosixEngineClosure(
       [that = Ref(), on_read = std::move(on_read),
@@ -278,8 +279,8 @@ bool CFStreamEndpointImpl::Read(
 
 void CFStreamEndpointImpl::DoRead(
     absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::DoRead, this: %p",
-                                   this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::DoRead, this: " << this;
 
   auto buffer_index = buffer->AppendIndexed(
       Slice(memory_allocator_.MakeSlice(kDefaultReadBufferSize)));
@@ -292,8 +293,8 @@ void CFStreamEndpointImpl::DoRead(
 
   if (read_size < 0) {
     auto status = CFErrorToStatus(CFReadStreamCopyError(cf_read_stream_));
-    GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStream read error: %s, read_size: %ld",
-                                     status.ToString().c_str(), read_size);
+    GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+        << "CFStream read error: " << status << ", read_size: " << read_size;
     on_read(status);
     return;
   }
@@ -305,8 +306,8 @@ void CFStreamEndpointImpl::DoRead(
 bool CFStreamEndpointImpl::Write(
     absl::AnyInvocable<void(absl::Status)> on_writable, SliceBuffer* data,
     const EventEngine::Endpoint::WriteArgs* /* args */) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::Write, this: %p",
-                                   this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::Write, this: " << this;
 
   write_event_.NotifyOn(new PosixEngineClosure(
       [that = Ref(), on_writable = std::move(on_writable),
@@ -324,8 +325,8 @@ bool CFStreamEndpointImpl::Write(
 
 void CFStreamEndpointImpl::DoWrite(
     absl::AnyInvocable<void(absl::Status)> on_writable, SliceBuffer* data) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("CFStreamEndpointImpl::DoWrite, this: %p",
-                                   this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "CFStreamEndpointImpl::DoWrite, this: " << this;
 
   size_t total_written_size = 0;
   for (size_t i = 0; i < data->Count(); i++) {