grpc 1.72.0 → 1.74.0.pre2

data/src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h

@@ -0,0 +1,223 @@
+// Copyright 2025 The 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_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_ZTRACE_COLLECTOR_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_ZTRACE_COLLECTOR_H
+
+#include <cstdint>
+#include <map>
+#include <string>
+
+#include "src/core/channelz/ztrace_collector.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+
+namespace grpc_core {
+namespace http2_ztrace_collector_detail {
+
+class Config {
+ public:
+  explicit Config(std::map<std::string, std::string>) {}
+
+  template <typename T>
+  bool Finishes(const T&) {
+    return false;
+  }
+};
+
+}  // namespace http2_ztrace_collector_detail
+
+template <bool kRead>
+struct H2DataTrace {
+  uint32_t stream_id;
+  bool end_stream;
+  uint32_t payload_length;
+
+  void RenderJson(Json::Object& json) const {
+    json["read"] = Json::FromBool(kRead);
+    json["frame_type"] = Json::FromString("DATA");
+    json["stream_id"] = Json::FromNumber(stream_id);
+    json["end_stream"] = Json::FromBool(end_stream);
+    json["payload_length"] = Json::FromNumber(payload_length);
+  }
+};
+
+template <bool kRead>
+struct H2HeaderTrace {
+  uint32_t stream_id;
+  bool end_headers;
+  bool end_stream;
+  bool continuation;
+  uint32_t payload_length;
+
+  void RenderJson(Json::Object& json) const {
+    json["read"] = Json::FromBool(kRead);
+    json["frame_type"] = continuation ? Json::FromString("CONTINUATION")
+                                      : Json::FromString("HEADERS");
+    json["stream_id"] = Json::FromNumber(stream_id);
+    json["end_headers"] = Json::FromBool(end_headers);
+    json["end_stream"] = Json::FromBool(end_stream);
+    json["payload_length"] = Json::FromNumber(payload_length);
+  }
+};
+
+template <bool kRead>
+struct H2RstStreamTrace {
+  uint32_t stream_id;
+  uint32_t error_code;
+
+  void RenderJson(Json::Object& json) const {
+    json["read"] = Json::FromBool(kRead);
+    json["frame_type"] = Json::FromString("RST_STREAM");
+    json["stream_id"] = Json::FromNumber(stream_id);
+    json["error_code"] = Json::FromNumber(error_code);
+  }
+};
+
+template <bool kRead>
+struct H2SettingsTrace {
+  bool ack;
+  std::vector<Http2SettingsFrame::Setting> settings;
+
+  void RenderJson(Json::Object& json) const {
+    json["read"] = Json::FromBool(kRead);
+    json["frame_type"] = Json::FromString("SETTINGS");
+    json["ack"] = Json::FromBool(ack);
+    Json::Array settings_array;
+    for (const auto& setting : settings) {
+      Json::Object setting_object;
+      setting_object["id"] = Json::FromNumber(setting.id);
+      setting_object["value"] = Json::FromNumber(setting.value);
+      settings_array.push_back(Json::FromObject(std::move(setting_object)));
+    }
+    json["settings"] = Json::FromArray(std::move(settings_array));
+  }
+};
+
+template <bool kRead>
+struct H2PingTrace {
+  bool ack;
+  uint64_t opaque;
+
+  void RenderJson(Json::Object& json) const {
+    json["read"] = Json::FromBool(kRead);
+    json["frame_type"] = Json::FromString("PING");
+    json["ack"] = Json::FromBool(ack);
+    json["opaque"] = Json::FromNumber(opaque);
+  }
+};
+
+template <bool kRead>
+struct H2GoAwayTrace {
+  uint32_t last_stream_id;
+  uint32_t error_code;
+  std::string debug_data;
+
+  void RenderJson(Json::Object& json) const {
+    json["read"] = Json::FromBool(kRead);
+    json["frame_type"] = Json::FromString("GOAWAY");
+    json["last_stream_id"] = Json::FromNumber(last_stream_id);
+    json["error_code"] = Json::FromNumber(error_code);
+    json["debug_data"] = Json::FromString(debug_data);
+  }
+};
+
+template <bool kRead>
+struct H2WindowUpdateTrace {
+  uint32_t stream_id;
+  uint32_t window_size_increment;
+
+  void RenderJson(Json::Object& json) const {
+    json["read"] = Json::FromBool(kRead);
+    json["frame_type"] = Json::FromString("WINDOW_UPDATE");
+    json["stream_id"] = Json::FromNumber(stream_id);
+    json["window_size_increment"] = Json::FromNumber(window_size_increment);
+  }
+};
+
+template <bool kRead>
+struct H2SecurityTrace {
+  uint32_t payload_length;
+
+  void RenderJson(Json::Object& json) const {
+    json["read"] = Json::FromBool(kRead);
+    json["frame_type"] = Json::FromString("SECURITY");
+    json["payload_length"] = Json::FromNumber(payload_length);
+  }
+};
+
+struct H2UnknownFrameTrace {
+  uint8_t type;
+  uint8_t flags;
+  uint32_t stream_id;
+  uint32_t payload_length;
+
+  void RenderJson(Json::Object& json) const {
+    json["frame_type"] = Json::FromString("UNKNOWN");
+    json["type"] = Json::FromNumber(type);
+    json["flags"] = Json::FromNumber(flags);
+    json["stream_id"] = Json::FromNumber(stream_id);
+    json["payload_length"] = Json::FromNumber(payload_length);
+  }
+};
+
+struct H2FlowControlStall {
+  int64_t transport_window;
+  int64_t stream_window;
+  uint32_t stream_id;
+
+  void RenderJson(Json::Object& json) const {
+    json["metadata_type"] = Json::FromString("FLOW_CONTROL_STALL");
+    json["transport_window"] = Json::FromNumber(transport_window);
+    json["stream_window"] = Json::FromNumber(stream_window);
+    json["stream_id"] = Json::FromNumber(stream_id);
+  }
+};
+
+struct H2BeginWriteCycle {
+  uint32_t target_size;
+
+  void RenderJson(Json::Object& json) const {
+    json["metadata_type"] = Json::FromString("BEGIN_WRITE_CYCLE");
+    json["target_size"] = Json::FromNumber(target_size);
+  }
+};
+
+struct H2BeginEndpointWrite {
+  uint32_t write_size;
+
+  void RenderJson(Json::Object& json) const {
+    json["metadata_type"] = Json::FromString("BEGIN_ENDPOINT_WRITE");
+    json["write_size"] = Json::FromNumber(write_size);
+  }
+};
+
+struct H2EndWriteCycle {
+  void RenderJson(Json::Object& json) const {
+    json["metadata_type"] = Json::FromString("END_WRITE_CYCLE");
+  }
+};
+
+using Http2ZTraceCollector = channelz::ZTraceCollector<
+    http2_ztrace_collector_detail::Config, H2DataTrace<false>,
+    H2HeaderTrace<false>, H2RstStreamTrace<false>, H2SettingsTrace<false>,
+    H2PingTrace<false>, H2GoAwayTrace<false>, H2WindowUpdateTrace<false>,
+    H2SecurityTrace<false>, H2DataTrace<true>, H2HeaderTrace<true>,
+    H2RstStreamTrace<true>, H2SettingsTrace<true>, H2PingTrace<true>,
+    H2GoAwayTrace<true>, H2WindowUpdateTrace<true>, H2SecurityTrace<true>,
+    H2UnknownFrameTrace, H2FlowControlStall, H2BeginWriteCycle, H2EndWriteCycle,
+    H2BeginEndpointWrite>;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_ZTRACE_COLLECTOR_H

data/src/core/ext/transport/chttp2/transport/internal.h

@@ -41,7 +41,6 @@
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
-#include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/frame_ping.h"
@@ -52,10 +51,13 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
+#include "src/core/ext/transport/chttp2/transport/internal_channel_arg_names.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
+#include "src/core/ext/transport/chttp2/transport/transport_common.h"
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -73,6 +75,9 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
 #include "src/core/telemetry/call_tracer.h"
+#include "src/core/telemetry/context_list_entry.h"
+#include "src/core/telemetry/stats.h"
+#include "src/core/telemetry/tcp_tracer.h"
 #include "src/core/util/bitset.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/ref_counted.h"
@@ -229,6 +234,23 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
                         bool is_client);
   ~grpc_chttp2_transport() override;
 
