grpc 1.73.0 → 1.74.0

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

@@ -32,6 +32,7 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
@@ -271,6 +272,11 @@ class TransportFlowControl final {
 
   FlowControlAction SetAckedInitialWindow(uint32_t value);
 
+  void set_target_initial_window_size(uint32_t value) {
+    target_initial_window_size_ =
+        std::min(value, Http2Settings::max_initial_window_size());
+  }
+
   // Getters
   int64_t remote_window() const { return remote_window_; }
   int64_t announced_window() const { return announced_window_; }
@@ -302,23 +308,22 @@ class TransportFlowControl final {
     double bdp_bw_est;
 
     std::string ToString() const;
-    Json::Object ToJsonObject() {
-      Json::Object object;
-      object["targetWindow"] = Json::FromNumber(target_window);
-      object["targetFrameSize"] = Json::FromNumber(target_frame_size);
-      object["targetPreferredRxCryptoFrameSize"] =
-          Json::FromNumber(target_preferred_rx_crypto_frame_size);
-      object["ackedInitWindow"] = Json::FromNumber(acked_init_window);
-      object["queuedInitWindow"] = Json::FromNumber(queued_init_window);
-      object["sentInitWindow"] = Json::FromNumber(sent_init_window);
-      object["remoteWindow"] = Json::FromNumber(remote_window);
-      object["announcedWindow"] = Json::FromNumber(announced_window);
-      object["announcedStreamTotalOverIncomingWindow"] =
-          Json::FromNumber(announced_stream_total_over_incoming_window);
-      object["bdpAccumulator"] = Json::FromNumber(bdp_accumulator);
-      object["bdpEstimate"] = Json::FromNumber(bdp_estimate);
-      object["bdpBwEst"] = Json::FromNumber(bdp_bw_est);
-      return object;
+    channelz::PropertyList ChannelzProperties() const {
+      return channelz::PropertyList()
+          .Set("target_window", target_window)
+          .Set("target_frame_size", target_frame_size)
+          .Set("target_preferred_rx_crypto_frame_size",
+               target_preferred_rx_crypto_frame_size)
+          .Set("acked_init_window", acked_init_window)
+          .Set("queued_init_window", queued_init_window)
+          .Set("sent_init_window", sent_init_window)
+          .Set("remote_window", remote_window)
+          .Set("announced_window", announced_window)
+          .Set("announced_stream_total_over_incoming_window",
+               announced_stream_total_over_incoming_window)
+          .Set("bdp_accumulator", bdp_accumulator)
+          .Set("bdp_estimate", bdp_estimate)
+          .Set("bdp_bw_est", bdp_bw_est);
     }
   };
 

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

@@ -632,6 +632,16 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
   }
 }
 
+http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code) {
+  if (GPR_UNLIKELY(error_code > http2::GetMaxHttp2ErrorCode())) {
+    LOG(ERROR) << "Http2ErrorCodeFromRstFrameErrorCode: Invalid error code "
+                  "received from RST_STREAM frame: "
+               << error_code;
+    return http2::Http2ErrorCode::kInternalError;
+  }
+  return static_cast<http2::Http2ErrorCode>(error_code);
+}
+
 GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload) {
   CHECK_GE(payload.Length(), kGrpcHeaderSizeInBytes);
   uint8_t buffer[kGrpcHeaderSizeInBytes];

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

@@ -237,6 +237,8 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
 // move things out of frames)
 void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
 
+http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code);
+
 ///////////////////////////////////////////////////////////////////////////////
 // GRPC Header
 
@@ -321,8 +323,6 @@ 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

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

@@ -80,7 +80,7 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
 
   grpc_slice_buffer_move_first_no_ref(inbuf, write_bytes, outbuf);
 
-  grpc_core::global_stats().IncrementHttp2WriteDataFrameSize(write_bytes);
+  grpc_core::http2_global_stats().IncrementHttp2WriteDataFrameSize(write_bytes);
   call_tracer->RecordOutgoingBytes({header_size, 0, 0});
 }
 

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

