perf(ext/node): skip node:http perf timing without observers (#34409)

## Summary

Avoids unconditional `performance.now()` work on the node:http server
request hot path when there are no Node `PerformanceObserver`s
interested in `entryType: "http"`.

The previous implementation timestamped every incoming server request,
then discovered at finish time whether any observer wanted an
`HttpRequest` entry. This patch mirrors Node's shape more closely: Node
gates `startPerf()` in `lib/_http_server.js` behind
`hasObserver('http')`, and gates `_finish()` behind both stored perf
state and `hasObserver('http')`.

## Node compatibility

Checked upstream Node main:

- `lib/_http_server.js`: `ServerResponse` calls `startPerf(...)` only
when `hasObserver('http')` is true.
- `lib/_http_server.js`: `_finish()` calls `stopPerf(...)` only when
response perf state exists and `hasObserver('http')` is still true.
- `lib/internal/perf/observe.js`: `hasObserver(type)` reads the internal
observer count for the entry type.

Behavior spot-checks against Node v25.9.0:

- Observer attached before a request sees an `HttpRequest` entry with
request and response detail.
- Observer attached after request start but before response finish does
not receive a retroactive server entry.
- Observer disconnected before response finish does not receive the
entry.

## Validation

Correctness:

```sh
DENO_TEST_UTIL_DENO_EXE=/home/bot/work/stuff/shared/a3f6b36b-f67/workers/313cb9ff-3b9/perf-http-observer-validation-20260527T014052Z/deno-candidate cargo test -p unit_node_tests --test unit_node -- perf_hooks_test
```

Result: passed, 1 file-test (`tests/unit_node/perf_hooks_test.ts`).

Benchmark command, execution target `bigboi`:

```sh
RUN_DIR=/home/bot/work/stuff/shared/a3f6b36b-f67/workers/c68aca61-79c/perf-http-observer-rerun-20260527T055454Z \
BASELINE=/home/bot/work/stuff/shared/a3f6b36b-f67/workers/313cb9ff-3b9/perf-http-observer-validation-20260527T014052Z/deno-baseline \
CANDIDATE=/home/bot/work/stuff/shared/a3f6b36b-f67/workers/313cb9ff-3b9/perf-http-observer-validation-20260527T014052Z/deno-candidate \
SERVER=$RUN_DIR/server_get.mjs \
SAMPLES=8 DURATION=8s WARMUP=3s CONNECTIONS=128 SERVER_CPU=2 CLIENT_CPUS=3-5 \
$RUN_DIR/run_get_bench.sh
```

Fresh 8-sample rerun:

- Baseline: 10,987.68 req/s mean, median 10,813.26, CV 7.72%.
- Candidate: 11,482.77 req/s mean, median 11,406.40, CV 8.38%.
- Paired delta: +495.10 req/s, +5.04% mean; 6/8 pairs positive.
- Confidence: directional improvement, but noisy; the 95% interval on
percent delta crosses zero.

Earlier same-target 20-sample validation using the same release-lite
binaries:

- Baseline: 14,909.34 req/s mean, CV 10.54%.
- Candidate: 15,419.35 req/s mean, CV 6.21%.
- Paired delta: +510.01 req/s, +4.07% mean; 13/20 pairs positive.
- 95% CI: delta req/s [-65.93, 1085.96], percent delta [0.22%, 7.92%].
- Confidence: moderate; noisy host, but the larger paired run supports a
small real improvement.

Co-authored-by: Nathan Whitaker <nathan@deno.com>

Author: nathanwhitbot

ext/node/polyfills/_http_server.js

@@ -88,9 +88,10 @@ const {
   enterAsyncResource,
   exitAsyncResource,
 } = core.loadExtScript("ext:deno_node/internal/async_hooks.ts");
-const { enqueueNodePerformanceEntry } = core.loadExtScript(
-  "ext:deno_node/perf_hooks.js",
-);
+const { enqueueNodePerformanceEntry, hasNodeObserverForType } = core
+  .loadExtScript(
+    "ext:deno_node/perf_hooks.js",
+  );
 const {
   otelState,
   builtinTracer,
@@ -824,7 +825,9 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
   }
 
   state.incoming.push(req);
-  req[kPerfStartTime] = performance.now();
+  if (hasNodeObserverForType("http")) {
+    req[kPerfStartTime] = performance.now();
+  }
 
   if (!socket._paused) {
     const ws = socket._writableState;
@@ -1009,7 +1012,7 @@ function resOnFinish(req, res, socket, state, server) {
 
   // Emit HttpRequest perf entry
   const perfStartTime = req[kPerfStartTime];
-  if (perfStartTime !== undefined) {
+  if (perfStartTime !== undefined && hasNodeObserverForType("http")) {
     enqueueNodePerformanceEntry({
       name: "HttpRequest",
       entryType: "http",

ext/node/polyfills/perf_hooks.js

@@ -160,6 +160,15 @@ function enqueueNodePerformanceEntry(entry) {
   }
 }
 
+function hasNodeObserverForType(entryType) {
+  for (let i = 0; i < nodeObservers.length; i++) {
+    if (nodeObservers[i][_nodeTypes].includes(entryType)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 const eventLoopUtilization = () => {
   // TODO(@marvinhagemeister): Return actual non-stubbed values
   return { idle: 0, active: 0, utilization: 0 };
@@ -609,6 +618,7 @@ return {
   createHistogram,
   enqueueNodePerformanceEntry,
   eventLoopUtilization,
+  hasNodeObserverForType,
   monitorEventLoopDelay,
   performance,
   PerformanceEntry,

tests/unit_node/perf_hooks_test.ts

@@ -5,6 +5,7 @@ import {
   PerformanceEntry,
   PerformanceObserver,
 } from "node:perf_hooks";
+import http from "node:http";
 import { assert, assertEquals, assertThrows } from "@std/assert";
 
 // Basic performance API tests removed - covered by Node compat tests:
@@ -135,3 +136,89 @@ Deno.test("[perf_hooks]: PerformanceObserver takeRecords", () => {
   observer.disconnect();
   performance.clearMarks();
 });
+
+Deno.test("[perf_hooks]: PerformanceObserver observes node:http server entries", async () => {
+  const server = http.createServer((_req, res) => {
+    res.end("ok");
+  });
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let observer: PerformanceObserver | undefined;
+  const entryPromise = new Promise<PerformanceEntry>((resolve, reject) => {
+    timer = setTimeout(
+      () => reject(new Error("Timed out waiting for HTTP performance entry")),
+      1000,
+    );
+    observer = new PerformanceObserver((list) => {
+      const entry = list.getEntries().find((entry) =>
+        entry.entryType === "http"
+      );
+      if (entry) {
+        clearTimeout(timer);
+        resolve(entry);
+      }
+    });
+    observer.observe({ entryTypes: ["http"] });
+  });
+
+  try {
+    const address = server.address();
+    if (!address || typeof address !== "object") {
+      throw new Error("Server did not listen on a TCP address");
+    }
+    const response = await fetch(`http://127.0.0.1:${address.port}/observed`);
+    assertEquals(await response.text(), "ok");
+
+    const entry = await entryPromise;
+    assertEquals(entry.name, "HttpRequest");
+    assertEquals(entry.entryType, "http");
+    assert(entry.duration >= 0);
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+    observer?.disconnect();
+    await new Promise<void>((resolve, reject) =>
+      server.close((err) => err ? reject(err) : resolve())
+    );
+  }
+});
+
+Deno.test("[perf_hooks]: node:http server entries are not retroactive", async () => {
+  let finishResponse: (() => void) | undefined;
+  let resolveRequestStarted = () => {};
+  const requestStarted = new Promise<void>((resolve) => {
+    resolveRequestStarted = resolve;
+  });
+  const server = http.createServer((_req, res) => {
+    finishResponse = () => res.end("ok");
+    resolveRequestStarted();
+  });
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+
+  const entries: PerformanceEntry[] = [];
+  const observer = new PerformanceObserver((list) => {
+    entries.push(...list.getEntries());
+  });
+
+  try {
+    const address = server.address();
+    if (!address || typeof address !== "object") {
+      throw new Error("Server did not listen on a TCP address");
+    }
+    const responsePromise = fetch(`http://127.0.0.1:${address.port}/late`);
+    await requestStarted;
+
+    observer.observe({ entryTypes: ["http"] });
+    finishResponse?.();
+    const response = await responsePromise;
+    assertEquals(await response.text(), "ok");
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    assertEquals(entries.length, 0);
+  } finally {
+    observer.disconnect();
+    await new Promise<void>((resolve, reject) =>
+      server.close((err) => err ? reject(err) : resolve())
+    );
+  }
+});