fix(ext/node): emit perf_hooks PerformanceEntry for http2 sessions and streams (#33618)

Enables `test-http2-perf_hooks` in node_compat suite.

Co-authored-by: Divy Srivastava <me@littledivy.com>

Author: divybot

ext/node/ops/http2/session.rs

@@ -1736,6 +1736,7 @@ unsafe extern "C" fn on_frame_send_callback(
 ) -> i32 {
   // SAFETY: data is the user_data pointer set during session creation
   let session = unsafe { Session::from_user_data(data) };
+  session.frames_sent = session.frames_sent.saturating_add(1);
   // SAFETY: frame is valid per nghttp2 callback contract
   let f = unsafe { &*frame };
   // SAFETY: union access of `hd` is always valid (every nghttp2 frame has a
@@ -1973,6 +1974,12 @@ pub struct Session {
   pub max_invalid_frames: u32,
   /// Running count of invalid frames received on this session.
   pub invalid_frame_count: u32,
+  /// Total HTTP/2 frames received on this session, used for the
+  /// `framesReceived` field of perf_hooks `Http2Session` entries.
+  pub frames_received: u32,
+  /// Total HTTP/2 frames sent on this session, used for the
+  /// `framesSent` field of perf_hooks `Http2Session` entries.
+  pub frames_sent: u32,
   /// Custom error code set by an nghttp2 callback when it returns a fatal
   /// error so that `receive_data` can surface it to JS via
   /// `session_internal_error_cb`. Mirrors Node's
@@ -2012,10 +2019,6 @@ pub struct Session {
   /// (see `HandlePingFrame` in node_http2.cc): there is no legitimate
   /// reason for a peer to send an unsolicited PING ACK.
   pub pending_pings: u32,
-  /// Total number of HTTP/2 frames received on this session. Mirrors
-  /// Node's `Http2Session::statistics_.frame_count`, surfaced via the
-  /// PerformanceObserver `Http2Session` entry's `framesReceived` field.
-  pub frames_received: u32,
 }
 
 impl Session {
@@ -2553,13 +2556,14 @@ impl Http2Session {
       outgoing_chunks: VecDeque::new(),
       max_invalid_frames: 1000,
       invalid_frame_count: 0,
+      frames_received: 0,
+      frames_sent: 0,
       custom_recv_error_code: None,
       sent_goaway_code: None,
       local_custom_settings: Vec::new(),
       remote_custom_settings: Vec::new(),
       pending_settings_acks: VecDeque::new(),
       pending_pings: 0,
-      frames_received: 0,
     }));
 
     // SAFETY: inner is valid (just allocated); callbacks and options are valid
@@ -2922,6 +2926,22 @@ impl Http2Session {
     session.active_stream_count() as u32
   }
 
+  #[fast]
+  #[smi]
+  fn frames_received(&self) -> u32 {
+    // SAFETY: self.inner was allocated by Box::into_raw and is valid
+    let session = unsafe { &*self.inner };
+    session.frames_received
+  }
+
+  #[fast]
+  #[smi]
+  fn frames_sent(&self) -> u32 {
+    // SAFETY: self.inner was allocated by Box::into_raw and is valid
+    let session = unsafe { &*self.inner };
+    session.frames_sent
+  }
+
   #[fast]
   fn has_pending_data(&self) -> bool {
     // SAFETY: self.session is a valid nghttp2 session pointer
@@ -3111,13 +3131,6 @@ impl Http2Session {
     session.outgoing_buffers.len() as u32
   }
 
-  #[fast]
-  fn frames_received(&self) -> u32 {
-    // SAFETY: self.inner was allocated by Box::into_raw and is valid
-    let session = unsafe { &*self.inner };
-    session.frames_received
-  }
-
   #[fast]
   fn origin(&self, #[string] origins: &str, count: i32) -> i32 {
     // Origins are concatenated and separated by NUL bytes (Node-compatible

ext/node/polyfills/http2.ts

@@ -51,6 +51,9 @@ import {
   op_http2_callbacks,
 } from "ext:core/ops";
 import { enqueueNodePerformanceEntry } from "node:perf_hooks";
+const { performance: webPerformance } = core.loadExtScript(
+  "ext:deno_web/15_performance.js",
+);
 import net from "node:net";
 import assert from "node:assert";
 import http from "node:http";
@@ -259,6 +262,89 @@ function getURLOrigin(urlStr) {
   }
 }
 
+function perfNow() {
+  return webPerformance.now();
+}
+
+function emitSessionPerfEntry(session) {
+  if (session[kPerfEmitted]) return;
+  session[kPerfEmitted] = true;
+  const stats = session[kPerfStats];
+  if (!stats) return;
+
+  const startTime = stats.startTime;
+  const duration = perfNow() - startTime;
+  const handle = session[kHandle];
+  const framesReceived = handle && typeof handle.framesReceived === "function"
+    ? handle.framesReceived()
+    : 0;
+  const framesSent = handle && typeof handle.framesSent === "function"
+    ? handle.framesSent()
+    : 0;
+  const streamCount = stats.streamCount;
+  const streamAverageDuration = streamCount > 0
+    ? stats.streamTotalDuration / streamCount
+    : 0;
+  const type = session[kType] === NGHTTP2_SESSION_SERVER ? "server" : "client";
+  const detail = {
+    bytesRead: stats.bytesRead,
+    bytesWritten: stats.bytesWritten,
+    framesReceived,
+    framesSent,
+    maxConcurrentStreams: stats.maxConcurrentStreams,
+    pingRTT: stats.pingRTT,
+    streamAverageDuration,
+    streamCount,
+    type,
+  };
+
+  enqueueNodePerformanceEntry({
+    name: "Http2Session",
+    entryType: "http2",
+    startTime,
+    duration,
+    detail,
+  });
+}
+
+function emitStreamPerfEntry(stream) {
+  if (stream[kPerfEmitted]) return;
+  stream[kPerfEmitted] = true;
+  const stats = stream[kPerfStats];
+  if (!stats) return;
+
+  const startTime = stats.startTime;
+  const duration = perfNow() - startTime;
+  const detail = {
+    bytesRead: stats.bytesRead,
+    bytesWritten: stats.bytesWritten,
+    timeToFirstByte: stats.firstByte > 0 ? stats.firstByte - startTime : 0,
+    timeToFirstByteSent: stats.firstByteSent > 0
+      ? stats.firstByteSent - startTime
+      : 0,
+    timeToFirstHeader: stats.firstHeader > 0
+      ? stats.firstHeader - startTime
+      : 0,
+  };
+
+  enqueueNodePerformanceEntry({
+    name: "Http2Stream",
+    entryType: "http2",
+    startTime,
+    duration,
+    detail,
+  });
+
+  // Roll the stream's lifetime into the parent session's averageDuration.
+  const session = stream[kSession];
+  if (session) {
+    const sstats = session[kPerfStats];
+    if (sstats) {
+      sstats.streamTotalDuration += duration;
+    }
+  }
+}
+
 // Schedule a deferred sendPending() call on the session's native handle.
 // This is deferred via queueMicrotask to avoid re-entrancy: nghttp2's
 // send_pending_data can invoke callbacks that call back into JS ops.
@@ -399,6 +485,13 @@ const kType = Symbol("type");
 const kWriteGeneric = Symbol("write-generic");
 const kSessions = Symbol("sessions");
 
+// Symbols for tracking perf_hooks `http2` performance entry stats. The
+// `pingRTT`, `streamCount`, etc. fields surfaced via `entry.detail` are
+// populated by Http2Session/Http2Stream methods when those events occur,
+// then read back when the entry is enqueued at session/stream destroy.
+const kPerfStats = Symbol("perf-stats");
+const kPerfEmitted = Symbol("perf-emitted");
+
 const kMaxOutstandingSettings = Symbol("maxOutstandingSettings");
 const kMaxOutstandingPings = Symbol("maxOutstandingPings");
 
@@ -1748,6 +1841,16 @@ class Http2Stream extends Duplex {
     this[kRequest] = null;
     this[kProxySocket] = null;
 
+    this[kPerfEmitted] = false;
+    this[kPerfStats] = {
+      startTime: perfNow(),
+      firstByte: 0,
+      firstByteSent: 0,
+      firstHeader: 0,
+      bytesRead: 0,
+      bytesWritten: 0,
+    };
+
     this.on("pause", streamOnPause);
 
     this.on("newListener", streamListenerAdded);
@@ -1774,6 +1877,11 @@ class Http2Stream extends Duplex {
     session[kState].pendingStreams.delete(this);
     session[kState].streams.set(id, this);
 
+    const sstats = session[kPerfStats];
+    if (sstats) {
+      sstats.streamCount++;
+    }
+
     this[kID] = id;
     //this[async_id_symbol] = handle.getAsyncId();
     handle[kOwner] = this;
@@ -2315,6 +2423,8 @@ class Http2Stream extends Duplex {
       err = new ERR_HTTP2_STREAM_ERROR(nameForErrorCode[code] || code);
     }
 
+    emitStreamPerfEntry(this);
+
     this[kSession] = undefined;
     this[kHandle] = undefined;
 
@@ -3424,25 +3534,7 @@ function cleanupSession(session) {
 function finishSessionClose(session, error) {
   debugSessionObj(session, "finishSessionClose");
 
-  // Emit a `Http2Session` PerformanceObserver entry with frame statistics
-  // from the native session before cleanupSession() drops the handle. Mirrors
-  // Node's `Http2Session::Close` reporting via PerformanceEntry. We surface
-  // only the fields the perf-hooks docs document and the in-tree tests
-  // observe.
-  const perfHandle = session[kHandle];
-  if (perfHandle && typeof perfHandle.framesReceived === "function") {
-    const framesReceived = perfHandle.framesReceived();
-    enqueueNodePerformanceEntry({
-      name: "Http2Session",
-      entryType: "http2",
-      startTime: 0,
-      duration: 0,
-      detail: {
-        type: session[kType] === NGHTTP2_SESSION_CLIENT ? "client" : "server",
-        framesReceived,
-      },
-    });
-  }
+  emitSessionPerfEntry(session);
 
   const socket = session[kSocket];
   cleanupSession(session);
@@ -3691,6 +3783,16 @@ class Http2Session extends EventEmitter {
       2 ** 31 - 1,
     ) || 10;
     this[kStrictSingleValueFields] = options.strictSingleValueFields !== false;
+    this[kPerfEmitted] = false;
+    this[kPerfStats] = {
+      startTime: perfNow(),
+      streamCount: 0,
+      streamTotalDuration: 0,
+      pingRTT: 0,
+      bytesRead: 0,
+      bytesWritten: 0,
+      maxConcurrentStreams: 0xffffffff,
+    };
 
     // Do not use nagle's algorithm
     if (typeof socket.setNoDelay === "function") {

tests/node_compat/config.jsonc

@@ -1788,6 +1788,7 @@
     "parallel/test-http2-origin.js": {},
     "parallel/test-http2-pack-end-stream-flag.js": {},
     "parallel/test-http2-padding-aligned.js": {},
+    "parallel/test-http2-perf_hooks.js": {},
     "parallel/test-http2-perform-server-handshake.js": {},
     "parallel/test-http2-ping.js": {},
     "parallel/test-http2-ping-settings-heapdump.js": {},