grpc 1.66.0 → 1.67.0.pre1

data/src/core/lib/config/config_vars.h

@@ -38,6 +38,7 @@ class GPR_DLL ConfigVars {
     absl::optional<bool> enable_fork_support;
     absl::optional<bool> abort_on_leaks;
     absl::optional<bool> not_use_system_ssl_roots;
+    absl::optional<bool> cpp_experimental_disable_reflection;
     absl::optional<std::string> dns_resolver;
     absl::optional<std::string> verbosity;
     absl::optional<std::string> poll_strategy;
@@ -97,6 +98,12 @@ class GPR_DLL ConfigVars {
   bool NotUseSystemSslRoots() const { return not_use_system_ssl_roots_; }
   // A colon separated list of cipher suites to use with OpenSSL
   absl::string_view SslCipherSuites() const { return ssl_cipher_suites_; }
+  // EXPERIMENTAL. Only respected when there is a dependency on
+  // :grpc++_reflection. If true, no reflection server will be automatically
+  // added.
+  bool CppExperimentalDisableReflection() const {
+    return cpp_experimental_disable_reflection_;
+  }
 
  private:
   explicit ConfigVars(const Overrides& overrides);
@@ -106,6 +113,7 @@ class GPR_DLL ConfigVars {
   bool enable_fork_support_;
   bool abort_on_leaks_;
   bool not_use_system_ssl_roots_;
+  bool cpp_experimental_disable_reflection_;
   std::string dns_resolver_;
   std::string verbosity_;
   std::string poll_strategy_;

data/src/core/lib/config/core_configuration.cc

@@ -20,7 +20,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {

data/src/core/lib/config/core_configuration.h

@@ -20,7 +20,6 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/handshaker/handshaker_registry.h"

data/src/core/lib/debug/event_log.cc

@@ -21,7 +21,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {

data/src/core/lib/debug/trace_flags.cc

@@ -114,6 +114,7 @@ TraceFlag subchannel_pool_trace(false, "subchannel_pool");
 TraceFlag tcp_trace(false, "tcp");
 TraceFlag timer_trace(false, "timer");
 TraceFlag timer_check_trace(false, "timer_check");
+TraceFlag token_fetcher_credentials_trace(false, "token_fetcher_credentials");
 TraceFlag tsi_trace(false, "tsi");
 TraceFlag weighted_round_robin_lb_trace(false, "weighted_round_robin_lb");
 TraceFlag weighted_target_lb_trace(false, "weighted_target_lb");
@@ -121,18 +122,10 @@ TraceFlag xds_client_trace(false, "xds_client");
 TraceFlag xds_client_refcount_trace(false, "xds_client_refcount");
 TraceFlag xds_cluster_impl_lb_trace(false, "xds_cluster_impl_lb");
 TraceFlag xds_cluster_manager_lb_trace(false, "xds_cluster_manager_lb");
-TraceFlag xds_cluster_resource_type_test_trace(
-    true, "xds_cluster_resource_type_test");
-TraceFlag xds_common_types_test_trace(true, "xds_common_types_test");
-TraceFlag xds_endpoint_resource_type_test_trace(
-    true, "xds_endpoint_resource_type_test");
-TraceFlag xds_listener_resource_type_test_trace(
-    true, "xds_listener_resource_type_test");
 TraceFlag xds_override_host_lb_trace(false, "xds_override_host_lb");
 TraceFlag xds_resolver_trace(false, "xds_resolver");
-TraceFlag xds_route_config_resource_type_test_trace(
-    true, "xds_route_config_resource_type_test");
 TraceFlag xds_server_config_fetcher_trace(false, "xds_server_config_fetcher");
+TraceFlag xds_unittest_trace(true, "xds_unittest");
 TraceFlag xds_wrr_locality_lb_trace(false, "xds_wrr_locality_lb");
 
 const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
@@ -206,6 +199,7 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"tcp", &tcp_trace},
           {"timer", &timer_trace},
           {"timer_check", &timer_check_trace},
+          {"token_fetcher_credentials", &token_fetcher_credentials_trace},
           {"tsi", &tsi_trace},
           {"weighted_round_robin_lb", &weighted_round_robin_lb_trace},
           {"weighted_target_lb", &weighted_target_lb_trace},
@@ -213,18 +207,10 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"xds_client_refcount", &xds_client_refcount_trace},
           {"xds_cluster_impl_lb", &xds_cluster_impl_lb_trace},
           {"xds_cluster_manager_lb", &xds_cluster_manager_lb_trace},
-          {"xds_cluster_resource_type_test",
-           &xds_cluster_resource_type_test_trace},
-          {"xds_common_types_test", &xds_common_types_test_trace},
-          {"xds_endpoint_resource_type_test",
-           &xds_endpoint_resource_type_test_trace},
-          {"xds_listener_resource_type_test",
-           &xds_listener_resource_type_test_trace},
           {"xds_override_host_lb", &xds_override_host_lb_trace},
           {"xds_resolver", &xds_resolver_trace},
-          {"xds_route_config_resource_type_test",
-           &xds_route_config_resource_type_test_trace},
           {"xds_server_config_fetcher", &xds_server_config_fetcher_trace},
+          {"xds_unittest", &xds_unittest_trace},
           {"xds_wrr_locality_lb", &xds_wrr_locality_lb_trace},
 #ifndef NDEBUG
           {"auth_context_refcount", &auth_context_refcount_trace},

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

@@ -112,6 +112,7 @@ extern TraceFlag subchannel_pool_trace;
 extern TraceFlag tcp_trace;
 extern TraceFlag timer_trace;
 extern TraceFlag timer_check_trace;
+extern TraceFlag token_fetcher_credentials_trace;
 extern TraceFlag tsi_trace;
 extern TraceFlag weighted_round_robin_lb_trace;
 extern TraceFlag weighted_target_lb_trace;
@@ -119,14 +120,10 @@ extern TraceFlag xds_client_trace;
 extern TraceFlag xds_client_refcount_trace;
 extern TraceFlag xds_cluster_impl_lb_trace;
 extern TraceFlag xds_cluster_manager_lb_trace;
-extern TraceFlag xds_cluster_resource_type_test_trace;
-extern TraceFlag xds_common_types_test_trace;
-extern TraceFlag xds_endpoint_resource_type_test_trace;
-extern TraceFlag xds_listener_resource_type_test_trace;
 extern TraceFlag xds_override_host_lb_trace;
 extern TraceFlag xds_resolver_trace;
-extern TraceFlag xds_route_config_resource_type_test_trace;
 extern TraceFlag xds_server_config_fetcher_trace;
+extern TraceFlag xds_unittest_trace;
 extern TraceFlag xds_wrr_locality_lb_trace;
 
 }  // namespace grpc_core

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

@@ -81,10 +81,16 @@ class TraceFlag {
 };
 
 #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_DLOG(tracer, level) \
+  DLOG_IF(level, GRPC_TRACE_FLAG_ENABLED(tracer))
+
 #define GRPC_TRACE_VLOG(tracer, level) \
   if (GRPC_TRACE_FLAG_ENABLED(tracer)) VLOG(level)
 

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

@@ -61,7 +61,6 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -84,6 +83,11 @@ namespace experimental {
 
 namespace {
 
+// A hard limit on the number of records (A/AAAA or SRV) we may get from a
+// single response. This is to be defensive to prevent a bad DNS response from
+// OOMing the process.
+constexpr int kMaxRecordSize = 65536;
+
 absl::Status AresStatusToAbslStatus(int status, absl::string_view error_msg) {
   switch (status) {
     case ARES_ECANCELLED:
@@ -92,6 +96,8 @@ absl::Status AresStatusToAbslStatus(int status, absl::string_view error_msg) {
       return absl::UnimplementedError(error_msg);
     case ARES_ENOTFOUND:
       return absl::NotFoundError(error_msg);
+    case ARES_ECONNREFUSED:
+      return absl::UnavailableError(error_msg);
     default:
       return absl::UnknownError(error_msg);
   }
@@ -117,7 +123,8 @@ bool IsIpv6LoopbackAvailable() {
 
 absl::Status SetRequestDNSServer(absl::string_view dns_server,
                                  ares_channel* channel) {
-  GRPC_ARES_RESOLVER_TRACE_LOG("Using DNS server %s", dns_server.data());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) Using DNS server " << dns_server;
   grpc_resolved_address addr;
   struct ares_addr_port_node dns_server_addr = {};
   if (grpc_parse_ipv4_hostport(dns_server, &addr, /*log_errors=*/false)) {
@@ -244,8 +251,9 @@ void AresResolver::Orphan() {
     }
     for (const auto& fd_node : fd_node_list_) {
       if (!fd_node->already_shutdown) {
-        GRPC_ARES_RESOLVER_TRACE_LOG("resolver: %p shutdown fd: %s", this,
-                                     fd_node->polled_fd->GetName());
+        GRPC_TRACE_LOG(cares_resolver, INFO)
+            << "(EventEngine c-ares resolver) resolver: " << this
+            << " shutdown fd: " << fd_node->polled_fd->GetName();
         CHECK(fd_node->polled_fd->ShutdownLocked(
             absl::CancelledError("AresResolver::Orphan")));
         fd_node->already_shutdown = true;
@@ -416,8 +424,9 @@ void AresResolver::CheckSocketsLocked() {
             fd_node_list_.begin(), fd_node_list_.end(),
             [sock = socks[i]](const auto& node) { return node->as == sock; });
         if (iter == fd_node_list_.end()) {
-          GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p new fd: %d", this,
-                                       socks[i]);
+          GRPC_TRACE_LOG(cares_resolver, INFO)
+              << "(EventEngine c-ares resolver) resolver:" << this
+              << " new fd: " << socks[i];
           new_list.push_back(std::make_unique<FdNode>(
               socks[i], polled_fd_factory_->NewGrpcPolledFdLocked(socks[i])));
         } else {
@@ -433,8 +442,9 @@ void AresResolver::CheckSocketsLocked() {
             // to cope with the edge-triggered poller not getting an event if no
             // new data arrives and c-ares hasn't read all the data in the
             // previous ares_process_fd.
-            GRPC_ARES_RESOLVER_TRACE_LOG(
-                "resolver:%p schedule read directly on: %d", this, fd_node->as);
+            GRPC_TRACE_LOG(cares_resolver, INFO)
+                << "(EventEngine c-ares resolver) resolver:" << this
+                << " schedule read directly on: " << fd_node->as;
             event_engine_->Run(
                 [self = Ref(DEBUG_LOCATION, "CheckSocketsLocked"),
                  fd_node]() mutable {
@@ -443,8 +453,9 @@ void AresResolver::CheckSocketsLocked() {
                 });
           } else {
             // Otherwise register with the poller for readable event.
-            GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p notify read on: %d", this,
-                                         fd_node->as);
+            GRPC_TRACE_LOG(cares_resolver, INFO)
+                << "(EventEngine c-ares resolver) resolver:" << this
+                << " notify read on: " << fd_node->as;
             fd_node->polled_fd->RegisterForOnReadableLocked(
                 [self = Ref(DEBUG_LOCATION, "CheckSocketsLocked"),
                  fd_node](absl::Status status) mutable {
@@ -457,8 +468,9 @@ void AresResolver::CheckSocketsLocked() {
         // has not been registered with this socket.
         if (ARES_GETSOCK_WRITABLE(socks_bitmask, i) &&
             !fd_node->writable_registered) {
-          GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p notify write on: %d", this,
-                                       fd_node->as);
+          GRPC_TRACE_LOG(cares_resolver, INFO)
+              << "(EventEngine c-ares resolver) resolver:" << this
+              << " notify write on: " << fd_node->as;
           fd_node->writable_registered = true;
           fd_node->polled_fd->RegisterForOnWriteableLocked(
               [self = Ref(DEBUG_LOCATION, "CheckSocketsLocked"),
@@ -480,14 +492,16 @@ void AresResolver::CheckSocketsLocked() {
   while (!fd_node_list_.empty()) {
     FdNode* fd_node = fd_node_list_.front().get();
     if (!fd_node->already_shutdown) {
-      GRPC_ARES_RESOLVER_TRACE_LOG("resolver: %p shutdown fd: %s", this,
-                                   fd_node->polled_fd->GetName());
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) resolver: " << this
+          << " shutdown fd: " << fd_node->polled_fd->GetName();
       fd_node->already_shutdown =
           fd_node->polled_fd->ShutdownLocked(absl::OkStatus());
     }
     if (!fd_node->readable_registered && !fd_node->writable_registered) {
-      GRPC_ARES_RESOLVER_TRACE_LOG("resolver: %p delete fd: %s", this,
-                                   fd_node->polled_fd->GetName());
+      GRPC_TRACE_LOG(cares_resolver, INFO)
+          << "(EventEngine c-ares resolver) resolver: " << this
+          << " delete fd: " << fd_node->polled_fd->GetName();
       fd_node_list_.pop_front();
     } else {
       new_list.splice(new_list.end(), fd_node_list_, fd_node_list_.begin());
@@ -501,9 +515,10 @@ void AresResolver::MaybeStartTimerLocked() {
     return;
   }
   // Initialize the backup poll alarm
-  GRPC_ARES_RESOLVER_TRACE_LOG(
-      "request:%p MaybeStartTimerLocked next ares process poll time in %zu ms",
-      this, Milliseconds(kAresBackupPollAlarmDuration));
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) request:" << this
+      << " MaybeStartTimerLocked next ares process poll time in "
+      << Milliseconds(kAresBackupPollAlarmDuration) << " ms";
   ares_backup_poll_alarm_handle_ = event_engine_->RunAfter(
       kAresBackupPollAlarmDuration,
       [self = Ref(DEBUG_LOCATION, "MaybeStartTimerLocked")]() {
@@ -515,8 +530,9 @@ void AresResolver::OnReadable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
   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());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) OnReadable: fd: " << fd_node->as
+      << "; request: " << this << "; status: " << status;
   if (status.ok() && !shutting_down_) {
     ares_process_fd(channel_, fd_node->as, ARES_SOCKET_BAD);
   } else {
@@ -534,8 +550,9 @@ void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
   grpc_core::MutexLock lock(&mutex_);
   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());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) OnWritable: fd: " << fd_node->as
+      << "; request:" << this << "; status: " << status;
   if (status.ok() && !shutting_down_) {
     ares_process_fd(channel_, ARES_SOCKET_BAD, fd_node->as);
   } else {
@@ -560,15 +577,16 @@ void AresResolver::OnWritable(FdNode* fd_node, absl::Status status) {
 void AresResolver::OnAresBackupPollAlarm() {
   grpc_core::MutexLock lock(&mutex_);
   ares_backup_poll_alarm_handle_.reset();
-  GRPC_ARES_RESOLVER_TRACE_LOG(
-      "request:%p OnAresBackupPollAlarm shutting_down=%d.", this,
-      shutting_down_);
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) request:" << this
+      << " OnAresBackupPollAlarm shutting_down=" << shutting_down_;
   if (!shutting_down_) {
     for (const auto& fd_node : fd_node_list_) {
       if (!fd_node->already_shutdown) {
-        GRPC_ARES_RESOLVER_TRACE_LOG(
-            "request:%p OnAresBackupPollAlarm; ares_process_fd. fd=%s", this,
-            fd_node->polled_fd->GetName());
+        GRPC_TRACE_LOG(cares_resolver, INFO)
+            << "(EventEngine c-ares resolver) request:" << this
+            << " OnAresBackupPollAlarm; ares_process_fd. fd="
+            << fd_node->polled_fd->GetName();
         ares_socket_t as = fd_node->polled_fd->GetWrappedAresSocketLocked();
         ares_process_fd(channel_, as, as);
       }
@@ -588,14 +606,20 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
     std::string error_msg =
         absl::StrFormat("address lookup failed for %s: %s",
                         hostname_qa->query_name, ares_strerror(status));
-    GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p OnHostbynameDoneLocked: %s",
-                                 ares_resolver, error_msg.c_str());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+        << " OnHostbynameDoneLocked: " << error_msg;
     hostname_qa->error_status = AresStatusToAbslStatus(status, error_msg);
   } else {
-    GRPC_ARES_RESOLVER_TRACE_LOG(
-        "resolver:%p OnHostbynameDoneLocked name=%s ARES_SUCCESS",
-        ares_resolver, hostname_qa->query_name.c_str());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+        << " OnHostbynameDoneLocked name=" << hostname_qa->query_name
+        << " ARES_SUCCESS";
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; i++) {
+      if (hostname_qa->result.size() == kMaxRecordSize) {
+        LOG(ERROR) << "A/AAAA response exceeds maximum record size of 65536";
+        break;
+      }
       switch (hostent->h_addrtype) {
         case AF_INET6: {
           size_t addr_len = sizeof(struct sockaddr_in6);
@@ -609,10 +633,11 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
               reinterpret_cast<const sockaddr*>(&addr), addr_len);
           char output[INET6_ADDRSTRLEN];
           ares_inet_ntop(AF_INET6, &addr.sin6_addr, output, INET6_ADDRSTRLEN);
-          GRPC_ARES_RESOLVER_TRACE_LOG(
-              "resolver:%p c-ares resolver gets a AF_INET6 result: \n"
-              "  addr: %s\n  port: %d\n  sin6_scope_id: %d\n",
-              ares_resolver, output, hostname_qa->port, addr.sin6_scope_id);
+          GRPC_TRACE_LOG(cares_resolver, INFO)
+              << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+              << " c-ares resolver gets a AF_INET6 result: \n  addr: " << output
+              << "\n  port: " << hostname_qa->port
+              << "\n  sin6_scope_id: " << addr.sin6_scope_id;
           break;
         }
         case AF_INET: {
@@ -627,10 +652,10 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
               reinterpret_cast<const sockaddr*>(&addr), addr_len);
           char output[INET_ADDRSTRLEN];
           ares_inet_ntop(AF_INET, &addr.sin_addr, output, INET_ADDRSTRLEN);
-          GRPC_ARES_RESOLVER_TRACE_LOG(
-              "resolver:%p c-ares resolver gets a AF_INET result: \n"
-              "  addr: %s\n  port: %d\n",
-              ares_resolver, output, hostname_qa->port);
+          GRPC_TRACE_LOG(cares_resolver, INFO)
+              << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+              << " c-ares resolver gets a AF_INET result: \n  addr: " << output
+              << "\n  port: " << hostname_qa->port;
           break;
         }
         default:
@@ -678,8 +703,9 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   auto fail = [&](absl::string_view prefix) {
     std::string error_message = absl::StrFormat(
         "%s for %s: %s", prefix, qa->query_name, ares_strerror(status));
-    GRPC_ARES_RESOLVER_TRACE_LOG("OnSRVQueryDoneLocked: %s",
-                                 error_message.c_str());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) OnSRVQueryDoneLocked: "
+        << error_message;
     ares_resolver->event_engine_->Run(
         [callback = std::move(callback),
          status = AresStatusToAbslStatus(status, error_message)]() mutable {
@@ -690,13 +716,14 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
     fail("SRV lookup failed");
     return;
   }
-  GRPC_ARES_RESOLVER_TRACE_LOG(
-      "resolver:%p OnSRVQueryDoneLocked name=%s ARES_SUCCESS", ares_resolver,
-      qa->query_name.c_str());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+      << " OnSRVQueryDoneLocked name=" << qa->query_name << " ARES_SUCCESS";
   struct ares_srv_reply* reply = nullptr;
   status = ares_parse_srv_reply(abuf, alen, &reply);
-  GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p ares_parse_srv_reply: %d",
-                               ares_resolver, status);
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+      << " ares_parse_srv_reply: " << status;
   if (status != ARES_SUCCESS) {
     fail("Failed to parse SRV reply");
     return;
@@ -704,6 +731,10 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   std::vector<EventEngine::DNSResolver::SRVRecord> result;
   for (struct ares_srv_reply* srv_it = reply; srv_it != nullptr;
        srv_it = srv_it->next) {
+    if (result.size() == kMaxRecordSize) {
+      LOG(ERROR) << "SRV response exceeds maximum record size of 65536";
+      break;
+    }
     EventEngine::DNSResolver::SRVRecord record;
     record.host = srv_it->host;
     record.port = srv_it->port;
@@ -733,8 +764,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   auto fail = [&](absl::string_view prefix) {
     std::string error_message = absl::StrFormat(
         "%s for %s: %s", prefix, qa->query_name, ares_strerror(status));
-    GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p OnTXTDoneLocked: %s",
-                                 ares_resolver, error_message.c_str());
+    GRPC_TRACE_LOG(cares_resolver, INFO)
+        << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+        << " OnTXTDoneLocked: " << error_message;
     ares_resolver->event_engine_->Run(
         [callback = std::move(callback),
          status = AresStatusToAbslStatus(status, error_message)]() mutable {
@@ -745,9 +777,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
     fail("TXT lookup failed");
     return;
   }
-  GRPC_ARES_RESOLVER_TRACE_LOG(
-      "resolver:%p OnTXTDoneLocked name=%s ARES_SUCCESS", ares_resolver,
-      qa->query_name.c_str());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) resolver:" << ares_resolver
+      << " OnTXTDoneLocked name=" << qa->query_name << " ARES_SUCCESS";
   struct ares_txt_ext* reply = nullptr;
   status = ares_parse_txt_reply_ext(buf, len, &reply);
   if (status != ARES_SUCCESS) {
@@ -764,8 +796,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
           std::string(reinterpret_cast<char*>(part->txt), part->length));
     }
   }
-  GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p Got %zu TXT records", ares_resolver,
-                               result.size());
+  GRPC_TRACE_LOG(cares_resolver, INFO)
+      << "(EventEngine c-ares resolver) resolver:" << ares_resolver << " Got "
+      << result.size() << " TXT records";
   if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {
     for (const auto& record : result) {
       LOG(INFO) << record;

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

@@ -37,7 +37,6 @@
 #include "absl/types/variant.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.h"
@@ -47,14 +46,6 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-#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 {
  public:
   static absl::StatusOr<grpc_core::OrphanablePtr<AresResolver>>

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

@@ -331,9 +331,22 @@ void CFStreamEndpointImpl::DoWrite(
   size_t total_written_size = 0;
   for (size_t i = 0; i < data->Count(); i++) {
     auto slice = data->RefSlice(i);
-    size_t written_size =
+    if (slice.size() == 0) {
+      continue;
+    }
+
+    CFIndex written_size =
         CFWriteStreamWrite(cf_write_stream_, slice.begin(), slice.size());
 
+    if (written_size < 0) {
+      auto status = CFErrorToStatus(CFWriteStreamCopyError(cf_write_stream_));
+      GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+          << "CFStream write error: " << status
+          << ", written_size: " << written_size;
+      on_writable(status);
+      return;
+    }
+
     total_written_size += written_size;
     if (written_size < slice.size()) {
       SliceBuffer written;

data/src/core/lib/event_engine/cf_engine/cftype_unique_ref.h

@@ -37,7 +37,7 @@ class CFTypeUniqueRef {
   CFTypeUniqueRef(CFTypeUniqueRef const&) = delete;
   CFTypeUniqueRef& operator=(CFTypeUniqueRef const&) = delete;
 
-  CFTypeUniqueRef(CFTypeUniqueRef&& other) : cf_type_ref_(other.release()){};
+  CFTypeUniqueRef(CFTypeUniqueRef&& other) : cf_type_ref_(other.release()) {};
   CFTypeUniqueRef& operator=(CFTypeUniqueRef&& other) {
     reset(other.release());
     return *this;

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

@@ -16,7 +16,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK

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

@@ -17,7 +17,6 @@
 #include <memory>
 #include <vector>
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"

data/src/core/lib/event_engine/posix_engine/ev_epoll1_linux.cc

@@ -358,7 +358,7 @@ Epoll1Poller::Epoll1Poller(Scheduler* scheduler)
   CHECK_GE(g_epoll_set_.epfd, 0);
   GRPC_TRACE_LOG(event_engine_poller, INFO)
       << "grpc epoll fd: " << g_epoll_set_.epfd;
-  struct epoll_event ev;
+  struct epoll_event ev {};
   ev.events = static_cast<uint32_t>(EPOLLIN | EPOLLET);
   ev.data.ptr = wakeup_fd_.get();
   CHECK(epoll_ctl(g_epoll_set_.epfd, EPOLL_CTL_ADD, wakeup_fd_->ReadFd(),

data/src/core/lib/event_engine/posix_engine/ev_epoll1_linux.h

@@ -102,17 +102,17 @@ class Epoll1Poller : public PosixEventPoller {
   friend class Epoll1EventHandle;
 #ifdef GRPC_LINUX_EPOLL
   struct EpollSet {
-    int epfd;
+    int epfd = -1;
 
     // The epoll_events after the last call to epoll_wait()
-    struct epoll_event events[MAX_EPOLL_EVENTS];
+    struct epoll_event events[MAX_EPOLL_EVENTS]{};
 
     // The number of epoll_events after the last call to epoll_wait()
-    int num_events;
+    int num_events = 0;
 
     // Index of the first event in epoll_events that has to be processed. This
     // field is only valid if num_events > 0
-    int cursor;
+    int cursor = 0;
   };
 #else
   struct EpollSet {};

data/src/core/lib/event_engine/posix_engine/ev_poll_posix.cc

@@ -30,7 +30,6 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>

data/src/core/lib/event_engine/posix_engine/lockfree_event.cc

@@ -20,7 +20,6 @@
 #include "absl/status/status.h"
 
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"

data/src/core/lib/event_engine/posix_engine/posix_endpoint.cc

@@ -102,6 +102,7 @@ namespace {
 // of bytes sent.
 ssize_t TcpSend(int fd, const struct msghdr* msg, int* saved_errno,
                 int additional_flags = 0) {
+  GRPC_LATENT_SEE_INNER_SCOPE("TcpSend");
   ssize_t sent_length;
   do {
     sent_length = sendmsg(fd, msg, SENDMSG_FLAGS | additional_flags);
@@ -286,6 +287,8 @@ absl::Status PosixEndpointImpl::TcpAnnotateError(absl::Status src_error) const {
 
 // Returns true if data available to read or error other than EAGAIN.
 bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
+  GRPC_LATENT_SEE_INNER_SCOPE("TcpDoRead");
+
   struct msghdr msg;
   struct iovec iov[MAX_READ_IOVEC];
   ssize_t read_bytes;
@@ -345,7 +348,6 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
     // We have read something in previous reads. We need to deliver those bytes
     // to the upper layer.
     if (read_bytes <= 0 && total_read_bytes >= 1) {
-      inq_ = 1;
       break;
     }
 
@@ -407,6 +409,12 @@ bool PosixEndpointImpl::TcpDoRead(absl::Status& status) {
 
   if (inq_ == 0) {
     FinishEstimate();
+    // If this is using the epoll poller, then it is edge-triggered.
+    // Since this read did not consume the edge (i.e., did not get EAGAIN), the
+    // next read on this endpoint must assume there is something to read.
+    // Otherwise, assuming there is nothing to read and waiting for an epoll
+    // edge event could cause the next read to wait indefinitely.
+    inq_ = 1;
   }
 
   DCHECK_GT(total_read_bytes, 0u);

data/src/core/lib/event_engine/posix_engine/posix_endpoint.h

@@ -38,7 +38,6 @@
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/event_engine/extensions/supports_fd.h"
 #include "src/core/lib/event_engine/posix.h"