grpc 1.71.0 → 1.73.0

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

@@ -0,0 +1,252 @@
+// 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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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;
+
+  size_t MemoryUsage() const {
+    return sizeof(*this) +
+           sizeof(Http2SettingsFrame::Setting) * settings.size();
+  }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this) + debug_data.size(); }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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;
+
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  void RenderJson(Json::Object& json) const {
+    json["metadata_type"] = Json::FromString("BEGIN_ENDPOINT_WRITE");
+    json["write_size"] = Json::FromNumber(write_size);
+  }
+};
+
+struct H2EndWriteCycle {
+  size_t MemoryUsage() const { return sizeof(*this); }
+
+  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

@@ -38,9 +38,9 @@
 #include "absl/random/random.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#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"
@@ -51,6 +51,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/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"
@@ -69,11 +71,11 @@
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/init_internally.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #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/tcp_tracer.h"
+#include "src/core/telemetry/context_list_entry.h"
+#include "src/core/telemetry/stats.h"
 #include "src/core/util/bitset.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/ref_counted.h"
@@ -230,6 +232,21 @@ 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) {}
+    ~ChannelzDataSource() { ResetDataSource(); }
+
+    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() {
@@ -251,6 +268,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;
@@ -276,7 +297,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
@@ -472,7 +492,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
@@ -489,6 +508,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
@@ -561,6 +581,9 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::Timestamp last_window_update_time =
       grpc_core::Timestamp::InfPast();
 
+  grpc_core::Http2StatsCollector http2_stats;
+  grpc_core::Http2ZTraceCollector http2_ztrace_collector;
+
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
 };
 
@@ -671,15 +694,23 @@ struct grpc_chttp2_stream {
   int64_t write_counter = 0;
 
   grpc_core::Chttp2CallTracerWrapper call_tracer_wrapper;
-
-  // TODO(roth): Remove this when call v3 is supported.
+  // 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.)
+  // In the transport, we use tracers for two things, recording byte stats and
+  // recording annotations. Recording byte stats is safe as long as call_tracer
+  // is non null. Recording annotations on the other hand is only safe after
+  // send_initial_metadata. On the client, this is not an issue since that is
+  // the first operation. On the server, we would ideally be able to record
+  // annotations as soon as we have parsed initial metadata, but in our legacy
+  // stack, we create the stream before parsing headers. In the new v3 stack,
+  // that won't be an issue.
   grpc_core::CallTracerInterface* call_tracer = nullptr;
   // TODO(yashykt): Remove this once call_tracer_transport_fix is rolled out
   grpc_core::CallTracerAnnotationInterface* parent_call_tracer = nullptr;
 
-  /// Only set when enabled.
-  std::shared_ptr<grpc_core::TcpTracerInterface> tcp_tracer;
-
   // time this stream was created
   gpr_timespec creation_time = gpr_now(GPR_CLOCK_MONOTONIC);
 
@@ -700,18 +731,8 @@ struct grpc_chttp2_stream {
   // The last time a stream window update was received.
   grpc_core::Timestamp last_window_update_time =
       grpc_core::Timestamp::InfPast();
-
-  // TODO(yashykt): Remove this when call v3 is supported.
-  grpc_core::CallTracerInterface* CallTracer() const {
-    if (t->is_client) {
-      return call_tracer;
-    }
-    return arena->GetContext<grpc_core::CallTracerInterface>();
-  }
 };
 
-#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

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/parsing.cc

@@ -40,6 +40,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
+#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/flow_control.h"
@@ -53,6 +54,8 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
@@ -65,17 +68,17 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/bdp_estimator.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/http2_errors.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/random_early_detection.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
 
 using grpc_core::HPackParser;
+using grpc_core::http2::Http2ErrorCode;
 
 static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
                                            size_t& requests_started);
