grpc 1.64.0 → 1.65.0.pre1

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

@@ -0,0 +1,133 @@
+// Copyright 2024 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.
+
+//
+// Automatically generated by tools/codegen/core/gen_trace_flags.py
+//
+
+#ifndef GRPC_SRC_CORE_LIB_DEBUG_TRACE_FLAGS_H
+#define GRPC_SRC_CORE_LIB_DEBUG_TRACE_FLAGS_H
+
+#include "src/core/lib/debug/trace_impl.h"
+
+namespace grpc_core {
+
+extern DebugOnlyTraceFlag auth_context_refcount_trace;
+extern DebugOnlyTraceFlag call_combiner_trace;
+extern DebugOnlyTraceFlag call_refcount_trace;
+extern DebugOnlyTraceFlag closure_trace;
+extern DebugOnlyTraceFlag combiner_trace;
+extern DebugOnlyTraceFlag cq_refcount_trace;
+extern DebugOnlyTraceFlag error_refcount_trace;
+extern DebugOnlyTraceFlag fd_refcount_trace;
+extern DebugOnlyTraceFlag fd_trace_trace;
+extern DebugOnlyTraceFlag lb_policy_refcount_trace;
+extern DebugOnlyTraceFlag party_state_trace;
+extern DebugOnlyTraceFlag pending_tags_trace;
+extern DebugOnlyTraceFlag polling_trace;
+extern DebugOnlyTraceFlag polling_api_trace;
+extern DebugOnlyTraceFlag promise_primitives_trace;
+extern DebugOnlyTraceFlag resolver_refcount_trace;
+extern DebugOnlyTraceFlag security_connector_refcount_trace;
+extern DebugOnlyTraceFlag slice_refcount_trace;
+extern DebugOnlyTraceFlag stream_refcount_trace;
+extern DebugOnlyTraceFlag subchannel_refcount_trace;
+extern DebugOnlyTraceFlag work_serializer_trace;
+extern TraceFlag api_trace;
+extern TraceFlag apple_polling_trace;
+extern TraceFlag backend_metric_trace;
+extern TraceFlag backend_metric_filter_trace;
+extern TraceFlag bdp_estimator_trace;
+extern TraceFlag call_trace;
+extern TraceFlag call_error_trace;
+extern TraceFlag cares_address_sorting_trace;
+extern TraceFlag cares_resolver_trace;
+extern TraceFlag cds_lb_trace;
+extern TraceFlag channel_trace;
+extern TraceFlag channel_stack_trace;
+extern TraceFlag chaotic_good_trace;
+extern TraceFlag chttp2_hpack_parser_trace;
+extern TraceFlag chttp2_new_stream_trace;
+extern TraceFlag client_channel_trace;
+extern TraceFlag client_channel_call_trace;
+extern TraceFlag client_channel_lb_call_trace;
+extern TraceFlag client_idle_filter_trace;
+extern TraceFlag compression_trace;
+extern TraceFlag connectivity_state_trace;
+extern TraceFlag cronet_trace;
+extern TraceFlag dns_resolver_trace;
+extern TraceFlag environment_autodetect_trace;
+extern TraceFlag event_engine_trace;
+extern TraceFlag event_engine_client_channel_resolver_trace;
+extern TraceFlag event_engine_dns_trace;
+extern TraceFlag event_engine_endpoint_trace;
+extern TraceFlag event_engine_endpoint_data_trace;
+extern TraceFlag event_engine_poller_trace;
+extern TraceFlag executor_trace;
+extern TraceFlag fault_injection_filter_trace;
+extern TraceFlag flowctl_trace;
+extern TraceFlag fork_trace;
+extern TraceFlag fuzzing_ee_timers_trace;
+extern TraceFlag fuzzing_ee_writes_trace;
+extern TraceFlag glb_trace;
+extern TraceFlag grpc_authz_api_trace;
+extern TraceFlag handshaker_trace;
+extern TraceFlag health_check_client_trace;
+extern TraceFlag http_trace;
+extern TraceFlag http1_trace;
+extern TraceFlag http2_ping_trace;
+extern TraceFlag http2_stream_state_trace;
+extern TraceFlag http_keepalive_trace;
+extern TraceFlag inproc_trace;
+extern TraceFlag metadata_query_trace;
+extern TraceFlag op_failure_trace;
+extern TraceFlag orca_client_trace;
+extern TraceFlag outlier_detection_lb_trace;
+extern TraceFlag pick_first_trace;
+extern TraceFlag plugin_credentials_trace;
+extern TraceFlag priority_lb_trace;
+extern TraceFlag queue_pluck_trace;
+extern TraceFlag resource_quota_trace;
+extern TraceFlag retry_trace;
+extern TraceFlag ring_hash_lb_trace;
+extern TraceFlag rls_lb_trace;
+extern TraceFlag round_robin_trace;
+extern TraceFlag secure_endpoint_trace;
+extern TraceFlag server_channel_trace;
+extern TraceFlag stateful_session_filter_trace;
+extern TraceFlag subchannel_trace;
+extern TraceFlag subchannel_pool_trace;
+extern TraceFlag tcp_trace;
+extern TraceFlag timer_trace;
+extern TraceFlag timer_check_trace;
+extern TraceFlag tsi_trace;
+extern TraceFlag weighted_round_robin_lb_trace;
+extern TraceFlag weighted_target_lb_trace;
+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_wrr_locality_lb_trace;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_DEBUG_TRACE_FLAGS_H

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

@@ -0,0 +1,115 @@
+// 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>
+
+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

@@ -53,6 +53,7 @@
 #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"
@@ -80,8 +81,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) {
@@ -200,7 +199,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)));
@@ -221,8 +220,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)) {
@@ -767,9 +765,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.

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

@@ -46,11 +46,9 @@
 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)) {                   \
+    if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {                             \
       gpr_log(GPR_INFO, "(EventEngine c-ares resolver) " format, __VA_ARGS__); \
     }                                                                          \
   } while (0)

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