+  class ChannelzDataSource final : public grpc_core::channelz::DataSource {
+   public:
+    explicit ChannelzDataSource(grpc_chttp2_transport* transport)
+        : grpc_core::channelz::DataSource(transport->channelz_socket),
+          transport_(transport) {
+      SourceConstructed();
+    }
+    ~ChannelzDataSource() { SourceDestructing(); }
+
+    void AddData(grpc_core::channelz::DataSink sink) override;
+    std::unique_ptr<grpc_core::channelz::ZTrace> GetZTrace(
+        absl::string_view name) override;
+
+   private:
+    grpc_chttp2_transport* transport_;
+  };
+
   void Orphan() override;
 
   grpc_core::RefCountedPtr<grpc_chttp2_transport> Ref() {
@@ -250,6 +272,10 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::ServerTransport* server_transport() override { return nullptr; }
 
   absl::string_view GetTransportName() const override;
+  grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> GetSocketNode()
+      const override {
+    return channelz_socket;
+  }
   void InitStream(grpc_stream* gs, grpc_stream_refcount* refcount,
                   const void* server_data, grpc_core::Arena* arena) override;
   void SetPollset(grpc_stream* stream, grpc_pollset* pollset) override;
@@ -261,6 +287,9 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   void WriteSecurityFrame(grpc_core::SliceBuffer* data);
   void WriteSecurityFrameLocked(grpc_core::SliceBuffer* data);
 
+  // We depend on the ep being available for the life of the transport in
+  // at least one place - event callback in WriteEventSink. Hence, this should
+  // only be orphaned in the destructor.
   grpc_core::OrphanablePtr<grpc_endpoint> ep;
   grpc_core::Mutex ep_destroy_mu;  // Guards endpoint destruction only.
 
@@ -275,7 +304,6 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
 
   std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine;
   grpc_core::Combiner* combiner;
-  absl::BitGen bitgen;
 
   // On the client side, when the transport is first created, the
   // endpoint will already have been added to this pollset_set, and it
@@ -471,7 +499,6 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_event_engine::experimental::EventEngine::TaskHandle
       keepalive_ping_timer_handle =
           grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
-  ;
   /// time duration in between pings
   grpc_core::Duration keepalive_time;
   /// Tracks any adjustments to the absolute timestamp of the next keepalive
@@ -488,6 +515,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   uint32_t max_header_list_size_soft_limit = 0;
   grpc_core::ContextList* context_list = nullptr;
   grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> channelz_socket;
+  std::unique_ptr<ChannelzDataSource> channelz_data_source;
   uint32_t num_messages_in_next_write = 0;
   /// The number of pending induced frames (SETTINGS_ACK, PINGS_ACK and
   /// RST_STREAM) in the outgoing buffer (t->qbuf). If this number goes beyond
@@ -560,6 +588,9 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::Timestamp last_window_update_time =
       grpc_core::Timestamp::InfPast();
 
+  std::shared_ptr<grpc_core::Http2StatsCollector> http2_stats;
+  grpc_core::Http2ZTraceCollector http2_ztrace_collector;
+
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
 };
 
