From 890e9049f117e9077132760d3e5dee77412bb34b Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 4 Dec 2019 08:50:07 -0800
Subject: [PATCH 1/5] quic: add blockCount statistic

Count the number of times sending stream data is blocked by
flow control
---
 doc/api/quic.md                      | 13 +++++++++++++
 lib/internal/quic/core.js            |  6 ++++++
 src/node_quic.cc                     |  1 +
 src/node_quic_default_application.cc |  1 +
 src/node_quic_http3_application.cc   |  1 +
 src/node_quic_session.cc             |  5 +++++
 src/node_quic_session.h              |  9 ++++++++-
 7 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index d8a65e7910..c8b5f69a50 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -441,6 +441,19 @@ added: REPLACEME
 A `BigInt` representing the total number of bidirectional streams
 created for this `QuicSession`.
 
+#### quicsession.blockCount
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BigInt` representing the total number of times the `QuicSession` has
+been blocked from sending stream data due to flow control.
+
+Such blocks indicate that transmitted stream data is not being consumed
+quickly enough by the connected peer.
+
 #### quicsession.bytesInFlight
 <!-- YAML
 added: REPLACEME
diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index 6f566af4ca..f0f053e0c1 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -153,6 +153,7 @@ const {
     IDX_QUIC_SESSION_STATS_LOSS_RETRANSMIT_COUNT,
     IDX_QUIC_SESSION_STATS_ACK_DELAY_RETRANSMIT_COUNT,
     IDX_QUIC_SESSION_STATS_MAX_BYTES_IN_FLIGHT,
+    IDX_QUIC_SESSION_STATS_BLOCK_COUNT,
     ERR_INVALID_REMOTE_TRANSPORT_PARAMS,
     ERR_INVALID_TLS_SESSION_TICKET,
     NGTCP2_PATH_VALIDATION_RESULT_FAILURE,
@@ -1702,6 +1703,11 @@ class QuicSession extends EventEmitter {
       this[kHandle].state[IDX_QUIC_SESSION_STATE_BYTES_IN_FLIGHT] : 0;
   }
 
+  get blockCount() {
+    return this[kHandle] ?
+      this[kHandle].state[IDX_QUIC_SESSION_STATS_BLOCK_COUNT] : 0;
+  }
+
   get authenticated() {
     // Specifically check for null. Undefined means the check has not
     // been performed yet, another other value other than null means
diff --git a/src/node_quic.cc b/src/node_quic.cc
index 8f894f89ba..d05bf943e0 100755
--- a/src/node_quic.cc
+++ b/src/node_quic.cc
@@ -213,6 +213,7 @@ void Initialize(Local<Object> target,
   NODE_DEFINE_CONSTANT(constants,
                        IDX_QUIC_SESSION_STATS_PATH_VALIDATION_FAILURE_COUNT);
   NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SESSION_STATS_MAX_BYTES_IN_FLIGHT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SESSION_STATS_BLOCK_COUNT);
 
   NODE_DEFINE_CONSTANT(constants, IDX_HTTP3_QPACK_MAX_TABLE_CAPACITY);
   NODE_DEFINE_CONSTANT(constants, IDX_HTTP3_QPACK_BLOCKED_STREAMS);
diff --git a/src/node_quic_default_application.cc b/src/node_quic_default_application.cc
index ba7af66294..0269cb95b4 100644
--- a/src/node_quic_default_application.cc
+++ b/src/node_quic_default_application.cc
@@ -177,6 +177,7 @@ bool DefaultApplication::SendStreamData(QuicStream* stream) {
           return false;
         case NGTCP2_ERR_STREAM_DATA_BLOCKED:
           Debug(stream, "Stream data blocked");
+          Session()->StreamDataBlocked(stream->GetID());
           return true;
         case NGTCP2_ERR_STREAM_SHUT_WR:
           Debug(stream, "Stream writable side is closed");
diff --git a/src/node_quic_http3_application.cc b/src/node_quic_http3_application.cc
index 4e8d027406..01aa699389 100644
--- a/src/node_quic_http3_application.cc
+++ b/src/node_quic_http3_application.cc
@@ -460,6 +460,7 @@ bool Http3Application::SendPendingData() {
     if (nwrite < 0) {
       switch (nwrite) {
         case NGTCP2_ERR_STREAM_DATA_BLOCKED:
+          Session()->StreamDataBlocked(stream_id);
           if (Session()->GetMaxDataLeft() == 0)
             return true;
           // Fall through
diff --git a/src/node_quic_session.cc b/src/node_quic_session.cc
index b2ee29d67d..bf9fcbf29f 100644
--- a/src/node_quic_session.cc
+++ b/src/node_quic_session.cc
@@ -1378,6 +1378,11 @@ void QuicSession::RemoveListener(QuicSessionListener* listener) {
   listener->previous_listener_ = nullptr;
 }
 
+void QuicSession::StreamDataBlocked(int64_t stream_id) {
+  // Increments the block count
+  IncrementStat(1, &session_stats_, &session_stats::block_count);
+}
+
 std::string QuicSession::diagnostic_name() const {
   return std::string("QuicSession ") +
       (IsServer() ? "Server" : "Client") +
diff --git a/src/node_quic_session.h b/src/node_quic_session.h
index 97ce4b6600..02ac330111 100644
--- a/src/node_quic_session.h
+++ b/src/node_quic_session.h
@@ -197,7 +197,8 @@ enum QuicSessionStatsIdx : int {
   IDX_QUIC_SESSION_STATS_ACK_DELAY_RETRANSMIT_COUNT,
   IDX_QUIC_SESSION_STATS_PATH_VALIDATION_SUCCESS_COUNT,
   IDX_QUIC_SESSION_STATS_PATH_VALIDATION_FAILURE_COUNT,
-  IDX_QUIC_SESSION_STATS_MAX_BYTES_IN_FLIGHT
+  IDX_QUIC_SESSION_STATS_MAX_BYTES_IN_FLIGHT,
+  IDX_QUIC_SESSION_STATS_BLOCK_COUNT,
 };
 
 class QuicSessionListener {
@@ -933,6 +934,9 @@ class QuicSession : public AsyncWrap,
 
   void SetConnectionIDStrategory(ConnectionIDStrategy* strategy);
 
+  // Report that the stream data is flow control blocked
+  void StreamDataBlocked(int64_t stream_id);
+
   // Tracks whether or not we are currently within an ngtcp2 callback
   // function. Certain ngtcp2 APIs are not supposed to be called when
   // within a callback. We use this as a gate to check.
@@ -1370,6 +1374,9 @@ class QuicSession : public AsyncWrap,
     uint64_t path_validation_failure_count;
     // The max number of in flight bytes recorded
     uint64_t max_bytes_in_flight;
+    // The total number of times the session has been
+    // flow control blocked.
+    uint64_t block_count;
   };
   session_stats session_stats_{};
 

From a30835fe324cf36ea647835049a9b97878eb6fe3 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 4 Dec 2019 09:50:47 -0800
Subject: [PATCH 2/5] quic: add max offset statistic, expose stream stats to js

---
 doc/api/quic.md           | 39 +++++++++++++++++++++++++++++++++++++++
 lib/internal/quic/core.js | 34 +++++++++++++++++++++++++++++++++-
 src/node_quic.cc          |  8 ++++++++
 src/node_quic_stream.cc   | 18 +++++++++++++++++-
 src/node_quic_stream.h    | 15 ++++++++++++++-
 5 files changed, 111 insertions(+), 3 deletions(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index c8b5f69a50..9ec079e523 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -1628,6 +1628,26 @@ added: REPLACEME
 
 Set to `true` if the `QuicStream` is bidirectional.
 
+#### quicstream.bytesReceived
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BigInt` representing the total number of bytes received for this
+`QuicStream`.
+
+#### quicstream.bytesSent
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BigInt` representing the total number of bytes sent by this
+`QuicStream`.
+
 #### quicstream.clientInitiated
 <!-- YAML
 added: REPLACEME
@@ -1667,6 +1687,15 @@ added: REPLACEME
 -->
 TBD
 
+#### quicstream.duration
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BigInt` representing the length of time the `QuicStream` has been active.
+
 #### quicstream.id
 <!-- YAML
 added: REPLACEME