@@ -63,7 +63,7 @@ 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,

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

@@ -35,11 +35,9 @@ namespace experimental {
 void DNSServiceResolverImpl::LookupHostname(
     EventEngine::DNSResolver::LookupHostnameCallback on_resolve,
     absl::string_view name, absl::string_view default_port) {
-  GRPC_EVENT_ENGINE_DNS_TRACE(
-      "DNSServiceResolverImpl::LookupHostname: name: %.*s, default_port: %.*s, "
-      "this: %p",
-      static_cast<int>(name.length()), name.data(),
-      static_cast<int>(default_port.length()), default_port.data(), this);
+  GRPC_TRACE_LOG(event_engine_dns, INFO)
+      << "DNSServiceResolverImpl::LookupHostname: name: " << name
+      << ", default_port: " << default_port << ", this: " << this;
 
   absl::string_view host;
   absl::string_view port_string;
@@ -139,13 +137,12 @@ void DNSServiceResolverImpl::ResolveCallback(
     DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t interfaceIndex,
     DNSServiceErrorType errorCode, const char* hostname,
     const struct sockaddr* address, uint32_t ttl, void* context) {
-  GRPC_EVENT_ENGINE_DNS_TRACE(
-      "DNSServiceResolverImpl::ResolveCallback: sdRef: %p, flags: %x, "
-      "interface: %d, errorCode: %d, hostname: %s, addressFamily: %d, ttl: "
-      "%d, "
-      "this: %p",
-      sdRef, flags, interfaceIndex, errorCode, hostname, address->sa_family,
-      ttl, context);
+  GRPC_TRACE_LOG(event_engine_dns, INFO)
+      << "DNSServiceResolverImpl::ResolveCallback: sdRef: " << sdRef
+      << ", flags: " << flags << ", interface: " << interfaceIndex
+      << ", errorCode: " << errorCode << ", hostname: " << hostname
+      << ", addressFamily: " << address->sa_family << ", ttl: " << ttl
+      << ", this: " << context;
 
   // no need to increase refcount here, since ResolveCallback and Shutdown is
   // called from the serial queue and it is guarenteed that it won't be called
@@ -195,12 +192,11 @@ void DNSServiceResolverImpl::ResolveCallback(
           ->sin6_port = htons(request.port);
     }
 
-    GRPC_EVENT_ENGINE_DNS_TRACE(
-        "DNSServiceResolverImpl::ResolveCallback: "
-        "sdRef: %p, hostname: %s, addressPort: %s, this: %p",
-        sdRef, hostname,
-        ResolvedAddressToString(resolved_address).value_or("ERROR").c_str(),
-        context);
+    GRPC_TRACE_LOG(event_engine_dns, INFO)
+        << "DNSServiceResolverImpl::ResolveCallback: sdRef: " << sdRef
+        << ", hostname: " << hostname << ", addressPort: "
+        << ResolvedAddressToString(resolved_address).value_or("ERROR")
+        << ", this: " << context;
   }
 
   // received both ipv4 and ipv6 responses, and no more responses (e.g. multiple
@@ -231,10 +227,9 @@ void DNSServiceResolverImpl::Shutdown() {
     for (auto& kv : that->requests_) {
       auto& sdRef = kv.first;
       auto& request = kv.second;
-      GRPC_EVENT_ENGINE_DNS_TRACE(
-          "DNSServiceResolverImpl::Shutdown sdRef: %p, this: %p", sdRef,
-          thatPtr);
-
+      GRPC_TRACE_LOG(event_engine_dns, INFO)
+          << "DNSServiceResolverImpl::Shutdown sdRef: " << sdRef
+          << ", this: " << thatPtr;
       request.on_resolve(
           absl::CancelledError("DNSServiceResolverImpl::Shutdown"));
       DNSServiceRefDeallocate(static_cast<DNSServiceRef>(sdRef));

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

@@ -11,6 +11,8 @@
 // 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 "absl/strings/str_cat.h"
+
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 
@@ -21,24 +23,47 @@ const EventEngine::TaskHandle EventEngine::TaskHandle::kInvalid = {-1, -1};
 const EventEngine::ConnectionHandle EventEngine::ConnectionHandle::kInvalid = {
     -1, -1};
 
+namespace {
+template <typename T>
+bool eq(const T& lhs, const T& rhs) {
+  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
+}
+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), "}");
+  return out;
+}
+}  // namespace
+
 bool operator==(const EventEngine::TaskHandle& lhs,
                 const EventEngine::TaskHandle& rhs) {
-  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
+  return eq(lhs, rhs);
 }
 
 bool operator!=(const EventEngine::TaskHandle& lhs,
                 const EventEngine::TaskHandle& rhs) {
-  return !(lhs == rhs);
+  return !eq(lhs, rhs);
+}
+
+std::ostream& operator<<(std::ostream& out,
+                         const EventEngine::TaskHandle& handle) {
+  return printout(out, handle);
 }
 
 bool operator==(const EventEngine::ConnectionHandle& lhs,
                 const EventEngine::ConnectionHandle& rhs) {
-  return lhs.keys[0] == rhs.keys[0] && lhs.keys[1] == rhs.keys[1];
+  return eq(lhs, rhs);
 }
 
 bool operator!=(const EventEngine::ConnectionHandle& lhs,
                 const EventEngine::ConnectionHandle& rhs) {
-  return !(lhs == rhs);
+  return !eq(lhs, rhs);
+}
+
+std::ostream& operator<<(std::ostream& out,
+                         const EventEngine::ConnectionHandle& handle) {
+  return printout(out, handle);
 }
 
 }  // namespace experimental