@@ -670,6 +701,8 @@ struct grpc_chttp2_stream {
   int64_t write_counter = 0;
 
   grpc_core::Chttp2CallTracerWrapper call_tracer_wrapper;
+  // null by default, set by the transport data source upon first query
+  grpc_core::RefCountedPtr<grpc_core::channelz::CallNode> channelz_call_node;
 
   // TODO(yashykt): Remove call_tracer field after transition to call v3. (See
   // https://github.com/grpc/grpc/pull/38729 for more information.)
@@ -707,8 +740,6 @@ struct grpc_chttp2_stream {
       grpc_core::Timestamp::InfPast();
 };
 
-#define GRPC_ARG_PING_TIMEOUT_MS "grpc.http2.ping_timeout_ms"
-
 // EXPERIMENTAL: provide protection against overloading a server with too many
 // requests: wait for streams to be deallocated before they stop counting
 // against MAX_CONCURRENT_STREAMS
@@ -735,6 +766,11 @@ struct grpc_chttp2_stream {
 void grpc_chttp2_initiate_write(grpc_chttp2_transport* t,
                                 grpc_chttp2_initiate_write_reason reason);
 
+struct TcpCallTracerWithOffset {
+  std::shared_ptr<grpc_core::TcpCallTracer> tcp_call_tracer;
+  size_t byte_offset;
+};
+
 struct grpc_chttp2_begin_write_result {
   /// are we writing?
   bool writing;
@@ -742,6 +778,8 @@ struct grpc_chttp2_begin_write_result {
   bool partial;
   /// did we queue any completions as part of beginning the write
   bool early_results_scheduled;
+  /// Tcp Call Tracers if any
+  std::vector<TcpCallTracerWithOffset> tcp_call_tracers;
 };
 grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
     grpc_chttp2_transport* t);
@@ -798,10 +836,6 @@ void grpc_chttp2_settings_timeout(
 #define GRPC_HEADER_SIZE_IN_BYTES 5
 #define MAX_SIZE_T (~(size_t)0)
 
-#define GRPC_CHTTP2_CLIENT_CONNECT_STRING "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
-#define GRPC_CHTTP2_CLIENT_CONNECT_STRLEN \
-  (sizeof(GRPC_CHTTP2_CLIENT_CONNECT_STRING) - 1)
-
 #define GRPC_CHTTP2_IF_TRACING(severity) \
   LOG_IF(severity, GRPC_TRACE_FLAG_ENABLED(http))
 

data/src/core/ext/transport/chttp2/transport/internal_channel_arg_names.h

@@ -0,0 +1,24 @@
+//
+//
+// Copyright 2025 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_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_CHANNEL_ARG_NAMES_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_CHANNEL_ARG_NAMES_H
+
+#define GRPC_ARG_PING_TIMEOUT_MS "grpc.http2.ping_timeout_ms"
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_CHANNEL_ARG_NAMES_H

data/src/core/ext/transport/chttp2/transport/keepalive.cc

@@ -0,0 +1,105 @@
+//
+//
+// Copyright 2025 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.
+//
+//
+#include "src/core/ext/transport/chttp2/transport/keepalive.h"
+
+#include "src/core/lib/promise/all_ok.h"
+#include "src/core/lib/promise/if.h"
+#include "src/core/lib/promise/loop.h"
+#include "src/core/lib/promise/race.h"
+#include "src/core/lib/promise/sleep.h"
+#include "src/core/lib/promise/try_seq.h"
+
+namespace grpc_core {
+namespace http2 {
+KeepaliveManager::KeepaliveManager(
+    std::unique_ptr<KeepAliveInterface> keep_alive_interface,
+    Duration keepalive_timeout, const Duration keepalive_time)
+    : keep_alive_interface_(std::move(keep_alive_interface)),
+      keepalive_timeout_(keepalive_timeout),
+      keepalive_time_(keepalive_time) {}
+
+auto KeepaliveManager::WaitForKeepAliveTimeout() {
+  return AssertResultType<absl::Status>(
+      TrySeq(Sleep(keepalive_timeout_), [this] {
+        return If(
+            data_received_in_last_cycle_,
+            [] {
+              GRPC_HTTP2_KEEPALIVE_LOG
+                  << "Keepalive timeout triggered but "
+                  << "received data. Resolving with ok status";
+              return Immediate(absl::OkStatus());
+            },
+            [this] {
+              GRPC_HTTP2_KEEPALIVE_LOG
+                  << "Keepalive timeout triggered and no "
+                     "data received. Triggering keepalive timeout.";
+              // Once the keepalive timeout is triggered, ensure that
+              // WaitForData() is never resolved. This is needed as the
+              // keepalive loop should break once the timeout is triggered.
+              keep_alive_timeout_triggered_ = true;
+              return TrySeq(keep_alive_interface_->OnKeepAliveTimeout(), [] {
+                return absl::CancelledError("keepalive timeout");
+              });
+            });
+      }));
+}
+auto KeepaliveManager::TimeoutAndSendPing() {
+  DCHECK(!data_received_in_last_cycle_);
+  DCHECK(keepalive_timeout_ != Duration::Infinity());
+
+  return AllOk<absl::Status>(Race(WaitForData(), WaitForKeepAliveTimeout()),
+                             SendPingAndWaitForAck());
+}
+auto KeepaliveManager::MaybeSendKeepAlivePing() {
+  GRPC_HTTP2_KEEPALIVE_LOG << "KeepaliveManager::MaybeSendKeepAlivePing";
+  return AssertResultType<absl::Status>(
+      TrySeq(If(
+                 NeedToSendKeepAlivePing(),
+                 [this]() {
+                   return If(
+                       keepalive_timeout_ != Duration::Infinity(),
+                       [this] { return TimeoutAndSendPing(); },
+                       [this] { return SendPingAndWaitForAck(); });
+                 },
+                 []() { return Immediate(absl::OkStatus()); }),
+             [this] {
+               data_received_in_last_cycle_ = false;
+               return Immediate(absl::OkStatus());
+             }));
+}
+
+void KeepaliveManager::Spawn(Party* party) {
+  if (!IsKeepAliveNeeded()) {
+    GRPC_HTTP2_KEEPALIVE_LOG << "Not spawning keepalive loop.";
+    return;
+  }
+  keep_alive_spawned_ = true;
+
+  party->Spawn("KeepAliveLoop", Loop([this]() {
+                 return TrySeq(
+                     Sleep(keepalive_time_),
+                     [this]() { return MaybeSendKeepAlivePing(); },
+                     []() -> LoopCtl<absl::Status> { return Continue(); });
+               }),
+               [](auto status) {
+                 GRPC_HTTP2_KEEPALIVE_LOG << "KeepAlive end with status: "
+                                          << status;
+               });
+}
+}  // namespace http2
+}  // namespace grpc_core

data/src/core/ext/transport/chttp2/transport/keepalive.h

@@ -0,0 +1,138 @@
+//
+//
+// Copyright 2025 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_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H
+
+#include "absl/status/status.h"
+#include "src/core/lib/promise/party.h"
+#include "src/core/lib/promise/promise.h"
+
+namespace grpc_core {
+namespace http2 {
+
+#define GRPC_HTTP2_KEEPALIVE_LOG VLOG(2)
+
+class KeepAliveInterface {
+ public:
+  // Returns a promise that sends a ping frame and resolves when the ack is
+  // received.
+  virtual Promise<absl::Status> SendPingAndWaitForAck() = 0;
+
+  // Returns a promise that processes the keepalive timeout.
+  virtual Promise<absl::Status> OnKeepAliveTimeout() = 0;
+
+  // Returns true if a keepalive ping needs to be sent.
+  virtual bool NeedToSendKeepAlivePing() = 0;
+  virtual ~KeepAliveInterface() = default;
+};
+
+class KeepaliveManager {
+ public:
+  KeepaliveManager(std::unique_ptr<KeepAliveInterface> keep_alive_interface,
+                   Duration keepalive_timeout, Duration keepalive_time);
+
+  // Spawns the keepalive loop on the given party. This MUST be called at most
+  // once during the lifetime of the keepalive manager.
+  void Spawn(Party* party);
+
+  // Needs to be called when any data is read from the endpoint.
+  void GotData() {
+    if (keep_alive_timeout_triggered_) {
+      GRPC_HTTP2_KEEPALIVE_LOG
+          << "KeepAlive timeout triggered. Not setting data_received_ to true";
+      return;
+    }
+    GRPC_HTTP2_KEEPALIVE_LOG << "Data received. Setting data_received_ to true";
+    data_received_in_last_cycle_ = true;
+    auto waker = std::move(waker_);
+    // This will only trigger a wakeup if WaitForData() is pending on this
+    // waker. Otherwise this would be noop.
+    waker.Wakeup();
+  }
+  void SetKeepAliveTimeout(Duration keepalive_timeout) {
+    keepalive_timeout_ = keepalive_timeout;
+  }
+
+ private:
+  // Returns a promise that sleeps for the keepalive_timeout_ and triggers the
+  // keepalive timeout unless data is read within the keepalive timeout.
+  auto WaitForKeepAliveTimeout();
+
+  // Returns a promise that sends a keepalive ping and spawns the keepalive
+  // timeout promise. The promise resolves in the following scenarios:
+  // 1. Ping ack is received within the keepalive timeout (when the ping ack is
+  //     received, a call to GotData() is expected).
+  // 2. Ping ack is received after keepalive timeout (but before the ping
+  //     timeout). In this case, if there is some data received while
+  //     waiting for ping ack, the keepalive timeout is not triggered and the
+  //     promise resolves when SendPingAndWaitForAck() resolves.
+  // 3. No data is received within the keepalive timeout and the keepalive
+  //    timeout is triggered.
+  auto TimeoutAndSendPing();
+
+  // Returns a promise that determines if a keepalive ping needs to be sent and
+  // sends a keepalive ping if needed. The promise resolves when either a ping
+  // ack is received or the keepalive timeout is triggered.
+  auto MaybeSendKeepAlivePing();
+
+  auto WaitForData() {
+    return [this]() -> Poll<absl::Status> {
+      if (data_received_in_last_cycle_) {
+        GRPC_HTTP2_KEEPALIVE_LOG << "WaitForData: Data received. Poll resolved";
+        return absl::OkStatus();
+      } else {
+        GRPC_HTTP2_KEEPALIVE_LOG
+            << "WaitForData: Data not received. Poll pending";
+        waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+        return Pending{};
+      }
+    };
+  }
+  auto SendPingAndWaitForAck() {
+    DCHECK_EQ(data_received_in_last_cycle_, false);
+    return keep_alive_interface_->SendPingAndWaitForAck();
+  }
+
+  // If no data is received in the last keepalive_time, we should send a
+  // keepalive ping. This also means that there can be scenarios where we would
+  // send one keepalive ping in ~(2*keepalive_time).
+  bool NeedToSendKeepAlivePing() {
+    return (!data_received_in_last_cycle_) &&
+           (keep_alive_interface_->NeedToSendKeepAlivePing());
+  }
+
+  bool IsKeepAliveNeeded() {
+    return (keepalive_time_ != Duration::Infinity() && !keep_alive_spawned_);
+  }
+
+  std::unique_ptr<KeepAliveInterface> keep_alive_interface_;
+  // If the keepalive_timeout_ is set to infinity, then the timeout is dictated
+  // by the ping timeout. Otherwise, this field can be used to set a specific
+  // timeout for keepalive pings.
+  Duration keepalive_timeout_;
+  const Duration keepalive_time_;
+  bool data_received_in_last_cycle_ = false;
+  bool keep_alive_timeout_triggered_ = false;
+  bool keep_alive_spawned_ = false;
+  Waker waker_;
+};
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H