@@ -108,19 +108,18 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
           if (is_last) {
             grpc_core::Http2Settings* target_settings =
                 parser->incoming_settings.get();
-            grpc_core::global_stats().IncrementHttp2HeaderTableSize(
+            t->http2_stats->IncrementHttp2HeaderTableSize(
                 target_settings->header_table_size());
-            grpc_core::global_stats().IncrementHttp2InitialWindowSize(
+            t->http2_stats->IncrementHttp2InitialWindowSize(
                 target_settings->initial_window_size());
-            grpc_core::global_stats().IncrementHttp2MaxConcurrentStreams(
+            t->http2_stats->IncrementHttp2MaxConcurrentStreams(
                 target_settings->max_concurrent_streams());
-            grpc_core::global_stats().IncrementHttp2MaxFrameSize(
+            t->http2_stats->IncrementHttp2MaxFrameSize(
                 target_settings->max_frame_size());
-            grpc_core::global_stats().IncrementHttp2MaxHeaderListSize(
+            t->http2_stats->IncrementHttp2MaxHeaderListSize(
                 target_settings->max_header_list_size());
-            grpc_core::global_stats()
-                .IncrementHttp2PreferredReceiveCryptoMessageSize(
-                    target_settings->preferred_receive_crypto_message_size());
+            t->http2_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

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

@@ -109,15 +109,14 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
       if (s != nullptr) {
         grpc_core::Timestamp now = grpc_core::Timestamp::Now();
         if (s->last_window_update_time != grpc_core::Timestamp::InfPast()) {
-          grpc_core::global_stats().IncrementHttp2StreamWindowUpdatePeriod(
+          t->http2_stats->IncrementHttp2StreamWindowUpdatePeriod(
               (now - s->last_window_update_time).millis());
         }
         s->last_window_update_time = now;
         grpc_core::chttp2::StreamFlowControl::OutgoingUpdateContext(
             &s->flow_control)
             .RecvUpdate(received_update);
-        grpc_core::global_stats().IncrementHttp2StreamRemoteWindowUpdate(
-            received_update);
+        t->http2_stats->IncrementHttp2StreamRemoteWindowUpdate(received_update);
         if (grpc_chttp2_list_remove_stalled_by_stream(t, s)) {
           grpc_chttp2_mark_stream_writable(t, s);
           grpc_chttp2_initiate_write(
@@ -129,11 +128,11 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
           &t->flow_control);
       grpc_core::Timestamp now = grpc_core::Timestamp::Now();
       if (t->last_window_update_time != grpc_core::Timestamp::InfPast()) {
-        grpc_core::global_stats().IncrementHttp2TransportWindowUpdatePeriod(
+        t->http2_stats->IncrementHttp2TransportWindowUpdatePeriod(
             (now - t->last_window_update_time).millis());
       }
       t->last_window_update_time = now;
-      grpc_core::global_stats().IncrementHttp2TransportRemoteWindowUpdate(
+      t->http2_stats->IncrementHttp2TransportRemoteWindowUpdate(
           received_update);
       upd.RecvUpdate(received_update);
       if (upd.Finish() == grpc_core::chttp2::StallEdge::kUnstalled) {

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

@@ -0,0 +1,299 @@
+//
+//
+// 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_HEADER_ASSEMBLER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HEADER_ASSEMBLER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <cstddef>
+#include <cstdint>
+
+#include "absl/log/check.h"
+#include "absl/log/log.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#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_status.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/shared_bit_gen.h"
+
+// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// assembler and disassembler code
+
+namespace grpc_core {
+namespace http2 {
+
+// If the Client Transport code is using HeaderAssembler in the wrong way,
+// we fail with a DCHECK.
+// If the peer sent some bad data, we fail with the appropriate Http2Status.
+
+#define ASSEMBLER_LOG DVLOG(3)
+
+constexpr absl::string_view kAssemblerContiguousSequenceError =
+    "RFC9113 : Field blocks MUST be transmitted as a contiguous sequence "
+    "of frames, with no interleaved frames of any other type or from any "
+    "other stream.";
+
+constexpr absl::string_view kAssemblerMismatchedStreamId =
+    "CONTINUATION frame has a different Stream Identifier than the preceeding "
+    "HEADERS frame.";
+
+constexpr absl::string_view kAssemblerHpackError =
+    "RFC9113 : A decoding error in a field block MUST be treated as a "
+    "connection error of type COMPRESSION_ERROR.";
+
+constexpr absl::string_view kGrpcErrorMaxTwoHeaderFrames =
+    "Too many header frames sent by peer";
+
+// A gRPC server is permitted to send both initial metadata and trailing
+// metadata where initial metadata is optional. A gRPC C++ client is permitted
+// to send only initial metadata. However, other gRPC Client implementations may
+// send trailing metadata too. So we allow only a maximum of 2 metadata per
+// streams. Which means only 2 HEADER frames are legal per stream.
+constexpr uint8_t kMaxHeaderFrames = 2;
+
+// TODO(tjagtap) : [PH2][P3] : Handle the case where a Server receives two
+// header frames. Which means that the client sent trailing metadata. While we
+// dont expect a gRPC C++ peer to behave like this, this might break interop
+// tests and genuine interop cases.
+
+// RFC9113
+// https://www.rfc-editor.org/rfc/rfc9113.html#name-field-section-compression-a
+// A complete field section (which contains our gRPC Metadata) consists of
+// either: a single HEADERS or PUSH_PROMISE frame, with the END_HEADERS flag
+// set, or a HEADERS or PUSH_PROMISE frame with the END_HEADERS flag unset
+// and one or more CONTINUATION frames, where the last CONTINUATION frame
+// has the END_HEADERS flag set.
+//
+// Each field block is processed as a discrete unit. Field blocks MUST be
+// transmitted as a contiguous sequence of frames, with no interleaved
+// frames of any other type or from any other stream. The last frame in a
+// sequence of HEADERS or CONTINUATION frames has the END_HEADERS flag set.
+//
+// This class will first assemble all the header data into one SliceBuffer
+// from each frame. And when END_HEADERS is received, the caller can generate
+// the gRPC Metadata.
+class HeaderAssembler {
+ public:
+  // Call this for each incoming HTTP2 Header frame.
+  // The payload of the Http2HeaderFrame will be cleared in this function.
+  Http2Status AppendHeaderFrame(Http2HeaderFrame&& frame) {
+    // Validate input frame
+    DCHECK_GT(frame.stream_id, 0u)
+        << "RFC9113 : HEADERS frames MUST be associated with a stream.";
+
+    // Manage size constraints
+    const size_t current_len = frame.payload.Length();
+    if constexpr (sizeof(size_t) == 4) {
+      if (GPR_UNLIKELY(buffer_.Length() >= UINT32_MAX - current_len)) {
+        Cleanup();
+        LOG(ERROR)
+            << "Stream Error: SliceBuffer overflow for 32 bit platforms.";
+        return Http2Status::Http2StreamError(
+            Http2ErrorCode::kInternalError,
+            "Stream Error: SliceBuffer overflow for 32 bit platforms.");
+      }
+    }
+
+    // Start header workflow
+    header_in_progress_ = true;
+
+    // Manage payload
+    frame.payload.MoveFirstNBytesIntoSliceBuffer(current_len, buffer_);
+    ASSEMBLER_LOG << "AppendHeaderFrame " << current_len << " Bytes.";
+
+    // Manage if last frame
+    if (frame.end_headers) {
+      ASSEMBLER_LOG << "AppendHeaderFrame end_headers";
+      is_ready_ = true;
+    }
+
+    return Http2Status::Ok();
+  }
+
+  // Call this for each incoming HTTP2 Continuation frame.
+  // The payload of the Http2ContinuationFrame will be cleared in this function.
+  Http2Status AppendContinuationFrame(Http2ContinuationFrame&& frame) {
+    // Manage payload
+    const size_t current_len = frame.payload.Length();
+    frame.payload.MoveFirstNBytesIntoSliceBuffer(current_len, buffer_);
+    ASSEMBLER_LOG << "AppendContinuationFrame " << current_len << " Bytes.";
+
+    // Manage if last frame
+    if (frame.end_headers) {
+      ASSEMBLER_LOG << "AppendHeaderFrame end_headers";
+      is_ready_ = true;
+    }
+
+    return Http2Status::Ok();
+  }
+
+  // The caller MUST check using IsReady() before calling this function
+  ValueOrHttp2Status<Arena::PoolPtr<grpc_metadata_batch>> ReadMetadata(
+      HPackParser& parser, bool is_initial_metadata, bool is_client) {
+    ASSEMBLER_LOG << "ReadMetadata " << buffer_.Length() << " Bytes.";
+
+    // Validate
+    DCHECK_EQ(is_ready_, true);
+
+    // Generate the gRPC Metadata from buffer_
+    // RFC9113 :  A receiver MUST terminate the connection with a connection
+    // error (Section 5.4.1) of type COMPRESSION_ERROR if it does not decompress
+    // a field block. A decoding error in a field block MUST be treated as a
+    // connection error (Section 5.4.1) of type COMPRESSION_ERROR.
+    Arena::PoolPtr<grpc_metadata_batch> metadata =
+        Arena::MakePooledForOverwrite<grpc_metadata_batch>();
+    parser.BeginFrame(
+        /*grpc_metadata_batch*/ metadata.get(),
+        // TODO(tjagtap) : [PH2][P2] : Manage limits
+        /*metadata_size_soft_limit*/ std::numeric_limits<uint32_t>::max(),
+        /*metadata_size_hard_limit*/ std::numeric_limits<uint32_t>::max(),
+        is_initial_metadata ? HPackParser::Boundary::EndOfHeaders
+                            : HPackParser::Boundary::EndOfStream,
+        HPackParser::Priority::None,
+        HPackParser::LogInfo{stream_id_,
+                             is_initial_metadata
+                                 ? HPackParser::LogInfo::Type::kHeaders
+                                 : HPackParser::LogInfo::Type::kTrailers,
+                             is_client});
+    for (size_t i = 0; i < buffer_.Count(); i++) {
+      absl::Status result = parser.Parse(
+          buffer_.c_slice_at(i), i == buffer_.Count() - 1, SharedBitGen(),
+          /*call_tracer=*/nullptr);
+      if (GPR_UNLIKELY(!result.ok())) {
+        Cleanup();
+        LOG(ERROR) << "Connection Error: " << kAssemblerHpackError;
+        return Http2Status::Http2ConnectionError(
+            Http2ErrorCode::kCompressionError,
+            std::string(kAssemblerHpackError));
+      }
+    }
+    parser.FinishFrame();
+
+    Cleanup();
+
+    return ValueOrHttp2Status<Arena::PoolPtr<grpc_metadata_batch>>(
+        std::move(metadata));
+  }
+
+  size_t GetBufferedHeadersLength() const { return buffer_.Length(); }
+
+  // This value MUST be checked before calling ReadMetadata()
+  bool IsReady() const { return is_ready_; }
+
+  explicit HeaderAssembler(const uint32_t stream_id)
+      : header_in_progress_(false), is_ready_(false), stream_id_(stream_id) {}
+
+  ~HeaderAssembler() = default;
+
+  HeaderAssembler(HeaderAssembler&& rvalue) = delete;
+  HeaderAssembler& operator=(HeaderAssembler&& rvalue) = delete;
+  HeaderAssembler(const HeaderAssembler&) = delete;
+  HeaderAssembler& operator=(const HeaderAssembler&) = delete;
+
+ private:
+  void Cleanup() {
+    buffer_.Clear();
+    header_in_progress_ = false;
+    is_ready_ = false;
+  }
+
+  bool header_in_progress_;
+  bool is_ready_;
+  const uint32_t stream_id_;
+  SliceBuffer buffer_;
+};
+
+class HeaderDisassembler {
+ public:
+  // This function will take ownership of metadata object
+  // The method will return false if encoding fails. A failed encoding operation
+  // is MUST be treated as a connection error by the caller.
+  // This function can queue a trailing metadata for sending even before the
+  // initial metadata has been extracted.
+  bool PrepareForSending(Arena::PoolPtr<grpc_metadata_batch>&& metadata,
+                         HPackCompressor& encoder) {
+    // Validate disassembler state
+    DCHECK(!is_done_);
+    // Prepare metadata for sending
+    return encoder.EncodeRawHeaders(*metadata.get(), buffer_);
+  }
+
+  Http2Frame GetNextFrame(const uint32_t max_frame_length,
+                          bool& out_end_headers) {
+    if (buffer_.Length() == 0 || is_done_) {
+      DCHECK(false) << "Calling code must check size using HasMoreData() "
+                       "before GetNextFrame()";
+    }
+    out_end_headers = buffer_.Length() <= max_frame_length;
+    SliceBuffer temp;
+    if (out_end_headers) {
+      is_done_ = true;
+      temp.Swap(&buffer_);
+    } else {
+      buffer_.MoveFirstNBytesIntoSliceBuffer(max_frame_length, temp);
+    }
+    if (!did_send_header_frame_) {
+      did_send_header_frame_ = true;
+      return Http2HeaderFrame{stream_id_, out_end_headers, end_stream_,
+                              std::move(temp)};
+    } else {
+      return Http2ContinuationFrame{stream_id_, out_end_headers,
+                                    std::move(temp)};
+    }
+  }
+
+  bool HasMoreData() const { return !is_done_ && buffer_.Length() > 0; }
+
+  // This number can be used for backpressure related calculations.
+  size_t GetBufferedLength() const { return buffer_.Length(); }
+
+  // A separate HeaderDisassembler object MUST be made for Initial Metadata and
+  // Trailing Metadata
+  explicit HeaderDisassembler(const uint32_t stream_id,
+                              const bool is_trailing_metadata)
+      : stream_id_(stream_id),
+        end_stream_(is_trailing_metadata),
+        did_send_header_frame_(false),
+        is_done_(false) {}
+
+  ~HeaderDisassembler() = default;
+
+  HeaderDisassembler(HeaderDisassembler&& rvalue) = delete;
+  HeaderDisassembler& operator=(HeaderDisassembler&& rvalue) = delete;
+  HeaderDisassembler(const HeaderDisassembler&) = delete;
+  HeaderDisassembler& operator=(const HeaderDisassembler&) = delete;
+
+  size_t TestOnlyGetMainBufferLength() const { return buffer_.Length(); }
+
+ private:
+  const uint32_t stream_id_;
+  const bool end_stream_;
+  bool did_send_header_frame_;
+  bool is_done_;  // Protect against the same disassembler from being used twice
+
+  SliceBuffer buffer_;
+};
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HEADER_ASSEMBLER_H

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

@@ -1137,7 +1137,7 @@ grpc_error_handle HPackParser::ParseInput(
                                                input.bitsrc())) {
       HandleMetadataSoftSizeLimitExceeded(&input);
     }
-    global_stats().IncrementHttp2MetadataSize(state_.frame_length);
+    http2_global_stats().IncrementHttp2MetadataSize(state_.frame_length);
     if (call_tracer != nullptr && call_tracer->IsSampled() &&
         metadata_buffer_ != nullptr) {
       MetadataSizesAnnotation metadata_sizes_annotation(

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

@@ -33,6 +33,7 @@
 #include "absl/strings/string_view.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/ext/transport/chttp2/transport/http2_stats_collector.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/telemetry/stats.h"
@@ -58,7 +59,7 @@ auto HPackTable::MementoRingBuffer::PopOne() -> Memento {
   CHECK_GT(num_entries_, 0u);
   size_t index = first_entry_ % max_entries_;
   if (index == timestamp_index_) {
-    global_stats().IncrementHttp2HpackEntryLifetime(
+    http2_stats_collector_->IncrementHttp2HpackEntryLifetime(
         (Timestamp::Now() - timestamp_).millis());
     timestamp_index_ = kNoTimestamp;
   }
@@ -66,7 +67,7 @@ auto HPackTable::MementoRingBuffer::PopOne() -> Memento {
   --num_entries_;
   auto& entry = entries_[index];
   if (!entry.parse_status.TestBit(Memento::kUsedBit)) {
-    global_stats().IncrementHttp2HpackMisses();
+    http2_stats_collector_->IncrementHttp2HpackMisses();
   }
   return std::move(entry);
 }
@@ -77,7 +78,7 @@ auto HPackTable::MementoRingBuffer::Lookup(uint32_t index) -> const Memento* {
   auto& entry = entries_[offset];
   const bool was_used = entry.parse_status.TestBit(Memento::kUsedBit);
   entry.parse_status.SetBit(Memento::kUsedBit);
-  if (!was_used) global_stats().IncrementHttp2HpackHits();
+  if (!was_used) http2_stats_collector_->IncrementHttp2HpackHits();
   return &entry;
 }
 
@@ -110,9 +111,9 @@ void HPackTable::MementoRingBuffer::ForEach(F f) const {
 }
 
 HPackTable::MementoRingBuffer::~MementoRingBuffer() {
-  ForEach([](uint32_t, const Memento& m) {
+  ForEach([this](uint32_t, const Memento& m) {
     if (!m.parse_status.TestBit(Memento::kUsedBit)) {
-      global_stats().IncrementHttp2HpackMisses();
+      http2_stats_collector_->IncrementHttp2HpackMisses();
     }
   });
 }
@@ -124,6 +125,11 @@ void HPackTable::EvictOne() {
   mem_used_ -= first_entry.md.transport_size();
 }
 
+void HPackTable::SetHttp2StatsCollector(
+    std::shared_ptr<Http2StatsCollector> http2_stats_collector) {
+  entries_.SetHttp2StatsCollector(http2_stats_collector);
+}
+
 void HPackTable::SetMaxBytes(uint32_t max_bytes) {
   if (max_bytes_ == max_bytes) {
     return;

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

@@ -33,6 +33,7 @@
 #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/ext/transport/chttp2/transport/http2_stats_collector.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/unique_ptr_with_bitset.h"
 
@@ -49,6 +50,8 @@ class HPackTable {
   HPackTable(HPackTable&&) = default;
   HPackTable& operator=(HPackTable&&) = default;
 
+  void SetHttp2StatsCollector(
+      std::shared_ptr<Http2StatsCollector> http2_stats_collector);
   void SetMaxBytes(uint32_t max_bytes);
   bool SetCurrentTableSize(uint32_t bytes);
   uint32_t current_table_size() { return current_table_bytes_; }
@@ -101,7 +104,8 @@ class HPackTable {
 
   class MementoRingBuffer {
    public:
-    MementoRingBuffer() {}
+    MementoRingBuffer()
+        : http2_stats_collector_(CreateHttp2StatsCollector(nullptr)) {}
     ~MementoRingBuffer();
 
     MementoRingBuffer(const MementoRingBuffer&) = delete;
@@ -109,6 +113,11 @@ class HPackTable {
     MementoRingBuffer(MementoRingBuffer&&) = default;
     MementoRingBuffer& operator=(MementoRingBuffer&&) = default;
 
+    void SetHttp2StatsCollector(
+        std::shared_ptr<Http2StatsCollector> http2_stats_collector) {
+      http2_stats_collector_ = http2_stats_collector;
+    }
+
     // Rebuild this buffer with a new max_entries_ size.
     void Rebuild(uint32_t max_entries);
 
@@ -146,6 +155,8 @@ class HPackTable {
     // The timestamp associated with timestamp_entry_.
     Timestamp timestamp_;
 
+    std::shared_ptr<Http2StatsCollector> http2_stats_collector_ = nullptr;
+
     std::vector<Memento> entries_;
   };