grpc 1.65.2 → 1.66.0.pre3

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

@@ -44,8 +44,8 @@
 /// from the caller; if the caller still needs the resource_user after creating
 /// a transport, the caller must take another ref.
 grpc_core::Transport* grpc_create_chttp2_transport(
-    const grpc_core::ChannelArgs& channel_args, grpc_endpoint* ep,
-    bool is_client);
+    const grpc_core::ChannelArgs& channel_args,
+    grpc_core::OrphanablePtr<grpc_endpoint> ep, bool is_client);
 
 grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode>
 grpc_chttp2_transport_get_socket_node(grpc_core::Transport* transport);

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

@@ -28,11 +28,11 @@
 #include <vector>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
@@ -234,8 +234,8 @@ void TransportFlowControl::UpdateSetting(
                                                  uint32_t)) {
   if (new_desired_value != *desired_value) {
     if (GRPC_TRACE_FLAG_ENABLED(flowctl)) {
-      gpr_log(GPR_INFO, "[flowctl] UPDATE SETTING %s from %" PRId64 " to %d",
-              std::string(name).c_str(), *desired_value, new_desired_value);
+      LOG(INFO) << "[flowctl] UPDATE SETTING " << name << " from "
+                << *desired_value << " to " << new_desired_value;
     }
     // Reaching zero can only happen for initial window size, and if it occurs
     // we really want to wake up writes and ensure all the queued stream

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

@@ -55,7 +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_transport_one_way_stats* stats,
+                             grpc_core::CallTracerInterface* call_tracer,
                              grpc_slice_buffer* outbuf) {
   grpc_slice hdr;
   uint8_t* p;
@@ -77,10 +77,7 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
 
   grpc_slice_buffer_move_first_no_ref(inbuf, write_bytes, outbuf);
 
-  stats->framing_bytes += header_size;
-  if (!grpc_core::IsHttp2StatsFixEnabled()) {
-    stats->data_bytes += write_bytes;
-  }
+  call_tracer->RecordOutgoingBytes({header_size, 0, 0});
 }
 
 grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
@@ -129,8 +126,7 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
   if (min_progress_size != nullptr) *min_progress_size = 0;
 
   if (stream_out != nullptr) {
-    s->stats.incoming.framing_bytes += 5;
-    s->stats.incoming.data_bytes += length;
+    s->call_tracer_wrapper.RecordIncomingBytes({5, length, 0});
     grpc_slice_buffer_move_first_into_buffer(slices, 5, header);
     grpc_slice_buffer_move_first(slices, length, stream_out->c_slice_buffer());
   }

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

@@ -33,6 +33,7 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/call_tracer.h"
 
 // start processing a new data frame
 absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
@@ -49,7 +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_transport_one_way_stats* stats,
+                             grpc_core::CallTracerInterface* call_tracer,
                              grpc_slice_buffer* outbuf);
 
 grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(

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

@@ -25,11 +25,11 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
@@ -94,8 +94,8 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
     CHECK(is_last);
     if (p->is_ack) {
       if (GRPC_TRACE_FLAG_ENABLED(http2_ping)) {
-        gpr_log(GPR_INFO, "%s[%p]: received ping ack %" PRIx64,
-                t->is_client ? "CLIENT" : "SERVER", t, p->opaque_8bytes);
+        LOG(INFO) << (t->is_client ? "CLIENT" : "SERVER") << "[" << t
+                  << "]: received ping ack " << p->opaque_8bytes;
       }
       grpc_chttp2_ack_ping(t, p->opaque_8bytes);
     } else {
@@ -104,16 +104,15 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
             t->keepalive_permit_without_calls == 0 && t->stream_map.empty();
         if (GRPC_TRACE_FLAG_ENABLED(http_keepalive) ||
             GRPC_TRACE_FLAG_ENABLED(http)) {
-          gpr_log(GPR_INFO, "SERVER[%p]: received ping %" PRIx64 ": %s", t,
-                  p->opaque_8bytes,
-                  t->ping_abuse_policy.GetDebugString(transport_idle).c_str());
+          LOG(INFO) << "SERVER[" << t << "]: received ping " << p->opaque_8bytes
+                    << ": "
+                    << t->ping_abuse_policy.GetDebugString(transport_idle);
         }
         if (t->ping_abuse_policy.ReceivedOnePing(transport_idle)) {
           grpc_chttp2_exceeded_ping_strikes(t);
         }
       } else if (GRPC_TRACE_FLAG_ENABLED(http2_ping)) {
-        gpr_log(GPR_INFO, "CLIENT[%p]: received ping %" PRIx64, t,
-                p->opaque_8bytes);
+        LOG(INFO) << "CLIENT[" << t << "]: received ping " << p->opaque_8bytes;
       }
       if (t->ack_pings) {
         if (t->ping_ack_count == t->ping_ack_capacity) {

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

@@ -21,13 +21,13 @@
 #include <stddef.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/random/distributions.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/slice_buffer.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
@@ -39,11 +39,13 @@
 #include "src/core/lib/transport/http2_errors.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
-grpc_slice grpc_chttp2_rst_stream_create(uint32_t id, uint32_t code,
-                                         grpc_transport_one_way_stats* stats) {
+grpc_slice grpc_chttp2_rst_stream_create(
+    uint32_t id, uint32_t code, grpc_core::CallTracerInterface* call_tracer) {
   static const size_t frame_size = 13;
   grpc_slice slice = GRPC_SLICE_MALLOC(frame_size);
-  if (stats != nullptr) stats->framing_bytes += frame_size;
+  if (call_tracer != nullptr) {
+    call_tracer->RecordOutgoingBytes({frame_size, 0, 0});
+  }
   uint8_t* p = GRPC_SLICE_START_PTR(slice);
 
   // Frame size.
@@ -70,10 +72,10 @@ grpc_slice grpc_chttp2_rst_stream_create(uint32_t id, uint32_t code,
 
 void grpc_chttp2_add_rst_stream_to_next_write(
     grpc_chttp2_transport* t, uint32_t id, uint32_t code,
-    grpc_transport_one_way_stats* stats) {
+    grpc_core::CallTracerInterface* call_tracer) {
   t->num_pending_induced_frames++;
   grpc_slice_buffer_add(&t->qbuf,
-                        grpc_chttp2_rst_stream_create(id, code, stats));
+                        grpc_chttp2_rst_stream_create(id, code, call_tracer));
 }
 
 grpc_error_handle grpc_chttp2_rst_stream_parser_begin_frame(
@@ -102,7 +104,8 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
     cur++;
     p->byte++;
   }
-  s->stats.incoming.framing_bytes += static_cast<uint64_t>(end - cur);
+  uint64_t framing_bytes = static_cast<uint64_t>(end - cur);
+  s->call_tracer_wrapper.RecordIncomingBytes({framing_bytes, 0, 0});
 
   if (p->byte == 4) {
     CHECK(is_last);
@@ -111,9 +114,8 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
                       ((static_cast<uint32_t>(p->reason_bytes[2])) << 8) |
                       ((static_cast<uint32_t>(p->reason_bytes[3])));
     if (GRPC_TRACE_FLAG_ENABLED(http)) {
-      gpr_log(GPR_INFO,
-              "[chttp2 transport=%p stream=%p] received RST_STREAM(reason=%d)",
-              t, s, reason);
+      LOG(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()) {

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

@@ -27,20 +27,22 @@
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/call_tracer.h"
 
 struct grpc_chttp2_rst_stream_parser {
   uint8_t byte;
   uint8_t reason_bytes[4];
 };
-grpc_slice grpc_chttp2_rst_stream_create(uint32_t stream_id, uint32_t code,
-                                         grpc_transport_one_way_stats* stats);
+grpc_slice grpc_chttp2_rst_stream_create(
+    uint32_t stream_id, uint32_t code,
+    grpc_core::CallTracerInterface* call_tracer);
 
 // 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
 // write_action_begin_locked.
 void grpc_chttp2_add_rst_stream_to_next_write(
     grpc_chttp2_transport* t, uint32_t id, uint32_t code,
-    grpc_transport_one_way_stats* stats);
+    grpc_core::CallTracerInterface* call_tracer);
 
 grpc_error_handle grpc_chttp2_rst_stream_parser_begin_frame(
     grpc_chttp2_rst_stream_parser* parser, uint32_t length, uint8_t flags);

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

@@ -23,11 +23,11 @@
 #include <string>
 
 #include "absl/base/attributes.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/slice_buffer.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
@@ -110,7 +110,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
             if (t->notify_on_receive_settings != nullptr) {
               if (t->interested_parties_until_recv_settings != nullptr) {
                 grpc_endpoint_delete_from_pollset_set(
-                    t->ep, t->interested_parties_until_recv_settings);
+                    t->ep.get(), t->interested_parties_until_recv_settings);
                 t->interested_parties_until_recv_settings = nullptr;
               }
               grpc_core::ExecCtx::Run(DEBUG_LOCATION,
@@ -172,9 +172,9 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
               parser->incoming_settings->initial_window_size();
           if (GRPC_TRACE_FLAG_ENABLED(http) ||
               GRPC_TRACE_FLAG_ENABLED(flowctl)) {
-            gpr_log(GPR_INFO, "%p[%s] adding %d for initial_window change", t,
-                    t->is_client ? "cli" : "svr",
-                    static_cast<int>(t->initial_window_update));
+            LOG(INFO) << t << "[" << (t->is_client ? "cli" : "svr")
+                      << "] adding " << t->initial_window_update
+                      << " for initial_window change";
           }
         }
         auto error =
@@ -188,11 +188,10 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
               grpc_core::Http2Settings::WireIdToName(parser->id).c_str()));
         }
         if (GRPC_TRACE_FLAG_ENABLED(http)) {
-          gpr_log(GPR_INFO, "CHTTP2:%s:%s: got setting %s = %d",
-                  t->is_client ? "CLI" : "SVR",
-                  std::string(t->peer_string.as_string_view()).c_str(),
-                  grpc_core::Http2Settings::WireIdToName(parser->id).c_str(),
-                  parser->value);
+          LOG(INFO) << "CHTTP2:" << (t->is_client ? "CLI" : "SVR") << ":"
+                    << t->peer_string.as_string_view() << ": got setting "
+                    << grpc_core::Http2Settings::WireIdToName(parser->id)
+                    << " = " << parser->value;
         }
       } break;
     }

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

@@ -32,10 +32,13 @@
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 
 grpc_slice grpc_chttp2_window_update_create(
-    uint32_t id, uint32_t window_delta, grpc_transport_one_way_stats* stats) {
+    uint32_t id, uint32_t window_delta,
+    grpc_core::CallTracerInterface* call_tracer) {
   static const size_t frame_size = 13;
   grpc_slice slice = GRPC_SLICE_MALLOC(frame_size);
-  stats->framing_bytes += frame_size;
+  if (call_tracer != nullptr) {
+    call_tracer->RecordOutgoingBytes({frame_size, 0, 0});
+  }
   uint8_t* p = GRPC_SLICE_START_PTR(slice);
 
   CHECK(window_delta);
@@ -84,7 +87,8 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
   }
 
   if (s != nullptr) {
-    s->stats.incoming.framing_bytes += static_cast<uint32_t>(end - cur);
+    uint64_t framing_bytes = static_cast<uint32_t>(end - cur);
+    s->call_tracer_wrapper.RecordIncomingBytes({framing_bytes, 0, 0});
   }
 
   if (p->byte == 4) {

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

@@ -27,6 +27,7 @@
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/call_tracer.h"
 
 struct grpc_chttp2_window_update_parser {
   uint8_t byte;
@@ -34,7 +35,8 @@ struct grpc_chttp2_window_update_parser {
   uint32_t amount;
 };
 grpc_slice grpc_chttp2_window_update_create(
-    uint32_t id, uint32_t window_delta, grpc_transport_one_way_stats* stats);
+    uint32_t id, uint32_t window_delta,
+    grpc_core::CallTracerInterface* call_tracer);
 
 grpc_error_handle grpc_chttp2_window_update_parser_begin_frame(
     grpc_chttp2_window_update_parser* parser, uint32_t length, uint8_t flags);

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

@@ -22,10 +22,10 @@
 #include <cstdint>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
@@ -87,7 +87,7 @@ void HPackCompressor::Frame(const EncodeHeaderOptions& options,
   if (options.is_end_of_stream) {
     flags |= GRPC_CHTTP2_DATA_FLAG_END_STREAM;
   }
-  options.stats->header_bytes += raw.Length();
+  options.call_tracer->RecordOutgoingBytes({0, 0, raw.Length()});
   while (frame_type == GRPC_CHTTP2_FRAME_HEADER || raw.Length() > 0) {
     // per the HTTP/2 spec:
     //   A HEADERS frame without the END_HEADERS flag set MUST be followed by
@@ -101,7 +101,7 @@ void HPackCompressor::Frame(const EncodeHeaderOptions& options,
     }
     FillHeader(grpc_slice_buffer_tiny_add(output, kHeadersFrameHeaderSize),
                frame_type, options.stream_id, len, flags);
-    options.stats->framing_bytes += kHeadersFrameHeaderSize;
+    options.call_tracer->RecordOutgoingBytes({kHeadersFrameHeaderSize, 0, 0});
     grpc_slice_buffer_move_first(raw.c_slice_buffer(), len, output);
 
     frame_type = GRPC_CHTTP2_FRAME_CONTINUATION;
@@ -118,8 +118,7 @@ void HPackCompressor::SetMaxTableSize(uint32_t max_table_size) {
   if (table_.SetMaxSize(std::min(max_usable_size_, max_table_size))) {
     advertise_table_size_change_ = true;
     if (GRPC_TRACE_FLAG_ENABLED(http)) {
-      gpr_log(GPR_INFO, "set max table size from encoder to %d",
-              max_table_size);
+      LOG(INFO) << "set max table size from encoder to " << max_table_size;
     }
   }
 }

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

@@ -25,12 +25,12 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
@@ -42,6 +42,7 @@
 #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"
 
 namespace grpc_core {
 
@@ -208,9 +209,7 @@ class Compressor<
   void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
                   Encoder* encoder) {
     if (value != known_value) {
-      gpr_log(GPR_ERROR, "%s",
-              absl::StrCat("Not encoding bad ", MetadataTrait::key(), " header")
-                  .c_str());
+      LOG(ERROR) << "Not encoding bad " << MetadataTrait::key() << " header";
       encoder->NoteEncodingError();
       return;
     }
@@ -355,7 +354,7 @@ class HPackCompressor {
     bool is_end_of_stream;
     bool use_true_binary_metadata;
     size_t max_frame_size;
-    grpc_transport_one_way_stats* stats;
+    CallTracerInterface* call_tracer;
   };
 
   template <typename HeaderSet>

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

@@ -28,6 +28,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
@@ -37,7 +38,6 @@
 #include "absl/types/variant.h"
 
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/decode_huff.h"
@@ -90,12 +90,14 @@ constexpr Base64InverseTable kBase64InverseTable;
 class HPackParser::Input {
  public:
   Input(grpc_slice_refcount* current_slice_refcount, const uint8_t* begin,
-        const uint8_t* end, absl::BitGenRef bitsrc, HpackParseResult& error)
+        const uint8_t* end, absl::BitGenRef bitsrc,
+        HpackParseResult& frame_error, HpackParseResult& field_error)
       : current_slice_refcount_(current_slice_refcount),
         begin_(begin),
         end_(end),
         frontier_(begin),
-        error_(error),
+        frame_error_(frame_error),
+        field_error_(field_error),
         bitsrc_(bitsrc) {}
 
   // If input is backed by a slice, retrieve its refcount. If not, return
@@ -214,14 +216,18 @@ class HPackParser::Input {
 
   // Check if we saw an EOF
   bool eof_error() const {
-    return min_progress_size_ != 0 || error_.connection_error();
+    return min_progress_size_ != 0 || frame_error_.connection_error();
+  }
+
+  // Reset the field error to be ok
+  void ClearFieldError() {
+    if (field_error_.ok()) return;
+    field_error_ = HpackParseResult();
   }
 
   // Minimum number of bytes to unstuck the current parse
   size_t min_progress_size() const { return min_progress_size_; }
 
-  bool has_error() const { return !error_.ok(); }
-
   // Set the current error - tweaks the error to include a stream id so that
   // chttp2 does not close the connection.
   // Intended for errors that are specific to a stream and recoverable.
@@ -245,10 +251,7 @@ class HPackParser::Input {
   // read prior to being able to get further in this parse.
   void UnexpectedEOF(size_t min_progress_size) {
     CHECK_GT(min_progress_size, 0u);
-    if (min_progress_size_ != 0 || error_.connection_error()) {
-      DCHECK(eof_error());
-      return;
-    }
+    if (eof_error()) return;
     // Set min progress size, taking into account bytes parsed already but not
     // consumed.
     min_progress_size_ = min_progress_size + (begin_ - frontier_);
@@ -301,13 +304,18 @@ class HPackParser::Input {
   // Do not use this directly, instead use SetErrorAndContinueParsing or
   // SetErrorAndStopParsing.
   void SetError(HpackParseResult error) {
-    if (!error_.ok() || min_progress_size_ > 0) {
-      if (error.connection_error() && !error_.connection_error()) {
-        error_ = std::move(error);  // connection errors dominate
+    SetErrorFor(frame_error_, error);
+    SetErrorFor(field_error_, std::move(error));
+  }
+
+  void SetErrorFor(HpackParseResult& error, HpackParseResult new_error) {
+    if (!error.ok() || min_progress_size_ > 0) {
+      if (new_error.connection_error() && !error.connection_error()) {
+        error = std::move(new_error);  // connection errors dominate
       }
       return;
     }
-    error_ = std::move(error);
+    error = std::move(new_error);
   }
 
   // Refcount if we are backed by a slice
@@ -319,7 +327,8 @@ class HPackParser::Input {
   // Frontier denotes the first byte past successfully processed input
   const uint8_t* frontier_;
   // Current error
-  HpackParseResult& error_;
+  HpackParseResult& frame_error_;
+  HpackParseResult& field_error_;
   // If the error was EOF, we flag it here by noting how many more bytes would
   // be needed to make progress
   size_t min_progress_size_ = 0;
@@ -596,6 +605,7 @@ class HPackParser::Parser {
   bool ParseTop() {
     DCHECK(state_.parse_state == ParseState::kTop);
     auto cur = *input_->Next();
+    input_->ClearFieldError();
     switch (cur >> 4) {
         // Literal header not indexed - First byte format: 0000xxxx
         // Literal header never indexed - First byte format: 0001xxxx
@@ -700,14 +710,15 @@ class HPackParser::Parser {
         type = "???";
         break;
     }
-    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 == nullptr
-            ? ""
-            : absl::StrCat(" (parse error: ",
-                           memento.parse_status->Materialize().ToString(), ")")
-                  .c_str());
+    LOG(INFO) << "HTTP:" << log_info_.stream_id << ":" << type << ":"
+              << (log_info_.is_client ? "CLI" : "SVR") << ": "
+              << memento.md.DebugString()
+              << (memento.parse_status == nullptr
+                      ? ""
+                      : absl::StrCat(
+                            " (parse error: ",
+                            memento.parse_status->Materialize().ToString(),
+                            ")"));
   }
 
   void EmitHeader(const HPackTable::Memento& md) {
@@ -950,11 +961,10 @@ class HPackParser::Parser {
                                   state_.string_length)
             : String::Parse(input_, state_.is_string_huff_compressed,
                             state_.string_length);
-    HpackParseResult& status = state_.frame_error;
     absl::string_view key_string;
     if (auto* s = absl::get_if<Slice>(&state_.key)) {
       key_string = s->as_string_view();
-      if (status.ok()) {
+      if (state_.field_error.ok()) {
         auto r = ValidateKey(key_string);
         if (r != ValidateMetadataResult::kOk) {
           input_->SetErrorAndContinueParsing(
@@ -964,7 +974,7 @@ 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 != nullptr) {
+      if (state_.field_error.ok() && memento->parse_status != nullptr) {
         input_->SetErrorAndContinueParsing(*memento->parse_status);
       }
     }
@@ -991,16 +1001,15 @@ class HPackParser::Parser {
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     auto md = grpc_metadata_batch::Parse(
         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;
+        [key_string, this](absl::string_view message, const Slice&) {
+          if (!state_.field_error.ok()) return;
           input_->SetErrorAndContinueParsing(
               HpackParseResult::MetadataParseError(key_string));
-          gpr_log(GPR_ERROR, "Error parsing '%s' metadata: %s",
-                  std::string(key_string).c_str(),
-                  std::string(message).c_str());
+          LOG(ERROR) << "Error parsing '" << key_string
+                     << "' metadata: " << message;
         });
-    HPackTable::Memento memento{std::move(md),
-                                status.PersistentStreamErrorOrNullptr()};
+    HPackTable::Memento memento{
+        std::move(md), state_.field_error.PersistentStreamErrorOrNullptr()};
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
     if (state_.add_to_table) {
@@ -1113,13 +1122,13 @@ grpc_error_handle HPackParser::Parse(
     std::vector<uint8_t> buffer = std::move(unparsed_bytes_);
     return ParseInput(
         Input(nullptr, buffer.data(), buffer.data() + buffer.size(), bitsrc,
-              state_.frame_error),
+              state_.frame_error, state_.field_error),
         is_last, call_tracer);
   }
-  return ParseInput(
-      Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
-            GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error),
-      is_last, call_tracer);
+  return ParseInput(Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
+                          GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error,
+                          state_.field_error),
+                    is_last, call_tracer);
 }
 
 grpc_error_handle HPackParser::ParseInput(

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

@@ -235,6 +235,8 @@ class HPackParser {
     HPackTable hpack_table;
     // Error so far for this frame (set by class Input)
     HpackParseResult frame_error;
+    // Error so far for this field (set by class Input)
+    HpackParseResult field_error;
     // Length of frame so far.
     uint32_t frame_length = 0;
     // Length of the string being parsed