data/src/core/lib/event_engine/extensions/supports_fd.h

@@ -112,6 +112,13 @@ class EventEngineSupportsFdExtension {
       int fd, const EndpointConfig& config,
       MemoryAllocator memory_allocator) = 0;
 
+  /// Creates an EventEngine::Endpoint from an fd which is already assumed to be
+  /// connected to a remote peer. See \a CreatePosixEndpointFromFd for details.
+  /// This has the same behavior, but the \a memory_allocator is taken from the
+  /// EndpointConfig's resource quota.
+  virtual std::unique_ptr<EventEngine::Endpoint> CreateEndpointFromFd(
+      int fd, const EndpointConfig& config) = 0;
+
   /// Called when the posix listener has accepted a new client connection.
   /// \a listener_fd - The listening socket fd that accepted the new client
   /// connection.

data/src/core/lib/event_engine/extensions/tcp_trace.h

@@ -0,0 +1,43 @@
+// Copyright 2024 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_EVENT_ENGINE_EXTENSIONS_TCP_TRACE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_TCP_TRACE_H
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/telemetry/tcp_tracer.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/** If non-zero, enable TCP tracing and stats collection. */
+#define GRPC_ARG_TCP_TRACING_ENABLED "grpc.tcp_tracing_enabled"
+
+class TcpTraceExtension {
+ public:
+  virtual ~TcpTraceExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.tcp_trace";
+  }
+  virtual std::shared_ptr<grpc_core::TcpTracerInterface>
+  InitializeAndReturnTcpTracer() = 0;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_TCP_TRACE_H

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

