grpc 1.73.0 → 1.74.0

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

@@ -0,0 +1,185 @@
+//
+//
+// 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_MESSAGE_ASSEMBLER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MESSAGE_ASSEMBLER_H
+
+#include <cstdint>
+#include <utility>
+
+#include "absl/log/check.h"
+#include "src/core/call/message.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/ref_counted_ptr.h"
+
+namespace grpc_core {
+namespace http2 {
+
+// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// assembler and disassembler code
+
+constexpr uint32_t kOneGb = (1024u * 1024u * 1024u);
+
+// For the mapping of gRPC Messages to Http2DataFrame, we can have
+// 1. One gRPC Message in one Http2DataFrame
+// 2. Many gRPC Messages in one Http2DataFrame
+// 3. One gRPC Message spread across multiple consecutive Http2DataFrames
+// 4. An Http2DataFrame could also hold multiple gRPC Messages with the first
+//    and last gRPC Messages being partial messages.
+// This class helps to assemble gRPC Messages from a series of Http2DataFrame
+// payloads by processing the payloads one at a time.
+class GrpcMessageAssembler {
+ public:
+  // Input : The input must contain the payload from the Http2DataFrame.
+  // This function will move the payload into an internal buffer.
+  Http2Status AppendNewDataFrame(SliceBuffer& payload,
+                                 const bool is_end_stream) {
+    DCHECK(!is_end_stream_)
+        << "Calling this function when a previous frame was marked as the last "
+           "frame does not make sense.";
+    is_end_stream_ = is_end_stream;
+    if constexpr (sizeof(size_t) == 4) {
+      if (GPR_UNLIKELY(message_buffer_.Length() >=
+                       UINT32_MAX - payload.Length())) {
+        return Http2Status::Http2StreamError(
+            Http2ErrorCode::kInternalError,
+            "Stream Error: SliceBuffer overflow for 32 bit platforms.");
+      }
+    }
+    payload.MoveFirstNBytesIntoSliceBuffer(payload.Length(), message_buffer_);
+    DCHECK_EQ(payload.Length(), 0u);
+    return Http2Status::Ok();
+  }
+
+  // Returns a valid MessageHandle if it has a complete message.
+  // Returns a nullptr if it does not have a complete message.
+  // Returns an error if an incomplete message is received and the stream ends.
+  ValueOrHttp2Status<MessageHandle> ExtractMessage() {
+    const size_t current_len = message_buffer_.Length();
+    if (current_len < kGrpcHeaderSizeInBytes) {
+      // TODO(tjagtap) : [PH2][P3] : Write a test for this failure.
+      LOG(ERROR) << "Incomplete gRPC message received";
+      return ReturnNullOrError();
+    }
+    GrpcMessageHeader header = ExtractGrpcHeader(message_buffer_);
+    if constexpr (sizeof(size_t) == 4) {
+      if (GPR_UNLIKELY(header.length > kOneGb)) {
+        return Http2Status::Http2StreamError(
+            Http2ErrorCode::kInternalError,
+            "Stream Error: SliceBuffer overflow for 32 bit platforms.");
+      }
+    }
+    if (GPR_LIKELY(current_len - kGrpcHeaderSizeInBytes >= header.length)) {
+      SliceBuffer discard;
+      message_buffer_.MoveFirstNBytesIntoSliceBuffer(kGrpcHeaderSizeInBytes,
+                                                     discard);
+      discard.Clear();
+      // If gRPC header has length 0, we return an empty message.
+      // Bounds: Max len of a valid gRPC message is 4 GB in gRPC C++. 2GB for
+      // other stacks. Since 4 bytes can hold length of 4GB, we dont check
+      // bounds.
+      MessageHandle grpc_message = Arena::MakePooled<Message>();
+      message_buffer_.MoveFirstNBytesIntoSliceBuffer(
+          header.length, *(grpc_message->payload()));
+      uint32_t& flag = grpc_message->mutable_flags();
+      flag = header.flags;
+      return std::move(grpc_message);
+    }
+    return ReturnNullOrError();
+  }
+
+ private:
+  ValueOrHttp2Status<MessageHandle> ReturnNullOrError() {
+    if (GPR_UNLIKELY(is_end_stream_ && message_buffer_.Length() > 0)) {
+      return Http2Status::Http2StreamError(Http2ErrorCode::kInternalError,
+                                           "Incomplete gRPC frame received");
+    }
+    return ValueOrHttp2Status<MessageHandle>(nullptr);
+  }
+  bool is_end_stream_ = false;
+  SliceBuffer message_buffer_;
+};
+
+constexpr uint32_t kMaxMessageBatchSize = (16 * 1024u);
+
+// This class is meant to convert gRPC Messages into Http2DataFrame ensuring
+// that the payload size of the data frame is configurable.
+// This class is not responsible for queueing or backpressure. That will be done
+// by other classes.
+// TODO(tjagtap) : [PH2][P2] Edit comment once this
+// class is integrated and exercised.
+class GrpcMessageDisassembler {
+ public:
+  // One GrpcMessageDisassembler instance MUST be associated with one stream
+  // for its lifetime.
+  GrpcMessageDisassembler() = default;
+
+  // GrpcMessageDisassembler object will take ownership of the message.
+  void PrepareSingleMessageForSending(MessageHandle message) {
+    DCHECK_EQ(GetBufferedLength(), 0u);
+    PrepareMessageForSending(std::move(message));
+  }
+
+  // GrpcMessageDisassembler object will take ownership of the message.
+  void PrepareBatchedMessageForSending(MessageHandle message) {
+    PrepareMessageForSending(std::move(message));
+    DCHECK_LE(GetBufferedLength(), kMaxMessageBatchSize)
+        << "Avoid batches larger than " << kMaxMessageBatchSize << "bytes";
+  }
+
+  size_t GetBufferedLength() const { return message_.Length(); }
+
+  // Gets the next Http2DataFrame with a payload of size max_length or lesser.
+  Http2DataFrame GenerateNextFrame(const uint32_t stream_id,
+                                   const uint32_t max_length,
+                                   const bool is_end_stream = false) {
+    DCHECK_GT(max_length, 0u);
+    DCHECK_GT(GetBufferedLength(), 0u);
+    SliceBuffer temp;
+    const uint32_t current_length =
+        message_.Length() >= max_length ? max_length : message_.Length();
+    message_.MoveFirstNBytesIntoSliceBuffer(current_length, temp);
+    return Http2DataFrame{stream_id, is_end_stream, std::move(temp)};
+  }
+
+  Http2DataFrame GenerateEmptyEndFrame(const uint32_t stream_id) {
+    // RFC9113 : Frames with zero length with the END_STREAM flag set (that is,
+    // an empty DATA frame) MAY be sent if there is no available space in either
+    // flow-control window.
+    SliceBuffer temp;
+    return Http2DataFrame{stream_id, /*end_stream=*/true, std::move(temp)};
+  }
+
+ private:
+  void PrepareMessageForSending(MessageHandle message) {
+    AppendGrpcHeaderToSliceBuffer(message_, message->flags(),
+                                  message->payload()->Length());
+    message_.Append(*(message->payload()));
+  }
+
+  SliceBuffer message_;
+};
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MESSAGE_ASSEMBLER_H

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

@@ -545,8 +545,7 @@ void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport* t) {
 static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t) {
   // Update BDP accounting since we have received a data frame.
   grpc_core::BdpEstimator* bdp_est = t->flow_control.bdp_estimator();
-  grpc_core::global_stats().IncrementHttp2ReadDataFrameSize(
-      t->incoming_frame_size);
+  t->http2_stats->IncrementHttp2ReadDataFrameSize(t->incoming_frame_size);
   if (bdp_est) {
     if (t->bdp_ping_blocked) {
       t->bdp_ping_blocked = false;
@@ -671,8 +670,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                         nullptr, &t->http2_ztrace_collector));
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
-    } else if (grpc_core::IsRqFastRejectEnabled() &&
-               GPR_UNLIKELY(t->memory_owner.IsMemoryPressureHigh())) {
+    } else if (GPR_UNLIKELY(t->memory_owner.IsMemoryPressureHigh())) {
       // We have more streams allocated than we'd like, so apply some pushback
       // by refusing this stream.
       grpc_core::global_stats().IncrementRqCallsRejected();

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

@@ -28,6 +28,7 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
 #include "absl/random/bit_gen_ref.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/time.h"
 
@@ -90,6 +91,24 @@ class Chttp2PingCallbacks {
       grpc_event_engine::experimental::EventEngine* event_engine,
       Callback callback);
 
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("ping_requested", ping_requested_)
+        .Set("most_recent_inflight", most_recent_inflight_)
+        .Set("started_new_ping_without_setting_timeout",
+             started_new_ping_without_setting_timeout_)
+        .Set("inflight",
+             [this]() {
+               channelz::PropertyTable inflight;
+               for (const auto& [id, ping] : inflight_) {
+                 inflight.AppendRow(channelz::PropertyList().Set("id", id));
+               }
+               return inflight;
+             }())
+        .Set("num_on_start", on_start_.size())
+        .Set("num_on_ack", on_ack_.size());
+  }
+
  private:
   using CallbackVec = std::vector<Callback>;
   struct InflightPing {

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

@@ -0,0 +1,151 @@
+//
+//
+// 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/ping_promise.h"
+
+#include "src/core/lib/promise/if.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/party.h"
+#include "src/core/lib/promise/race.h"
+#include "src/core/lib/promise/sleep.h"
+#include "src/core/lib/promise/try_seq.h"
+#include "src/core/util/match.h"
+#include "src/core/util/time.h"
+
+namespace grpc_core {
+namespace http2 {
+using SendPingArgs = ::grpc_core::http2::PingInterface::SendPingArgs;
+using Callback = absl::AnyInvocable<void()>;
+using grpc_event_engine::experimental::EventEngine;
+
+#define GRPC_HTTP2_PING_LOG                                \
+  LOG_IF(INFO, (GRPC_TRACE_FLAG_ENABLED(http) ||           \
+                GRPC_TRACE_FLAG_ENABLED(bdp_estimator) ||  \
+                GRPC_TRACE_FLAG_ENABLED(http_keepalive) || \
+                GRPC_TRACE_FLAG_ENABLED(http2_ping)))
+
+Promise<absl::Status> PingManager::PingPromiseCallbacks::RequestPing(
+    Callback on_initiate) {
+  std::shared_ptr<Latch<void>> latch = std::make_shared<Latch<void>>();
+  auto on_ack = [latch]() { latch->Set(); };
+  ping_callbacks_.OnPing(std::move(on_initiate), std::move(on_ack));
+  return Map(latch->Wait(), [latch](Empty) { return absl::OkStatus(); });
+}
+
+Promise<absl::Status> PingManager::PingPromiseCallbacks::WaitForPingAck() {
+  std::shared_ptr<Latch<void>> latch = std::make_shared<Latch<void>>();
+  auto on_ack = [latch]() { latch->Set(); };
+  ping_callbacks_.OnPingAck(std::move(on_ack));
+  return Map(latch->Wait(), [latch](Empty) { return absl::OkStatus(); });
+}
+
+// Ping System implementation
+PingManager::PingManager(const ChannelArgs& channel_args,
+                         std::unique_ptr<PingInterface> ping_interface,
+                         std::shared_ptr<EventEngine> event_engine)
+    : ping_callbacks_(event_engine),
+      ping_abuse_policy_(channel_args),
+      ping_rate_policy_(channel_args, /*is_client=*/true),
+      ping_interface_(std::move(ping_interface)) {}
+
+void PingManager::TriggerDelayedPing(Duration wait) {
+  // Spawn at most once.
+  if (delayed_ping_spawned_) {
+    return;
+  }
+  delayed_ping_spawned_ = true;
+  GetContext<Party>()->Spawn(
+      "DelayedPing",
+      [this, wait]() mutable {
+        VLOG(2) << "Scheduling delayed ping after wait=" << wait;
+        return AssertResultType<absl::Status>(TrySeq(
+            Sleep(wait),
+            [this]() mutable { return ping_interface_->TriggerWrite(); }));
+      },
+      [this](auto) { delayed_ping_spawned_ = false; });
+}
+
+bool PingManager::NeedToPing(Duration next_allowed_ping_interval) {
+  if (!ping_callbacks_.PingRequested()) {
+    return false;
+  }
+
+  return Match(
+      ping_rate_policy_.RequestSendPing(next_allowed_ping_interval,
+                                        ping_callbacks_.CountPingInflight()),
+      [this](Chttp2PingRatePolicy::SendGranted) {
+        // TODO(akshitpatel) : [PH2][P1] : Update some keepalive flags.
+        GRPC_HTTP2_PING_LOG << "CLIENT" << "[" << "PH2"
+                            << "]: Ping sent"
+                            << ping_rate_policy_.GetDebugString();
+        return true;
+      },
+      [this](Chttp2PingRatePolicy::TooManyRecentPings) {
+        GRPC_HTTP2_PING_LOG << "CLIENT" << "[" << "PH2"
+                            << "]: Ping delayed too many recent pings: "
+                            << ping_rate_policy_.GetDebugString();
+        return false;
+      },
+      [this](Chttp2PingRatePolicy::TooSoon too_soon) mutable {
+        GRPC_HTTP2_PING_LOG
+            << "]: Ping delayed not enough time elapsed since last "
+               "ping. Last ping:"
+            << too_soon.last_ping
+            << ", minimum wait:" << too_soon.next_allowed_ping_interval
+            << ", need to wait:" << too_soon.wait;
+        TriggerDelayedPing(too_soon.wait);
+        return false;
+      });
+}
+
+void PingManager::SpawnTimeout(Duration ping_timeout,
+                               const uint64_t opaque_data) {
+  GetContext<Party>()->Spawn(
+      "PingTimeout",
+      [this, ping_timeout, opaque_data]() {
+        return AssertResultType<absl::Status>(Race(
+            TrySeq(ping_callbacks_.PingTimeout(ping_timeout),
+                   [this, opaque_data]() mutable {
+                     VLOG(2) << " Ping ack not received for id=" << opaque_data
+                             << ". Ping timeout triggered.";
+                     return ping_interface_->PingTimeout();
+                   }),
+            ping_callbacks_.WaitForPingAck()));
+      },
+      [](auto) {});
+}
+
+Promise<absl::Status> PingManager::MaybeSendPing(
+    Duration next_allowed_ping_interval, Duration ping_timeout) {
+  return If(
+      NeedToPing(next_allowed_ping_interval),
+      [this, ping_timeout]() mutable {
+        const uint64_t opaque_data = ping_callbacks_.StartPing();
+        return AssertResultType<absl::Status>(
+            TrySeq(ping_interface_->SendPing(SendPingArgs{false, opaque_data}),
+                   [this, ping_timeout, opaque_data]() {
+                     VLOG(2) << "Ping Sent with id: " << opaque_data;
+                     SpawnTimeout(ping_timeout, opaque_data);
+                     SentPing();
+                     return absl::OkStatus();
+                   }));
+      },
+      []() { return Immediate(absl::OkStatus()); });
+}
+}  // namespace http2
+}  // namespace grpc_core

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

@@ -0,0 +1,180 @@
+//
+//
+// 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_PING_PROMISE_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_PROMISE_H
+
+#include <memory>
+
+#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/lib/promise/inter_activity_latch.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/util/shared_bit_gen.h"
+#include "src/core/util/time.h"
+
+namespace grpc_core {
+namespace http2 {
+
+// Ping Promise Spawns Overview
+
+// | Promise Spawn   | Max Duration | Promise      | Max Spawns              |
+// |                 | for Spawn    | Resolution   |                         |
+// |-----------------|--------------|--------------|-------------------------|
+// | Ping Timeout    | 1 minute     | On Ping ack  | One per inflight ping   |
+// |                 |              | or timeout   |                         |
+// | Delayed Ping    | 2 Hours      | On scheduled | One                     |
+// |                 |              | time         |                         |
+// | Ping Waiter     | 1 minute     | On Ping ack  | One per ping request    |
+// |                 |              | or timeout   |                         |
+// Max Party Slots:
+// - Without multi ping:
+//   - 1 per ping request + 1 (for delayed ping) + 1 (for ping timeout)
+//   - Worst case(3 ping requests): 5
+
+// - With multi ping:
+//   - 1 per ping request + 1 (for delayed ping) + 1 per inflight ping
+//                                                (for ping timeout)
+//   - Worst case(3 ping requests): 7
+
+class PingInterface {
+ public:
+  struct SendPingArgs {
+    bool ack = false;
+    // RFC9113: PING frames MUST contain 8 octets of opaque data in the frame
+    // payload. A sender can include any value it chooses and use those octets
+    // in any fashion.
+    uint64_t opaque_data = 0;
+  };
+
+  // Returns a promise that creates and sends a ping frame to the peer.
+  virtual Promise<absl::Status> SendPing(SendPingArgs args) = 0;
+
+  // Returns a promise that triggers a write cycle on the transport.
+  virtual Promise<absl::Status> TriggerWrite() = 0;
+
+  // Returns a promise that handles the ping timeout.
+  virtual Promise<absl::Status> PingTimeout() = 0;
+  virtual ~PingInterface() = default;
+};
+
+// The code in this class is NOT thread safe. It has been designed to run on a
+// single thread. This guarantee is achieved by spawning all the promises
+// returned by this class on the same transport party.
+class PingManager {
+ public:
+  PingManager(const ChannelArgs& channel_args,
+              std::unique_ptr<PingInterface> ping_interface,
+              std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+                  event_engine);
+
+  // Returns a promise that determines if a ping frame should be sent to the
+  // peer. If a ping frame is sent, it also spawns a timeout promise that
+  // handles the ping timeout.
+  Promise<absl::Status> MaybeSendPing(Duration next_allowed_ping_interval,
+                                      Duration ping_timeout);
+
+  // Ping Rate policy wrapper
+  void ReceivedDataFrame() { ping_rate_policy_.ReceivedDataFrame(); }
+
+  // Ping abuse policy wrapper
+  bool NotifyPingAbusePolicy(const bool transport_idle) {
+    return ping_abuse_policy_.ReceivedOnePing(transport_idle);
+  }
+
+  void ResetPingClock(bool is_client) {
+    if (!is_client) {
+      ping_abuse_policy_.ResetPingStrikes();
+    }
+    ping_rate_policy_.ResetPingsBeforeDataRequired();
+  }
+
+  // Ping callbacks wrapper
+
+  // Returns a promise that resolves once a new ping is initiated and ack is
+  // received for the same. The on_initiate callback is executed when the
+  // ping is initiated.
+  auto RequestPing(absl::AnyInvocable<void()> on_initiate) {
+    return ping_callbacks_.RequestPing(std::move(on_initiate));
+  }
+
+  // Returns a promise that resolves once the next valid ping ack is received.
+  auto WaitForPingAck() { return ping_callbacks_.WaitForPingAck(); }
+
+  // Cancels all the callbacks for the inflight pings. This function does not
+  // cancel the promises that are waiting on the ping ack.
+  // This should be called as part of closing the transport to free up any
+  // memory in use by the ping callbacks.
+  void CancelCallbacks() { ping_callbacks_.CancelCallbacks(); }
+
+  uint64_t StartPing() { return ping_callbacks_.StartPing(); }
+  bool PingRequested() { return ping_callbacks_.PingRequested(); }
+  bool AckPing(uint64_t id) { return ping_callbacks_.AckPing(id); }
+  size_t CountPingInflight() { return ping_callbacks_.CountPingInflight(); }
+
+ private:
+  class PingPromiseCallbacks {
+   public:
+    explicit PingPromiseCallbacks(
+        std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+            event_engine)
+        : event_engine_(event_engine) {}
+    Promise<absl::Status> RequestPing(absl::AnyInvocable<void()> on_initiate);
+    Promise<absl::Status> WaitForPingAck();
+    void CancelCallbacks() { ping_callbacks_.CancelAll(event_engine_.get()); }
+    uint64_t StartPing() { return ping_callbacks_.StartPing(SharedBitGen()); }
+    bool PingRequested() { return ping_callbacks_.ping_requested(); }
+    bool AckPing(uint64_t id) {
+      return ping_callbacks_.AckPing(id, event_engine_.get());
+    }
+    size_t CountPingInflight() { return ping_callbacks_.pings_inflight(); }
+
+    auto PingTimeout(Duration ping_timeout) {
+      std::shared_ptr<InterActivityLatch<void>> latch =
+          std::make_shared<InterActivityLatch<void>>();
+      auto timeout_cb = [latch]() { latch->Set(); };
+      auto id = ping_callbacks_.OnPingTimeout(ping_timeout, event_engine_.get(),
+                                              std::move(timeout_cb));
+      DCHECK(id.has_value());
+      VLOG(2) << "Ping timeout of duration: " << ping_timeout
+              << " initiated for ping id: " << *id;
+      return Map(latch->Wait(), [latch](Empty) { return absl::OkStatus(); });
+    }
+
+   private:
+    Chttp2PingCallbacks ping_callbacks_;
+    std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
+  };
+
+  PingPromiseCallbacks ping_callbacks_;
+  Chttp2PingAbusePolicy ping_abuse_policy_;
+  Chttp2PingRatePolicy ping_rate_policy_;
+  bool delayed_ping_spawned_ = false;
+  std::unique_ptr<PingInterface> ping_interface_;
+
+  void TriggerDelayedPing(Duration wait);
+  bool NeedToPing(Duration next_allowed_ping_interval);
+  void SpawnTimeout(Duration ping_timeout, uint64_t opaque_data);
+
+  void SentPing() { ping_rate_policy_.SentPing(); }
+};
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_PROMISE_H

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

@@ -79,15 +79,11 @@ Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval,
   // Throttle pings to 1 minute if we haven't sent any data recently
   if (max_pings_without_data_sent_ != 0 &&
       pings_before_data_sending_required_ == 0) {
-    if (IsMaxPingsWoDataThrottleEnabled()) {
-      const Timestamp next_allowed_ping =
-          last_ping_sent_time_ + kThrottleIntervalWithoutDataSent;
-      if (next_allowed_ping > now) {
-        return TooSoon{kThrottleIntervalWithoutDataSent, last_ping_sent_time_,
-                       next_allowed_ping - now};
-      }
-    } else {
-      return TooManyRecentPings{};
+    const Timestamp next_allowed_ping =
+        last_ping_sent_time_ + kThrottleIntervalWithoutDataSent;
+    if (next_allowed_ping > now) {
+      return TooSoon{kThrottleIntervalWithoutDataSent, last_ping_sent_time_,
+                     next_allowed_ping - now};
     }
   }
 

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

@@ -22,7 +22,9 @@
 #include <string>
 #include <variant>
 
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/util/string.h"
 #include "src/core/util/time.h"
 
 namespace grpc_core {
@@ -78,6 +80,15 @@ class Chttp2PingRatePolicy {
     return max_pings_without_data_sent_;
   }
 
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("max_pings_without_data_sent", max_pings_without_data_sent_)
+        .Set("max_inflight_pings", max_inflight_pings_)
+        .Set("pings_before_data_sending_required",
+             pings_before_data_sending_required_)
+        .Set("last_ping_sent_time", last_ping_sent_time_);
+  }
+
  private:
   const int max_pings_without_data_sent_;
   const int max_inflight_pings_;