@@ -519,6 +522,12 @@ static grpc_error_handle init_header_skip_frame_parser(
 
 static grpc_error_handle init_non_header_skip_frame_parser(
     grpc_chttp2_transport* t) {
+  t->http2_ztrace_collector.Append(grpc_core::H2UnknownFrameTrace{
+      t->incoming_frame_type,
+      t->incoming_frame_flags,
+      t->incoming_stream_id,
+      t->incoming_frame_size,
+  });
   t->parser =
       grpc_chttp2_transport::Parser{"skip_parser", skip_parser, nullptr};
   return absl::OkStatus();
@@ -536,6 +545,8 @@ 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);
   if (bdp_est) {
     if (t->bdp_ping_blocked) {
       t->bdp_ping_blocked = false;
@@ -583,9 +594,10 @@ error_handler:
     // handle stream errors by closing the stream
     grpc_chttp2_mark_stream_closed(t, s, true, false,
                                    absl_status_to_grpc_error(status));
-    grpc_chttp2_add_rst_stream_to_next_write(t, t->incoming_stream_id,
-                                             GRPC_HTTP2_PROTOCOL_ERROR,
-                                             &s->call_tracer_wrapper);
+    grpc_chttp2_add_rst_stream_to_next_write(
+        t, t->incoming_stream_id,
+        static_cast<uint32_t>(Http2ErrorCode::kProtocolError),
+        &s->call_tracer_wrapper);
     return init_non_header_skip_frame_parser(t);
   } else {
     return absl_status_to_grpc_error(status);
@@ -619,6 +631,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
 
   t->ping_rate_policy.ReceivedDataFrame();
 
+  grpc_core::SharedBitGen g;
   // could be a new grpc_chttp2_stream or an existing grpc_chttp2_stream
   s = grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
   if (s == nullptr) {
@@ -651,9 +664,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     } else if (GPR_UNLIKELY(t->stream_map.size() + t->extra_streams >=
                             t->settings.acked().max_concurrent_streams())) {
       ++t->num_pending_induced_frames;
-      grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_rst_stream_create(
-                                          t->incoming_stream_id,
-                                          GRPC_HTTP2_REFUSED_STREAM, nullptr));
+      grpc_slice_buffer_add(
+          &t->qbuf, grpc_chttp2_rst_stream_create(
+                        t->incoming_stream_id,
+                        static_cast<uint32_t>(Http2ErrorCode::kRefusedStream),
+                        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() &&
@@ -663,9 +678,10 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       grpc_core::global_stats().IncrementRqCallsRejected();
       ++t->num_pending_induced_frames;
       grpc_slice_buffer_add(
-          &t->qbuf,
-          grpc_chttp2_rst_stream_create(t->incoming_stream_id,
-                                        GRPC_HTTP2_ENHANCE_YOUR_CALM, nullptr));
+          &t->qbuf, grpc_chttp2_rst_stream_create(
+                        t->incoming_stream_id,
+                        static_cast<uint32_t>(Http2ErrorCode::kEnhanceYourCalm),
+                        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 (GPR_UNLIKELY(
@@ -675,9 +691,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       // We have more streams allocated than we'd like, so apply some pushback
       // by refusing this stream.
       ++t->num_pending_induced_frames;
-      grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_rst_stream_create(
-                                          t->incoming_stream_id,
-                                          GRPC_HTTP2_REFUSED_STREAM, nullptr));
+      grpc_slice_buffer_add(
+          &t->qbuf, grpc_chttp2_rst_stream_create(
+                        t->incoming_stream_id,
+                        static_cast<uint32_t>(Http2ErrorCode::kRefusedStream),
+                        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 (GPR_UNLIKELY(t->stream_map.size() >=
@@ -685,14 +703,16 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                             grpc_core::RandomEarlyDetection(
                                 t->settings.local().max_concurrent_streams(),
                                 t->settings.acked().max_concurrent_streams())
-                                .Reject(t->stream_map.size(), t->bitgen))) {
+                                .Reject(t->stream_map.size(), g))) {
       // We are under the limit of max concurrent streams for the current
       // setting, but are over the next value that will be advertised.
       // Apply some backpressure by randomly not accepting new streams.
       ++t->num_pending_induced_frames;
-      grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_rst_stream_create(
-                                          t->incoming_stream_id,
-                                          GRPC_HTTP2_REFUSED_STREAM, nullptr));
+      grpc_slice_buffer_add(
+          &t->qbuf, grpc_chttp2_rst_stream_create(
+                        t->incoming_stream_id,
+                        static_cast<uint32_t>(Http2ErrorCode::kRefusedStream),
+                        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 (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT ||
@@ -716,9 +736,10 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           << " before settings have been acknowledged";
       ++t->num_pending_induced_frames;
       grpc_slice_buffer_add(
-          &t->qbuf,
-          grpc_chttp2_rst_stream_create(t->incoming_stream_id,
-                                        GRPC_HTTP2_ENHANCE_YOUR_CALM, nullptr));
+          &t->qbuf, grpc_chttp2_rst_stream_create(
+                        t->incoming_stream_id,
+                        static_cast<uint32_t>(Http2ErrorCode::kEnhanceYourCalm),
+                        nullptr, &t->http2_ztrace_collector));
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
       t->last_new_stream_id = t->incoming_stream_id;
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
@@ -941,8 +962,9 @@ 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.get();
   if (!s->write_closed) {
-    grpc_chttp2_add_rst_stream_to_next_write(t, s->id, GRPC_HTTP2_NO_ERROR,
-                                             &s->call_tracer_wrapper);
+    grpc_chttp2_add_rst_stream_to_next_write(
+        t, s->id, static_cast<uint32_t>(Http2ErrorCode::kNoError),
+        &s->call_tracer_wrapper);
     grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_FORCE_RST_STREAM);
     grpc_chttp2_mark_stream_closed(t, s, true, true, absl::OkStatus());
   }
@@ -959,17 +981,23 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
   if (s != nullptr) {
     s->call_tracer_wrapper.RecordIncomingBytes(
         {0, 0, GRPC_SLICE_LENGTH(slice)});
-    call_tracer =
-        grpc_core::IsCallTracerTransportFixEnabled()
-            ? s->CallTracer()
-            : s->arena->GetContext<grpc_core::CallTracerAnnotationInterface>();
+    call_tracer = s->call_tracer;
   }
-  grpc_error_handle error = parser->Parse(
-      slice, is_last != 0, absl::BitGenRef(t->bitgen), call_tracer);
+  grpc_core::SharedBitGen g;
+  grpc_error_handle error =
+      parser->Parse(slice, is_last != 0, absl::BitGenRef(g), call_tracer);
   if (!error.ok()) {
     return error;
   }
   if (is_last) {
+    t->http2_ztrace_collector.Append([t]() {
+      return grpc_core::H2HeaderTrace<true>{
+          t->incoming_stream_id,
+          (t->incoming_frame_flags & GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0,
+          (t->incoming_frame_flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) != 0,
+          t->incoming_frame_type == GRPC_CHTTP2_FRAME_CONTINUATION,
+          t->incoming_frame_size};
+    });
     // need to check for null stream: this can occur if we receive an invalid
     // stream id on a header
     if (s != nullptr) {

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

@@ -25,12 +25,6 @@
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/util/match.h"
 
-// How many pings do we allow to be inflight at any given time?
-// In older versions of gRPC this was implicitly 1.
-// With the multiping experiment we allow this to rise to 100 by default.
-// TODO(ctiller): consider making this public API
-#define GRPC_ARG_HTTP2_MAX_INFLIGHT_PINGS "grpc.http2.max_inflight_pings"
-
 namespace grpc_core {
 
 namespace {
@@ -64,9 +58,16 @@ void Chttp2PingRatePolicy::SetDefaults(const ChannelArgs& args) {
 Chttp2PingRatePolicy::RequestSendPingResult
 Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval,
                                       size_t inflight_pings) const {
-  if (max_inflight_pings_ > 0 &&
-      inflight_pings > static_cast<size_t>(max_inflight_pings_)) {
-    return TooManyRecentPings{};
+  if (max_inflight_pings_ > 0) {
+    if (!IsMaxInflightPingsStrictLimitEnabled()) {
+      if (inflight_pings > static_cast<size_t>(max_inflight_pings_)) {
+        return TooManyRecentPings{};
+      }
+    } else {
+      if (inflight_pings >= static_cast<size_t>(max_inflight_pings_)) {
+        return TooManyRecentPings{};
+      }
+    }
   }
   const Timestamp next_allowed_ping =
       last_ping_sent_time_ + next_allowed_ping_interval;

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

@@ -27,6 +27,12 @@
 
 namespace grpc_core {
 
+// How many pings do we allow to be inflight at any given time?
+// In older versions of gRPC this was implicitly 1.
+// With the multiping experiment we allow this to rise to 100 by default.
+// TODO(ctiller): consider making this public API
+#define GRPC_ARG_HTTP2_MAX_INFLIGHT_PINGS "grpc.http2.max_inflight_pings"
+
 class Chttp2PingRatePolicy {
  public:
   explicit Chttp2PingRatePolicy(const ChannelArgs& args, bool is_client);