@@ -28,12 +28,11 @@
 #include <vector>
 
 #include "src/core/lib/config/config_vars.h"
+#include "src/core/lib/debug/trace.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-grpc_core::TraceFlag grpc_trace_fork(false, "fork");
-
 namespace {
 bool IsForkEnabled() {
   static bool enabled = grpc_core::ConfigVars::Get().EnableForkSupport();
@@ -58,7 +57,7 @@ void ObjectGroupForkHandler::RegisterForkable(
 void ObjectGroupForkHandler::Prefork() {
   if (IsForkEnabled()) {
     CHECK(!std::exchange(is_forking_, true));
-    GRPC_FORK_TRACE_LOG_STRING("PrepareFork");
+    GRPC_TRACE_LOG(fork, INFO) << "PrepareFork";
     for (auto it = forkables_.begin(); it != forkables_.end();) {
       auto shared = it->lock();
       if (shared) {
@@ -74,7 +73,7 @@ void ObjectGroupForkHandler::Prefork() {
 void ObjectGroupForkHandler::PostforkParent() {
   if (IsForkEnabled()) {
     CHECK(is_forking_);
-    GRPC_FORK_TRACE_LOG_STRING("PostforkParent");
+    GRPC_TRACE_LOG(fork, INFO) << "PostforkParent";
     for (auto it = forkables_.begin(); it != forkables_.end();) {
       auto shared = it->lock();
       if (shared) {
@@ -91,7 +90,7 @@ void ObjectGroupForkHandler::PostforkParent() {
 void ObjectGroupForkHandler::PostforkChild() {
   if (IsForkEnabled()) {
     CHECK(is_forking_);
-    GRPC_FORK_TRACE_LOG_STRING("PostforkChild");
+    GRPC_TRACE_LOG(fork, INFO) << "PostforkChild";
     for (auto it = forkables_.begin(); it != forkables_.end();) {
       auto shared = it->lock();
       if (shared) {

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

@@ -25,17 +25,6 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-extern grpc_core::TraceFlag grpc_trace_fork;
-
-#define GRPC_FORK_TRACE_LOG(format, ...)                 \
-  do {                                                   \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fork)) {      \
-      gpr_log(GPR_DEBUG, "[fork] " format, __VA_ARGS__); \
-    }                                                    \
-  } while (0)
-
-#define GRPC_FORK_TRACE_LOG_STRING(format) GRPC_FORK_TRACE_LOG("%s", format)
-
 // An interface to be implemented by EventEngines that wish to have managed fork
 // support. The child class must guarantee that those methods are thread-safe.
 class Forkable {

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

@@ -19,13 +19,13 @@
 #include <memory>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 
 #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>
 
@@ -164,14 +164,14 @@ int EpollCreateAndCloexec() {
 #ifdef GRPC_LINUX_EPOLL_CREATE1
   int fd = epoll_create1(EPOLL_CLOEXEC);
   if (fd < 0) {
-    gpr_log(GPR_ERROR, "epoll_create1 unavailable");
+    LOG(ERROR) << "epoll_create1 unavailable";
   }
 #else
   int fd = epoll_create(MAX_EPOLL_EVENTS);
   if (fd < 0) {
-    gpr_log(GPR_ERROR, "epoll_create unavailable");
+    LOG(ERROR) << "epoll_create unavailable";
   } else if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) {
-    gpr_log(GPR_ERROR, "fcntl following epoll_create failed");
+    LOG(ERROR) << "fcntl following epoll_create failed";
     return -1;
   }
 #endif
@@ -297,8 +297,8 @@ void Epoll1EventHandle::OrphanHandle(PosixEngineClosure* on_done,
       epoll_event phony_event;
       if (epoll_ctl(poller_->g_epoll_set_.epfd, EPOLL_CTL_DEL, fd_,
                     &phony_event) != 0) {
-        gpr_log(GPR_ERROR, "OrphanHandle: epoll_ctl failed: %s",
-                grpc_core::StrError(errno).c_str());
+        LOG(ERROR) << "OrphanHandle: epoll_ctl failed: "
+                   << grpc_core::StrError(errno);
       }
     }
     *release_fd = fd_;
@@ -341,8 +341,8 @@ void Epoll1EventHandle::HandleShutdownInternal(absl::Status why,
       epoll_event phony_event;
       if (epoll_ctl(poller_->g_epoll_set_.epfd, EPOLL_CTL_DEL, fd_,
                     &phony_event) != 0) {
-        gpr_log(GPR_ERROR, "HandleShutdownInternal: epoll_ctl failed: %s",
-                grpc_core::StrError(errno).c_str());
+        LOG(ERROR) << "HandleShutdownInternal: epoll_ctl failed: "
+                   << grpc_core::StrError(errno);
       }
     }
     write_closure_->SetShutdown(why);
@@ -356,7 +356,7 @@ Epoll1Poller::Epoll1Poller(Scheduler* scheduler)
   wakeup_fd_ = *CreateWakeupFd();
   CHECK(wakeup_fd_ != nullptr);
   CHECK_GE(g_epoll_set_.epfd, 0);
-  gpr_log(GPR_INFO, "grpc epoll fd: %d", g_epoll_set_.epfd);
+  LOG(INFO) << "grpc epoll fd: " << g_epoll_set_.epfd;
   struct epoll_event ev;
   ev.events = static_cast<uint32_t>(EPOLLIN | EPOLLET);
   ev.data.ptr = wakeup_fd_.get();
@@ -414,8 +414,7 @@ EventHandle* Epoll1Poller::CreateHandle(int fd, absl::string_view /*name*/,
   ev.data.ptr = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(new_handle) |
                                         (track_err ? 1 : 0));
   if (epoll_ctl(g_epoll_set_.epfd, EPOLL_CTL_ADD, fd, &ev) != 0) {
-    gpr_log(GPR_ERROR, "epoll_ctl failed: %s",
-            grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "epoll_ctl failed: " << grpc_core::StrError(errno);
   }
 
   return new_handle;

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

@@ -14,7 +14,8 @@
 
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
 
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
+
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/port.h"
@@ -49,7 +50,7 @@ bool KernelSupportsErrqueue() {
     // least 4.0.0
     struct utsname buffer;
     if (uname(&buffer) != 0) {
-      gpr_log(GPR_ERROR, "uname: %s", grpc_core::StrError(errno).c_str());
+      LOG(ERROR) << "uname: " << grpc_core::StrError(errno);
       return false;
     }
     char* release = buffer.release;
@@ -60,7 +61,7 @@ bool KernelSupportsErrqueue() {
     if (strtol(release, nullptr, 10) >= 4) {
       return true;
     } else {
-      gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
+      VLOG(2) << "ERRQUEUE support not enabled";
     }
 #endif  // GRPC_LINUX_ERRQUEUE
     return false;