grpc 1.59.2 → 1.60.0.pre1

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

@@ -31,6 +31,8 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
@@ -128,10 +130,18 @@ class HpackParseResult {
  public:
   HpackParseResult() : HpackParseResult{HpackParseStatus::kOk} {}
 
-  bool ok() const { return status_.get() == HpackParseStatus::kOk; }
-  bool stream_error() const { return IsStreamError(status_.get()); }
-  bool connection_error() const { return IsConnectionError(status_.get()); }
-  bool ephemeral() const { return IsEphemeralError(status_.get()); }
+  bool ok() const {
+    return state_ == nullptr || state_->status.get() == HpackParseStatus::kOk;
+  }
+  bool stream_error() const {
+    return state_ != nullptr && IsStreamError(state_->status.get());
+  }
+  bool connection_error() const {
+    return state_ != nullptr && IsConnectionError(state_->status.get());
+  }
+  bool ephemeral() const {
+    return state_ != nullptr && IsEphemeralError(state_->status.get());
+  }
 
   std::unique_ptr<HpackParseResult> PersistentStreamErrorOrNullptr() const {
     if (ok() || connection_error() || ephemeral()) return nullptr;
@@ -154,20 +164,22 @@ class HpackParseResult {
   static HpackParseResult FromStatusWithKey(HpackParseStatus status,
                                             absl::string_view key) {
     auto r = FromStatus(status);
-    r.key_ = std::string(key);
+    if (r.state_ != nullptr) {
+      r.state_->key = std::string(key);
+    }
     return r;
   }
 
   static HpackParseResult MetadataParseError(absl::string_view key) {
     HpackParseResult r{HpackParseStatus::kMetadataParseError};
-    r.key_ = std::string(key);
+    r.state_->key = std::string(key);
     return r;
   }
 
   static HpackParseResult AddBeforeTableSizeUpdated(uint32_t current_size,
                                                     uint32_t max_size) {
     HpackParseResult p{HpackParseStatus::kAddBeforeTableSizeUpdated};
-    p.illegal_table_size_change_ =
+    p.state_->illegal_table_size_change =
         IllegalTableSizeChange{current_size, max_size};
     return p;
   }
@@ -184,8 +196,8 @@ class HpackParseResult {
                                                absl::string_view key) {
     GPR_DEBUG_ASSERT(result != ValidateMetadataResult::kOk);
     HpackParseResult p{HpackParseStatus::kInvalidMetadata};
-    p.key_ = std::string(key);
-    p.validate_metadata_result_ = result;
+    p.state_->key = std::string(key);
+    p.state_->validate_metadata_result = result;
     return p;
   }
 
@@ -196,20 +208,21 @@ class HpackParseResult {
   static HpackParseResult VarintOutOfRangeError(uint32_t value,
                                                 uint8_t last_byte) {
     HpackParseResult p{HpackParseStatus::kVarintOutOfRange};
-    p.varint_out_of_range_ = VarintOutOfRange{last_byte, value};
+    p.state_->varint_out_of_range = VarintOutOfRange{last_byte, value};
     return p;
   }
 
   static HpackParseResult InvalidHpackIndexError(uint32_t index) {
     HpackParseResult p{HpackParseStatus::kInvalidHpackIndex};
-    p.invalid_hpack_index_ = index;
+    p.state_->invalid_hpack_index = index;
     return p;
   }
 
   static HpackParseResult IllegalTableSizeChangeError(uint32_t new_size,
                                                       uint32_t max_size) {
     HpackParseResult p{HpackParseStatus::kIllegalTableSizeChange};
-    p.illegal_table_size_change_ = IllegalTableSizeChange{new_size, max_size};
+    p.state_->illegal_table_size_change =
+        IllegalTableSizeChange{new_size, max_size};
     return p;
   }
 
@@ -220,7 +233,7 @@ class HpackParseResult {
   static HpackParseResult SoftMetadataLimitExceededError(
       grpc_metadata_batch* metadata, uint32_t frame_length, uint32_t limit) {
     HpackParseResult p{HpackParseStatus::kSoftMetadataLimitExceeded};
-    p.metadata_limit_exceeded_ =
+    p.state_->metadata_limit_exceeded =
         MetadataLimitExceeded{frame_length, limit, metadata};
     return p;
   }
@@ -228,7 +241,7 @@ class HpackParseResult {
   static HpackParseResult HardMetadataLimitExceededError(
       grpc_metadata_batch* metadata, uint32_t frame_length, uint32_t limit) {
     HpackParseResult p{HpackParseStatus::kHardMetadataLimitExceeded};
-    p.metadata_limit_exceeded_ =
+    p.state_->metadata_limit_exceeded =
         MetadataLimitExceeded{frame_length, limit, metadata};
     return p;
   }
@@ -236,7 +249,7 @@ class HpackParseResult {
   static HpackParseResult HardMetadataLimitExceededByKeyError(
       uint32_t key_length, uint32_t limit) {
     HpackParseResult p{HpackParseStatus::kHardMetadataLimitExceededByKey};
-    p.metadata_limit_exceeded_by_atom_ =
+    p.state_->metadata_limit_exceeded_by_atom =
         MetadataLimitExceededByAtom{key_length, limit};
     return p;
   }
@@ -244,9 +257,9 @@ class HpackParseResult {
   static HpackParseResult HardMetadataLimitExceededByValueError(
       absl::string_view key, uint32_t value_length, uint32_t limit) {
     HpackParseResult p{HpackParseStatus::kHardMetadataLimitExceededByValue};
-    p.metadata_limit_exceeded_by_atom_ =
+    p.state_->metadata_limit_exceeded_by_atom =
         MetadataLimitExceededByAtom{value_length, limit};
-    p.key_ = std::string(key);
+    p.state_->key = std::string(key);
     return p;
   }
 
@@ -255,7 +268,13 @@ class HpackParseResult {
   absl::Status Materialize() const;
 
  private:
-  explicit HpackParseResult(HpackParseStatus status) : status_(status) {}
+  explicit HpackParseResult(HpackParseStatus status) {
+    // Dynamically allocate state if status is not ok.
+    if (status != HpackParseStatus::kOk) {
+      state_ = MakeRefCounted<HpackParseResultState>(status);
+    }
+  }
+
   absl::Status BuildMaterialized() const;
 
   struct VarintOutOfRange {
@@ -300,25 +319,31 @@ class HpackParseResult {
     HpackParseStatus status_;
   };
 
-  StatusWrapper status_;
-  union {
-    // Set if status == kInvalidMetadata
-    ValidateMetadataResult validate_metadata_result_;
-    // Set if status == kVarintOutOfRange
-    VarintOutOfRange varint_out_of_range_;
-    // Set if status == kInvalidHpackIndex
-    uint32_t invalid_hpack_index_;
-    // Set if status == kHardMetadataLimitExceeded or
-    // kSoftMetadataLimitExceeded
-    MetadataLimitExceeded metadata_limit_exceeded_;
-    // Set if status == kHardMetadataLimitExceededByKey or
-    // kHardMetadataLimitExceededByValue
-    MetadataLimitExceededByAtom metadata_limit_exceeded_by_atom_;
-    // Set if status == kIllegalTableSizeChange
-    IllegalTableSizeChange illegal_table_size_change_;
+  struct HpackParseResultState : public RefCounted<HpackParseResultState> {
+    explicit HpackParseResultState(HpackParseStatus incoming_status)
+        : status(incoming_status) {}
+    StatusWrapper status;
+    union {
+      // Set if status == kInvalidMetadata
+      ValidateMetadataResult validate_metadata_result;
+      // Set if status == kVarintOutOfRange
+      VarintOutOfRange varint_out_of_range;
+      // Set if status == kInvalidHpackIndex
+      uint32_t invalid_hpack_index;
+      // Set if status == kHardMetadataLimitExceeded or
+      // kSoftMetadataLimitExceeded
+      MetadataLimitExceeded metadata_limit_exceeded;
+      // Set if status == kHardMetadataLimitExceededByKey or
+      // kHardMetadataLimitExceededByValue
+      MetadataLimitExceededByAtom metadata_limit_exceeded_by_atom;
+      // Set if status == kIllegalTableSizeChange
+      IllegalTableSizeChange illegal_table_size_change;
+    };
+    std::string key;
+    mutable absl::optional<absl::Status> materialized_status;
   };
-  std::string key_;
-  mutable absl::optional<absl::Status> materialized_status_;
+
+  RefCountedPtr<HpackParseResultState> state_ = nullptr;
 };
 
 }  // namespace grpc_core

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

@@ -240,10 +240,6 @@ class HPackParser {
     uint32_t frame_length = 0;
     // Length of the string being parsed
     uint32_t string_length;
-    // How many more dynamic table updates are allowed
-    uint8_t dynamic_table_updates_allowed;
-    // Current parse state
-    ParseState parse_state = ParseState::kTop;
     // RED for overly large metadata sets
     RandomEarlyDetection metadata_early_detection;
     // Should the current header be added to the hpack table?
@@ -252,6 +248,10 @@ class HPackParser {
     bool is_string_huff_compressed;
     // Is the value being parsed binary?
     bool is_binary_header;
+    // How many more dynamic table updates are allowed
+    uint8_t dynamic_table_updates_allowed;
+    // Current parse state
+    ParseState parse_state = ParseState::kTop;
     absl::variant<const HPackTable::Memento*, Slice> key;
   };
 

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

@@ -29,7 +29,6 @@
 #include <utility>
 
 #include "absl/container/flat_hash_map.h"
-#include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
@@ -58,8 +57,10 @@
 #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"
+#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/channel/tcp_tracer.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -70,6 +71,7 @@
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice.h"
@@ -78,8 +80,6 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
-#include "src/core/lib/transport/transport_fwd.h"
-#include "src/core/lib/transport/transport_impl.h"
 
 // Flag that this closure barrier may be covering a write in a pollset, and so
 //   we should not complete this closure until we can prove that the write got
@@ -236,26 +236,40 @@ typedef enum {
   GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED,
 } grpc_chttp2_keepalive_state;
 
-struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
+struct grpc_chttp2_transport final
+    : public grpc_core::Transport,
+      public grpc_core::FilterStackTransport,
+      public grpc_core::RefCounted<grpc_chttp2_transport,
+                                   grpc_core::NonPolymorphicRefCount>,
+      public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
                         grpc_endpoint* ep, bool is_client);
-  ~grpc_chttp2_transport();
-
-  // Make this be able to be contained in RefCountedPtr<>
-  // Can't yet make this derive from RefCounted because we need to keep
-  // `grpc_transport base` first.
-  // TODO(ctiller): Make a transport interface.
-  void IncrementRefCount() { refs.Ref(); }
-  void Unref() {
-    if (refs.Unref()) delete this;
-  }
-  grpc_core::RefCountedPtr<grpc_chttp2_transport> Ref() {
-    IncrementRefCount();
-    return grpc_core::RefCountedPtr<grpc_chttp2_transport>(this);
+  ~grpc_chttp2_transport() override;
+
+  void Orphan() override;
+
+  size_t SizeOfStream() const override;
+  bool HackyDisableStreamOpBatchCoalescingInConnectedChannel() const override;
+  void PerformStreamOp(grpc_stream* gs,
+                       grpc_transport_stream_op_batch* op) override;
+  void DestroyStream(grpc_stream* gs,
+                     grpc_closure* then_schedule_closure) override;
+
+  grpc_core::FilterStackTransport* filter_stack_transport() override {
+    return this;
   }
+  grpc_core::ClientTransport* client_transport() override { return nullptr; }
+  grpc_core::ServerTransport* server_transport() override { return nullptr; }
+
+  absl::string_view GetTransportName() const override;
+  void InitStream(grpc_stream* gs, grpc_stream_refcount* refcount,
+                  const void* server_data, grpc_core::Arena* arena) override;
+  void SetPollset(grpc_stream* stream, grpc_pollset* pollset) override;
+  void SetPollsetSet(grpc_stream* stream,
+                     grpc_pollset_set* pollset_set) override;
+  void PerformOp(grpc_transport_op* op) override;
+  grpc_endpoint* GetEndpoint() override;
 
-  grpc_transport base;  // must be first
-  grpc_core::RefCount refs;
   grpc_endpoint* ep;
   grpc_core::Slice peer_string;
 
@@ -305,7 +319,6 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   };
 
   grpc_closure write_action_begin_locked;
-  grpc_closure write_action;
   grpc_closure write_action_end_locked;
 
   grpc_closure read_action_locked;
@@ -319,7 +332,7 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_stream** accepting_stream = nullptr;
 
   // accept stream callback
-  void (*accept_stream_cb)(void* user_data, grpc_transport* transport,
+  void (*accept_stream_cb)(void* user_data, grpc_core::Transport* transport,
                            const void* server_data);
   // registered_method_matcher_cb is called before invoking the recv initial
   // metadata callback.
@@ -371,8 +384,9 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   grpc_core::Chttp2PingAbusePolicy ping_abuse_policy;
   grpc_core::Chttp2PingRatePolicy ping_rate_policy;
   grpc_core::Chttp2PingCallbacks ping_callbacks;
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
-      delayed_ping_timer_handle;
+  grpc_event_engine::experimental::EventEngine::TaskHandle
+      delayed_ping_timer_handle =
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
   grpc_closure retry_initiate_ping_locked;
 
   grpc_core::Chttp2MaxConcurrentStreamsPolicy max_concurrent_streams_policy;
@@ -444,21 +458,20 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   grpc_closure destructive_reclaimer_locked;
 
   // next bdp ping timer handle
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
-      next_bdp_ping_timer_handle;
+  grpc_event_engine::experimental::EventEngine::TaskHandle
+      next_bdp_ping_timer_handle =
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
 
   // keep-alive ping support
   /// Closure to initialize a keepalive ping
   grpc_closure init_keepalive_ping_locked;
-  /// Closure to run when the keepalive ping is sent
-  grpc_closure start_keepalive_ping_locked;
   /// Closure to run when the keepalive ping ack is received
   grpc_closure finish_keepalive_ping_locked;
-  /// Closure to run when the keepalive ping timeouts
-  grpc_closure keepalive_watchdog_fired_locked;
   /// timer to initiate ping events
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
-      keepalive_ping_timer_handle;
+  grpc_event_engine::experimental::EventEngine::TaskHandle
+      keepalive_ping_timer_handle =
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
+  ;
   /// time duration in between pings
   grpc_core::Duration keepalive_time;
   /// grace period to wait for data after sending a ping before keepalives
@@ -492,6 +505,9 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   /// how much data are we willing to buffer when the WRITE_BUFFER_HINT is set?
   uint32_t write_buffer_size = grpc_core::chttp2::kDefaultWindow;
 
+  /// write execution state of the transport
+  grpc_chttp2_write_state write_state = GRPC_CHTTP2_WRITE_STATE_IDLE;
+
   /// policy for how much data we're willing to put into one http2 write
   grpc_core::Chttp2WriteSizePolicy write_size_policy;
 
@@ -511,8 +527,6 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
 
   /// if keepalive pings are allowed when there's no outstanding streams
   bool keepalive_permit_without_calls = false;
-  /// If start_keepalive_ping_locked has been called
-  bool keepalive_ping_started = false;
 
   // bdp estimator
   bool bdp_ping_blocked =
@@ -521,9 +535,6 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   /// is the transport destroying itself?
   uint8_t destroying = false;
 
-  /// is there a read request to the endpoint outstanding?
-  uint8_t endpoint_reading = 1;
-
   /// is this a client?
   bool is_client;
 
@@ -538,13 +549,13 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   bool ack_pings = true;
   /// True if the keepalive system wants to see some data incoming
   bool keepalive_incoming_data_wanted = false;
+  /// True if we count stream allocation (instead of HTTP2 concurrency) for
+  /// MAX_CONCURRENT_STREAMS
+  bool max_concurrent_streams_overload_protection = false;
 
   // What percentage of rst_stream frames on the server should cause a ping
   // frame to be generated.
   uint8_t ping_on_rst_stream_percent;
-
-  /// write execution state of the transport
-  grpc_chttp2_write_state write_state = GRPC_CHTTP2_WRITE_STATE_IDLE;
 };
 
 typedef enum {
@@ -650,6 +661,12 @@ struct grpc_chttp2_stream {
   /// Byte counter for number of bytes written
   size_t byte_counter = 0;
 
+  /// Only set when enabled.
+  grpc_core::CallTracerInterface* call_tracer = nullptr;
+
+  /// Only set when enabled.
+  std::shared_ptr<grpc_core::TcpTracerInterface> tcp_tracer;
+
   // time this stream was created
   gpr_timespec creation_time = gpr_now(GPR_CLOCK_MONOTONIC);
 
@@ -670,6 +687,12 @@ struct grpc_chttp2_stream {
 
 #define GRPC_ARG_PING_TIMEOUT_MS "grpc.http2.ping_timeout_ms"
 
+// EXPERIMENTAL: provide protection against overloading a server with too many
+// requests: wait for streams to be deallocated before they stop counting
+// against MAX_CONCURRENT_STREAMS
+#define GRPC_ARG_MAX_CONCURRENT_STREAMS_OVERLOAD_PROTECTION \
+  "grpc.http.overload_protection"
+
 /// Transport writing call flow:
 /// grpc_chttp2_initiate_write() is called anywhere that we know bytes need to
 /// go out on the wire.

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

@@ -651,9 +651,19 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                    t->stream_map.size() + t->extra_streams >=
                    t->settings[GRPC_ACKED_SETTINGS]
                               [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])) {
-      return GRPC_ERROR_CREATE("Max stream count exceeded");
+      if (grpc_core::IsRfcMaxConcurrentStreamsEnabled()) {
+        ++t->num_pending_induced_frames;
+        grpc_slice_buffer_add(
+            &t->qbuf,
+            grpc_chttp2_rst_stream_create(t->incoming_stream_id,
+                                          GRPC_HTTP2_REFUSED_STREAM, nullptr));
+        grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
+        return init_header_skip_frame_parser(t, priority_type, is_eoh);
+      } else {
+        return GRPC_ERROR_CREATE("Max stream count exceeded");
+      }
     } else if (GPR_UNLIKELY(
-                   grpc_core::IsOverloadProtectionEnabled() &&
+                   t->max_concurrent_streams_overload_protection &&
                    t->streams_allocated.load(std::memory_order_relaxed) >
                        t->max_concurrent_streams_policy.AdvertiseValue())) {
       // We have more streams allocated than we'd like, so apply some pushback

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

@@ -18,7 +18,6 @@
 
 #include <algorithm>
 #include <ostream>
-#include <utility>
 
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
@@ -68,7 +67,8 @@ Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval,
   if (max_pings_without_data_ != 0 && pings_before_data_required_ == 0) {
     return TooManyRecentPings{};
   }
-  if (max_inflight_pings_ != 0 && inflight_pings > max_inflight_pings_) {
+  if (max_inflight_pings_ > 0 &&
+      inflight_pings > static_cast<size_t>(max_inflight_pings_)) {
     return TooManyRecentPings{};
   }
   const Timestamp next_allowed_ping =

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

@@ -29,11 +29,9 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
 
@@ -54,6 +52,7 @@
 #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"
+#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/stats_data.h"
@@ -173,7 +172,9 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
               too_soon.next_allowed_ping_interval.ToString().c_str(),
               too_soon.wait.ToString().c_str());
         }
-        if (!t->delayed_ping_timer_handle.has_value()) {
+        if (t->delayed_ping_timer_handle ==
+            grpc_event_engine::experimental::EventEngine::TaskHandle::
+                kInvalid) {
           t->delayed_ping_timer_handle = t->event_engine->RunAfter(
               too_soon.wait, [t = t->Ref()]() mutable {
                 grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
@@ -322,6 +323,10 @@ class WriteContext {
   }
 
   void FlushPingAcks() {
+    if (t_->ping_ack_count == 0) return;
+    // Limit the size of writes if we include ping acks - to avoid the ack being
+    // delayed by crypto operations.
+    target_write_size_ = 0;
     for (size_t i = 0; i < t_->ping_ack_count; i++) {
       grpc_slice_buffer_add(t_->outbuf.c_slice_buffer(),
                             grpc_chttp2_ping_create(true, t_->ping_acks[i]));
@@ -348,7 +353,7 @@ class WriteContext {
   }
 
   grpc_chttp2_stream* NextStream() {
-    if (t_->outbuf.c_slice_buffer()->length > target_write_size()) {
+    if (t_->outbuf.c_slice_buffer()->length > target_write_size_) {
       result_.partial = true;
       return nullptr;
     }
@@ -509,6 +514,12 @@ class StreamWriteContext {
     grpc_chttp2_complete_closure_step(
         t_, s_, &s_->send_initial_metadata_finished, absl::OkStatus(),
         "send_initial_metadata_finished");
+    if (s_->call_tracer) {
+      s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
+          grpc_core::HttpAnnotation::Type::kHeadWritten,
+          grpc_core::Timestamp::Now(), s_->t->flow_control.stats(),
+          s_->flow_control.stats()));
+    }
   }
 
   void FlushWindowUpdates() {
@@ -636,6 +647,11 @@ class StreamWriteContext {
     }
     grpc_chttp2_mark_stream_closed(t_, s_, !t_->is_client, true,
                                    absl::OkStatus());
+    if (s_->call_tracer) {
+      s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
+          grpc_core::HttpAnnotation::Type::kEnd, grpc_core::Timestamp::Now(),
+          s_->t->flow_control.stats(), s_->flow_control.stats()));
+    }
   }
 
   WriteContext* const write_context_;
@@ -682,7 +698,7 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
             grpc_core::GrpcHttp2GetWriteTimestampsCallback() != nullptr) {
           t->cl->emplace_back(copy_context_fn(s->context),
                               outbuf_relative_start_pos, num_stream_bytes,
-                              s->byte_counter);
+                              s->byte_counter, s->tcp_tracer);
         }
       }
       outbuf_relative_start_pos += num_stream_bytes;