grpc 1.65.1 → 1.66.0.pre3

data/src/core/lib/compression/message_compress.cc

@@ -62,17 +62,17 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
       }
       r = flate(zs, flush);
       if (r < 0 && r != Z_BUF_ERROR /* not fatal */) {
-        LOG(INFO) << "zlib error (" << r << ")";
+        VLOG(2) << "zlib error (" << r << ")";
         goto error;
       }
     } while (zs->avail_out == 0);
     if (zs->avail_in) {
-      LOG(INFO) << "zlib: not all input consumed";
+      VLOG(2) << "zlib: not all input consumed";
       goto error;
     }
   }
   if (r != Z_STREAM_END) {
-    LOG(INFO) << "zlib: Data error";
+    VLOG(2) << "zlib: Data error";
     goto error;
   }
 

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

@@ -55,9 +55,6 @@ ABSL_FLAG(std::vector<std::string>, grpc_trace, {},
           "into how gRPC C core is processing requests via debug logs.");
 ABSL_FLAG(absl::optional<std::string>, grpc_verbosity, {},
           "Logging verbosity.");
-ABSL_FLAG(absl::optional<std::string>, grpc_stacktrace_minloglevel, {},
-          "Messages logged at the same or higher level than this will print "
-          "stacktrace");
 ABSL_FLAG(absl::optional<bool>, grpc_enable_fork_support, {},
           "Enable fork support");
 ABSL_FLAG(absl::optional<std::string>, grpc_poll_strategy, {},
@@ -97,9 +94,6 @@ ConfigVars::ConfigVars(const Overrides& overrides)
       verbosity_(LoadConfig(FLAGS_grpc_verbosity, "GRPC_VERBOSITY",
                             overrides.verbosity,
                             GPR_DEFAULT_LOG_VERBOSITY_STRING)),
-      stacktrace_minloglevel_(LoadConfig(FLAGS_grpc_stacktrace_minloglevel,
-                                         "GRPC_STACKTRACE_MINLOGLEVEL",
-                                         overrides.stacktrace_minloglevel, "")),
       poll_strategy_(LoadConfig(FLAGS_grpc_poll_strategy, "GRPC_POLL_STRATEGY",
                                 overrides.poll_strategy, "all")),
       ssl_cipher_suites_(LoadConfig(
@@ -134,8 +128,7 @@ std::string ConfigVars::ToString() const {
       ClientChannelBackupPollIntervalMs(), ", dns_resolver: ", "\"",
       absl::CEscape(DnsResolver()), "\"", ", trace: ", "\"",
       absl::CEscape(Trace()), "\"", ", verbosity: ", "\"",
-      absl::CEscape(Verbosity()), "\"", ", stacktrace_minloglevel: ", "\"",
-      absl::CEscape(StacktraceMinloglevel()), "\"",
+      absl::CEscape(Verbosity()), "\"",
       ", enable_fork_support: ", EnableForkSupport() ? "true" : "false",
       ", poll_strategy: ", "\"", absl::CEscape(PollStrategy()), "\"",
       ", abort_on_leaks: ", AbortOnLeaks() ? "true" : "false",

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

@@ -40,7 +40,6 @@ class GPR_DLL ConfigVars {
     absl::optional<bool> not_use_system_ssl_roots;
     absl::optional<std::string> dns_resolver;
     absl::optional<std::string> verbosity;
-    absl::optional<std::string> stacktrace_minloglevel;
     absl::optional<std::string> poll_strategy;
     absl::optional<std::string> system_ssl_roots_dir;
     absl::optional<std::string> default_ssl_roots_file_path;
@@ -81,10 +80,6 @@ class GPR_DLL ConfigVars {
   absl::string_view Trace() const { return trace_; }
   // Logging verbosity.
   absl::string_view Verbosity() const { return verbosity_; }
-  // Messages logged at the same or higher level than this will print stacktrace
-  absl::string_view StacktraceMinloglevel() const {
-    return stacktrace_minloglevel_;
-  }
   // Enable fork support
   bool EnableForkSupport() const { return enable_fork_support_; }
   // Declares which polling engines to try when starting gRPC. This is a
@@ -113,7 +108,6 @@ class GPR_DLL ConfigVars {
   bool not_use_system_ssl_roots_;
   std::string dns_resolver_;
   std::string verbosity_;
-  std::string stacktrace_minloglevel_;
   std::string poll_strategy_;
   std::string ssl_cipher_suites_;
   std::string experiments_;

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

@@ -30,7 +30,6 @@
 #include "absl/strings/strip.h"
 
 #include <grpc/grpc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/config/config_vars.h"
@@ -41,7 +40,7 @@ int grpc_tracer_set_enabled(const char* name, int enabled);
 namespace grpc_core {
 namespace {
 void LogAllTracers() {
-  gpr_log(GPR_DEBUG, "available tracers:");
+  VLOG(2) << "available tracers:";
   for (const auto& name : GetAllTraceFlags()) {
     LOG(INFO) << "  " << name.first;
   }

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

@@ -26,6 +26,7 @@ namespace grpc_core {
 DebugOnlyTraceFlag auth_context_refcount_trace(false, "auth_context_refcount");
 DebugOnlyTraceFlag call_combiner_trace(false, "call_combiner");
 DebugOnlyTraceFlag call_refcount_trace(false, "call_refcount");
+DebugOnlyTraceFlag call_state_trace(false, "call_state");
 DebugOnlyTraceFlag closure_trace(false, "closure");
 DebugOnlyTraceFlag combiner_trace(false, "combiner");
 DebugOnlyTraceFlag cq_refcount_trace(false, "cq_refcount");
@@ -229,6 +230,7 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"auth_context_refcount", &auth_context_refcount_trace},
           {"call_combiner", &call_combiner_trace},
           {"call_refcount", &call_refcount_trace},
+          {"call_state", &call_state_trace},
           {"closure", &closure_trace},
           {"combiner", &combiner_trace},
           {"cq_refcount", &cq_refcount_trace},

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

@@ -26,6 +26,7 @@ namespace grpc_core {
 extern DebugOnlyTraceFlag auth_context_refcount_trace;
 extern DebugOnlyTraceFlag call_combiner_trace;
 extern DebugOnlyTraceFlag call_refcount_trace;
+extern DebugOnlyTraceFlag call_state_trace;
 extern DebugOnlyTraceFlag closure_trace;
 extern DebugOnlyTraceFlag combiner_trace;
 extern DebugOnlyTraceFlag cq_refcount_trace;

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

@@ -25,6 +25,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#ifdef _WIN32
+#undef ERROR
+#endif
+
 void grpc_tracer_init();
 void grpc_tracer_shutdown(void);
 

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

@@ -65,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"
@@ -788,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

@@ -16,6 +16,8 @@
 
 #include <utility>
 
+#include "absl/status/status.h"
+
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -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,11 +47,12 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-#define GRPC_ARES_RESOLVER_TRACE_LOG(format, ...)                              \
-  do {                                                                         \
-    if (GRPC_TRACE_FLAG_ENABLED(cares_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 {
@@ -146,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

@@ -21,6 +21,7 @@
 #include <CoreFoundation/CoreFoundation.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/cpu.h>
 
@@ -30,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"
 
@@ -44,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);
@@ -65,9 +65,9 @@ CFEventEngine::~CFEventEngine() {
     grpc_core::MutexLock lock(&task_mu_);
     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);
       }
     }
     CHECK(GPR_LIKELY(known_handles_.empty()));
@@ -145,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);
@@ -210,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,
@@ -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++) {

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

@@ -26,7 +26,6 @@
 #include "src/core/lib/event_engine/cf_engine/dns_service_resolver.h"
 #include "src/core/lib/event_engine/posix_engine/lockfree_event.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/gprpp/host_port.h"
 
 namespace grpc_event_engine {

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

@@ -26,7 +26,6 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/default_event_engine_factory.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -79,15 +78,15 @@ std::shared_ptr<EventEngine> GetDefaultEventEngine(
     grpc_core::SourceLocation location) {
   grpc_core::MutexLock lock(&*g_mu);
   if (std::shared_ptr<EventEngine> engine = g_event_engine->lock()) {
-    GRPC_EVENT_ENGINE_TRACE(
-        "Returning existing EventEngine::%p. use_count:%ld. Called from "
-        "[%s:%d]",
-        engine.get(), engine.use_count(), location.file(), location.line());
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "Returning existing EventEngine::" << engine.get()
+        << ". use_count:" << engine.use_count() << ". Called from " << location;
     return engine;
   }
   std::shared_ptr<EventEngine> engine{CreateEventEngine()};
-  GRPC_EVENT_ENGINE_TRACE("Created DefaultEventEngine::%p. Called from [%s:%d]",
-                          engine.get(), location.file(), location.line());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "Created DefaultEventEngine::" << engine.get() << ". Called from "
+      << location;
   *g_event_engine = engine;
   return engine;
 }

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

@@ -23,6 +23,13 @@ const EventEngine::TaskHandle EventEngine::TaskHandle::kInvalid = {-1, -1};
 const EventEngine::ConnectionHandle EventEngine::ConnectionHandle::kInvalid = {
     -1, -1};
 
+namespace detail {
+std::string FormatHandleString(uint64_t key1, uint64_t key2) {
+  return absl::StrCat("{", absl::Hex(key1, absl::kZeroPad16), ",",
+                      absl::Hex(key2, absl::kZeroPad16), "}");
+}
+}  // namespace detail
+
 namespace {
 template <typename T>
 bool eq(const T& lhs, const T& rhs) {
@@ -30,8 +37,7 @@ bool eq(const T& lhs, const T& rhs) {
 }
 template <typename T>
 std::ostream& printout(std::ostream& out, const T& handle) {
-  out << absl::StrCat("{", absl::Hex(handle.keys[0], absl::kZeroPad16), ",",
-                      absl::Hex(handle.keys[1], absl::kZeroPad16), "}");
+  out << detail::FormatHandleString(handle.keys[0], handle.keys[1]);
   return out;
 }
 }  // namespace

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

@@ -18,12 +18,14 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/arena.h"
 
 namespace grpc_core {
 
 template <>
-struct ContextType<grpc_event_engine::experimental::EventEngine> {};
+struct ArenaContextType<grpc_event_engine::experimental::EventEngine> {
+  static void Destroy(grpc_event_engine::experimental::EventEngine*) {}
+};
 
 }  // namespace grpc_core