grpc 1.71.0 → 1.73.0

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

@@ -25,6 +25,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 
@@ -50,6 +51,19 @@ namespace grpc_core {
 //
 // Equality operators are defined for use in unit tests.
 
+// All frames begin with a fixed 9-octet header followed by a variable-length
+// frame payload. The following sizes are in bits.
+// HTTP Frame {
+//   Length(24),
+//   Type(8),
+//   Flags(8),
+//   Reserved(1),
+//   Stream Identifier(31),
+//   Frame Payload(..),
+// }
+// Reference : https://www.rfc-editor.org/rfc/rfc9113.html#name-frame-format
+constexpr uint8_t kFrameHeaderSize = 9;
+
 // DATA frame
 struct Http2DataFrame {
   uint32_t stream_id = 0;
@@ -143,8 +157,8 @@ struct Http2GoawayFrame {
 
 // WINDOW_UPDATE frame
 struct Http2WindowUpdateFrame {
-  uint32_t stream_id;
-  uint32_t increment;
+  uint32_t stream_id = 0;
+  uint32_t increment = 0;
 
   bool operator==(const Http2WindowUpdateFrame& other) const {
     return stream_id == other.stream_id && increment == other.increment;
@@ -165,6 +179,11 @@ struct Http2UnknownFrame {
   bool operator==(const Http2UnknownFrame&) const { return true; }
 };
 
+// This is used as a fake frame to trigger events in the HTTP2 transport.
+struct Http2EmptyFrame {
+  bool operator==(const Http2EmptyFrame&) const { return true; }
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 // Frame variant
 //
@@ -174,7 +193,7 @@ using Http2Frame =
     std::variant<Http2DataFrame, Http2HeaderFrame, Http2ContinuationFrame,
                  Http2RstStreamFrame, Http2SettingsFrame, Http2PingFrame,
                  Http2GoawayFrame, Http2WindowUpdateFrame, Http2SecurityFrame,
-                 Http2UnknownFrame>;
+                 Http2UnknownFrame, Http2EmptyFrame>;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Frame header
@@ -211,13 +230,102 @@ struct Http2FrameHeader {
 // If a frame should simply be ignored, this function returns a
 // Http2UnknownFrame.
 // It is expected that hdr.length == payload.Length().
-absl::StatusOr<Http2Frame> ParseFramePayload(const Http2FrameHeader& hdr,
-                                             SliceBuffer payload);
+http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
+    const Http2FrameHeader& hdr, SliceBuffer payload);
 
 // Serialize frame and append to out, leaves frames in an unknown state (may
 // move things out of frames)
 void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
 
+///////////////////////////////////////////////////////////////////////////////
+// GRPC Header
+
+constexpr uint8_t kGrpcHeaderSizeInBytes = 5;
+
+struct GrpcMessageHeader {
+  uint8_t flags = 0;
+  uint32_t length = 0;
+};
+
+// If the payload SliceBuffer is too small to hold a gRPC header, this function
+// will crash. The calling function MUST ensure that the payload SliceBuffer
+// has length greater than or equal to the gRPC header.
+GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload);
+
+void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint8_t flags,
+                                   const uint32_t length);
+
+namespace RFC9113 {
+// RFC9113: 5.1.1.
+inline constexpr absl::string_view kStreamIdMustBeOdd =
+    "RFC9113: Streams initiated by a client MUST use odd-numbered stream "
+    "identifiers";  // gRPC streams are only initiated by a client.
+
+// 6.
+// Stream Identifier related errors
+// Non-Zero Stream Identifier
+inline constexpr absl::string_view kDataStreamIdMustBeNonZero =
+    "RFC9113: DATA frames MUST be associated with a stream";
+inline constexpr absl::string_view kHeaderStreamIdMustBeNonZero =
+    "RFC9113: HEADERS frames MUST be associated with a stream";
+inline constexpr absl::string_view kContinuationStreamIdMustBeNonZero =
+    "RFC9113: CONTINUATION frames MUST be associated with a stream";
+inline constexpr absl::string_view kRstStreamStreamIdMustBeNonZero =
+    "RFC9113: RST_STREAM frames frames MUST be associated with a stream";
+
+// Zero Stream Identifier
+inline constexpr absl::string_view kPingStreamIdMustBeZero =
+    "RFC9113: If a PING frame is received with a Stream Identifier field "
+    "value other than 0x00, the recipient MUST respond with a connection error";
+inline constexpr absl::string_view kGoAwayStreamIdMustBeZero =
+    "RFC9113: An endpoint MUST treat a GOAWAY frame with a stream identifier "
+    "other than 0x00 as a connection error";
+inline constexpr absl::string_view kSettingsStreamIdMustBeZero =
+    "RFC9113: If an endpoint receives a SETTINGS frame whose Stream "
+    "Identifier field is anything other than 0x00, the endpoint MUST respond "
+    "with a connection error";
+
+// Frame length related errors
+inline constexpr absl::string_view kRstStreamLength4 =
+    "RFC9113: A RST_STREAM frame with a length other than 4 octets MUST be "
+    "treated as a connection error";
+inline constexpr absl::string_view kSettingsLength0 =
+    "RFC9113: Receipt of a SETTINGS frame with the ACK flag set and a length "
+    "field value other than 0 MUST be treated as a connection error";
+inline constexpr absl::string_view kSettingsLength6x =
+    "RFC9113: SETTINGS frame with a length other than a multiple of 6 octets "
+    "MUST be treated as a connection error";
+inline constexpr absl::string_view kPingLength8 =
+    "RFC9113: Receipt of a PING frame with a length field value other than 8 "
+    "MUST be treated as a connection error";
+inline constexpr absl::string_view kWindowUpdateLength4 =
+    "RFC9113: A WINDOW_UPDATE frame with a length other than 4 octets MUST be "
+    "treated as a connection error";
+inline constexpr absl::string_view kWindowSizeIncrement =
+    "RFC9113: The legal range for the increment to the flow-control window is "
+    "1 to (2^31)-1";
+inline constexpr absl::string_view kPaddingLengthLargerThanFrameLength =
+    "RFC9113: If the length of the padding is the length of the frame payload "
+    "or greater, the recipient MUST treat this as a connection error";
+
+// Misc Errors
+inline constexpr absl::string_view kNoPushPromise =
+    "RFC9113: PUSH_PROMISE MUST NOT be sent if the SETTINGS_ENABLE_PUSH "
+    "setting of the "
+    "peer endpoint is set to 0";
+
+inline constexpr absl::string_view kFrameParserIncorrectPadding =
+    "Incorrect length of padding in frame";
+inline constexpr absl::string_view kIncorrectFrame = "Incorrect Frame";
+inline constexpr absl::string_view kGoAwayLength8 =
+    "GOAWAY frame should have a Last-Stream-ID and Error Code making the "
+    "minimum length 8 octets";
+
+// TODO(tjagtap) : [PH2][P2] : Take care that our transport class does not make
+// stream id larger than this.
+inline constexpr uint32_t kMaxStreamId31Bit = 0x7fffffffu;
+
+}  // namespace RFC9113
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_H

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

@@ -31,6 +31,7 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/stats.h"
 #include "src/core/util/status_helper.h"
 
 absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
@@ -54,6 +55,7 @@ absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
 void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
                              uint32_t write_bytes, int is_eof,
                              grpc_core::CallTracerInterface* call_tracer,
+                             grpc_core::Http2ZTraceCollector* ztrace_collector,
                              grpc_slice_buffer* outbuf) {
   grpc_slice hdr;
   uint8_t* p;
@@ -73,8 +75,12 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
   *p++ = static_cast<uint8_t>(id);
   grpc_slice_buffer_add(outbuf, hdr);
 
+  ztrace_collector->Append(
+      grpc_core::H2DataTrace<false>{id, is_eof != 0, write_bytes});
+
   grpc_slice_buffer_move_first_no_ref(inbuf, write_bytes, outbuf);
 
+  grpc_core::global_stats().IncrementHttp2WriteDataFrameSize(write_bytes);
   call_tracer->RecordOutgoingBytes({header_size, 0, 0});
 }
 
@@ -146,6 +152,12 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* /*parser*/,
   grpc_slice_buffer_add(&s->frame_storage, slice);
   grpc_chttp2_maybe_complete_recv_message(t, s);
 
+  if (is_last) {
+    t->http2_ztrace_collector.Append(grpc_core::H2DataTrace<true>{
+        t->incoming_stream_id,
+        (t->incoming_frame_flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) != 0,
+        t->incoming_frame_size});
+  }
   if (is_last && s->received_last_frame) {
     grpc_chttp2_mark_stream_closed(
         t, s, true, false,

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

@@ -26,6 +26,7 @@
 #include <stdint.h>
 
 #include "absl/status/status.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/promise/poll.h"
@@ -49,6 +50,7 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* parser,
 void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
                              uint32_t write_bytes, int is_eof,
                              grpc_core::CallTracerInterface* call_tracer,
+                             grpc_core::Http2ZTraceCollector* ztrace_collector,
                              grpc_slice_buffer* outbuf);
 
 grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(

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

@@ -138,6 +138,11 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
       p->debug_pos += static_cast<uint32_t>(end - cur);
       p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
       if (is_last) {
+        t->http2_ztrace_collector.Append([p]() {
+          return grpc_core::H2GoAwayTrace<true>{
+              p->last_stream_id, p->error_code,
+              std::string(absl::string_view(p->debug_data, p->debug_length))};
+        });
         grpc_chttp2_add_incoming_goaway(
             t, p->error_code, p->last_stream_id,
             absl::string_view(p->debug_data, p->debug_length));
@@ -149,15 +154,22 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
   GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE("Should never reach here"));
 }
 
-void grpc_chttp2_goaway_append(uint32_t last_stream_id, uint32_t error_code,
-                               const grpc_slice& debug_data,
-                               grpc_slice_buffer* slice_buffer) {
+void grpc_chttp2_goaway_append(
+    uint32_t last_stream_id, uint32_t error_code, const grpc_slice& debug_data,
+    grpc_slice_buffer* slice_buffer,
+    grpc_core::Http2ZTraceCollector* ztrace_collector) {
   grpc_slice header = GRPC_SLICE_MALLOC(9 + 4 + 4);
   uint8_t* p = GRPC_SLICE_START_PTR(header);
   uint32_t frame_length;
   CHECK(GRPC_SLICE_LENGTH(debug_data) < UINT32_MAX - 4 - 4);
   frame_length = 4 + 4 + static_cast<uint32_t> GRPC_SLICE_LENGTH(debug_data);
 
+  ztrace_collector->Append([last_stream_id, error_code, debug_data]() {
+    return grpc_core::H2GoAwayTrace<false>{
+        last_stream_id, error_code,
+        std::string(grpc_core::StringViewFromSlice(debug_data))};
+  });
+
   // frame header: length
   *p++ = static_cast<uint8_t>(frame_length >> 16);
   *p++ = static_cast<uint8_t>(frame_length >> 8);

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

@@ -23,6 +23,7 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 
@@ -56,8 +57,9 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
                                                   const grpc_slice& slice,
                                                   int is_last);
 
-void grpc_chttp2_goaway_append(uint32_t last_stream_id, uint32_t error_code,
-                               const grpc_slice& debug_data,
-                               grpc_slice_buffer* slice_buffer);
+void grpc_chttp2_goaway_append(
+    uint32_t last_stream_id, uint32_t error_code, const grpc_slice& debug_data,
+    grpc_slice_buffer* slice_buffer,
+    grpc_core::Http2ZTraceCollector* ztrace_collector);
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_GOAWAY_H

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

@@ -90,6 +90,8 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
 
   if (p->byte == 8) {
     CHECK(is_last);
+    t->http2_ztrace_collector.Append(
+        grpc_core::H2PingTrace<true>{p->is_ack != 0, p->opaque_8bytes});
     if (p->is_ack) {
       GRPC_TRACE_LOG(http2_ping, INFO)
           << (t->is_client ? "CLIENT" : "SERVER") << "[" << t

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

@@ -28,23 +28,28 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.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_callbacks.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
-#include "src/core/lib/transport/http2_errors.h"
-#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
 
+using grpc_core::http2::Http2ErrorCode;
+
 grpc_slice grpc_chttp2_rst_stream_create(
-    uint32_t id, uint32_t code, grpc_core::CallTracerInterface* call_tracer) {
+    uint32_t id, uint32_t code, grpc_core::CallTracerInterface* call_tracer,
+    grpc_core::Http2ZTraceCollector* ztrace_collector) {
   static const size_t frame_size = 13;
   grpc_slice slice = GRPC_SLICE_MALLOC(frame_size);
   if (call_tracer != nullptr) {
     call_tracer->RecordOutgoingBytes({frame_size, 0, 0});
   }
+  ztrace_collector->Append(grpc_core::H2RstStreamTrace<false>{id, code});
   uint8_t* p = GRPC_SLICE_START_PTR(slice);
 
   // Frame size.
@@ -73,8 +78,9 @@ void grpc_chttp2_add_rst_stream_to_next_write(
     grpc_chttp2_transport* t, uint32_t id, uint32_t code,
     grpc_core::CallTracerInterface* call_tracer) {
   t->num_pending_induced_frames++;
-  grpc_slice_buffer_add(&t->qbuf,
-                        grpc_chttp2_rst_stream_create(id, code, call_tracer));
+  grpc_slice_buffer_add(
+      &t->qbuf, grpc_chttp2_rst_stream_create(id, code, call_tracer,
+                                              &t->http2_ztrace_collector));
 }
 
 grpc_error_handle grpc_chttp2_rst_stream_parser_begin_frame(
@@ -112,11 +118,14 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
                       ((static_cast<uint32_t>(p->reason_bytes[1])) << 16) |
                       ((static_cast<uint32_t>(p->reason_bytes[2])) << 8) |
                       ((static_cast<uint32_t>(p->reason_bytes[3])));
+    t->http2_ztrace_collector.Append(
+        grpc_core::H2RstStreamTrace<true>{t->incoming_stream_id, reason});
     GRPC_TRACE_LOG(http, INFO)
         << "[chttp2 transport=" << t << " stream=" << s
         << "] received RST_STREAM(reason=" << reason << ")";
     grpc_error_handle error;
-    if (reason != GRPC_HTTP2_NO_ERROR || s->trailing_metadata_buffer.empty()) {
+    if (reason != static_cast<uint32_t>(Http2ErrorCode::kNoError) ||
+        s->trailing_metadata_buffer.empty()) {
       error = grpc_error_set_int(
           grpc_error_set_str(
               GRPC_ERROR_CREATE("RST_STREAM"),
@@ -125,8 +134,9 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
           grpc_core::StatusIntProperty::kHttp2Error,
           static_cast<intptr_t>(reason));
     }
+    grpc_core::SharedBitGen g;
     if (!t->is_client &&
-        absl::Bernoulli(t->bitgen, t->ping_on_rst_stream_percent / 100.0)) {
+        absl::Bernoulli(g, t->ping_on_rst_stream_percent / 100.0)) {
       ++t->num_pending_induced_frames;
       t->ping_callbacks.RequestPing();
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_KEEPALIVE_PING);

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

@@ -23,6 +23,7 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/transport.h"
@@ -34,7 +35,8 @@ struct grpc_chttp2_rst_stream_parser {
 };
 grpc_slice grpc_chttp2_rst_stream_create(
     uint32_t stream_id, uint32_t code,
-    grpc_core::CallTracerInterface* call_tracer);
+    grpc_core::CallTracerInterface* call_tracer,
+    grpc_core::Http2ZTraceCollector* ztrace_collector);
 
 // Adds RST_STREAM frame to t->qbuf (buffer for the next write). Should be
 // called when we want to add RST_STREAM and we are not in

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

@@ -31,6 +31,7 @@
 #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/http2_settings.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/lib/debug/trace.h"
@@ -40,6 +41,8 @@
 #include "src/core/util/debug_location.h"
 #include "src/core/util/useful.h"
 
+using grpc_core::http2::Http2ErrorCode;
+
 static uint8_t* fill_header(uint8_t* out, uint32_t length, uint8_t flags) {
   *out++ = static_cast<uint8_t>(length >> 16);
   *out++ = static_cast<uint8_t>(length >> 8);
@@ -92,6 +95,8 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
   const uint8_t* end = GRPC_SLICE_END_PTR(slice);
 
   if (parser->is_ack) {
+    t->http2_ztrace_collector.Append(
+        grpc_core::H2SettingsTrace<true>{true, {}});
     return absl::OkStatus();
   }
 
@@ -116,6 +121,20 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
             grpc_core::global_stats()
                 .IncrementHttp2PreferredReceiveCryptoMessageSize(
                     target_settings->preferred_receive_crypto_message_size());
+            t->http2_ztrace_collector.Append([parser]() {
+              grpc_core::H2SettingsTrace<true> settings{false, {}};
+              // TODO(ctiller): produce actual wire settings here, not a
+              // diff. Likely this needs to wait for PH2 where we separate
+              // the parse loop from the application loop.
+              parser->incoming_settings->Diff(
+                  false, *parser->target_settings,
+                  [&settings](uint16_t key, uint32_t value) {
+                    settings.settings.push_back({key, value});
+                  });
+              return settings;
+            });
+            t->http2_ztrace_collector.Append(
+                []() { return grpc_core::H2SettingsTrace<false>{true, {}}; });
             *parser->target_settings = *parser->incoming_settings;
             t->num_pending_induced_frames++;
             grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_settings_ack_create());
@@ -193,10 +212,11 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         }
         auto error =
             parser->incoming_settings->Apply(parser->id, parser->value);
-        if (error != GRPC_HTTP2_NO_ERROR) {
+        if (error != Http2ErrorCode::kNoError) {
           grpc_chttp2_goaway_append(
-              t->last_new_stream_id, error,
-              grpc_slice_from_static_string("HTTP2 settings error"), &t->qbuf);
+              t->last_new_stream_id, static_cast<uint32_t>(error),
+              grpc_slice_from_static_string("HTTP2 settings error"), &t->qbuf,
+              &t->http2_ztrace_collector);
           return GRPC_ERROR_CREATE(absl::StrFormat(
               "invalid value %u passed for %s", parser->value,
               grpc_core::Http2Settings::WireIdToName(parser->id).c_str()));

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

@@ -27,6 +27,7 @@
 #include "absl/strings/str_format.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.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/stream_lists.h"
 #include "src/core/telemetry/stats.h"
@@ -101,6 +102,9 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
     }
     CHECK(is_last);
 
+    t->http2_ztrace_collector.Append(grpc_core::H2WindowUpdateTrace<true>{
+        t->incoming_stream_id, received_update});
+
     if (t->incoming_stream_id != 0) {
       if (s != nullptr) {
         grpc_core::Timestamp now = grpc_core::Timestamp::Now();

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

@@ -101,6 +101,13 @@ void HPackCompressor::Frame(const EncodeHeaderOptions& options,
     FillHeader(grpc_slice_buffer_tiny_add(output, kHeadersFrameHeaderSize),
                frame_type, options.stream_id, len, flags);
     options.call_tracer->RecordOutgoingBytes({kHeadersFrameHeaderSize, 0, 0});
+    options.ztrace_collector->Append([&]() {
+      return H2HeaderTrace<false>{
+          options.stream_id, (flags & GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0,
+          (flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) != 0,
+          frame_type == GRPC_CHTTP2_FRAME_CONTINUATION,
+          static_cast<uint32_t>(len)};
+    });
     grpc_slice_buffer_move_first(raw.c_slice_buffer(), len, output);
 
     frame_type = GRPC_CHTTP2_FRAME_CONTINUATION;

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

@@ -31,12 +31,13 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/metadata_compression_traits.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
-#include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/metadata_compression_traits.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"
@@ -353,6 +354,7 @@ class HPackCompressor {
     bool use_true_binary_metadata;
     size_t max_frame_size;
     CallTracerInterface* call_tracer;
+    Http2ZTraceCollector* ztrace_collector;
   };
 
   template <typename HeaderSet>

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

@@ -27,8 +27,8 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"

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

@@ -38,6 +38,8 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "src/core/call/metadata_info.h"
+#include "src/core/call/parsed_metadata.h"
 #include "src/core/ext/transport/chttp2/transport/decode_huff.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
@@ -46,8 +48,6 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/metadata_info.h"
-#include "src/core/lib/transport/parsed_metadata.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"

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

@@ -34,13 +34,13 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "src/core/call/metadata_batch.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/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_refcount.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/util/random_early_detection.h"
 

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

@@ -29,10 +29,10 @@
 #include <vector>
 
 #include "absl/functional/function_ref.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/parsed_metadata.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
-#include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/parsed_metadata.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/unique_ptr_with_bitset.h"
 

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

@@ -24,9 +24,11 @@
 
 #include "absl/strings/str_cat.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/lib/transport/http2_errors.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/util/useful.h"
 
+using grpc_core::http2::Http2ErrorCode;
+
 namespace grpc_core {
 
 void Http2Settings::Diff(
@@ -88,13 +90,13 @@ std::string Http2Settings::WireIdToName(uint16_t wire_id) {
   }
 }
 
-grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
+Http2ErrorCode Http2Settings::Apply(uint16_t key, uint32_t value) {
   switch (key) {
     case kHeaderTableSizeWireId:
       header_table_size_ = value;
       break;
     case kEnablePushWireId:
-      if (value > 1) return GRPC_HTTP2_PROTOCOL_ERROR;
+      if (value > 1) return Http2ErrorCode::kProtocolError;
       enable_push_ = value != 0;
       break;
     case kMaxConcurrentStreamsWireId:
@@ -102,13 +104,13 @@ grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
       break;
     case kInitialWindowSizeWireId:
       if (value > max_initial_window_size()) {
-        return GRPC_HTTP2_FLOW_CONTROL_ERROR;
+        return Http2ErrorCode::kFlowControlError;
       }
       initial_window_size_ = value;
       break;
     case kMaxFrameSizeWireId:
       if (value < min_max_frame_size() || value > max_max_frame_size()) {
-        return GRPC_HTTP2_PROTOCOL_ERROR;
+        return Http2ErrorCode::kProtocolError;
       }
       max_frame_size_ = value;
       break;
@@ -116,7 +118,7 @@ grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
       max_header_list_size_ = std::min(value, 16777216u);
       break;
     case kGrpcAllowTrueBinaryMetadataWireId:
-      if (value > 1) return GRPC_HTTP2_PROTOCOL_ERROR;
+      if (value > 1) return Http2ErrorCode::kProtocolError;
       allow_true_binary_metadata_ = value != 0;
       break;
     case kGrpcPreferredReceiveCryptoFrameSizeWireId:
@@ -125,11 +127,11 @@ grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
                 max_preferred_receive_crypto_message_size());
       break;
     case kGrpcAllowSecurityFrameWireId:
-      if (value > 1) return GRPC_HTTP2_PROTOCOL_ERROR;
+      if (value > 1) return Http2ErrorCode::kProtocolError;
       allow_security_frame_ = value != 0;
       break;
   }
-  return GRPC_HTTP2_NO_ERROR;
+  return Http2ErrorCode::kNoError;
 }
 
 std::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {