grpc 1.66.0 → 1.67.0.pre1

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

@@ -233,10 +233,9 @@ void TransportFlowControl::UpdateSetting(
     FlowControlAction& (FlowControlAction::*set)(FlowControlAction::Urgency,
                                                  uint32_t)) {
   if (new_desired_value != *desired_value) {
-    if (GRPC_TRACE_FLAG_ENABLED(flowctl)) {
-      LOG(INFO) << "[flowctl] UPDATE SETTING " << name << " from "
-                << *desired_value << " to " << new_desired_value;
-    }
+    GRPC_TRACE_LOG(flowctl, 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
     // window updates are flushed, since stream flow control operates

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

@@ -32,7 +32,6 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"

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

@@ -23,7 +23,6 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"

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

@@ -25,7 +25,6 @@
 #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"

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

@@ -28,7 +28,6 @@
 
 #include <grpc/slice_buffer.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"

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

@@ -93,10 +93,9 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
   if (p->byte == 8) {
     CHECK(is_last);
     if (p->is_ack) {
-      if (GRPC_TRACE_FLAG_ENABLED(http2_ping)) {
-        LOG(INFO) << (t->is_client ? "CLIENT" : "SERVER") << "[" << t
-                  << "]: received ping ack " << p->opaque_8bytes;
-      }
+      GRPC_TRACE_LOG(http2_ping, INFO)
+          << (t->is_client ? "CLIENT" : "SERVER") << "[" << t
+          << "]: received ping ack " << p->opaque_8bytes;
       grpc_chttp2_ack_ping(t, p->opaque_8bytes);
     } else {
       if (!t->is_client) {
@@ -111,8 +110,9 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
         if (t->ping_abuse_policy.ReceivedOnePing(transport_idle)) {
           grpc_chttp2_exceeded_ping_strikes(t);
         }
-      } else if (GRPC_TRACE_FLAG_ENABLED(http2_ping)) {
-        LOG(INFO) << "CLIENT[" << t << "]: received ping " << p->opaque_8bytes;
+      } else {
+        GRPC_TRACE_LOG(http2_ping, 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

@@ -113,10 +113,9 @@ 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])));
-    if (GRPC_TRACE_FLAG_ENABLED(http)) {
-      LOG(INFO) << "[chttp2 transport=" << t << " stream=" << s
-                << "] received RST_STREAM(reason=" << 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()) {
       error = grpc_error_set_int(

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

@@ -187,12 +187,11 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
               "invalid value %u passed for %s", parser->value,
               grpc_core::Http2Settings::WireIdToName(parser->id).c_str()));
         }
-        if (GRPC_TRACE_FLAG_ENABLED(http)) {
-          LOG(INFO) << "CHTTP2:" << (t->is_client ? "CLI" : "SVR") << ":"
-                    << t->peer_string.as_string_view() << ": got setting "
-                    << grpc_core::Http2Settings::WireIdToName(parser->id)
-                    << " = " << parser->value;
-        }
+        GRPC_TRACE_LOG(http, 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

@@ -25,7 +25,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"

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

@@ -117,9 +117,8 @@ void HPackCompressor::SetMaxUsableSize(uint32_t max_table_size) {
 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)) {
-      LOG(INFO) << "set max table size from encoder to " << max_table_size;
-    }
+    GRPC_TRACE_LOG(http, INFO)
+        << "set max table size from encoder to " << max_table_size;
   }
 }
 

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

@@ -18,7 +18,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {

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

@@ -27,7 +27,6 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/crash.h"

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

@@ -713,7 +713,7 @@ class HPackParser::Parser {
     LOG(INFO) << "HTTP:" << log_info_.stream_id << ":" << type << ":"
               << (log_info_.is_client ? "CLI" : "SVR") << ": "
               << memento.md.DebugString()
-              << (memento.parse_status == nullptr
+              << (memento.parse_status.get() == nullptr
                       ? ""
                       : absl::StrCat(
                             " (parse error: ",
@@ -724,7 +724,7 @@ class HPackParser::Parser {
   void EmitHeader(const HPackTable::Memento& md) {
     // Pass up to the transport
     state_.frame_length += md.md.transport_size();
-    if (md.parse_status != nullptr) {
+    if (md.parse_status.get() != nullptr) {
       // Reject any requests with invalid metadata.
       input_->SetErrorAndContinueParsing(*md.parse_status);
     }
@@ -974,7 +974,7 @@ class HPackParser::Parser {
     } else {
       const auto* memento = absl::get<const HPackTable::Memento*>(state_.key);
       key_string = memento->md.key();
-      if (state_.field_error.ok() && memento->parse_status != nullptr) {
+      if (state_.field_error.ok() && memento->parse_status.get() != nullptr) {
         input_->SetErrorAndContinueParsing(*memento->parse_status);
       }
     }

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

@@ -37,6 +37,7 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/telemetry/stats.h"
 
 namespace grpc_core {
 
@@ -47,6 +48,10 @@ void HPackTable::MementoRingBuffer::Put(Memento m) {
     return entries_.push_back(std::move(m));
   }
   size_t index = (first_entry_ + num_entries_) % max_entries_;
+  if (timestamp_index_ == kNoTimestamp) {
+    timestamp_index_ = index;
+    timestamp_ = Timestamp::Now();
+  }
   entries_[index] = std::move(m);
   ++num_entries_;
 }
@@ -54,12 +59,31 @@ void HPackTable::MementoRingBuffer::Put(Memento m) {
 auto HPackTable::MementoRingBuffer::PopOne() -> Memento {
   CHECK_GT(num_entries_, 0u);
   size_t index = first_entry_ % max_entries_;
+  if (index == timestamp_index_) {
+    global_stats().IncrementHttp2HpackEntryLifetime(
+        (Timestamp::Now() - timestamp_).millis());
+    timestamp_index_ = kNoTimestamp;
+  }
   ++first_entry_;
   --num_entries_;
-  return std::move(entries_[index]);
+  auto& entry = entries_[index];
+  if (!entry.parse_status.TestBit(Memento::kUsedBit)) {
+    global_stats().IncrementHttp2HpackMisses();
+  }
+  return std::move(entry);
 }
 
-auto HPackTable::MementoRingBuffer::Lookup(uint32_t index) const
+auto HPackTable::MementoRingBuffer::Lookup(uint32_t index) -> const Memento* {
+  if (index >= num_entries_) return nullptr;
+  uint32_t offset = (num_entries_ - 1u - index + first_entry_) % max_entries_;
+  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();
+  return &entry;
+}
+
+auto HPackTable::MementoRingBuffer::Peek(uint32_t index) const
     -> const Memento* {
   if (index >= num_entries_) return nullptr;
   uint32_t offset = (num_entries_ - 1u - index + first_entry_) % max_entries_;
@@ -79,14 +103,22 @@ void HPackTable::MementoRingBuffer::Rebuild(uint32_t max_entries) {
   entries_.swap(entries);
 }
 
-void HPackTable::MementoRingBuffer::ForEach(
-    absl::FunctionRef<void(uint32_t, const Memento&)> f) const {
+template <typename F>
+void HPackTable::MementoRingBuffer::ForEach(F f) const {
   uint32_t index = 0;
-  while (auto* m = Lookup(index++)) {
+  while (auto* m = Peek(index++)) {
     f(index, *m);
   }
 }
 
+HPackTable::MementoRingBuffer::~MementoRingBuffer() {
+  ForEach([](uint32_t, const Memento& m) {
+    if (!m.parse_status.TestBit(Memento::kUsedBit)) {
+      global_stats().IncrementHttp2HpackMisses();
+    }
+  });
+}
+
 // Evict one element from the table
 void HPackTable::EvictOne() {
   auto first_entry = entries_.PopOne();

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

@@ -21,6 +21,8 @@
 
 #include <stdint.h>
 
+#include <cstdint>
+#include <limits>
 #include <memory>
 #include <string>
 #include <vector>
@@ -34,6 +36,7 @@
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/parsed_metadata.h"
+#include "src/core/util/unique_ptr_with_bitset.h"
 
 namespace grpc_core {
 
@@ -54,11 +57,14 @@ class HPackTable {
 
   struct Memento {
     ParsedMetadata<grpc_metadata_batch> md;
-    std::unique_ptr<HpackParseResult> parse_status;
+    // Alongside parse_status we store one bit indicating whether this memento
+    // has been looked up (and therefore consumed) or not.
+    UniquePtrWithBitset<HpackParseResult, 1> parse_status;
+    static const int kUsedBit = 0;
   };
 
   // Lookup, but don't ref.
-  const Memento* Lookup(uint32_t index) const {
+  const Memento* Lookup(uint32_t index) {
     // Static table comes first, just return an entry from it.
     // NB: This imposes the constraint that the first
     // GRPC_CHTTP2_LAST_STATIC_ENTRY entries in the core static metadata table
@@ -97,6 +103,14 @@ class HPackTable {
 
   class MementoRingBuffer {
    public:
+    MementoRingBuffer() {}
+    ~MementoRingBuffer();
+
+    MementoRingBuffer(const MementoRingBuffer&) = delete;
+    MementoRingBuffer& operator=(const MementoRingBuffer&) = delete;
+    MementoRingBuffer(MementoRingBuffer&&) = default;
+    MementoRingBuffer& operator=(MementoRingBuffer&&) = default;
+
     // Rebuild this buffer with a new max_entries_ size.
     void Rebuild(uint32_t max_entries);
 
@@ -109,10 +123,11 @@ class HPackTable {
     Memento PopOne();
 
     // Lookup the entry at index, or return nullptr if none exists.
-    const Memento* Lookup(uint32_t index) const;
+    const Memento* Lookup(uint32_t index);
+    const Memento* Peek(uint32_t index) const;
 
-    void ForEach(absl::FunctionRef<void(uint32_t dynamic_index, const Memento&)>
-                     f) const;
+    template <typename F>
+    void ForEach(F f) const;
 
     uint32_t max_entries() const { return max_entries_; }
     uint32_t num_entries() const { return num_entries_; }
@@ -126,11 +141,17 @@ class HPackTable {
     // Maximum number of entries we could possibly fit in the table, given
     // defined overheads.
     uint32_t max_entries_ = hpack_constants::kInitialTableEntries;
+    // Which index holds a timestamp (or kNoTimestamp if none do).
+    static constexpr uint32_t kNoTimestamp =
+        std::numeric_limits<uint32_t>::max();
+    uint32_t timestamp_index_ = kNoTimestamp;
+    // The timestamp associated with timestamp_entry_.
+    Timestamp timestamp_;
 
     std::vector<Memento> entries_;
   };
 
-  const Memento* LookupDynamic(uint32_t index) const {
+  const Memento* LookupDynamic(uint32_t index) {
     // Not static - find the value in the list of valid entries
     const uint32_t tbl_index = index - (hpack_constants::kLastStaticEntry + 1);
     return entries_.Lookup(tbl_index);

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

@@ -52,7 +52,6 @@
 #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/legacy_frame.h"
-#include "src/core/ext/transport/chttp2/transport/max_concurrent_streams_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
@@ -383,8 +382,6 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
           grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
   grpc_closure retry_initiate_ping_locked;
 
-  grpc_core::Chttp2MaxConcurrentStreamsPolicy max_concurrent_streams_policy;
-
   /// ping acks
   size_t ping_ack_count = 0;
   size_t ping_ack_capacity = 0;
@@ -545,6 +542,8 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   // What percentage of rst_stream frames on the server should cause a ping
   // frame to be generated.
   uint8_t ping_on_rst_stream_percent;
+
+  GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
 };
 
 typedef enum {

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

@@ -55,7 +55,6 @@
 #include "src/core/ext/transport/chttp2/transport/http2_settings.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/max_concurrent_streams_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 #include "src/core/lib/backoff/random_early_detection.h"
 #include "src/core/lib/debug/trace.h"
@@ -205,6 +204,8 @@ std::string FrameTypeString(uint8_t frame_type, uint8_t flags) {
 absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
     grpc_chttp2_transport* t, const grpc_slice& slice,
     size_t& requests_started) {
+  GRPC_LATENT_SEE_INNER_SCOPE("grpc_chttp2_perform_read");
+
   const uint8_t* beg = GRPC_SLICE_START_PTR(slice);
   const uint8_t* end = GRPC_SLICE_END_PTR(slice);
   const uint8_t* cur = beg;
@@ -330,13 +331,11 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
     case GRPC_DTS_FH_8:
       DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
-      if (GRPC_TRACE_FLAG_ENABLED(http)) {
-        LOG(INFO) << "INCOMING[" << t << "]: "
-                  << FrameTypeString(t->incoming_frame_type,
-                                     t->incoming_frame_flags)
-                  << " len:" << t->incoming_frame_size
-                  << absl::StrFormat(" id:0x%08x", t->incoming_stream_id);
-      }
+      GRPC_TRACE_LOG(http, INFO)
+          << "INCOMING[" << t << "]: "
+          << FrameTypeString(t->incoming_frame_type, t->incoming_frame_flags)
+          << " len:" << t->incoming_frame_size
+          << absl::StrFormat(" id:0x%08x", t->incoming_stream_id);
       t->deframe_state = GRPC_DTS_FRAME;
       err = init_frame_parser(t, requests_started);
       if (!err.ok()) {
@@ -452,10 +451,9 @@ static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
     case GRPC_CHTTP2_FRAME_GOAWAY:
       return init_goaway_parser(t);
     default:
-      if (GRPC_TRACE_FLAG_ENABLED(http)) {
-        LOG(ERROR) << "Unknown frame type "
-                   << absl::StrFormat("%02x", t->incoming_frame_type);
-      }
+      GRPC_TRACE_LOG(http, ERROR)
+          << "Unknown frame type "
+          << absl::StrFormat("%02x", t->incoming_frame_type);
       return init_non_header_skip_frame_parser(t);
   }
 }
@@ -648,7 +646,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     } else if (GPR_UNLIKELY(
                    t->max_concurrent_streams_overload_protection &&
                    t->streams_allocated.load(std::memory_order_relaxed) >
-                       t->max_concurrent_streams_policy.AdvertiseValue())) {
+                       t->settings.local().max_concurrent_streams())) {
       // We have more streams allocated than we'd like, so apply some pushback
       // by refusing this stream.
       ++t->num_pending_induced_frames;
@@ -657,13 +655,12 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                                           GRPC_HTTP2_REFUSED_STREAM, nullptr));
       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() >=
-                       t->max_concurrent_streams_policy.AdvertiseValue() &&
-                   grpc_core::RandomEarlyDetection(
-                       t->max_concurrent_streams_policy.AdvertiseValue(),
-                       t->settings.acked().max_concurrent_streams())
-                       .Reject(t->stream_map.size(), t->bitgen))) {
+    } else if (GPR_UNLIKELY(t->stream_map.size() >=
+                                t->settings.local().max_concurrent_streams() &&
+                            grpc_core::RandomEarlyDetection(
+                                t->settings.local().max_concurrent_streams(),
+                                t->settings.acked().max_concurrent_streams())
+                                .Reject(t->stream_map.size(), t->bitgen))) {
       // 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.
@@ -790,10 +787,8 @@ static grpc_error_handle init_window_update_frame_parser(
     grpc_chttp2_stream* s = t->incoming_stream =
         grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
     if (s == nullptr) {
-      if (GRPC_TRACE_FLAG_ENABLED(http)) {
-        LOG(ERROR) << "Stream " << t->incoming_stream_id
-                   << " not found, ignoring WINDOW_UPDATE";
-      }
+      GRPC_TRACE_LOG(http, ERROR) << "Stream " << t->incoming_stream_id
+                                  << " not found, ignoring WINDOW_UPDATE";
       return init_non_header_skip_frame_parser(t);
     }
     s->call_tracer_wrapper.RecordIncomingBytes({9, 0, 0});
@@ -825,9 +820,6 @@ static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
   s->call_tracer_wrapper.RecordIncomingBytes({9, 0, 0});
   t->parser = grpc_chttp2_transport::Parser{
       "rst_stream", grpc_chttp2_rst_stream_parser_parse, &t->simple.rst_stream};
-  if (!t->is_client && grpc_core::IsRstpitEnabled()) {
-    t->max_concurrent_streams_policy.AddDemerit();
-  }
   return absl::OkStatus();
 }
 
@@ -852,7 +844,6 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
     return err;
   }
   if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_ACK) {
-    t->max_concurrent_streams_policy.AckLastSend();
     if (!t->settings.AckLastSend()) {
       return GRPC_ERROR_CREATE("Received unexpected settings ack");
     }
@@ -892,10 +883,8 @@ static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
   if (GPR_LIKELY(err.ok())) {
     return err;
   }
-  if (GRPC_TRACE_FLAG_ENABLED(http)) {
-    LOG(ERROR) << "INCOMING[" << t << ";" << s << "]: Parse failed with "
-               << err;
-  }
+  GRPC_TRACE_LOG(http, ERROR)
+      << "INCOMING[" << t << ";" << s << "]: Parse failed with " << err;
   if (grpc_error_get_int(err, grpc_core::StatusIntProperty::kStreamId,
                          &unused)) {
     grpc_chttp2_parsing_become_skip_parser(t);

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

@@ -20,7 +20,6 @@
 #include "absl/meta/type_traits.h"
 #include "absl/random/distributions.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {

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

@@ -90,10 +90,9 @@ static void stream_list_remove(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
   } else {
     t->lists[id].tail = s->links[id].prev;
   }
-  if (GRPC_TRACE_FLAG_ENABLED(http2_stream_state)) {
-    LOG(INFO) << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
-              << "]: remove from " << stream_list_id_string(id);
-  }
+  GRPC_TRACE_LOG(http2_stream_state, INFO)
+      << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
+      << "]: remove from " << stream_list_id_string(id);
 }
 
 static bool stream_list_maybe_remove(grpc_chttp2_transport* t,
@@ -122,10 +121,9 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
   }
   t->lists[id].tail = s;
   s->included.set(id);
-  if (GRPC_TRACE_FLAG_ENABLED(http2_stream_state)) {
-    LOG(INFO) << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
-              << "]: add to " << stream_list_id_string(id);
-  }
+  GRPC_TRACE_LOG(http2_stream_state, INFO)
+      << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
+      << "]: add to " << stream_list_id_string(id);
 }
 
 static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,

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

@@ -24,7 +24,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 // Helpers for hpack varint encoding

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

@@ -18,7 +18,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 namespace grpc_core {

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

@@ -49,7 +49,6 @@
 #include "src/core/ext/transport/chttp2/transport/http2_settings.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/max_concurrent_streams_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
@@ -205,24 +204,21 @@ static bool update_list(grpc_chttp2_transport* t, int64_t send_bytes,
 
 static void report_stall(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                          const char* staller) {
-  if (GRPC_TRACE_FLAG_ENABLED(flowctl)) {
-    VLOG(2) << t->peer_string.as_string_view() << ":" << t << " stream "
-            << s->id << " moved to stalled list by " << staller
-            << ". This is FULLY expected to happen in a healthy program that "
-               "is not seeing flow control stalls. However, if you know that "
-               "there are unwanted stalls, here is some helpful data: "
-               "[fc:pending="
-            << s->flow_controlled_buffer.length
-            << ":flowed=" << s->flow_controlled_bytes_flowed
-            << ":peer_initwin=" << t->settings.acked().initial_window_size()
-            << ":t_win=" << t->flow_control.remote_window() << ":s_win="
-            << static_cast<uint32_t>(
-                   std::max(int64_t{0},
-                            s->flow_control.remote_window_delta() +
-                                static_cast<int64_t>(
-                                    t->settings.peer().initial_window_size())))
-            << ":s_delta=" << s->flow_control.remote_window_delta() << "]";
-  }
+  GRPC_TRACE_VLOG(flowctl, 2)
+      << t->peer_string.as_string_view() << ":" << t << " stream " << s->id
+      << " moved to stalled list by " << staller
+      << ". This is FULLY expected to happen in a healthy program that is not "
+         "seeing flow control stalls. However, if you know that there are "
+         "unwanted stalls, here is some helpful data: [fc:pending="
+      << s->flow_controlled_buffer.length
+      << ":flowed=" << s->flow_controlled_bytes_flowed
+      << ":peer_initwin=" << t->settings.acked().initial_window_size()
+      << ":t_win=" << t->flow_control.remote_window() << ":s_win="
+      << static_cast<uint32_t>(std::max(
+             int64_t{0}, s->flow_control.remote_window_delta() +
+                             static_cast<int64_t>(
+                                 t->settings.peer().initial_window_size())))
+      << ":s_delta=" << s->flow_control.remote_window_delta() << "]";
 }
 
 namespace {
@@ -260,8 +256,6 @@ class WriteContext {
   }
 
   void FlushSettings() {
-    t_->settings.mutable_local().SetMaxConcurrentStreams(
-        t_->max_concurrent_streams_policy.AdvertiseValue());
     auto update = t_->settings.MaybeSendUpdate();
     if (update.has_value()) {
       grpc_core::Http2Frame frame(std::move(*update));
@@ -280,7 +274,6 @@ class WriteContext {
             });
       }
       t_->flow_control.FlushedSettings();
-      t_->max_concurrent_streams_policy.FlushedSettings();
       grpc_core::global_stats().IncrementHttp2SettingsWrites();
     }
   }
@@ -677,6 +670,8 @@ class StreamWriteContext {
 
 grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
     grpc_chttp2_transport* t) {
+  GRPC_LATENT_SEE_INNER_SCOPE("grpc_chttp2_begin_write");
+
   int64_t outbuf_relative_start_pos = 0;
   WriteContext ctx(t);
   ctx.FlushSettings();
@@ -732,12 +727,17 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
 
   maybe_initiate_ping(t);
 
+  t->write_flow.Begin(GRPC_LATENT_SEE_METADATA("write"));
+
   return ctx.Result();
 }
 
 void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
+  GRPC_LATENT_SEE_INNER_SCOPE("grpc_chttp2_end_write");
   grpc_chttp2_stream* s;
 
+  t->write_flow.End();
+
   if (t->channelz_socket != nullptr) {
     t->channelz_socket->RecordMessagesSent(t->num_messages_in_next_write);
   }