grpc 1.73.0 → 1.74.0

data/src/core/lib/event_engine/posix_engine/traced_buffer_list.cc

@@ -25,7 +25,9 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
 #include "src/core/lib/iomgr/port.h"
+#include "src/core/util/crash.h"
 #include "src/core/util/sync.h"
 
 #ifdef GRPC_LINUX_ERRQUEUE
@@ -36,25 +38,6 @@
 namespace grpc_event_engine::experimental {
 
 namespace {
-// Fills gpr_timespec gts based on values from timespec ts.
-void FillGprFromTimestamp(gpr_timespec* gts, const struct timespec* ts) {
-  gts->tv_sec = ts->tv_sec;
-  gts->tv_nsec = static_cast<int32_t>(ts->tv_nsec);
-  gts->clock_type = GPR_CLOCK_REALTIME;
-}
-
-void DefaultTimestampsCallback(void* /*arg*/, Timestamps* /*ts*/,
-                               absl::Status /*shutdown_err*/) {
-  VLOG(2) << "Timestamps callback has not been registered";
-}
-
-// The saved callback function that will be invoked when we get all the
-// timestamps that we are going to get for a TracedBuffer.
-absl::AnyInvocable<void(void*, Timestamps*, absl::Status)>
-    g_timestamps_callback =
-        []() -> absl::AnyInvocable<void(void*, Timestamps*, absl::Status)> {
-  return DefaultTimestampsCallback;
-}();
 
 // Used to extract individual opt stats from cmsg, so as to avoid troubles with
 // unaligned reads.
@@ -66,260 +49,243 @@ T ReadUnaligned(const void* ptr) {
 }
 
 // Extracts opt stats from the tcp_info struct \a info to \a metrics
-void ExtractOptStatsFromTcpInfo(ConnectionMetrics* metrics,
-                                const tcp_info* info) {
+PosixWriteEventSink::ConnectionMetrics ExtractOptStatsFromTcpInfo(
+    const tcp_info* info) {
+  PosixWriteEventSink::ConnectionMetrics metrics;
   if (info == nullptr) {
-    return;
+    return metrics;
   }
   if (info->length > offsetof(tcp_info, tcpi_sndbuf_limited)) {
-    metrics->recurring_retrans = info->tcpi_retransmits;
-    metrics->is_delivery_rate_app_limited =
-        info->tcpi_delivery_rate_app_limited;
-    metrics->congestion_window = info->tcpi_snd_cwnd;
-    metrics->reordering = info->tcpi_reordering;
-    metrics->packet_retx = info->tcpi_total_retrans;
-    metrics->pacing_rate = info->tcpi_pacing_rate;
-    metrics->data_notsent = info->tcpi_notsent_bytes;
+    metrics.recurring_retrans = info->tcpi_retransmits;
+    metrics.is_delivery_rate_app_limited = info->tcpi_delivery_rate_app_limited;
+    metrics.congestion_window = info->tcpi_snd_cwnd;
+    metrics.reordering = info->tcpi_reordering;
+    metrics.packet_retx = info->tcpi_total_retrans;
+    metrics.pacing_rate = info->tcpi_pacing_rate;
+    metrics.data_notsent = info->tcpi_notsent_bytes;
     if (info->tcpi_min_rtt != UINT32_MAX) {
-      metrics->min_rtt = info->tcpi_min_rtt;
+      metrics.min_rtt = info->tcpi_min_rtt;
     }
-    metrics->packet_sent = info->tcpi_data_segs_out;
-    metrics->delivery_rate = info->tcpi_delivery_rate;
-    metrics->busy_usec = info->tcpi_busy_time;
-    metrics->rwnd_limited_usec = info->tcpi_rwnd_limited;
-    metrics->sndbuf_limited_usec = info->tcpi_sndbuf_limited;
+    metrics.packet_sent = info->tcpi_data_segs_out;
+    metrics.delivery_rate = info->tcpi_delivery_rate;
+    metrics.busy_usec = info->tcpi_busy_time;
+    metrics.rwnd_limited_usec = info->tcpi_rwnd_limited;
+    metrics.sndbuf_limited_usec = info->tcpi_sndbuf_limited;
   }
   if (info->length > offsetof(tcp_info, tcpi_dsack_dups)) {
-    metrics->data_sent = info->tcpi_bytes_sent;
-    metrics->data_retx = info->tcpi_bytes_retrans;
-    metrics->packet_spurious_retx = info->tcpi_dsack_dups;
+    metrics.data_sent = info->tcpi_bytes_sent;
+    metrics.data_retx = info->tcpi_bytes_retrans;
+    metrics.packet_spurious_retx = info->tcpi_dsack_dups;
   }
+  return metrics;
 }
 
 // Extracts opt stats from the given control message \a opt_stats to the
 // connection metrics \a metrics.
-void ExtractOptStatsFromCmsg(ConnectionMetrics* metrics,
-                             const cmsghdr* opt_stats) {
+PosixWriteEventSink::ConnectionMetrics ExtractOptStatsFromCmsg(
+    const cmsghdr* opt_stats) {
+  PosixWriteEventSink::ConnectionMetrics metrics;
   if (opt_stats == nullptr) {
-    return;
+    return metrics;
   }
   const auto* data = CMSG_DATA(opt_stats);
   constexpr int64_t cmsg_hdr_len = CMSG_ALIGN(sizeof(struct cmsghdr));
   const int64_t len = opt_stats->cmsg_len - cmsg_hdr_len;
   int64_t offset = 0;
-
   while (offset < len) {
     const auto* attr = reinterpret_cast<const nlattr*>(data + offset);
     const void* val = data + offset + NLA_HDRLEN;
     switch (attr->nla_type) {
       case TCP_NLA_BUSY: {
-        metrics->busy_usec = ReadUnaligned<uint64_t>(val);
+        metrics.busy_usec = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_RWND_LIMITED: {
-        metrics->rwnd_limited_usec = ReadUnaligned<uint64_t>(val);
+        metrics.rwnd_limited_usec = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_SNDBUF_LIMITED: {
-        metrics->sndbuf_limited_usec = ReadUnaligned<uint64_t>(val);
+        metrics.sndbuf_limited_usec = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_PACING_RATE: {
-        metrics->pacing_rate = ReadUnaligned<uint64_t>(val);
+        metrics.pacing_rate = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DELIVERY_RATE: {
-        metrics->delivery_rate = ReadUnaligned<uint64_t>(val);
+        metrics.delivery_rate = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DELIVERY_RATE_APP_LMT: {
-        metrics->is_delivery_rate_app_limited = ReadUnaligned<uint8_t>(val);
+        metrics.is_delivery_rate_app_limited = ReadUnaligned<uint8_t>(val);
         break;
       }
       case TCP_NLA_SND_CWND: {
-        metrics->congestion_window = ReadUnaligned<uint32_t>(val);
+        metrics.congestion_window = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_MIN_RTT: {
-        metrics->min_rtt = ReadUnaligned<uint32_t>(val);
+        metrics.min_rtt = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_SRTT: {
-        metrics->srtt = ReadUnaligned<uint32_t>(val);
+        metrics.srtt = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_RECUR_RETRANS: {
-        metrics->recurring_retrans = ReadUnaligned<uint8_t>(val);
+        metrics.recurring_retrans = ReadUnaligned<uint8_t>(val);
         break;
       }
       case TCP_NLA_BYTES_SENT: {
-        metrics->data_sent = ReadUnaligned<uint64_t>(val);
+        metrics.data_sent = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DATA_SEGS_OUT: {
-        metrics->packet_sent = ReadUnaligned<uint64_t>(val);
+        metrics.packet_sent = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_TOTAL_RETRANS: {
-        metrics->packet_retx = ReadUnaligned<uint64_t>(val);
+        metrics.packet_retx = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DELIVERED: {
-        metrics->packet_delivered = ReadUnaligned<uint32_t>(val);
+        metrics.packet_delivered = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_DELIVERED_CE: {
-        metrics->packet_delivered_ce = ReadUnaligned<uint32_t>(val);
+        metrics.packet_delivered_ce = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_BYTES_RETRANS: {
-        metrics->data_retx = ReadUnaligned<uint64_t>(val);
+        metrics.data_retx = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DSACK_DUPS: {
-        metrics->packet_spurious_retx = ReadUnaligned<uint32_t>(val);
+        metrics.packet_spurious_retx = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_REORDERING: {
-        metrics->reordering = ReadUnaligned<uint32_t>(val);
+        metrics.reordering = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_SND_SSTHRESH: {
-        metrics->snd_ssthresh = ReadUnaligned<uint32_t>(val);
+        metrics.snd_ssthresh = ReadUnaligned<uint32_t>(val);
+        break;
+      }
+      case TCP_NLA_BYTES_NOTSENT: {
+        metrics.data_notsent = ReadUnaligned<uint16_t>(val);
         break;
       }
     }
     offset += NLA_ALIGN(attr->nla_len);
   }
+  return metrics;
 }
+
+grpc_core::Duration g_max_pending_ack_time = grpc_core::Duration::Seconds(10);
+
 }  // namespace.
 
-bool TracedBufferList::TracedBuffer::Finished(gpr_timespec ts) {
-  constexpr int kGrpcMaxPendingAckTimeMillis = 10000;
-  return gpr_time_to_millis(gpr_time_sub(ts, last_timestamp_)) >
-         kGrpcMaxPendingAckTimeMillis;
+bool TracedBufferList::TracedBuffer::TimedOut(grpc_core::Timestamp now) {
+  return last_timestamp_ + g_max_pending_ack_time < now;
 }
 
-void TracedBufferList::AddNewEntry(int32_t seq_no, int fd, void* arg) {
-  TracedBuffer* new_elem = new TracedBuffer(seq_no, arg);
+void TracedBufferList::AddNewEntry(int32_t seq_no,
+                                   EventEnginePosixInterface* posix_interface,
+                                   const FileDescriptor& fd,
+                                   EventEngine::Endpoint::WriteEventSink sink) {
+  TracedBuffer new_elem(seq_no, std::move(sink));
   // Store the current time as the sendmsg time.
-  new_elem->ts_.sendmsg_time.time = gpr_now(GPR_CLOCK_REALTIME);
-  new_elem->ts_.scheduled_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
-  new_elem->ts_.sent_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
-  new_elem->ts_.acked_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
-  if (GetSocketTcpInfo(&(new_elem->ts_.info), fd) == 0) {
-    ExtractOptStatsFromTcpInfo(&(new_elem->ts_.sendmsg_time.metrics),
-                               &(new_elem->ts_.info));
-  }
-  new_elem->last_timestamp_ = new_elem->ts_.sendmsg_time.time;
-  grpc_core::MutexLock lock(&mu_);
-  if (!head_) {
-    head_ = tail_ = new_elem;
+  // new_elem.ts_.sendmsg_time.time = gpr_now(GPR_CLOCK_REALTIME);
+  auto curr_time = absl::Now();
+  struct tcp_info info;
+  if (posix_interface != nullptr &&
+      GetSocketTcpInfo(&info, posix_interface, fd).ok()) {
+    new_elem.sink_.RecordEvent(EventEngine::Endpoint::WriteEvent::kSendMsg,
+                               curr_time, ExtractOptStatsFromTcpInfo(&info));
   } else {
-    tail_->next_ = new_elem;
-    tail_ = new_elem;
+    new_elem.sink_.RecordEvent(EventEngine::Endpoint::WriteEvent::kSendMsg,
+                               curr_time,
+                               PosixWriteEventSink::ConnectionMetrics());
   }
+  new_elem.last_timestamp_ = grpc_core::Timestamp::Now();
+  // new_elem.last_timestamp_ = new_elem.ts_.sendmsg_time.time;
+  grpc_core::MutexLock lock(&mu_);
+  list_.push_back(std::move(new_elem));
 }
 
 void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
                                         struct cmsghdr* opt_stats,
                                         struct scm_timestamping* tss) {
+  absl::Time timestamp = absl::TimeFromTimespec(tss->ts[0]);
+  grpc_core::Timestamp core_timestamp = grpc_core::Timestamp::Now();
+  auto metrics = ExtractOptStatsFromCmsg(opt_stats);
   grpc_core::MutexLock lock(&mu_);
-  TracedBuffer* elem = head_;
-  TracedBuffer* prev = nullptr;
-  while (elem != nullptr) {
+  auto it = list_.begin();
+  while (it != list_.end()) {
     // The byte number refers to the sequence number of the last byte which this
     // timestamp relates to.
-    if (serr->ee_data >= elem->seq_no_) {
+    if (serr->ee_data >= it->seq_no_) {
       switch (serr->ee_info) {
         case SCM_TSTAMP_SCHED:
-          FillGprFromTimestamp(&(elem->ts_.scheduled_time.time), &(tss->ts[0]));
-          ExtractOptStatsFromCmsg(&(elem->ts_.scheduled_time.metrics),
-                                  opt_stats);
-          elem->last_timestamp_ = elem->ts_.scheduled_time.time;
-          elem = elem->next_;
+          it->sink_.RecordEvent(EventEngine::Endpoint::WriteEvent::kScheduled,
+                                timestamp, metrics);
+          it->last_timestamp_ = core_timestamp;
+          ++it;
           break;
         case SCM_TSTAMP_SND:
-          FillGprFromTimestamp(&(elem->ts_.sent_time.time), &(tss->ts[0]));
-          ExtractOptStatsFromCmsg(&(elem->ts_.sent_time.metrics), opt_stats);
-          elem->last_timestamp_ = elem->ts_.sent_time.time;
-          elem = elem->next_;
+          it->sink_.RecordEvent(EventEngine::Endpoint::WriteEvent::kSent,
+                                timestamp, metrics);
+          it->last_timestamp_ = core_timestamp;
+          ++it;
           break;
         case SCM_TSTAMP_ACK:
-          FillGprFromTimestamp(&(elem->ts_.acked_time.time), &(tss->ts[0]));
-          ExtractOptStatsFromCmsg(&(elem->ts_.acked_time.metrics), opt_stats);
-          // Got all timestamps. Do the callback and free this TracedBuffer. The
-          // thing below can be passed by value if we don't want the restriction
-          // on the lifetime.
-          g_timestamps_callback(elem->arg_, &(elem->ts_), absl::OkStatus());
-          // Safe to update head_ to elem->next_ because the list is ordered by
-          // seq_no. Thus if elem is to be deleted, it has to be the first
-          // element in the list.
-          head_ = elem->next_;
-          delete elem;
-          elem = head_;
+          it->sink_.RecordEvent(EventEngine::Endpoint::WriteEvent::kAcked,
+                                timestamp, metrics);
+          it = list_.erase(it);
           break;
         default:
-          abort();
+          grpc_core::Crash(
+              absl::StrCat("Unknown timestamp type %d", serr->ee_info));
       }
     } else {
       break;
     }
   }
 
-  elem = head_;
-  gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
-  while (elem != nullptr) {
-    if (!elem->Finished(now)) {
-      prev = elem;
-      elem = elem->next_;
+  it = list_.begin();
+  while (it != list_.end()) {
+    if (!it->TimedOut(core_timestamp)) {
+      ++it;
       continue;
-    }
-    g_timestamps_callback(elem->arg_, &(elem->ts_),
-                          absl::DeadlineExceededError("Ack timed out"));
-    if (prev != nullptr) {
-      prev->next_ = elem->next_;
-      delete elem;
-      elem = prev->next_;
     } else {
-      head_ = elem->next_;
-      delete elem;
-      elem = head_;
+      LOG(ERROR) << "No timestamp received for TracedBuffer in "
+                 << g_max_pending_ack_time << ". Removing.";
+      it = list_.erase(it);
     }
   }
-  tail_ = (head_ == nullptr) ? head_ : prev;
 }
 
-void TracedBufferList::Shutdown(void* remaining, absl::Status shutdown_err) {
-  grpc_core::MutexLock lock(&mu_);
-  while (head_) {
-    TracedBuffer* elem = head_;
-    g_timestamps_callback(elem->arg_, &(elem->ts_), shutdown_err);
-    head_ = head_->next_;
-    delete elem;
+void TracedBufferList::Shutdown(
+    std::optional<EventEngine::Endpoint::WriteEventSink> remaining) {
+  if (remaining.has_value()) {
+    PosixWriteEventSink sink(std::move(remaining).value());
+    sink.RecordEvent(EventEngine::Endpoint::WriteEvent::kClosed, absl::Now(),
+                     PosixWriteEventSink::ConnectionMetrics());
   }
-  if (remaining != nullptr) {
-    g_timestamps_callback(remaining, nullptr, shutdown_err);
+  grpc_core::MutexLock lock(&mu_);
+  if (list_.empty()) return;
+  auto curr_time = absl::Now();
+  for (auto it = list_.begin(); it != list_.end(); ++it) {
+    it->sink_.RecordEvent(EventEngine::Endpoint::WriteEvent::kClosed, curr_time,
+                          PosixWriteEventSink::ConnectionMetrics());
   }
-  tail_ = head_;
+  list_.clear();
 }
 
-void TcpSetWriteTimestampsCallback(
-    absl::AnyInvocable<void(void*, Timestamps*, absl::Status)> fn) {
-  g_timestamps_callback = std::move(fn);
-}
-
-}  // namespace grpc_event_engine::experimental
-
-#else  // GRPC_LINUX_ERRQUEUE
-
-#include "src/core/util/crash.h"
-
-namespace grpc_event_engine::experimental {
-
-void TcpSetWriteTimestampsCallback(
-    absl::AnyInvocable<void(void*, Timestamps*, absl::Status)> /*fn*/) {
-  grpc_core::Crash("Timestamps callback is not enabled for this platform");
+void TracedBufferList::TestOnlySetMaxPendingAckTime(
+    grpc_core::Duration duration) {
+  g_max_pending_ack_time = duration;
 }
 
 }  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/traced_buffer_list.h

@@ -15,6 +15,7 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 #include <stdint.h>
@@ -24,78 +25,13 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
+#include "src/core/lib/event_engine/posix_engine/posix_write_event_sink.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_event_engine::experimental {
 
-struct ConnectionMetrics {  // Delivery rate in Bytes/s.
-  std::optional<uint64_t> delivery_rate;
-  // If the delivery rate is limited by the application, this is set to true.
-  std::optional<bool> is_delivery_rate_app_limited;
-  // Total packets retransmitted.
-  std::optional<uint32_t> packet_retx;
-  // Total packets retransmitted spuriously. This metric is smaller than or
-  // equal to packet_retx.
-  std::optional<uint32_t> packet_spurious_retx;
-  // Total packets sent.
-  std::optional<uint32_t> packet_sent;
-  // Total packets delivered.
-  std::optional<uint32_t> packet_delivered;
-  // Total packets delivered with ECE marked. This metric is smaller than or
-  // equal to packet_delivered.
-  std::optional<uint32_t> packet_delivered_ce;
-  // Total bytes lost so far.
-  std::optional<uint64_t> data_retx;
-  // Total bytes sent so far.
-  std::optional<uint64_t> data_sent;
-  // Total bytes in write queue but not sent.
-  std::optional<uint64_t> data_notsent;
-  // Pacing rate of the connection in Bps
-  std::optional<uint64_t> pacing_rate;
-  // Minimum RTT observed in usec.
-  std::optional<uint32_t> min_rtt;
-  // Smoothed RTT in usec
-  std::optional<uint32_t> srtt;
-  // Send congestion window.
-  std::optional<uint32_t> congestion_window;
-  // Slow start threshold in packets.
-  std::optional<uint32_t> snd_ssthresh;
-  // Maximum degree of reordering (i.e., maximum number of packets reodered)
-  // on the connection.
-  std::optional<uint32_t> reordering;
-  // Represents the number of recurring retransmissions of the first sequence
-  // that is not acknowledged yet.
-  std::optional<uint8_t> recurring_retrans;
-  // The cumulative time (in usec) that the transport protocol was busy
-  // sending data.
-  std::optional<uint64_t> busy_usec;
-  // The cumulative time (in usec) that the transport protocol was limited by
-  // the receive window size.
-  std::optional<uint64_t> rwnd_limited_usec;
-  // The cumulative time (in usec) that the transport protocol was limited by
-  // the send buffer size.
-  std::optional<uint64_t> sndbuf_limited_usec;
-};
-
-struct BufferTimestamp {
-  gpr_timespec time;
-  ConnectionMetrics metrics;  // Metrics collected with this timestamp
-};
-
-struct Timestamps {
-  BufferTimestamp sendmsg_time;
-  BufferTimestamp scheduled_time;
-  BufferTimestamp sent_time;
-  BufferTimestamp acked_time;
-
-  uint32_t byte_offset;  // byte offset relative to the start of the RPC
-
-#ifdef GRPC_LINUX_ERRQUEUE
-  tcp_info info;  // tcp_info collected on sendmsg
-#endif            // GRPC_LINUX_ERRQUEUE
-};
-
 // TracedBuffer is a class to keep track of timestamps for a specific buffer in
 // the TCP layer. We are only tracking timestamps for Linux kernels and hence
 // this class would only be used by Linux platforms. For all other platforms,
@@ -108,10 +44,13 @@ struct Timestamps {
 class TracedBufferList {
  public:
   TracedBufferList() = default;
-  ~TracedBufferList() = default;
+  ~TracedBufferList() { Shutdown(std::nullopt); }
+
   // Add a new entry in the TracedBuffer list pointed to by head. Also saves
   // sendmsg_time with the current timestamp.
-  void AddNewEntry(int32_t seq_no, int fd, void* arg);
+  void AddNewEntry(int32_t seq_no, EventEnginePosixInterface* posix_interface,
+                   const FileDescriptor& fd,
+                   EventEngine::Endpoint::WriteEventSink sink);
   // Processes a received timestamp based on sock_extended_err and
   // scm_timestamping structures. It will invoke the timestamps callback if the
   // timestamp type is SCM_TSTAMP_ACK.
@@ -121,41 +60,37 @@ class TracedBufferList {
   // The Size() operation is slow and is used only in tests.
   int Size() {
     grpc_core::MutexLock lock(&mu_);
-    int size = 0;
-    TracedBuffer* curr = head_;
-    while (curr) {
-      ++size;
-      curr = curr->next_;
-    }
-    return size;
+    return list_.size();
   }
   // Cleans the list by calling the callback for each traced buffer in the list
   // with timestamps that it has.
-  void Shutdown(void* /*remaining*/, absl::Status /*shutdown_err*/);
+  void Shutdown(std::optional<EventEngine::Endpoint::WriteEventSink> remaining);
+
+  // Sets the maximum time we wait for a traced buffer to be Acked. Counted from
+  // the previous received event for the traced buffer.
+  static void TestOnlySetMaxPendingAckTime(grpc_core::Duration duration);
 
  private:
+  class Metrics {};
+
   class TracedBuffer {
    public:
-    TracedBuffer(uint32_t seq_no, void* arg) : seq_no_(seq_no), arg_(arg) {}
+    TracedBuffer(uint32_t seq_no, EventEngine::Endpoint::WriteEventSink sink)
+        : seq_no_(seq_no), sink_(std::move(sink)) {}
     // Returns true if the TracedBuffer is considered stale at the given
     // timestamp.
-    bool Finished(gpr_timespec ts);
+    bool TimedOut(grpc_core::Timestamp now);
 
    private:
     friend class TracedBufferList;
-    gpr_timespec last_timestamp_;
-    TracedBuffer* next_ = nullptr;
+    grpc_core::Timestamp last_timestamp_;
     uint32_t seq_no_;  // The sequence number for the last byte in the buffer
-    void* arg_;        // The arg to pass to timestamps_callback
-    Timestamps ts_;    // The timestamps corresponding to this buffer
+    PosixWriteEventSink sink_;
   };
   grpc_core::Mutex mu_;
   // TracedBuffers are ordered by sequence number and would need to be processed
-  // in a FIFO order starting with the smallest sequence number. To enable this,
-  // they are stored in a singly linked with head and tail pointers which allows
-  // easy appends and forward iteration operations.
-  TracedBuffer* head_ = nullptr;
-  TracedBuffer* tail_ = nullptr;
+  // in a FIFO order starting with the smallest sequence number.
+  std::list<TracedBuffer> list_ ABSL_GUARDED_BY(mu_);
 };
 
 #else   // GRPC_LINUX_ERRQUEUE
@@ -167,15 +102,12 @@ class TracedBufferList {
                         struct cmsghdr* /*opt_stats*/,
                         struct scm_timestamping* /*tss*/) {}
   int Size() { return 0; }
-  void Shutdown(void* /*remaining*/, absl::Status /*shutdown_err*/) {}
+  void Shutdown(
+      std::optional<EventEngine::Endpoint::WriteEventSink> /*remaining*/) {}
+  static void TestOnlySetMaxPendingAckTime(grpc_core::Duration /*duration*/);
 };
 #endif  // GRPC_LINUX_ERRQUEUE
 
-// Sets the callback function to call when timestamps for a write are collected.
-// This is expected to be called atmost once.
-void TcpSetWriteTimestampsCallback(
-    absl::AnyInvocable<void(void*, Timestamps*, absl::Status)>);
-
 }  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TRACED_BUFFER_LIST_H