@@ -1676,6 +1705,16 @@ added: REPLACEME
 
 The numeric identifier of the `QuicStream`.
 
+#### quicstream.maxExtendedOffset
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BigInt` representing the maximum extended data offset that has been
+reported to the connected peer.
+
 #### quicstream.pending
 <!-- YAML
 added: REPLACEME
diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index f0f053e0c1..a3dd40a206 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -154,6 +154,14 @@ const {
     IDX_QUIC_SESSION_STATS_ACK_DELAY_RETRANSMIT_COUNT,
     IDX_QUIC_SESSION_STATS_MAX_BYTES_IN_FLIGHT,
     IDX_QUIC_SESSION_STATS_BLOCK_COUNT,
+    IDX_QUIC_STREAM_STATS_CREATED_AT,
+    IDX_QUIC_STREAM_STATS_SENT_AT,
+    IDX_QUIC_STREAM_STATS_RECEIVED_AT,
+    IDX_QUIC_STREAM_STATS_ACKED_AT,
+    IDX_QUIC_STREAM_STATS_CLOSING_AT,
+    IDX_QUIC_STREAM_STATS_BYTES_RECEIVED,
+    IDX_QUIC_STREAM_STATS_BYTES_SENT,
+    IDX_QUIC_STREAM_STATS_MAX_OFFSET,
     ERR_INVALID_REMOTE_TRANSPORT_PARAMS,
     ERR_INVALID_TLS_SESSION_TICKET,
     NGTCP2_PATH_VALIDATION_RESULT_FAILURE,
@@ -2215,6 +2223,7 @@ class QuicStream extends Duplex {
   #dataRateHistogram = undefined;
   #dataSizeHistogram = undefined;
   #dataAckHistogram = undefined;
+  #stats = undefined;
 
   constructor(options, session) {
     super({
@@ -2578,8 +2587,10 @@ class QuicStream extends Duplex {
     // Do not use handle after this point as the underlying C++
     // object has been destroyed. Any attempt to use the object
     // will segfault and crash the process.
-    if (handle !== undefined)
+    if (handle !== undefined) {
+      this.#stats = new BigInt64Array(handle.stats);
       handle.destroy();
+    }
     callback(error);
   }
 
@@ -2689,6 +2700,27 @@ class QuicStream extends Duplex {
     return this[kHandle].submitTrailingHeaders(
       mapToHeaders(headers, assertValidPseudoHeaderTrailer));
   }
+
+  get duration() {
+    const now = process.hrtime.bigint();
+    const stats = this.#stats || this[kHandle].stats;
+    return now - stats[IDX_QUIC_STREAM_STATS_CREATED_AT];
+  }
+
+  get bytesReceived() {
+    const stats = this.#stats || this[kHandle].stats;
+    return stats[IDX_QUIC_STREAM_STATS_BYTES_RECEIVED];
+  }
+
+  get bytesSent() {
+    const stats = this.#stats || this[kHandle].stats;
+    return stats[IDX_QUIC_STREAM_STATS_BYTES_SENT];
+  }
+
+  get maxExtendedOffset() {
+    const stats = this.#stats || this[kHandle].stats;
+    return stats[IDX_QUIC_STREAM_STATS_MAX_OFFSET];
+  }
 }
 
 function createSocket(options = {}) {
diff --git a/src/node_quic.cc b/src/node_quic.cc
index d05bf943e0..6aa57d8160 100755
--- a/src/node_quic.cc
+++ b/src/node_quic.cc
@@ -214,6 +214,14 @@ void Initialize(Local<Object> target,
                        IDX_QUIC_SESSION_STATS_PATH_VALIDATION_FAILURE_COUNT);
   NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SESSION_STATS_MAX_BYTES_IN_FLIGHT);
   NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SESSION_STATS_BLOCK_COUNT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_CREATED_AT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_SENT_AT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_RECEIVED_AT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_ACKED_AT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_CLOSING_AT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_BYTES_RECEIVED);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_BYTES_SENT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_MAX_OFFSET);
 
   NODE_DEFINE_CONSTANT(constants, IDX_HTTP3_QPACK_MAX_TABLE_CAPACITY);
   NODE_DEFINE_CONSTANT(constants, IDX_HTTP3_QPACK_BLOCKED_STREAMS);
diff --git a/src/node_quic_stream.cc b/src/node_quic_stream.cc
index 4208350175..dab2ff4714 100644
--- a/src/node_quic_stream.cc
+++ b/src/node_quic_stream.cc
@@ -85,6 +85,13 @@ QuicStream::QuicStream(
           FIXED_ONE_BYTE_STRING(env()->isolate(), "data_rx_ack"),
           data_rx_ack_->object(),
           PropertyAttribute::ReadOnly).IsNothing()) return;
+
+  ngtcp2_transport_params params;
+  ngtcp2_conn_get_local_transport_params(Session()->Connection(), &params);
+  IncrementStat(
+      params.initial_max_data,
+      &stream_stats_,
+      &stream_stats::max_offset);
 }
 
 std::string QuicStream::diagnostic_name() const {
@@ -246,6 +253,10 @@ int QuicStream::ReadStart() {
   CHECK(IsReadable());
   SetReadStart();
   SetReadResume();
+  IncrementStat(
+      inbound_consumed_data_while_paused_,
+      &stream_stats_,
+      &stream_stats::max_offset);
   session_->ExtendStreamOffset(this, inbound_consumed_data_while_paused_);
   return 0;
 }
@@ -327,8 +338,13 @@ void QuicStream::ReceiveData(
       // so that pausing does not throw off our flow control.
       if (read_paused)
         inbound_consumed_data_while_paused_ += avail;
-      else
+      else {
+        IncrementStat(
+            avail,
+            &stream_stats_,
+            &stream_stats::max_offset);
         session_->ExtendStreamOffset(this, avail);
+      }
     }
   }
 
diff --git a/src/node_quic_stream.h b/src/node_quic_stream.h
index 80df7862c3..23205c2948 100644
--- a/src/node_quic_stream.h
+++ b/src/node_quic_stream.h
@@ -37,6 +37,17 @@ enum QuicStreamHeadersKind : int {
   QUICSTREAM_HEADERS_KIND_TRAILING
 };
 
+enum QuicStreamStatsIdx : int {
+  IDX_QUIC_STREAM_STATS_CREATED_AT,
+  IDX_QUIC_STREAM_STATS_SENT_AT,
+  IDX_QUIC_STREAM_STATS_RECEIVED_AT,
+  IDX_QUIC_STREAM_STATS_ACKED_AT,
+  IDX_QUIC_STREAM_STATS_CLOSING_AT,
+  IDX_QUIC_STREAM_STATS_BYTES_RECEIVED,
+  IDX_QUIC_STREAM_STATS_BYTES_SENT,
+  IDX_QUIC_STREAM_STATS_MAX_OFFSET
+};
+
 // QuicHeader is a base class for implementing QUIC application
 // specific headers. Each type of QUIC application may have
 // different internal representations for a header name+value
@@ -447,8 +458,10 @@ class QuicStream : public AsyncWrap, public StreamBase {
     uint64_t bytes_received;
     // The total number of bytes sent
     uint64_t bytes_sent;
+    // The maximum extended stream offset
+    uint64_t max_offset;
   };
-  stream_stats stream_stats_{0, 0, 0, 0, 0, 0, 0};
+  stream_stats stream_stats_{};
 
   // data_rx_rate_ measures the elapsed time between data packets
   // for this stream. When used in combination with the data_rx_size,

From d1fd2866d98112b64a0cc55d547881b8599c8ce2 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 4 Dec 2019 10:41:21 -0800
Subject: [PATCH 3/5] quic: use constants for QuicSocket stats

---
 lib/internal/quic/core.js | 28 +++++++++++++++++++---------
 src/node_quic.cc          | 11 +++++++++++
 src/node_quic_socket.h    | 13 +++++++++++++
 3 files changed, 43 insertions(+), 9 deletions(-)

diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index a3dd40a206..dcf485c7a1 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -162,6 +162,16 @@ const {
     IDX_QUIC_STREAM_STATS_BYTES_RECEIVED,
     IDX_QUIC_STREAM_STATS_BYTES_SENT,
     IDX_QUIC_STREAM_STATS_MAX_OFFSET,
+    IDX_QUIC_SOCKET_STATS_CREATED_AT,
+    IDX_QUIC_SOCKET_STATS_BOUND_AT,
+    IDX_QUIC_SOCKET_STATS_LISTEN_AT,
+    IDX_QUIC_SOCKET_STATS_BYTES_RECEIVED,
+    IDX_QUIC_SOCKET_STATS_BYTES_SENT,
+    IDX_QUIC_SOCKET_STATS_PACKETS_RECEIVED,
+    IDX_QUIC_SOCKET_STATS_PACKETS_IGNORED,
+    IDX_QUIC_SOCKET_STATS_PACKETS_SENT,
+    IDX_QUIC_SOCKET_STATS_SERVER_SESSIONS,
+    IDX_QUIC_SOCKET_STATS_CLIENT_SESSIONS,
     ERR_INVALID_REMOTE_TRANSPORT_PARAMS,
     ERR_INVALID_TLS_SESSION_TICKET,
     NGTCP2_PATH_VALIDATION_RESULT_FAILURE,
@@ -1337,39 +1347,39 @@ class QuicSocket extends EventEmitter {
   get duration() {
     const now = process.hrtime.bigint();
     const stats = this.#stats || this[kHandle].stats;
-    return now - stats[0];
+    return now - stats[IDX_QUIC_SOCKET_STATS_CREATED_AT];
   }
 
   get boundDuration() {
     const now = process.hrtime.bigint();
     const stats = this.#stats || this[kHandle].stats;
-    return now - stats[1];
+    return now - stats[IDX_QUIC_SOCKET_STATS_BOUND_AT];
   }
 
   get listenDuration() {
     const now = process.hrtime.bigint();
     const stats = this.#stats || this[kHandle].stats;
-    return now - stats[2];
+    return now - stats[IDX_QUIC_SOCKET_STATS_LISTEN_AT];
   }
 
   get bytesReceived() {
     const stats = this.#stats || this[kHandle].stats;
-    return stats[3];
+    return stats[IDX_QUIC_SOCKET_STATS_BYTES_RECEIVED];
   }
 
   get bytesSent() {
     const stats = this.#stats || this[kHandle].stats;
-    return stats[4];
+    return stats[IDX_QUIC_SOCKET_STATS_BYTES_SENT];
   }
 
   get packetsReceived() {
     const stats = this.#stats || this[kHandle].stats;
-    return stats[5];
+    return stats[IDX_QUIC_SOCKET_STATS_PACKETS_RECEIVED];
   }
 
   get packetsSent() {
     const stats = this.#stats || this[kHandle].stats;
-    return stats[6];
+    return stats[IDX_QUIC_SOCKET_STATS_PACKETS_SENT];
   }
 
   get serverBusy() {
@@ -1378,12 +1388,12 @@ class QuicSocket extends EventEmitter {
 
   get serverSessions() {
     const stats = this.#stats || this[kHandle].stats;
-    return stats[7];
+    return stats[IDX_QUIC_SOCKET_STATS_SERVER_SESSIONS];
   }
 
   get clientSessions() {
     const stats = this.#stats || this[kHandle].stats;
-    return stats[8];
+    return stats[IDX_QUIC_SOCKET_STATS_CLIENT_SESSIONS];
   }
 
   setDiagnosticPacketLoss(options) {
diff --git a/src/node_quic.cc b/src/node_quic.cc
index 6aa57d8160..3c7bfab3fa 100755
--- a/src/node_quic.cc
+++ b/src/node_quic.cc
@@ -223,6 +223,17 @@ void Initialize(Local<Object> target,
   NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_BYTES_SENT);
   NODE_DEFINE_CONSTANT(constants, IDX_QUIC_STREAM_STATS_MAX_OFFSET);
 
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_CREATED_AT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_BOUND_AT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_LISTEN_AT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_BYTES_RECEIVED);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_BYTES_SENT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_PACKETS_RECEIVED);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_PACKETS_IGNORED);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_PACKETS_SENT);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_SERVER_SESSIONS);
+  NODE_DEFINE_CONSTANT(constants, IDX_QUIC_SOCKET_STATS_CLIENT_SESSIONS);
+
   NODE_DEFINE_CONSTANT(constants, IDX_HTTP3_QPACK_MAX_TABLE_CAPACITY);
   NODE_DEFINE_CONSTANT(constants, IDX_HTTP3_QPACK_BLOCKED_STREAMS);
   NODE_DEFINE_CONSTANT(constants, IDX_HTTP3_MAX_HEADER_LIST_SIZE);
diff --git a/src/node_quic_socket.h b/src/node_quic_socket.h
index ad40174c3c..724f4a56e4 100644
--- a/src/node_quic_socket.h
+++ b/src/node_quic_socket.h
@@ -44,6 +44,19 @@ enum QuicSocketOptions : uint32_t {
   QUICSOCKET_OPTIONS_VALIDATE_ADDRESS_LRU = 0x2,
 };
 
+enum QuicSocketStatsIdx : int {
+    IDX_QUIC_SOCKET_STATS_CREATED_AT,
+    IDX_QUIC_SOCKET_STATS_BOUND_AT,
+    IDX_QUIC_SOCKET_STATS_LISTEN_AT,
+    IDX_QUIC_SOCKET_STATS_BYTES_RECEIVED,
+    IDX_QUIC_SOCKET_STATS_BYTES_SENT,
+    IDX_QUIC_SOCKET_STATS_PACKETS_RECEIVED,
+    IDX_QUIC_SOCKET_STATS_PACKETS_IGNORED,
+    IDX_QUIC_SOCKET_STATS_PACKETS_SENT,
+    IDX_QUIC_SOCKET_STATS_SERVER_SESSIONS,
+    IDX_QUIC_SOCKET_STATS_CLIENT_SESSIONS
+};
+
 class QuicSocket;
 
 // This is the generic interface for objects that control QuicSocket

From 2eee0e9b9d01d2040ce9cb896cede9a24ef7aef8 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 4 Dec 2019 10:51:49 -0800
Subject: [PATCH 4/5] quic: fix lint issues

---
 doc/api/quic.md                               |  5 ++-
 lib/internal/quic/core.js                     | 35 ++++++++++---------
 lib/internal/quic/util.js                     |  2 +-
 test/parallel/test-quic-client-server.js      |  2 +-
 .../parallel/test-quic-http3-client-server.js |  9 -----
 5 files changed, 22 insertions(+), 31 deletions(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 9ec079e523..8012d6fcf6 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -107,7 +107,7 @@ const { createSocket } = require('quic');
 // Create a QuicSocket associated with localhost and port 1234
 const socket = createSocket({ port: 1234 });
 
-const client = client.connect({
+const client = socket.connect({
   address: 'example.com',
   port: 4567,
   alpn: 'foo'
@@ -131,7 +131,7 @@ New instance of `QuicServerSession` are created internally by the
 `QuicSocket` if it has been configured to listen for new connections
 using the `listen()` method.
 
-```
+```js
 const key = getTLSKeySomehow();
 const cert = getTLSCertSomehow();
 
@@ -405,7 +405,6 @@ added: REPLACEME
 An object containing the local address information for the `QuicSocket` to which
 the `QuicSession` is currently associated.
 
-
 #### quicsession.alpnProtocol
 <!-- YAML
 added: REPLACEME
diff --git a/lib/internal/quic/core.js b/lib/internal/quic/core.js
index dcf485c7a1..1d371d7fd6 100644
--- a/lib/internal/quic/core.js
+++ b/lib/internal/quic/core.js
@@ -155,10 +155,6 @@ const {
     IDX_QUIC_SESSION_STATS_MAX_BYTES_IN_FLIGHT,
     IDX_QUIC_SESSION_STATS_BLOCK_COUNT,
     IDX_QUIC_STREAM_STATS_CREATED_AT,
-    IDX_QUIC_STREAM_STATS_SENT_AT,
-    IDX_QUIC_STREAM_STATS_RECEIVED_AT,
-    IDX_QUIC_STREAM_STATS_ACKED_AT,
-    IDX_QUIC_STREAM_STATS_CLOSING_AT,
     IDX_QUIC_STREAM_STATS_BYTES_RECEIVED,
     IDX_QUIC_STREAM_STATS_BYTES_SENT,
     IDX_QUIC_STREAM_STATS_MAX_OFFSET,
@@ -262,7 +258,7 @@ function setTransportParams(config) {
     maxPacketSize,
     maxAckDelay,
     maxCryptoBuffer,
-    h3 : {
+    h3: {
       qpackMaxTableCapacity,
       qpackBlockedStreams,
       maxHeaderListSize,
@@ -1382,6 +1378,11 @@ class QuicSocket extends EventEmitter {
     return stats[IDX_QUIC_SOCKET_STATS_PACKETS_SENT];
   }
 
+  get packetsIgnored() {
+    const stats = this.#stats || this[kHandle].stats;
+    return stats[IDX_QUIC_SOCKET_STATS_PACKETS_IGNORED];
+  }
+
   get serverBusy() {
     return this.#serverBusy;
   }
@@ -2641,14 +2642,14 @@ class QuicStream extends Duplex {
     let validator;
     if (this.session instanceof QuicServerSession) {
       validator =
-          this.clientInitiated ?
-              assertValidPseudoHeaderResponse :
-              assertValidPseudoHeader;
+        this.clientInitiated ?
+          assertValidPseudoHeaderResponse :
+          assertValidPseudoHeader;
     } else {  // QuicClientSession
       validator =
-          this.clientInitiated ?
-              assertValidPseudoHeader :
-              assertValidPseudoHeaderResponse;
+        this.clientInitiated ?
+          assertValidPseudoHeader :
+          assertValidPseudoHeaderResponse;
     }
 
     return this[kHandle].submitInformationalHeaders(
@@ -2676,14 +2677,14 @@ class QuicStream extends Duplex {
     let validator;
     if (this.session instanceof QuicServerSession) {
       validator =
-          this.clientInitiated ?
-              assertValidPseudoHeaderResponse :
-              assertValidPseudoHeader;
+        this.clientInitiated ?
+          assertValidPseudoHeaderResponse :
+          assertValidPseudoHeader;
     } else {  // QuicClientSession
       validator =
-          this.clientInitiated ?
-              assertValidPseudoHeader :
-              assertValidPseudoHeaderResponse;
+        this.clientInitiated ?
+          assertValidPseudoHeader :
+          assertValidPseudoHeaderResponse;
     }
 
     return this[kHandle].submitHeaders(
diff --git a/lib/internal/quic/util.js b/lib/internal/quic/util.js
index 947e77f93b..3c5e28b1cd 100644
--- a/lib/internal/quic/util.js
+++ b/lib/internal/quic/util.js
@@ -136,7 +136,7 @@ function validateTransportParams(params) {
     preferredAddress,
     rejectUnauthorized,
     requestCert,
-    h3 : {
+    h3: {
       qpackMaxTableCapacity,
       qpackBlockedStreams,
       maxHeaderListSize,
diff --git a/test/parallel/test-quic-client-server.js b/test/parallel/test-quic-client-server.js
index 64293e1c24..e85bb268dc 100644
--- a/test/parallel/test-quic-client-server.js
+++ b/test/parallel/test-quic-client-server.js
@@ -144,7 +144,7 @@ server.on('session', common.mustCall((session) => {
     // cause anything else to fail.
 
     // TODO(@jasnell): Move updateKey to a separate test
-    //setTimeout(() => assert(session.updateKey()), 500);
+    // setTimeout(() => assert(session.updateKey()), 500);
 
     debug('QuicServerSession TLS Handshake Complete');
     debug('  Server name: %s', servername);
diff --git a/test/parallel/test-quic-http3-client-server.js b/test/parallel/test-quic-http3-client-server.js
index 4cbee176eb..841bf15d72 100644
--- a/test/parallel/test-quic-http3-client-server.js
+++ b/test/parallel/test-quic-http3-client-server.js
@@ -7,14 +7,6 @@ const common = require('../common');
 if (!common.hasQuic)
   common.skip('missing quic');
 
-const { internalBinding } = require('internal/test/binding');
-const {
-  constants: {
-    NGTCP2_NO_ERROR,
-    QUIC_ERROR_APPLICATION,
-  }
-} = internalBinding('quic');
-
 const Countdown = require('../common/countdown');
 const assert = require('assert');
 const fs = require('fs');
@@ -35,7 +27,6 @@ const kClientPort = process.env.NODE_DEBUG_KEYLOG ? 5679 : 0;
 let client;
 const server = createSocket({ port: kServerPort, validateAddress: true });
 
-const unidata = ['I wonder if it worked.', 'test'];
 const kServerName = 'agent2';  // Intentionally the wrong servername
 const kALPN = 'h3-24';
 

From c21bae6acfa688d3b3f87aaf49b4c180b63bc90e Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 4 Dec 2019 11:02:40 -0800
Subject: [PATCH 5/5] quic: additional doc updates

---
 doc/api/quic.md | 113 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 113 insertions(+)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 8012d6fcf6..5392309594 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -1027,6 +1027,44 @@ added: REPLACEME
 Will be `true` if the `QuicSocket` has been successfully bound to the local UDP
 port.
 
+#### quicsocket.boundDuration
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the length of time this `QuicSocket` has been bound
+to a local port.
+
+#### quicsocket.bytesReceived
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the number of bytes received by this `QuicSocket`.
+
+#### quicsocket.bytesSent
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the number of bytes sent by this `QuicSocket`.
+
+#### quicsocket.clientSessions
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the number of client `QuicSession` instances that
+have been associated with this `QuicSocket`.
+
 #### quicsocket.close([callback])
 <!-- YAML
 added: REPLACEME
@@ -1199,6 +1237,15 @@ never have reason to call this.
 If `multicastInterface` is not specified, the operating system will attempt to
 drop membership on all valid interfaces.
 
+#### quicsocket.duration
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the length of time this `QuicSocket` has been active,
+
 #### quicsocket.fd
 <!-- YAML
 added: REPLACEME
@@ -1320,6 +1367,45 @@ Listen for new peer-initiated sessions.
 If a `callback` is given, it is registered as a handler for the
 `'session'` event.
 
+#### quicsocket.listenDuration
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the length of time this `QuicSocket` has been listening
+for connections.
+
+#### quicsocket.packetsIgnored
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the number of packets received by this `QuicSocket` that
+have been ignored.
+
+#### quicsocket.packetsReceived
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the number of packets successfully received by this
+`QuicSocket`.
+
+#### quicsocket.packetsSent
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the number of packets sent by this `QuicSocket`.
+
 #### quicsocket.pending
 <!-- YAML
 added: REPLACEME
@@ -1344,6 +1430,33 @@ added: REPLACEME
 Sets or clears the `SO_BROADCAST` socket option. When set to `true`, UDP
 packets may be sent to a local interface's broadcast address.
 
+#### quicsocket.serverSessions
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {BigInt}
+
+A `BitInt` representing the number of server `QuicSession` instances that
+have been associated with this `QuicSocket`.
+
+#### quicsocket.setDiagnosticPacketLoss(options)
+<!-- YAML-
+added: REPLACEME
+-->
+
+* `options` {Object}
+  * `rx` {double} A value in the range `0.0` to `1.0` that specifies the
+    probability of received packet loss.
+  * `tx` {double} A value in the range `0.0` to `1.0` that specifies the
+    probability of transmitted packet loss.
+
+The `quicsocket.setDiagnosticPacketLoss()` method is a diagnostic only tool
+that can be used to *simulate* packet loss conditions for this `QuicSocket`
+by artificially dropping received or transmitted packets.
+
+This method is *not* to be used in production applications.
+
 #### quicsocket.setMulticastLoopback([on])
 <!-- YAML
 added: REPLACEME