grpc 1.56.2 → 1.58.0

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

@@ -25,6 +25,7 @@
 #include <algorithm>
 #include <initializer_list>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -32,8 +33,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/ext/transport/chttp2/transport/stream_map.h"
-#include "src/core/lib/gprpp/time.h"
+#include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
 
 grpc_slice grpc_chttp2_ping_create(uint8_t ack, uint64_t opaque_8bytes) {
   grpc_slice slice = GRPC_SLICE_MALLOC(9 + 8);
@@ -94,25 +94,11 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
       grpc_chttp2_ack_ping(t, p->opaque_8bytes);
     } else {
       if (!t->is_client) {
-        grpc_core::Timestamp now = grpc_core::Timestamp::Now();
-        grpc_core::Timestamp next_allowed_ping =
-            t->ping_recv_state.last_ping_recv_time +
-            t->ping_policy.min_recv_ping_interval_without_data;
-
-        if (t->keepalive_permit_without_calls == 0 &&
-            grpc_chttp2_stream_map_size(&t->stream_map) == 0) {
-          // According to RFC1122, the interval of TCP Keep-Alive is default to
-          // no less than two hours. When there is no outstanding streams, we
-          // restrict the number of PINGS equivalent to TCP Keep-Alive.
-          next_allowed_ping = t->ping_recv_state.last_ping_recv_time +
-                              grpc_core::Duration::Hours(2);
-        }
-
-        if (next_allowed_ping > now) {
-          grpc_chttp2_add_ping_strike(t);
+        const bool transport_idle =
+            t->keepalive_permit_without_calls == 0 && t->stream_map.empty();
+        if (t->ping_abuse_policy.ReceivedOnePing(transport_idle)) {
+          grpc_chttp2_exceeded_ping_strikes(t);
         }
-
-        t->ping_recv_state.last_ping_recv_time = now;
       }
       if (t->ack_pings) {
         if (t->ping_ack_count == t->ping_ack_capacity) {

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

@@ -19,6 +19,7 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -132,9 +133,9 @@ class HpackParseResult {
   bool connection_error() const { return IsConnectionError(status_.get()); }
   bool ephemeral() const { return IsEphemeralError(status_.get()); }
 
-  HpackParseResult PersistentStreamErrorOrOk() const {
-    if (connection_error() || ephemeral()) return HpackParseResult();
-    return *this;
+  std::unique_ptr<HpackParseResult> PersistentStreamErrorOrNullptr() const {
+    if (ok() || connection_error() || ephemeral()) return nullptr;
+    return std::make_unique<HpackParseResult>(*this);
   }
 
   static HpackParseResult FromStatus(HpackParseStatus status) {

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

@@ -24,6 +24,7 @@
 #include <stdlib.h>
 
 #include <algorithm>
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -43,6 +44,7 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
+#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/debug/trace.h"
@@ -696,19 +698,19 @@ class HPackParser::Parser {
     gpr_log(
         GPR_DEBUG, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
         log_info_.is_client ? "CLI" : "SVR", memento.md.DebugString().c_str(),
-        memento.parse_status.ok()
+        memento.parse_status == nullptr
             ? ""
             : absl::StrCat(" (parse error: ",
-                           memento.parse_status.Materialize().ToString(), ")")
+                           memento.parse_status->Materialize().ToString(), ")")
                   .c_str());
   }
 
   void EmitHeader(const HPackTable::Memento& md) {
     // Pass up to the transport
     state_.frame_length += md.md.transport_size();
-    if (!md.parse_status.ok()) {
+    if (md.parse_status != nullptr) {
       // Reject any requests with invalid metadata.
-      input_->SetErrorAndContinueParsing(md.parse_status);
+      input_->SetErrorAndContinueParsing(*md.parse_status);
     }
     if (GPR_LIKELY(metadata_buffer_ != nullptr)) {
       metadata_buffer_->Set(md.md);
@@ -957,8 +959,8 @@ class HPackParser::Parser {
     } else {
       const auto* memento = absl::get<const HPackTable::Memento*>(state_.key);
       key_string = memento->md.key();
-      if (status.ok() && !memento->parse_status.ok()) {
-        input_->SetErrorAndContinueParsing(memento->parse_status);
+      if (status.ok() && memento->parse_status != nullptr) {
+        input_->SetErrorAndContinueParsing(*memento->parse_status);
       }
     }
     switch (value.status) {
@@ -983,7 +985,7 @@ class HPackParser::Parser {
     const auto transport_size =
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     auto md = grpc_metadata_batch::Parse(
-        key_string, std::move(value_slice), transport_size,
+        key_string, std::move(value_slice), state_.add_to_table, transport_size,
         [key_string, &status, this](absl::string_view message, const Slice&) {
           if (!status.ok()) return;
           input_->SetErrorAndContinueParsing(
@@ -993,7 +995,7 @@ class HPackParser::Parser {
                   std::string(message).c_str());
         });
     HPackTable::Memento memento{std::move(md),
-                                status.PersistentStreamErrorOrOk()};
+                                status.PersistentStreamErrorOrNullptr()};
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
     if (state_.add_to_table) {
@@ -1068,6 +1070,55 @@ Slice HPackParser::String::Take() {
   GPR_UNREACHABLE_CODE(return Slice());
 }
 
+class HPackParser::MetadataSizeEncoder {
+ public:
+  explicit MetadataSizeEncoder(std::string& summary) : summary_(summary) {}
+
+  void Encode(const Slice& key, const Slice& value) {
+    AddToSummary(key.as_string_view(), value.size());
+  }
+
+  template <typename Key, typename Value>
+  void Encode(Key, const Value& value) {
+    AddToSummary(Key::key(), EncodedSizeOfKey(Key(), value));
+  }
+
+ private:
+  void AddToSummary(absl::string_view key,
+                    size_t value_length) GPR_ATTRIBUTE_NOINLINE {
+    absl::StrAppend(&summary_, key, ":",
+                    hpack_constants::SizeForEntry(key.size(), value_length),
+                    ",");
+  }
+  std::string& summary_;
+};
+
+class HPackParser::MetadataSizesAnnotation
+    : public CallTracerAnnotationInterface::Annotation {
+ public:
+  MetadataSizesAnnotation(grpc_metadata_batch* metadata_buffer,
+                          uint64_t soft_limit, uint64_t hard_limit)
+      : CallTracerAnnotationInterface::Annotation(
+            CallTracerAnnotationInterface::AnnotationType::kMetadataSizes),
+        metadata_buffer_(metadata_buffer),
+        soft_limit_(soft_limit),
+        hard_limit_(hard_limit) {}
+
+  std::string ToString() const override {
+    std::string metadata_annotation =
+        absl::StrCat("gRPC metadata soft_limit:", soft_limit_,
+                     ",hard_limit:", hard_limit_, ",");
+    MetadataSizeEncoder encoder(metadata_annotation);
+    metadata_buffer_->Encode(&encoder);
+    return metadata_annotation;
+  }
+
+ private:
+  grpc_metadata_batch* metadata_buffer_;
+  uint64_t soft_limit_;
+  uint64_t hard_limit_;
+};
+
 // PUBLIC INTERFACE
 
 HPackParser::HPackParser() = default;
@@ -1092,7 +1143,9 @@ void HPackParser::BeginFrame(grpc_metadata_batch* metadata_buffer,
   log_info_ = log_info;
 }
 
-grpc_error_handle HPackParser::Parse(const grpc_slice& slice, bool is_last) {
+grpc_error_handle HPackParser::Parse(
+    const grpc_slice& slice, bool is_last,
+    CallTracerAnnotationInterface* call_tracer) {
   if (GPR_UNLIKELY(!unparsed_bytes_.empty())) {
     unparsed_bytes_.insert(unparsed_bytes_.end(), GRPC_SLICE_START_PTR(slice),
                            GRPC_SLICE_END_PTR(slice));
@@ -1104,20 +1157,27 @@ grpc_error_handle HPackParser::Parse(const grpc_slice& slice, bool is_last) {
     std::vector<uint8_t> buffer = std::move(unparsed_bytes_);
     return ParseInput(Input(nullptr, buffer.data(),
                             buffer.data() + buffer.size(), state_.frame_error),
-                      is_last);
+                      is_last, call_tracer);
   }
   return ParseInput(Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
                           GRPC_SLICE_END_PTR(slice), state_.frame_error),
-                    is_last);
+                    is_last, call_tracer);
 }
 
-grpc_error_handle HPackParser::ParseInput(Input input, bool is_last) {
+grpc_error_handle HPackParser::ParseInput(
+    Input input, bool is_last, CallTracerAnnotationInterface* call_tracer) {
   ParseInputInner(&input);
   if (is_last && is_boundary()) {
     if (state_.metadata_early_detection.Reject(state_.frame_length)) {
       HandleMetadataSoftSizeLimitExceeded(&input);
     }
     global_stats().IncrementHttp2MetadataSize(state_.frame_length);
+    if (call_tracer != nullptr && metadata_buffer_ != nullptr) {
+      MetadataSizesAnnotation metadata_sizes_annotation(
+          metadata_buffer_, state_.metadata_early_detection.soft_limit(),
+          state_.metadata_early_detection.hard_limit());
+      call_tracer->RecordAnnotation(metadata_sizes_annotation);
+    }
     if (!state_.frame_error.connection_error() &&
         (input.eof_error() || state_.parse_state != ParseState::kTop)) {
       state_.frame_error = HpackParseResult::IncompleteHeaderAtBoundaryError();

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

@@ -40,6 +40,7 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/lib/backoff/random_early_detection.h"
+#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_refcount.h"
@@ -99,7 +100,8 @@ class HPackParser {
   // Start throwing away any received headers after parsing them.
   void StopBufferingFrame() { metadata_buffer_ = nullptr; }
   // Parse one slice worth of data
-  grpc_error_handle Parse(const grpc_slice& slice, bool is_last);
+  grpc_error_handle Parse(const grpc_slice& slice, bool is_last,
+                          CallTracerAnnotationInterface* call_tracer);
   // Reset state ready for the next BeginFrame
   void FinishFrame();
 
@@ -117,6 +119,8 @@ class HPackParser {
   // Helper classes: see implementation
   class Parser;
   class Input;
+  class MetadataSizeEncoder;
+  class MetadataSizesAnnotation;
 
   // Helper to parse a string and turn it into a slice with appropriate memory
   // management characteristics
@@ -249,7 +253,8 @@ class HPackParser {
     absl::variant<const HPackTable::Memento*, Slice> key;
   };
 
-  grpc_error_handle ParseInput(Input input, bool is_last);
+  grpc_error_handle ParseInput(Input input, bool is_last,
+                               CallTracerAnnotationInterface* call_tracer);
   void ParseInputInner(Input* input);
   GPR_ATTRIBUTE_NOINLINE
   void HandleMetadataSoftSizeLimitExceeded(Input* input);

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

@@ -161,10 +161,10 @@ void HPackTable::AddLargerThanCurrentTableSize() {
 std::string HPackTable::TestOnlyDynamicTableAsString() const {
   std::string out;
   entries_.ForEach([&out](uint32_t i, const Memento& m) {
-    if (m.parse_status.ok()) {
+    if (m.parse_status == nullptr) {
       absl::StrAppend(&out, i, ": ", m.md.DebugString(), "\n");
     } else {
-      absl::StrAppend(&out, i, ": ", m.parse_status.Materialize().ToString(),
+      absl::StrAppend(&out, i, ": ", m.parse_status->Materialize().ToString(),
                       "\n");
     }
   });
@@ -245,12 +245,12 @@ HPackTable::Memento MakeMemento(size_t i) {
   auto sm = kStaticTable[i];
   return HPackTable::Memento{
       grpc_metadata_batch::Parse(
-          sm.key, Slice::FromStaticString(sm.value),
+          sm.key, Slice::FromStaticString(sm.value), true,
           strlen(sm.key) + strlen(sm.value) + hpack_constants::kEntryOverhead,
           [](absl::string_view, const Slice&) {
             abort();  // not expecting to see this
           }),
-      HpackParseResult()};
+      nullptr};
 }
 
 }  // namespace

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

@@ -23,6 +23,7 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -51,7 +52,7 @@ class HPackTable {
 
   struct Memento {
     ParsedMetadata<grpc_metadata_batch> md;
-    HpackParseResult parse_status;
+    std::unique_ptr<HpackParseResult> parse_status;
   };
 
   // Lookup, but don't ref.
@@ -70,7 +71,7 @@ class HPackTable {
   }
 
   // add a table entry to the index
-  bool Add(Memento md) GRPC_MUST_USE_RESULT;
+  GRPC_MUST_USE_RESULT bool Add(Memento md);
   void AddLargerThanCurrentTableSize();
 
   // Current entry count in the table.

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

@@ -26,6 +26,8 @@
 
 #include <memory>
 
+#include "absl/container/flat_hash_map.h"
+#include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -46,7 +48,8 @@
 #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/stream_map.h"
+#include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
+#include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/trace.h"
@@ -145,21 +148,14 @@ struct grpc_chttp2_ping_queue {
   grpc_closure_list lists[GRPC_CHTTP2_PCL_COUNT] = {};
   uint64_t inflight_id = 0;
 };
-struct grpc_chttp2_repeated_ping_policy {
-  int max_pings_without_data;
-  int max_ping_strikes;
-  grpc_core::Duration min_recv_ping_interval_without_data;
-};
+
 struct grpc_chttp2_repeated_ping_state {
   grpc_core::Timestamp last_ping_sent_time;
   int pings_before_data_required;
   absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       delayed_ping_timer_handle;
 };
-struct grpc_chttp2_server_ping_recv_state {
-  grpc_core::Timestamp last_ping_recv_time;
-  int ping_strikes;
-};
+
 // deframer state for the overall http2 stream of bytes
 typedef enum {
   // prefix: one entry per http2 connection prefix byte
@@ -249,6 +245,19 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
                         grpc_endpoint* ep, bool is_client);
   ~grpc_chttp2_transport();
 
+  // Make this be able to be contained in RefCountedPtr<>
+  // Can't yet make this derive from RefCounted because we need to keep
+  // `grpc_transport base` first.
+  // TODO(ctiller): Make a transport interface.
+  void IncrementRefCount() { refs.Ref(); }
+  void Unref() {
+    if (refs.Unref()) delete this;
+  }
+  grpc_core::RefCountedPtr<grpc_chttp2_transport> Ref() {
+    IncrementRefCount();
+    return grpc_core::RefCountedPtr<grpc_chttp2_transport>(this);
+  }
+
   grpc_transport base;  // must be first
   grpc_core::RefCount refs;
   grpc_endpoint* ep;
@@ -278,7 +287,7 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_stream_list lists[STREAM_LIST_COUNT] = {};
 
   /// maps stream id to grpc_chttp2_stream objects
-  grpc_chttp2_stream_map stream_map;
+  absl::flat_hash_map<uint32_t, grpc_chttp2_stream*> stream_map;
 
   grpc_closure write_action_begin_locked;
   grpc_closure write_action;
@@ -342,8 +351,10 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
 
   /// ping queues for various ping insertion points
   grpc_chttp2_ping_queue ping_queue = grpc_chttp2_ping_queue();
-  grpc_chttp2_repeated_ping_policy ping_policy;
-  grpc_chttp2_repeated_ping_state ping_state;
+  grpc_core::Chttp2PingAbusePolicy ping_abuse_policy;
+  grpc_core::Chttp2PingRatePolicy ping_rate_policy;
+  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      delayed_ping_timer_handle;
   uint64_t ping_ctr = 0;  // unique id for pings
   grpc_closure retry_initiate_ping_locked;
 
@@ -351,7 +362,6 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   size_t ping_ack_count = 0;
   size_t ping_ack_capacity = 0;
   uint64_t* ping_acks = nullptr;
-  grpc_chttp2_server_ping_recv_state ping_recv_state;
 
   /// parser for headers
   grpc_core::HPackParser hpack_parser;
@@ -485,15 +495,9 @@ struct grpc_chttp2_stream {
                      const void* server_data, grpc_core::Arena* arena);
   ~grpc_chttp2_stream();
 
-  void* context;
-  grpc_chttp2_transport* t;
+  void* context = nullptr;
+  const grpc_core::RefCountedPtr<grpc_chttp2_transport> t;
   grpc_stream_refcount* refcount;
-  // Reffer is a 0-len structure, simply reffing `t` and `refcount` in its ctor
-  // before initializing the rest of the stream, to avoid cache misses. This
-  // field MUST be right after `t` and `refcount`.
-  struct Reffer {
-    explicit Reffer(grpc_chttp2_stream* s);
-  } reffer;
 
   grpc_closure destroy_stream;
   grpc_closure* destroy_stream_arg;
@@ -679,8 +683,9 @@ void grpc_chttp2_act_on_flowctl_action(
 
 inline grpc_chttp2_stream* grpc_chttp2_parsing_lookup_stream(
     grpc_chttp2_transport* t, uint32_t id) {
-  return static_cast<grpc_chttp2_stream*>(
-      grpc_chttp2_stream_map_find(&t->stream_map, id));
+  auto it = t->stream_map.find(id);
+  if (it == t->stream_map.end()) return nullptr;
+  return it->second;
 }
 grpc_chttp2_stream* grpc_chttp2_parsing_accept_stream(grpc_chttp2_transport* t,
                                                       uint32_t id);
@@ -738,43 +743,11 @@ void grpc_chttp2_stream_ref(grpc_chttp2_stream* s);
 void grpc_chttp2_stream_unref(grpc_chttp2_stream* s);
 #endif
 
-#ifndef NDEBUG
-#define GRPC_CHTTP2_REF_TRANSPORT(t, r) \
-  grpc_chttp2_ref_transport(t, r, __FILE__, __LINE__)
-#define GRPC_CHTTP2_UNREF_TRANSPORT(t, r) \
-  grpc_chttp2_unref_transport(t, r, __FILE__, __LINE__)
-inline void grpc_chttp2_unref_transport(grpc_chttp2_transport* t,
-                                        const char* reason, const char* file,
-                                        int line) {
-  if (t->refs.Unref(grpc_core::DebugLocation(file, line), reason)) {
-    delete t;
-  }
-}
-inline void grpc_chttp2_ref_transport(grpc_chttp2_transport* t,
-                                      const char* reason, const char* file,
-                                      int line) {
-  t->refs.Ref(grpc_core::DebugLocation(file, line), reason);
-}
-#else
-#define GRPC_CHTTP2_REF_TRANSPORT(t, r) grpc_chttp2_ref_transport(t)
-#define GRPC_CHTTP2_UNREF_TRANSPORT(t, r) grpc_chttp2_unref_transport(t)
-inline void grpc_chttp2_unref_transport(grpc_chttp2_transport* t) {
-  if (t->refs.Unref()) {
-    delete t;
-  }
-}
-inline void grpc_chttp2_ref_transport(grpc_chttp2_transport* t) {
-  t->refs.Ref();
-}
-#endif
-
 void grpc_chttp2_ack_ping(grpc_chttp2_transport* t, uint64_t id);
 
-/// Add a new ping strike to ping_recv_state.ping_strikes. If
-/// ping_recv_state.ping_strikes > ping_policy.max_ping_strikes, it sends GOAWAY
-/// with error code ENHANCE_YOUR_CALM and additional debug data resembling
-/// "too_many_pings" followed by immediately closing the connection.
-void grpc_chttp2_add_ping_strike(grpc_chttp2_transport* t);
+/// Sends GOAWAY with error code ENHANCE_YOUR_CALM and additional debug data
+/// resembling "too_many_pings" followed by immediately closing the connection.
+void grpc_chttp2_exceeded_ping_strikes(grpc_chttp2_transport* t);
 
 /// Resets ping clock. Should be called when flushing window updates,
 /// initial/trailing metadata or data frames. For a server, it resets the number
@@ -805,10 +778,14 @@ void grpc_chttp2_fail_pending_writes(grpc_chttp2_transport* t,
 /// initialization
 void grpc_chttp2_config_default_keepalive_args(grpc_channel_args* args,
                                                bool is_client);
+void grpc_chttp2_config_default_keepalive_args(
+    const grpc_core::ChannelArgs& channel_args, bool is_client);
 
-void grpc_chttp2_retry_initiate_ping(grpc_chttp2_transport* t);
+void grpc_chttp2_retry_initiate_ping(
+    grpc_core::RefCountedPtr<grpc_chttp2_transport> t);
 
-void schedule_bdp_ping_locked(grpc_chttp2_transport* t);
+void schedule_bdp_ping_locked(
+    grpc_core::RefCountedPtr<grpc_chttp2_transport> t);
 
 uint32_t grpc_chttp2_min_read_progress_size(grpc_chttp2_transport* t);
 

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

@@ -25,6 +25,7 @@
 #include <string>
 
 #include "absl/base/attributes.h"
+#include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -46,14 +47,16 @@
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/ext/transport/chttp2/transport/stream_map.h"
+#include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
+#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/bdp_estimator.h"
@@ -64,6 +67,8 @@
 
 using grpc_core::HPackParser;
 
+grpc_core::TraceFlag grpc_trace_chttp2_new_stream(false, "chttp2_new_stream");
+
 static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t);
 static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                                                   int is_continuation);
@@ -507,8 +512,7 @@ static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t) {
   if (bdp_est) {
     if (t->bdp_ping_blocked) {
       t->bdp_ping_blocked = false;
-      GRPC_CHTTP2_REF_TRANSPORT(t, "bdp_ping");
-      schedule_bdp_ping_locked(t);
+      schedule_bdp_ping_locked(t->Ref());
     }
     bdp_est->AddIncomingBytes(t->incoming_frame_size);
   }
@@ -546,7 +550,7 @@ error_handler:
     t->incoming_stream = s;
     t->parser = grpc_chttp2_transport::Parser{
         "data", grpc_chttp2_data_parser_parse, nullptr};
-    t->ping_state.last_ping_sent_time = grpc_core::Timestamp::InfPast();
+    t->ping_rate_policy.ReceivedDataFrame();
     return absl::OkStatus();
   } else if (s != nullptr) {
     // handle stream errors by closing the stream
@@ -585,7 +589,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                                  ? HPackParser::Priority::Included
                                  : HPackParser::Priority::None;
 
-  t->ping_state.last_ping_sent_time = grpc_core::Timestamp::InfPast();
+  t->ping_rate_policy.ReceivedDataFrame();
 
   // could be a new grpc_chttp2_stream or an existing grpc_chttp2_stream
   s = grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
@@ -620,11 +624,13 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           t->incoming_stream_id));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(
-                   grpc_chttp2_stream_map_size(&t->stream_map) >=
+                   t->stream_map.size() >=
                    t->settings[GRPC_ACKED_SETTINGS]
                               [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])) {
       return GRPC_ERROR_CREATE("Max stream count exceeded");
-    } else if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT) {
+    } else if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT ||
+               t->sent_goaway_state ==
+                   GRPC_CHTTP2_FINAL_GOAWAY_SEND_SCHEDULED) {
       GRPC_CHTTP2_IF_TRACING(gpr_log(
           GPR_INFO,
           "transport:%p SERVER peer:%s Final GOAWAY sent. Ignoring new "
@@ -641,6 +647,12 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           gpr_log(GPR_ERROR, "grpc_chttp2_stream not accepted"));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     }
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
+        GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_new_stream)) {
+      gpr_log(GPR_INFO, "[t:%p fd:%d peer:%s] Accepting new stream", t,
+              grpc_endpoint_get_fd(t->ep),
+              std::string(t->peer_string.as_string_view()).c_str());
+    }
     if (t->channelz_socket != nullptr) {
       t->channelz_socket->RecordStreamStartedFromRemote();
     }
@@ -671,6 +683,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
         }
         s->parsed_trailers_only = true;
         s->trailing_metadata_buffer.Set(grpc_core::GrpcTrailersOnly(), true);
+        s->initial_metadata_buffer.Set(grpc_core::GrpcTrailersOnly(), true);
         incoming_metadata_buffer = &s->trailing_metadata_buffer;
         frame_type = HPackParser::LogInfo::kTrailers;
       } else {
@@ -829,7 +842,7 @@ static const maybe_complete_func_type maybe_complete_funcs[] = {
 
 static void force_client_rst_stream(void* sp, grpc_error_handle /*error*/) {
   grpc_chttp2_stream* s = static_cast<grpc_chttp2_stream*>(sp);
-  grpc_chttp2_transport* t = s->t;
+  grpc_chttp2_transport* t = s->t.get();
   if (!s->write_closed) {
     grpc_chttp2_add_rst_stream_to_next_write(t, s->id, GRPC_HTTP2_NO_ERROR,
                                              &s->stats.outgoing);
@@ -845,10 +858,18 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
                                                   const grpc_slice& slice,
                                                   int is_last) {
   auto* parser = static_cast<grpc_core::HPackParser*>(hpack_parser);
+  grpc_core::CallTracerAnnotationInterface* call_tracer = nullptr;
   if (s != nullptr) {
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
+
+    if (s->context != nullptr) {
+      call_tracer = static_cast<grpc_core::CallTracerAnnotationInterface*>(
+          static_cast<grpc_call_context_element*>(
+              s->context)[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE]
+              .value);
+    }
   }
-  grpc_error_handle error = parser->Parse(slice, is_last != 0);
+  grpc_error_handle error = parser->Parse(slice, is_last != 0, call_tracer);
   if (!error.ok()) {
     return error;
   }