perf(ext/node): gate node:http async resource entry (#34608)

## Summary
- Skips the per-request async-resource enter path in node:http request
handling when no async hooks are active and no async context mapping is
present.
- Still restores the request-entry async context snapshot on exit, so
`AsyncLocalStorage.enterWith()` inside a gated request cannot leak into
later request handlers.
- Preserves the existing async hooks and AsyncLocalStorage behavior by
falling back to the original request-resource path whenever those
observability mechanisms are active.
- Adds focused coverage for async context propagation, `enterWith()`
isolation in the gated path, and async resource observability through
node:http requests.

---------

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

Author: nathanwhitbot

ext/node/polyfills/_http_server.js

@@ -85,8 +85,8 @@ const {
 } = core.loadExtScript("ext:deno_node/internal/validators.mjs");
 const { nextTick } = core.loadExtScript("ext:deno_node/_next_tick.ts");
 const {
-  enterAsyncResource,
-  exitAsyncResource,
+  enterAsyncResourceIfActive,
+  exitAsyncResourceIfActive,
 } = core.loadExtScript("ext:deno_node/internal/async_hooks.ts");
 const { enqueueNodePerformanceEntry, hasNodeObserverForType } = core
   .loadExtScript(
@@ -923,7 +923,7 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
   // across timers, await transitions, etc. Without this, every request would
   // share the top-level resource and concurrent requests would race on any
   // state stashed there.
-  const prevAsyncResource = enterAsyncResource(req);
+  const prevAsyncResource = enterAsyncResourceIfActive(req);
   try {
     let handled = false;
 
@@ -979,7 +979,7 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
       server.emit("request", req, res);
     }
   } finally {
-    exitAsyncResource(prevAsyncResource);
+    exitAsyncResourceIfActive(prevAsyncResource);
   }
 
   return 0;

ext/node/polyfills/internal/async_hooks.ts

@@ -21,10 +21,13 @@ const {
   ArrayPrototypeSlice,
   ArrayPrototypeSplice,
   FunctionPrototypeApply,
+  ObjectKeys,
   Symbol,
 } = primordials;
 const {
   AsyncVariable,
+  getAsyncContext,
+  kNoAsyncContextRestore,
   setAsyncContext,
 } = core;
 
@@ -111,6 +114,31 @@ function exitAsyncResource(previousContext: any): void {
   setAsyncContext(previousContext);
 }
 
+// deno-lint-ignore no-explicit-any
+function enterAsyncResourceIfActive(resource: any): any {
+  if (active_hooks.array.length > 0) {
+    return executionResourceVariable.enter(resource);
+  }
+  return executionResourceVariable.enterIfActive(resource);
+}
+
+// deno-lint-ignore no-explicit-any
+function exitAsyncResourceIfActive(previousContext: any): void {
+  if (previousContext !== kNoAsyncContextRestore) {
+    setAsyncContext(previousContext);
+    return;
+  }
+
+  const currentContext = getAsyncContext();
+  if (
+    currentContext !== null &&
+    currentContext !== undefined &&
+    ObjectKeys(currentContext).length > 0
+  ) {
+    setAsyncContext(undefined);
+  }
+}
+
 // Emit functions that work with the internal hook system
 function emitBefore(asyncId: number): void {
   ArrayPrototypePush(executionAsyncIdStack, asyncId);
@@ -495,6 +523,8 @@ return {
   executionAsyncResource,
   enterAsyncResource,
   exitAsyncResource,
+  enterAsyncResourceIfActive,
+  exitAsyncResourceIfActive,
   emitBefore,
   emitAfter,
   emitDestroy,

libs/core/01_core.js

@@ -958,6 +958,7 @@
 
   const getAsyncContext = getContinuationPreservedEmbedderData;
   const setAsyncContext = setContinuationPreservedEmbedderData;
+  const kNoAsyncContextRestore = Symbol("Deno.core.noAsyncContextRestore");
 
   function scopeAsyncContext(ctx) {
     const old = getAsyncContext();
@@ -977,6 +978,24 @@
 
     enter(value) {
       const previousContextMapping = getAsyncContext();
+      this.#enterWithPreviousContext(value, previousContextMapping);
+      return previousContextMapping;
+    }
+
+    enterIfActive(value) {
+      const previousContextMapping = getAsyncContext();
+      if (
+        previousContextMapping === null ||
+        previousContextMapping === undefined ||
+        ObjectKeys(previousContextMapping).length === 0
+      ) {
+        return kNoAsyncContextRestore;
+      }
+      this.#enterWithPreviousContext(value, previousContextMapping);
+      return previousContextMapping;
+    }
+
+    #enterWithPreviousContext(value, previousContextMapping) {
       const entry = { id: this.#id };
       const asyncContextMapping = {
         __proto__: null,
@@ -985,7 +1004,6 @@
       };
       this.#data.set(entry, value);
       setAsyncContext(asyncContextMapping);
-      return previousContextMapping;
     }
 
     get() {
@@ -1238,6 +1256,7 @@
     setAsyncContext,
     scopeAsyncContext,
     AsyncVariable,
+    kNoAsyncContextRestore,
   });
 
   const internals = {};

tests/unit_node/http_test.ts

@@ -3,7 +3,11 @@
 // deno-lint-ignore-file no-console
 
 import { EventEmitter, once } from "node:events";
-import { createHook } from "node:async_hooks";
+import {
+  AsyncLocalStorage,
+  createHook,
+  executionAsyncResource,
+} from "node:async_hooks";
 import http, {
   IncomingMessage,
   type RequestOptions,
@@ -16,6 +20,7 @@ import net, { type AddressInfo, Socket } from "node:net";
 import fs from "node:fs";
 import type { Duplex } from "node:stream";
 import { text } from "node:stream/consumers";
+import { channel } from "node:diagnostics_channel";
 
 import { assert, assertEquals, assertStringIncludes, fail } from "@std/assert";
 import { assertSpyCalls, spy } from "@std/testing/mock";
@@ -2653,6 +2658,125 @@ Deno.test("[node/http] keep-alive timer is suspended during active request", asy
   }
 });
 
+Deno.test("[node/http] AsyncLocalStorage propagates into request handler", async () => {
+  const storage = new AsyncLocalStorage<string>();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
+  const responseDone = Promise.withResolvers<void>();
+  const requestStart = channel("http.server.request.start");
+  const subscriber = () => storage.enterWith("request-context");
+  const server = http.createServer((_req, res) => {
+    try {
+      assertEquals(storage.getStore(), "request-context");
+      resolve();
+    } catch (err) {
+      reject(err);
+    } finally {
+      res.end("ok");
+    }
+  });
+
+  requestStart.subscribe(subscriber);
+  await new Promise<void>((resolve) => server.listen(0, resolve));
+  try {
+    const port = (server.address() as AddressInfo).port;
+    const req = http.get(`http://127.0.0.1:${port}`, (res) => {
+      res.resume();
+      res.on("end", responseDone.resolve);
+      res.on("error", responseDone.reject);
+    });
+    req.on("error", reject);
+    await Promise.all([promise, responseDone.promise]);
+  } finally {
+    requestStart.unsubscribe(subscriber);
+    storage.disable();
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+});
+
+Deno.test("[node/http] AsyncLocalStorage enterWith in request handler is isolated", async () => {
+  const storage = new AsyncLocalStorage<string>();
+  const firstDone = Promise.withResolvers<void>();
+  const secondDone = Promise.withResolvers<void>();
+  let requests = 0;
+  const server = http.createServer((_req, res) => {
+    try {
+      requests++;
+      if (requests === 1) {
+        assertEquals(storage.getStore(), undefined);
+        storage.enterWith("first-request");
+        assertEquals(storage.getStore(), "first-request");
+      } else {
+        assertEquals(storage.getStore(), undefined);
+      }
+      res.end("ok");
+      if (requests === 1) {
+        firstDone.resolve();
+      } else {
+        secondDone.resolve();
+      }
+    } catch (err) {
+      firstDone.reject(err);
+      secondDone.reject(err);
+      res.destroy(err as Error);
+    }
+  });
+
+  await new Promise<void>((resolve) => server.listen(0, resolve));
+  try {
+    const port = (server.address() as AddressInfo).port;
+    const request = () =>
+      new Promise<void>((resolve, reject) => {
+        const req = http.get(`http://127.0.0.1:${port}`, (res) => {
+          res.resume();
+          res.on("end", resolve);
+          res.on("error", reject);
+        });
+        req.on("error", reject);
+      });
+
+    await request();
+    await firstDone.promise;
+    await request();
+    await secondDone.promise;
+  } finally {
+    storage.disable();
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+});
+
+Deno.test("[node/http] async_hooks observes request execution resource", async () => {
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
+  const responseDone = Promise.withResolvers<void>();
+  const hook = createHook({
+    before() {},
+  });
+  const server = http.createServer((req, res) => {
+    try {
+      assertEquals(executionAsyncResource(), req);
+      res.end("ok");
+      resolve();
+    } catch (err) {
+      reject(err);
+    }
+  });
+
+  hook.enable();
+  try {
+    await new Promise<void>((resolve) => server.listen(0, resolve));
+    const port = (server.address() as AddressInfo).port;
+    const req = http.get(`http://127.0.0.1:${port}`, (res) => {
+      res.resume();
+      res.on("end", responseDone.resolve);
+      res.on("error", responseDone.reject);
+    });
+    req.on("error", reject);
+    await Promise.all([promise, responseDone.promise]);
+  } finally {
+    hook.disable();
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  }
+});
+
 Deno.test("[node/http] abandoned suspended keep-alive timer emits async_hooks destroy", async () => {
   const server = http.createServer(
     { keepAliveTimeout: 10 },