From a41e830c200d1628bb491f3c9810dcc396b4549d Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 22 Jan 2020 12:11:58 -0800
Subject: [PATCH] quic: additional QuicStream tracking stats

PR-URL: https://github.com/nodejs/quic/pull/294
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 doc/api/quic.md                 | 19 +++++++++++++++++++
 lib/internal/quic/core.js       | 12 ++++++++++++
 src/quic/node_quic_stream-inl.h |  8 --------
 src/quic/node_quic_stream.cc    |  9 ++++-----
 src/quic/node_quic_stream.h     | 12 ++++--------
 5 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index fafb11db23..0ad4786ce9 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -1973,6 +1973,16 @@ added: REPLACEME
 
 The numeric identifier of the `QuicStream`.
 
+#### quicstream.maxAcknowledgedOffset
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BigInt` representing the highest acknowledged data offset received
+for this `QuicStream`.
+
 #### quicstream.maxExtendedOffset
 <!-- YAML
 added: REPLACEME
@@ -1983,6 +1993,15 @@ added: REPLACEME
 A `BigInt` representing the maximum extended data offset that has been
 reported to the connected peer.
 
+#### quicstream.maxReceivedOffset
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BigInt` representing the maximum received offset for this `QuicStream`.
+
 #### quicstream.pending
 <!-- YAML
 added: REPLACEME
diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index 6adf496e65..59c2f1d6eb 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -148,6 +148,8 @@ const {
     IDX_QUIC_STREAM_STATS_BYTES_SENT,
     IDX_QUIC_STREAM_STATS_MAX_OFFSET,
     IDX_QUIC_STREAM_STATS_FINAL_SIZE,
+    IDX_QUIC_STREAM_STATS_MAX_OFFSET_ACK,
+    IDX_QUIC_STREAM_STATS_MAX_OFFSET_RECV,
     IDX_QUIC_SOCKET_STATS_CREATED_AT,
     IDX_QUIC_SOCKET_STATS_BOUND_AT,
     IDX_QUIC_SOCKET_STATS_LISTEN_AT,
@@ -2857,6 +2859,16 @@ class QuicStream extends Duplex {
     const stats = this.#stats || this[kHandle].stats;
     return stats[IDX_QUIC_STREAM_STATS_FINAL_SIZE];
   }
+
+  get maxAcknowledgedOffset() {
+    const stats = this.#stats || this[kHandle].stats;
+    return stats[IDX_QUIC_STREAM_STATS_MAX_OFFSET_ACK];
+  }
+
+  get maxReceivedOffset() {
+    const stats = this.#stats || this[kHandle].stats;
+    return stats[IDX_QUIC_STREAM_STATS_MAX_OFFSET_RECV];
+  }
 }
 
 function createSocket(options) {
diff --git a/src/quic/node_quic_stream-inl.h b/src/quic/node_quic_stream-inl.h
index 6e23058b3f..47aa7d5d5b 100644
--- a/src/quic/node_quic_stream-inl.h
+++ b/src/quic/node_quic_stream-inl.h
@@ -80,14 +80,6 @@ bool QuicStream::is_write_finished() const {
          streambuf_.length() == 0;
 }
 
-void QuicStream::IncrementAvailableOutboundLength(size_t amount) {
-  available_outbound_length_ += amount;
-}
-
-void QuicStream::DecrementAvailableOutboundLength(size_t amount) {
-  available_outbound_length_ -= amount;
-}
-
 bool QuicStream::SubmitInformation(v8::Local<v8::Array> headers) {
   return session_->SubmitInformation(stream_id_, headers);
 }
diff --git a/src/quic/node_quic_stream.cc b/src/quic/node_quic_stream.cc
index e803a34871..ff8d8efa81 100644
--- a/src/quic/node_quic_stream.cc
+++ b/src/quic/node_quic_stream.cc
@@ -85,8 +85,8 @@ void QuicStream::Acknowledge(uint64_t offset, size_t datalen) {
   // ngtcp2 guarantees that offset must always be greater
   // than the previously received offset, but let's just
   // make sure that holds.
-  CHECK_GE(offset, max_offset_ack_);
-  max_offset_ack_ = offset;
+  CHECK_GE(offset, GetStat(&QuicStreamStats::max_offset_ack));
+  SetStat(&QuicStreamStats::max_offset_ack, offset);
 
   Debug(this, "Acknowledging %d bytes", datalen);
 
@@ -216,7 +216,6 @@ int QuicStream::DoWrite(
 
   session()->ResumeStream(stream_id_);
 
-  // IncrementAvailableOutboundLength(len);
   return 0;
 }
 
@@ -310,8 +309,8 @@ void QuicStream::ReceiveData(
 
   // ngtcp2 guarantees that offset is always greater than the previously
   // received offset. Let's just make sure.
-  CHECK_GE(offset, max_offset_);
-  max_offset_ = offset;
+  CHECK_GE(offset, GetStat(&QuicStreamStats::max_offset_received));
+  SetStat(&QuicStreamStats::max_offset_received, offset);
 
   if (datalen > 0) {
     // IncrementStats will update the data_rx_rate_ and data_rx_size_
diff --git a/src/quic/node_quic_stream.h b/src/quic/node_quic_stream.h
index d433be4beb..11218bc3fc 100644
--- a/src/quic/node_quic_stream.h
+++ b/src/quic/node_quic_stream.h
@@ -48,6 +48,8 @@ enum QuicStreamHeadersKind : int {
   V(BYTES_RECEIVED, bytes_received, "Bytes Received")                          \
   V(BYTES_SENT, bytes_sent, "Bytes Sent")                                      \
   V(MAX_OFFSET, max_offset, "Max Offset")                                      \
+  V(MAX_OFFSET_ACK, max_offset_ack, "Max Acknowledged Offset")                 \
+  V(MAX_OFFSET_RECV, max_offset_received, "Max Received Offset")               \
   V(FINAL_SIZE, final_size, "Final Size")
 
 #define V(name, _, __) IDX_QUIC_STREAM_STATS_##name,
@@ -280,9 +282,6 @@ class QuicStream : public AsyncWrap,
       size_t nbufs,
       uv_stream_t* send_handle) override;
 
-  inline void IncrementAvailableOutboundLength(size_t amount);
-  inline void DecrementAvailableOutboundLength(size_t amount);
-
   // Returns false if the header cannot be added. This will
   // typically only happen if a maximimum number of headers
   // has been reached.
@@ -367,14 +366,11 @@ class QuicStream : public AsyncWrap,
   void IncrementStats(size_t datalen);
 
   BaseObjectWeakPtr<QuicSession> session_;
+  QuicBuffer streambuf_;
+
   int64_t stream_id_ = 0;
   int64_t push_id_ = 0;
-  uint64_t max_offset_ = 0;
-  uint64_t max_offset_ack_ = 0;
   uint32_t flags_ = QUICSTREAM_FLAG_INITIAL;
-
-  QuicBuffer streambuf_;
-  size_t available_outbound_length_ = 0;
   size_t inbound_consumed_data_while_paused_ = 0;
 
   std::vector<std::unique_ptr<QuicHeader>> headers_;