grpc 1.65.2 → 1.66.0.pre3

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

@@ -18,6 +18,7 @@
 #include "absl/cleanup/cleanup.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -26,7 +27,6 @@
 
 #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/windows/windows_endpoint.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/status_helper.h"
@@ -74,11 +74,12 @@ WindowsEndpoint::WindowsEndpoint(
 
 WindowsEndpoint::~WindowsEndpoint() {
   io_state_->socket->Shutdown(DEBUG_LOCATION, "~WindowsEndpoint");
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("~WindowsEndpoint::%p", this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO) << "~WindowsEndpoint::" << this;
 }
 
 void WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p reading", endpoint);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WindowsEndpoint::" << endpoint << " reading";
   if (socket->IsShutdown()) {
     socket->read_info()->SetErrorStatus(
         absl::InternalError("Socket is shutting down."));
@@ -148,7 +149,8 @@ bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
 
 bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
                             SliceBuffer* data, const WriteArgs* /* args */) {
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p writing", this);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WindowsEndpoint::" << this << " writing";
   if (io_state_->socket->IsShutdown()) {
     io_state_->thread_pool->Run(
         [on_writable = std::move(on_writable)]() mutable {
@@ -279,8 +281,8 @@ void WindowsEndpoint::HandleReadClosure::Run() {
   // Deletes the shared_ptr when this closure returns
   // Note that the endpoint may have already been destroyed.
   auto io_state = std::move(io_state_);
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Read Event",
-                                   io_state->endpoint);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WindowsEndpoint::" << io_state->endpoint << " Handling Read Event";
   const auto result = io_state->socket->read_info()->result();
   if (!result.error_status.ok()) {
     buffer_->Clear();
@@ -340,8 +342,8 @@ void WindowsEndpoint::HandleReadClosure::DonateSpareSlices(
 void WindowsEndpoint::HandleWriteClosure::Run() {
   // Deletes the shared_ptr when this closure returns
   auto io_state = std::move(io_state_);
-  GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p Handling Write Event",
-                                   io_state->endpoint);
+  GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+      << "WindowsEndpoint::" << io_state->endpoint << " Handling Write Event";
   const auto result = io_state->socket->write_info()->result();
   if (!result.error_status.ok()) {
     buffer_->Clear();

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

@@ -36,7 +36,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/event_engine/windows/grpc_polled_fd_windows.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
@@ -190,9 +189,8 @@ struct WindowsEventEngine::TimerClosure final : public EventEngine::Closure {
   EventEngine::TaskHandle handle;
 
   void Run() override {
-    GRPC_EVENT_ENGINE_TRACE(
-        "WindowsEventEngine:%p executing callback:%s", engine,
-        HandleToString<EventEngine::TaskHandle>(handle).c_str());
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "WindowsEventEngine:" << engine << " executing callback:" << handle;
     {
       grpc_core::MutexLock lock(&engine->task_mu_);
       engine->known_handles_.erase(handle);
@@ -214,16 +212,15 @@ WindowsEventEngine::WindowsEventEngine()
 }
 
 WindowsEventEngine::~WindowsEventEngine() {
-  GRPC_EVENT_ENGINE_TRACE("~WindowsEventEngine::%p", this);
+  GRPC_TRACE_LOG(event_engine, INFO) << "~WindowsEventEngine::" << this;
   {
     task_mu_.Lock();
     if (!known_handles_.empty()) {
       if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
         for (auto handle : known_handles_) {
-          gpr_log(GPR_ERROR,
-                  "WindowsEventEngine:%p uncleared TaskHandle at shutdown:%s",
-                  this,
-                  HandleToString<EventEngine::TaskHandle>(handle).c_str());
+          LOG(ERROR) << "WindowsEventEngine:" << this
+                     << " uncleared TaskHandle at shutdown:"
+                     << HandleToString<EventEngine::TaskHandle>(handle);
         }
       }
       // Allow a small grace period for timers to be run before shutting down.
@@ -231,8 +228,8 @@ WindowsEventEngine::~WindowsEventEngine() {
           timer_manager_.Now() + grpc_core::Duration::FromSecondsAsDouble(10);
       while (!known_handles_.empty() && timer_manager_.Now() < deadline) {
         if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
-          GRPC_LOG_EVERY_N_SEC(1, GPR_DEBUG, "Waiting for timers. %d remaining",
-                               known_handles_.size());
+          VLOG_EVERY_N_SEC(2, 1) << "Waiting for timers. "
+                                 << known_handles_.size() << " remaining";
         }
         task_mu_.Unlock();
         absl::SleepFor(absl::Milliseconds(200));
@@ -253,9 +250,8 @@ WindowsEventEngine::~WindowsEventEngine() {
 bool WindowsEventEngine::Cancel(EventEngine::TaskHandle handle) {
   grpc_core::MutexLock lock(&task_mu_);
   if (!known_handles_.contains(handle)) return false;
-  GRPC_EVENT_ENGINE_TRACE(
-      "WindowsEventEngine::%p cancelling %s", this,
-      HandleToString<EventEngine::TaskHandle>(handle).c_str());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "WindowsEventEngine::" << this << " cancelling " << handle;
   auto* cd = reinterpret_cast<TimerClosure*>(handle.keys[0]);
   bool r = timer_manager_.TimerCancel(&cd->timer);
   known_handles_.erase(handle);
@@ -292,9 +288,8 @@ EventEngine::TaskHandle WindowsEventEngine::RunAfterInternal(
   grpc_core::MutexLock lock(&task_mu_);
   known_handles_.insert(handle);
   cd->handle = handle;
-  GRPC_EVENT_ENGINE_TRACE(
-      "WindowsEventEngine:%p scheduling callback:%s", this,
-      HandleToString<EventEngine::TaskHandle>(handle).c_str());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "WindowsEventEngine:" << this << " scheduling callback:" << handle;
   timer_manager_.TimerInit(&cd->timer, when_ts, cd);
   return handle;
 }
@@ -326,21 +321,24 @@ void WindowsEventEngine::WindowsDNSResolver::LookupTXT(
 absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
 WindowsEventEngine::GetDNSResolver(
     EventEngine::DNSResolver::ResolverOptions const& options) {
+  if (ShouldUseAresDnsResolver()) {
 #if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
-  auto ares_resolver = AresResolver::CreateAresResolver(
-      options.dns_server,
-      std::make_unique<GrpcPolledFdFactoryWindows>(poller()),
-      shared_from_this());
-  if (!ares_resolver.ok()) {
-    return ares_resolver.status();
+    GRPC_TRACE_LOG(event_engine_dns, INFO)
+        << "WindowsEventEngine::" << this << " creating AresResolver";
+    auto ares_resolver = AresResolver::CreateAresResolver(
+        options.dns_server,
+        std::make_unique<GrpcPolledFdFactoryWindows>(poller()),
+        shared_from_this());
+    if (!ares_resolver.ok()) {
+      return ares_resolver.status();
+    }
+    return std::make_unique<WindowsEventEngine::WindowsDNSResolver>(
+        std::move(*ares_resolver));
+#endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
   }
-  return std::make_unique<WindowsEventEngine::WindowsDNSResolver>(
-      std::move(*ares_resolver));
-#else   // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
   GRPC_TRACE_LOG(event_engine_dns, INFO)
       << "WindowsEventEngine::" << this << " creating NativeWindowsDNSResolver";
   return std::make_unique<NativeWindowsDNSResolver>(shared_from_this());
-#endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 }
 
 bool WindowsEventEngine::IsWorkerThread() { grpc_core::Crash("unimplemented"); }
@@ -360,8 +358,8 @@ void WindowsEventEngine::OnConnectCompleted(
           known_connection_handles_.erase(state->connection_handle());
     }
     if (erased_handles != 1 || !Cancel(state->timer_handle())) {
-      GRPC_EVENT_ENGINE_TRACE(
-          "%s", "Not accepting connection since the deadline timer has fired");
+      GRPC_TRACE_LOG(event_engine, INFO)
+          << "Not accepting connection since the deadline timer has fired";
       return;
     }
     // Release refs held by the deadline timer.
@@ -413,8 +411,8 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     });
     return EventEngine::ConnectionHandle::kInvalid;
   }
-  GRPC_EVENT_ENGINE_TRACE("EventEngine::%p connecting to %s", this,
-                          uri->c_str());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "EventEngine::" << this << " connecting to " << *uri;
   // Use dualstack sockets where available.
   ResolvedAddress address = addr;
   ResolvedAddress addr6_v4mapped;
@@ -540,17 +538,16 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
 
 bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
   if (handle == EventEngine::ConnectionHandle::kInvalid) {
-    GRPC_EVENT_ENGINE_TRACE("%s",
-                            "Attempted to cancel an invalid connection handle");
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "Attempted to cancel an invalid connection handle";
     return false;
   }
   // Erase the connection handle, which may be unknown
   {
     grpc_core::MutexLock lock(&connection_mu_);
     if (known_connection_handles_.erase(handle) != 1) {
-      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;
     }
   }
@@ -581,10 +578,8 @@ bool WindowsEventEngine::CancelConnectInternalStateLocked(
     ConnectionState* connection_state) {
   connection_state->socket()->Shutdown(DEBUG_LOCATION, "CancelConnect");
   // Release the connection_state shared_ptr owned by the connected callback.
-  GRPC_EVENT_ENGINE_TRACE("Successfully cancelled connection %s",
-                          HandleToString<EventEngine::ConnectionHandle>(
-                              connection_state->connection_handle())
-                              .c_str());
+  GRPC_TRACE_LOG(event_engine, INFO) << "Successfully cancelled connection "
+                                     << connection_state->connection_handle();
   return true;
 }
 

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

@@ -21,7 +21,6 @@
 #include "absl/strings/str_format.h"
 
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
@@ -52,10 +51,9 @@ void WindowsEventEngineListener::SinglePortSocketListener::
   CHECK_NE(io_state_, nullptr);
   grpc_core::ReleasableMutexLock lock(&io_state_->mu);
   if (io_state_->listener_socket->IsShutdown()) {
-    GRPC_EVENT_ENGINE_TRACE(
-        "SinglePortSocketListener::%p listener socket is shut down. Shutting "
-        "down listener.",
-        io_state_->port_listener);
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "SinglePortSocketListener::" << io_state_->port_listener
+        << " listener socket is shut down. Shutting down listener.";
     lock.Release();
     io_state_.reset();
     return;
@@ -103,7 +101,7 @@ WindowsEventEngineListener::SinglePortSocketListener::
   io_state_->listener_socket->Shutdown(DEBUG_LOCATION,
                                        "~SinglePortSocketListener");
   UnlinkIfUnixDomainSocket(listener_sockname());
-  GRPC_EVENT_ENGINE_TRACE("~SinglePortSocketListener::%p", this);
+  GRPC_TRACE_LOG(event_engine, INFO) << "~SinglePortSocketListener::" << this;
 }
 
 absl::StatusOr<
@@ -179,9 +177,9 @@ WindowsEventEngineListener::SinglePortSocketListener::StartLocked() {
     }
   }
   io_state_->accept_socket = accept_socket;
-  GRPC_EVENT_ENGINE_TRACE(
-      "SinglePortSocketListener::%p listening. listener_socket::%p", this,
-      io_state_->listener_socket.get());
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "SinglePortSocketListener::" << this
+      << " listening. listener_socket::" << io_state_->listener_socket.get();
   return absl::OkStatus();
 }
 
@@ -311,8 +309,7 @@ WindowsEventEngineListener::WindowsEventEngineListener(
       on_shutdown_(std::move(on_shutdown)) {}
 
 WindowsEventEngineListener::~WindowsEventEngineListener() {
-  GRPC_EVENT_ENGINE_TRACE(
-      "%s", absl::StrFormat("~WindowsEventEngineListener::%p", this).c_str());
+  GRPC_TRACE_LOG(event_engine, INFO) << "~WindowsEventEngineListener::" << this;
   ShutdownListeners();
   on_shutdown_(absl::OkStatus());
 }

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

@@ -30,7 +30,6 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/config/config_vars.h"
@@ -138,8 +137,7 @@ GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariableInner() {
     // If not found log an error, but don't take any other action.
     // Allows us an easy path to disabling experiments.
     if (!found) {
-      gpr_log(GPR_ERROR, "Unknown experiment: %s",
-              std::string(experiment).c_str());
+      LOG(ERROR) << "Unknown experiment: " << experiment;
     }
   }
   for (size_t i = 0; i < kNumExperiments; i++) {
@@ -172,6 +170,7 @@ Experiments& ExperimentsSingleton() {
 }  // namespace
 
 void TestOnlyReloadExperimentsFromConfigVariables() {
+  ExperimentFlags::TestOnlyClear();
   ExperimentsSingleton() = LoadExperimentsFromConfigVariable();
   PrintExperimentsList();
 }
@@ -182,8 +181,35 @@ void LoadTestOnlyExperimentsFromMetadata(
       new TestExperiments(experiment_metadata, num_experiments);
 }
 
-bool IsExperimentEnabled(size_t experiment_id) {
-  return ExperimentsSingleton().enabled[experiment_id];
+std::atomic<uint64_t>
+    ExperimentFlags::experiment_flags_[kNumExperimentFlagsWords];
+
+bool ExperimentFlags::LoadFlagsAndCheck(size_t experiment_id) {
+  static_assert(kNumExperiments < kNumExperimentFlagsWords * kFlagsPerWord,
+                "kNumExperiments must be less than "
+                "kNumExperimentFlagsWords*kFlagsPerWord; if this fails then "
+                "make kNumExperimentFlagsWords bigger.");
+  const auto& experiments = ExperimentsSingleton();
+  uint64_t building[kNumExperimentFlagsWords];
+  for (size_t i = 0; i < kNumExperimentFlagsWords; i++) {
+    building[i] = kLoadedFlag;
+  }
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    if (!experiments.enabled[i]) continue;
+    auto bit = i % kFlagsPerWord;
+    auto word = i / kFlagsPerWord;
+    building[word] |= 1ull << bit;
+  }
+  for (size_t i = 0; i < kNumExperimentFlagsWords; i++) {
+    experiment_flags_[i].store(building[i], std::memory_order_relaxed);
+  }
+  return experiments.enabled[experiment_id];
+}
+
+void ExperimentFlags::TestOnlyClear() {
+  for (size_t i = 0; i < kNumExperimentFlagsWords; i++) {
+    experiment_flags_[i].store(0, std::memory_order_relaxed);
+  }
 }
 
 bool IsExperimentEnabledInConfiguration(size_t experiment_id) {
@@ -258,8 +284,8 @@ void ForceEnableExperiment(absl::string_view experiment, bool enable) {
     }
     return;
   }
-  gpr_log(GPR_INFO, "gRPC EXPERIMENT %s not found to force %s",
-          std::string(experiment).c_str(), enable ? "enable" : "disable");
+  LOG(INFO) << "gRPC EXPERIMENT " << experiment << " not found to force "
+            << (enable ? "enable" : "disable");
 }
 
 void RegisterExperimentConstraintsValidator(

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

@@ -18,6 +18,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <atomic>
+
 #include "absl/functional/any_invocable.h"
 #include "absl/strings/string_view.h"
 
@@ -38,16 +40,68 @@ struct ExperimentMetadata {
 };
 
 #ifndef GRPC_EXPERIMENTS_ARE_FINAL
+class ExperimentFlags {
+ public:
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsExperimentEnabled(
+      size_t experiment_id) {
+    auto bit = experiment_id % kFlagsPerWord;
+    auto word = experiment_id / kFlagsPerWord;
+    auto cur = experiment_flags_[word].load(std::memory_order_relaxed);
+    if (cur & (1ull << bit)) return true;
+    if (cur & kLoadedFlag) return false;
+    return LoadFlagsAndCheck(experiment_id);
+  }
+
+  template <size_t kExperimentId>
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsExperimentEnabled() {
+    auto bit = kExperimentId % kFlagsPerWord;
+    auto word = kExperimentId / kFlagsPerWord;
+    auto cur = experiment_flags_[word].load(std::memory_order_relaxed);
+    if (cur & (1ull << bit)) return true;
+    if (cur & kLoadedFlag) return false;
+    return LoadFlagsAndCheck(kExperimentId);
+  }
+
+  static void TestOnlyClear();
+
+ private:
+  static bool LoadFlagsAndCheck(size_t experiment_id);
+
+  // We layout experiment flags in groups of 63... each 64 bit word contains
+  // 63 enablement flags (one per experiment), and the high bit which indicates
+  // whether the flags have been loaded from the configuration.
+  // Consequently, with one load, we can tell if the experiment is definitely
+  // enabled (the bit is set), or definitely disabled (the bit is clear, and the
+  // loaded flag is set), or if we need to load the flags and re-check.
+
+  static constexpr size_t kNumExperimentFlagsWords = 8;
+  static constexpr size_t kFlagsPerWord = 63;
+  static constexpr uint64_t kLoadedFlag = 0x8000000000000000ull;
+  static std::atomic<uint64_t> experiment_flags_[kNumExperimentFlagsWords];
+};
+
 // Return true if experiment \a experiment_id is enabled.
 // Experiments are numbered by their order in the g_experiment_metadata array
 // declared in experiments.h.
-bool IsExperimentEnabled(size_t experiment_id);
+inline bool IsExperimentEnabled(size_t experiment_id) {
+  return ExperimentFlags::IsExperimentEnabled(experiment_id);
+}
+
+template <size_t kExperimentId>
+inline bool IsExperimentEnabled() {
+  return ExperimentFlags::IsExperimentEnabled<kExperimentId>();
+}
 
 // Given a test experiment id, returns true if the test experiment is enabled.
 // Test experiments can be loaded using the LoadTestOnlyExperimentsFromMetadata
 // method.
 bool IsTestExperimentEnabled(size_t experiment_id);
 
+template <size_t kExperimentId>
+inline bool IsTestExperimentEnabled() {
+  return IsTestExperimentEnabled(kExperimentId);
+}
+
 // Slow check for if a named experiment is enabled.
 // Parses the configuration and looks up the experiment in that, so it does not
 // affect any global state, but it does require parsing the configuration every

data/src/core/lib/experiments/experiments.cc

@@ -27,6 +27,9 @@ const char* const description_call_status_override_on_cancellation =
     "with cancellation.";
 const char* const additional_constraints_call_status_override_on_cancellation =
     "{}";
+const char* const description_call_tracer_in_transport =
+    "Transport directly passes byte counts to CallTracer.";
+const char* const additional_constraints_call_tracer_in_transport = "{}";
 const char* const description_canary_client_privacy =
     "If set, canary client privacy";
 const char* const additional_constraints_canary_client_privacy = "{}";
@@ -44,17 +47,6 @@ const char* const additional_constraints_event_engine_listener = "{}";
 const char* const description_free_large_allocator =
     "If set, return all free bytes from a \042big\042 allocator";
 const char* const additional_constraints_free_large_allocator = "{}";
-const char* const description_http2_stats_fix =
-    "Fix on HTTP2 outgoing data stats reporting";
-const char* const additional_constraints_http2_stats_fix = "{}";
-const char* const description_keepalive_fix =
-    "Allows overriding keepalive_permit_without_calls. Refer "
-    "https://github.com/grpc/grpc/pull/33428 for more information.";
-const char* const additional_constraints_keepalive_fix = "{}";
-const char* const description_keepalive_server_fix =
-    "Allows overriding keepalive_permit_without_calls for servers. Refer "
-    "https://github.com/grpc/grpc/pull/33917 for more information.";
-const char* const additional_constraints_keepalive_server_fix = "{}";
 const char* const description_max_pings_wo_data_throttle =
     "Experiment to throttle pings to a period of 1 min when "
     "GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA limit has reached (instead of "
@@ -121,6 +113,8 @@ const ExperimentMetadata g_experiment_metadata[] = {
      description_call_status_override_on_cancellation,
      additional_constraints_call_status_override_on_cancellation, nullptr, 0,
      true, true},
+    {"call_tracer_in_transport", description_call_tracer_in_transport,
+     additional_constraints_call_tracer_in_transport, nullptr, 0, true, true},
     {"canary_client_privacy", description_canary_client_privacy,
      additional_constraints_canary_client_privacy, nullptr, 0, false, false},
     {"client_privacy", description_client_privacy,
@@ -133,12 +127,6 @@ const ExperimentMetadata g_experiment_metadata[] = {
      additional_constraints_event_engine_listener, nullptr, 0, false, true},
     {"free_large_allocator", description_free_large_allocator,
      additional_constraints_free_large_allocator, nullptr, 0, false, true},
-    {"http2_stats_fix", description_http2_stats_fix,
-     additional_constraints_http2_stats_fix, nullptr, 0, true, true},
-    {"keepalive_fix", description_keepalive_fix,
-     additional_constraints_keepalive_fix, nullptr, 0, false, false},
-    {"keepalive_server_fix", description_keepalive_server_fix,
-     additional_constraints_keepalive_server_fix, nullptr, 0, false, false},
     {"max_pings_wo_data_throttle", description_max_pings_wo_data_throttle,
      additional_constraints_max_pings_wo_data_throttle, nullptr, 0, false,
      true},
@@ -189,6 +177,9 @@ const char* const description_call_status_override_on_cancellation =
     "with cancellation.";
 const char* const additional_constraints_call_status_override_on_cancellation =
     "{}";
+const char* const description_call_tracer_in_transport =
+    "Transport directly passes byte counts to CallTracer.";
+const char* const additional_constraints_call_tracer_in_transport = "{}";
 const char* const description_canary_client_privacy =
     "If set, canary client privacy";
 const char* const additional_constraints_canary_client_privacy = "{}";
@@ -206,17 +197,6 @@ const char* const additional_constraints_event_engine_listener = "{}";
 const char* const description_free_large_allocator =
     "If set, return all free bytes from a \042big\042 allocator";
 const char* const additional_constraints_free_large_allocator = "{}";
-const char* const description_http2_stats_fix =
-    "Fix on HTTP2 outgoing data stats reporting";
-const char* const additional_constraints_http2_stats_fix = "{}";
-const char* const description_keepalive_fix =
-    "Allows overriding keepalive_permit_without_calls. Refer "
-    "https://github.com/grpc/grpc/pull/33428 for more information.";
-const char* const additional_constraints_keepalive_fix = "{}";
-const char* const description_keepalive_server_fix =
-    "Allows overriding keepalive_permit_without_calls for servers. Refer "
-    "https://github.com/grpc/grpc/pull/33917 for more information.";
-const char* const additional_constraints_keepalive_server_fix = "{}";
 const char* const description_max_pings_wo_data_throttle =
     "Experiment to throttle pings to a period of 1 min when "
     "GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA limit has reached (instead of "
@@ -283,6 +263,8 @@ const ExperimentMetadata g_experiment_metadata[] = {
      description_call_status_override_on_cancellation,
      additional_constraints_call_status_override_on_cancellation, nullptr, 0,
      true, true},
+    {"call_tracer_in_transport", description_call_tracer_in_transport,
+     additional_constraints_call_tracer_in_transport, nullptr, 0, true, true},
     {"canary_client_privacy", description_canary_client_privacy,
      additional_constraints_canary_client_privacy, nullptr, 0, false, false},
     {"client_privacy", description_client_privacy,
@@ -295,12 +277,6 @@ const ExperimentMetadata g_experiment_metadata[] = {
      additional_constraints_event_engine_listener, nullptr, 0, true, true},
     {"free_large_allocator", description_free_large_allocator,
      additional_constraints_free_large_allocator, nullptr, 0, false, true},
-    {"http2_stats_fix", description_http2_stats_fix,
-     additional_constraints_http2_stats_fix, nullptr, 0, true, true},
-    {"keepalive_fix", description_keepalive_fix,
-     additional_constraints_keepalive_fix, nullptr, 0, false, false},
-    {"keepalive_server_fix", description_keepalive_server_fix,
-     additional_constraints_keepalive_server_fix, nullptr, 0, false, false},
     {"max_pings_wo_data_throttle", description_max_pings_wo_data_throttle,
      additional_constraints_max_pings_wo_data_throttle, nullptr, 0, false,
      true},
@@ -351,6 +327,9 @@ const char* const description_call_status_override_on_cancellation =
     "with cancellation.";
 const char* const additional_constraints_call_status_override_on_cancellation =
     "{}";
+const char* const description_call_tracer_in_transport =
+    "Transport directly passes byte counts to CallTracer.";
+const char* const additional_constraints_call_tracer_in_transport = "{}";
 const char* const description_canary_client_privacy =
     "If set, canary client privacy";
 const char* const additional_constraints_canary_client_privacy = "{}";
@@ -368,17 +347,6 @@ const char* const additional_constraints_event_engine_listener = "{}";
 const char* const description_free_large_allocator =
     "If set, return all free bytes from a \042big\042 allocator";
 const char* const additional_constraints_free_large_allocator = "{}";
-const char* const description_http2_stats_fix =
-    "Fix on HTTP2 outgoing data stats reporting";
-const char* const additional_constraints_http2_stats_fix = "{}";
-const char* const description_keepalive_fix =
-    "Allows overriding keepalive_permit_without_calls. Refer "
-    "https://github.com/grpc/grpc/pull/33428 for more information.";
-const char* const additional_constraints_keepalive_fix = "{}";
-const char* const description_keepalive_server_fix =
-    "Allows overriding keepalive_permit_without_calls for servers. Refer "
-    "https://github.com/grpc/grpc/pull/33917 for more information.";
-const char* const additional_constraints_keepalive_server_fix = "{}";
 const char* const description_max_pings_wo_data_throttle =
     "Experiment to throttle pings to a period of 1 min when "
     "GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA limit has reached (instead of "
@@ -445,6 +413,8 @@ const ExperimentMetadata g_experiment_metadata[] = {
      description_call_status_override_on_cancellation,
      additional_constraints_call_status_override_on_cancellation, nullptr, 0,
      true, true},
+    {"call_tracer_in_transport", description_call_tracer_in_transport,
+     additional_constraints_call_tracer_in_transport, nullptr, 0, true, true},
     {"canary_client_privacy", description_canary_client_privacy,
      additional_constraints_canary_client_privacy, nullptr, 0, false, false},
     {"client_privacy", description_client_privacy,
@@ -457,12 +427,6 @@ const ExperimentMetadata g_experiment_metadata[] = {
      additional_constraints_event_engine_listener, nullptr, 0, true, true},
     {"free_large_allocator", description_free_large_allocator,
      additional_constraints_free_large_allocator, nullptr, 0, false, true},
-    {"http2_stats_fix", description_http2_stats_fix,
-     additional_constraints_http2_stats_fix, nullptr, 0, true, true},
-    {"keepalive_fix", description_keepalive_fix,
-     additional_constraints_keepalive_fix, nullptr, 0, false, false},
-    {"keepalive_server_fix", description_keepalive_server_fix,
-     additional_constraints_keepalive_server_fix, nullptr, 0, false, false},
     {"max_pings_wo_data_throttle", description_max_pings_wo_data_throttle,
      additional_constraints_max_pings_wo_data_throttle, nullptr, 0, false,
      true},