dd-trace 6.2.0 → 6.4.0

package/README.md

@@ -28,7 +28,7 @@ Most of the documentation for `dd-trace` is available on these webpages:
 | [`v2`](https://github.com/DataDog/dd-trace-js/tree/v2.x) | ![npm v2](https://img.shields.io/npm/v/dd-trace/latest-node12?color=white&label=%20&style=flat-square) | `>= v12` | NO | NO | **EOL** | 2022-01-28     | 2023-08-15  |
 | [`v3`](https://github.com/DataDog/dd-trace-js/tree/v3.x) | ![npm v3](https://img.shields.io/npm/v/dd-trace/latest-node14?color=white&label=%20&style=flat-square) | `>= v14` | NO | YES | **EOL** | 2022-08-15     | 2024-05-15  |
 | [`v4`](https://github.com/DataDog/dd-trace-js/tree/v4.x) | ![npm v4](https://img.shields.io/npm/v/dd-trace/latest-node16?color=white&label=%20&style=flat-square) | `>= v16` | YES | YES | **EOL**     | 2023-05-12     | 2025-01-11     |
-| [`v5`](https://github.com/DataDog/dd-trace-js/tree/v5.x) | ![npm v5](https://img.shields.io/npm/v/dd-trace/latest-node18?color=white&label=%20&style=flat-square)  | `>= v18` | YES | YES | **Maintenance** | 2024-01-11     | Unknown     |
+| [`v5`](https://github.com/DataDog/dd-trace-js/tree/v5.x) | ![npm v5](https://img.shields.io/npm/v/dd-trace/latest-node18?color=white&label=%20&style=flat-square)  | `>= v18` | YES | YES | **Maintenance** | 2024-01-11     | 2027-07-02     |
 | [`v6`](https://github.com/DataDog/dd-trace-js/tree/v6.x) | ![npm v6](https://img.shields.io/npm/v/dd-trace/latest?color=white&label=%20&style=flat-square)         | `>= v22` | YES | YES | **Current**     | 2026-07-02     | Unknown     |
 
 * EOL = End-of-life

package/index.electron.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./packages/dd-trace/index.electron')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.2.0",
+  "version": "6.4.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -12,7 +12,9 @@
     "bench:e2e:test-optimization": "node benchmark/e2e-test-optimization/benchmark-run.js",
     "dependencies:dedupe": "yarn-deduplicate yarn.lock",
     "generate:config:types": "node scripts/generate-config-types.js",
+    "generate:electron-package": "node scripts/generate-electron-package.js",
     "verify:config:types": "node scripts/generate-config-types.js --check",
+    "verify:electron-package": "node scripts/generate-electron-package.js --check",
     "generate:supported-integrations": "node scripts/generate-supported-integrations.js",
     "verify:supported-integrations": "node scripts/generate-supported-integrations.js --check",
     "type:check": "tsc --noEmit -p tsconfig.dev.json",
@@ -23,7 +25,7 @@
     "lint:inspect": "npx @eslint/config-inspector@latest",
     "lint:codeowners": "codeowners-audit",
     "lint:codeowners:ci": "codeowners-audit --glob='**/*.spec.js' --glob='benchmark/sirun/**' --glob='.agents/**' --glob='.claude/**' --glob='integration-tests/**'",
-    "lint:editorconfig": "editorconfig-checker",
+    "lint:editorconfig": "docker build -q -t ec .github/editorconfig-checker && docker run --rm --volume=$PWD:/check ec",
     "release:proposal": "node scripts/release/proposal",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
     "test": "echo '\nError: The root \"npm test\" command is intentionally disabled.\n\nInstead, run specific test suites:\n  - npm run test:trace:core\n  - npm run test:appsec\n  - etc.\n\nOr run individual test files:\n  npx mocha path/to/test.spec.js\n\nSee CONTRIBUTING.md (Testing section) for more details.\n' && exit 1",
@@ -142,6 +144,7 @@
     "webpack.js",
     "ext/**/*",
     "index.d.ts",
+    "index.electron.js",
     "index.js",
     "init.js",
     "initialize.mjs",
@@ -151,6 +154,7 @@
     "LICENSE.BSD3",
     "loader-hook.mjs",
     "packages/*/index.js",
+    "packages/*/index.electron.js",
     "packages/*/lib/**/*",
     "packages/*/src/**/*",
     "packages/datadog-instrumentations/orchestrion.yml",
@@ -198,15 +202,14 @@
     "bun": "1.3.14",
     "c8": "^11.0.0",
     "codeowners-audit": "^2.9.0",
-    "editorconfig-checker": "^6.1.1",
     "eslint": "^9.39.2",
     "eslint-plugin-cypress": "^6.4.2",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^63.0.10",
+    "eslint-plugin-jsdoc": "^63.0.12",
     "eslint-plugin-mocha": "^11.3.0",
     "eslint-plugin-n": "^18.2.1",
     "eslint-plugin-promise": "^7.3.0",
-    "eslint-plugin-sonarjs": "^4.1.0",
+    "eslint-plugin-sonarjs": "^4.2.0",
     "eslint-plugin-unicorn": "^64.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",

package/packages/datadog-instrumentations/src/ai.js

@@ -136,33 +136,38 @@ function wrapTracer (tracer) {
 
       args[args.length - 1] = shimmer.wrapFunction(cb, function (originalCb) {
         return function (span) {
-          // the below is necessary in the case that the span is vercel ai's noopSpan.
-          // while we don't want to patch the noopSpan more than once, we do want to treat each as a
-          // fresh instance. However, this is really not necessary for non-noop spans, but not sure
-          // how to differentiate.
-          const freshSpan = Object.create(span) // TODO: does this cause memory leaks?
-
-          shimmer.wrap(freshSpan, 'end', function (spanEnd) {
-            return function (...args) {
-              vercelAiTracingChannel.asyncEnd.publish(ctx)
-              return spanEnd.apply(this, args)
-            }
-          })
-
-          shimmer.wrap(freshSpan, 'setAttributes', function (setAttributes) {
-            return function (attributes) {
+          // A plain delegating wrapper is used instead of Object.create(span) because
+          // Object.create (and Proxy) cannot cross private-field brand checks — any span
+          // method that reads a private field (e.g. BridgeSpanBase#statusCode) would throw
+          // "Cannot read private member" on a prototype clone. Every method here calls
+          // through to the real span instance so private fields always resolve correctly.
+          const freshSpan = {
+            spanContext () { return span.spanContext() },
+            setAttribute (key, value) { span.setAttribute(key, value); return freshSpan },
+            setAttributes (attributes) {
               vercelAiSpanSetAttributesChannel.publish({ ctx, attributes })
-              return setAttributes.apply(this, arguments)
-            }
-          })
-
-          shimmer.wrap(freshSpan, 'recordException', function (recordException) {
-            return function (exception) {
+              span.setAttributes(attributes)
+              return freshSpan
+            },
+            addEvent (name, attributesOrStartTime, startTime) {
+              span.addEvent(name, attributesOrStartTime, startTime)
+              return freshSpan
+            },
+            addLink (link, attrs) { span.addLink(link, attrs); return freshSpan },
+            addLinks (links) { span.addLinks(links); return freshSpan },
+            setStatus (status) { span.setStatus(status); return freshSpan },
+            updateName (spanName) { span.updateName(spanName); return freshSpan },
+            isRecording () { return span.isRecording() },
+            recordException (exception, timeInput) {
               ctx.error = exception
               vercelAiTracingChannel.error.publish(ctx)
-              return recordException.apply(this, arguments)
-            }
-          })
+              span.recordException(exception, timeInput)
+            },
+            end (...endArgs) {
+              vercelAiTracingChannel.asyncEnd.publish(ctx)
+              span.end(...endArgs)
+            },
+          }
 
           return originalCb.call(this, freshSpan)
         }

package/packages/datadog-instrumentations/src/cookie.js

@@ -15,7 +15,13 @@ function wrapParse (originalParse) {
   }
 }
 
+/** @param {typeof import('cookie')} cookie */
 addHook({ name: 'cookie', versions: ['>=0.4'] }, cookie => {
-  shimmer.wrap(cookie, 'parse', wrapParse)
+  for (const name of ['parse', 'parseCookie']) {
+    if (typeof cookie[name] === 'function') {
+      // shimmer returns a mutable replacement when an ESM namespace export is non-configurable.
+      cookie = shimmer.wrap(cookie, name, wrapParse)
+    }
+  }
   return cookie
 })

package/packages/datadog-instrumentations/src/cucumber.js

@@ -180,7 +180,7 @@ function getSuiteStatusFromTestStatuses (testStatuses) {
 
 function getConfiguredEfdRetryCount () {
   const maxSlowTestRetryCount = getMaxEfdRetryCount(earlyFlakeDetectionSlowTestRetries)
-  return maxSlowTestRetryCount || earlyFlakeDetectionNumRetries
+  return maxSlowTestRetryCount ?? earlyFlakeDetectionNumRetries
 }
 
 function publishWorkerEfdRetryCount (pickle, retryCount) {
@@ -1178,7 +1178,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
     }
 
-    const success = await start.apply(this, arguments)
+    const result = await start.apply(this, arguments)
+    const success = satisfies(frameworkVersion, '>=13.1.0') ? result.success : result
 
     let untestedCoverage
     if (getCodeCoverageCh.hasSubscribers) {
@@ -1228,7 +1229,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     logTestOptimizationSummary({ attemptToFixExecutions })
     loggedAttemptToFixTests.clear()
     eventDataCollector = null
-    return success
+    return result
   }
 }
 

package/packages/datadog-instrumentations/src/express.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { createWrapRouterMethod } = require('./router')
+const { createWrapRouterMethod, createLayerDispatchWrappers } = require('./router')
 const { addHook, channel, tracingChannel } = require('./helpers/instrument')
 const { getCompileToRegexp } = require('./path-to-regexp')
 const {
@@ -164,7 +164,10 @@ addHook({ name: 'express', versions: ['>=4'], file: 'lib/express.js' }, express
 // It would otherwise produce spans for router and express, and so duplicating them.
 // We now fall back to router instrumentation
 addHook({ name: 'express', versions: ['4'], file: 'lib/express.js' }, express => {
-  const wrapRouterMethod = createWrapRouterMethod('express', getCompileToRegexp())
+  // `wrapLegacyHandle` only fires for express <4.6.0 layers, which have no
+  // prototype dispatch; 4.6.0+ keeps `handle` pristine (wrapped below).
+  const { wrapLegacyHandle } = createLayerDispatchWrappers('express')
+  const wrapRouterMethod = createWrapRouterMethod('express', getCompileToRegexp(), wrapLegacyHandle)
 
   shimmer.wrap(express.Router, 'use', wrapRouterMethod)
   shimmer.wrap(express.Router, 'route', wrapRouterMethod)
@@ -172,6 +175,21 @@ addHook({ name: 'express', versions: ['4'], file: 'lib/express.js' }, express =>
   return express
 })
 
+// Express 4 bundles its own Layer; express 5 delegates to the `router` package
+// (wrapped in router.js). Both keep `layer.handle` the user's function and trace
+// via the prototype dispatch. express <4.6.0 has no such dispatch and is traced
+// by the legacy handle wrap instead.
+addHook({ name: 'express', file: 'lib/router/layer.js', versions: ['4'] }, Layer => {
+  if (typeof Layer.prototype.handle_request !== 'function') return Layer
+
+  const { wrapLayerRequest, wrapLayerError } = createLayerDispatchWrappers('express')
+
+  shimmer.wrap(Layer.prototype, 'handle_request', wrapLayerRequest)
+  shimmer.wrap(Layer.prototype, 'handle_error', wrapLayerError)
+
+  return Layer
+})
+
 const queryParserReadCh = channel('datadog:query:read:finish')
 
 function publishQueryParsedAndNext (req, res, next) {

package/packages/datadog-instrumentations/src/grpc/server.js

@@ -2,6 +2,7 @@
 
 const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { FOREIGN_HTTP2_SERVER } = require('../../../dd-trace/src/constants')
 const types = require('./types')
 
 const startChannel = channel('apm:grpc:server:request:start')
@@ -76,6 +77,22 @@ function wrapRegister (register) {
   }
 }
 
+function wrapSetupHandlers (setupHandlers) {
+  return function (http2Server) {
+    // gRPC builds its transport on a core Node `Http2Server` and drives every
+    // call through its own span lifecycle over the raw 'stream' event. Mark the
+    // server so the http2 server instrumentation leaves it untraced; otherwise
+    // its re-enabled 'stream' path would wrap every gRPC call in a second
+    // web.request span and become the top frame. `_setupHandlers` is the single
+    // server-creation funnel across all supported versions (the older
+    // `createHttp2Server` does not exist), and it runs at bind time, before any
+    // request reaches the wrapped `emit`.
+    if (http2Server) http2Server[FOREIGN_HTTP2_SERVER] = true
+
+    return setupHandlers.apply(this, arguments)
+  }
+}
+
 function createWrapEmit (call, ctx, onCancel) {
   return function wrapEmit (emit) {
     return function (event, arg1) {
@@ -149,6 +166,7 @@ function isEmitter (obj) {
 
 addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3'], file: 'build/src/server.js' }, server => {
   shimmer.wrap(server.Server.prototype, 'register', wrapRegister)
+  shimmer.wrap(server.Server.prototype, '_setupHandlers', wrapSetupHandlers)
 
   return server
 })

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -20,7 +20,7 @@ module.exports = {
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
   '@langchain/langgraph': { esmFirst: true, fn: () => require('../langgraph') },
-  '@modelcontextprotocol/sdk': () => require('../modelcontextprotocol-sdk'),
+  '@modelcontextprotocol/sdk': { esmFirst: true, fn: () => require('../modelcontextprotocol-sdk') },
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@aws/durable-execution-sdk-js': () => require('../aws-durable-execution-sdk-js'),

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/modelcontextprotocol-sdk.js

@@ -1,59 +1,35 @@
 'use strict'
 
-// NOTE: Protocol.request (dist/esm|cjs/shared/protocol.js) is intentionally not instrumented here.
-// It will be used for distributed tracing header injection when server-side coverage is added.
+const CLIENT_METHODS = [
+  'callTool',
+  'listTools',
+  'listResources',
+  'readResource',
+  'listPrompts',
+  'getPrompt',
+]
+
+const SERVER_METHODS = [
+  'executeToolHandler',
+]
+
+function clientEntries (methodName) {
+  return ['dist/esm/client/index.js', 'dist/cjs/client/index.js'].map(filePath => ({
+    module: { name: '@modelcontextprotocol/sdk', versionRange: '>=1.27.1', filePath },
+    functionQuery: { methodName, className: 'Client', kind: 'Async' },
+    channelName: `Client_${methodName}`,
+  }))
+}
+
+function serverEntries (methodName) {
+  return ['dist/esm/server/mcp.js', 'dist/cjs/server/mcp.js'].map(filePath => ({
+    module: { name: '@modelcontextprotocol/sdk', versionRange: '>=1.27.1', filePath },
+    functionQuery: { methodName, className: 'McpServer', kind: 'Async' },
+    channelName: `McpServer_${methodName}`,
+  }))
+}
 
 module.exports = [
-  {
-    module: {
-      name: '@modelcontextprotocol/sdk',
-      versionRange: '>=1.27.1',
-      filePath: 'dist/esm/client/index.js',
-    },
-    functionQuery: {
-      methodName: 'callTool',
-      className: 'Client',
-      kind: 'Async',
-    },
-    channelName: 'Client_callTool',
-  },
-  {
-    module: {
-      name: '@modelcontextprotocol/sdk',
-      versionRange: '>=1.27.1',
-      filePath: 'dist/cjs/client/index.js',
-    },
-    functionQuery: {
-      methodName: 'callTool',
-      className: 'Client',
-      kind: 'Async',
-    },
-    channelName: 'Client_callTool',
-  },
-  {
-    module: {
-      name: '@modelcontextprotocol/sdk',
-      versionRange: '>=1.27.1',
-      filePath: 'dist/esm/client/index.js',
-    },
-    functionQuery: {
-      methodName: 'listTools',
-      className: 'Client',
-      kind: 'Async',
-    },
-    channelName: 'Client_listTools',
-  },
-  {
-    module: {
-      name: '@modelcontextprotocol/sdk',
-      versionRange: '>=1.27.1',
-      filePath: 'dist/cjs/client/index.js',
-    },
-    functionQuery: {
-      methodName: 'listTools',
-      className: 'Client',
-      kind: 'Async',
-    },
-    channelName: 'Client_listTools',
-  },
+  ...CLIENT_METHODS.flatMap(clientEntries),
+  ...SERVER_METHODS.flatMap(serverEntries),
 ]

package/packages/datadog-instrumentations/src/helpers/router-helper.js

@@ -4,7 +4,7 @@ const shimmer = require('../../../datadog-shimmer')
 const { channel } = require('./instrument')
 
 const routerMountPaths = new WeakMap() // to track mount paths for router instances
-const layerMatchers = new WeakMap() // to store layer matchers
+const layerMeta = new WeakMap() // per-layer middleware dispatch metadata (resolved name + route matchers)
 const appMountedRouters = new WeakSet() // to track routers mounted via app.use()
 
 const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
@@ -70,7 +70,7 @@ function collectRoutesFromRouter (router, prefix) {
       // Extract mount path from layer
       const mountPath = typeof layer.path === 'string'
         ? layer.path
-        : getLayerMatchers(layer)?.[0]?.path || ''
+        : getLayerMeta(layer)?.matchers?.[0]?.path || ''
 
       const nestedPrefix = joinPath(prefix, mountPath)
       if (nestedPrefix === null) continue
@@ -121,12 +121,12 @@ function getRouterMountPaths (router) {
   return [...paths]
 }
 
-function setLayerMatchers (layer, matchers) {
-  layerMatchers.set(layer, matchers)
+function setLayerMeta (layer, meta) {
+  layerMeta.set(layer, meta)
 }
 
-function getLayerMatchers (layer) {
-  return layerMatchers.get(layer)
+function getLayerMeta (layer) {
+  return layerMeta.get(layer)
 }
 
 function normalizeMethodName (method) {
@@ -224,8 +224,8 @@ module.exports = {
   setRouterMountPath,
   getRouterMountPaths,
   joinPath,
-  setLayerMatchers,
-  getLayerMatchers,
+  setLayerMeta,
+  getLayerMeta,
   markAppMounted,
   isAppMounted,
   normalizeRoutePath,

package/packages/datadog-instrumentations/src/http/server.js

@@ -13,6 +13,7 @@ const finishServerCh = channel('apm:http:server:request:finish')
 const startWriteHeadCh = channel('apm:http:server:response:writeHead:start')
 const finishSetHeaderCh = channel('datadog:http:server:response:set-header:finish')
 const startSetHeaderCh = channel('datadog:http:server:response:set-header:start')
+const startInformationalResponseCh = channel('datadog:http:server:informational-response:start')
 
 const requestFinishedSet = new WeakSet()
 
@@ -24,10 +25,19 @@ addHook({ name: 'http' }, http => {
   shimmer.wrap(http.ServerResponse.prototype, 'end', wrapEnd)
   shimmer.wrap(http.ServerResponse.prototype, 'setHeader', wrapSetHeader)
   shimmer.wrap(http.ServerResponse.prototype, 'removeHeader', wrapAppendOrRemoveHeader)
+  if (http.ServerResponse.prototype.writeContinue) {
+    shimmer.wrap(http.ServerResponse.prototype, 'writeContinue', wrapInformationalResponse)
+  }
+  if (http.ServerResponse.prototype.writeProcessing) {
+    shimmer.wrap(http.ServerResponse.prototype, 'writeProcessing', wrapInformationalResponse)
+  }
   // Added in node v16.17.0
   if (http.ServerResponse.prototype.appendHeader) {
     shimmer.wrap(http.ServerResponse.prototype, 'appendHeader', wrapAppendOrRemoveHeader)
   }
+  if (http.ServerResponse.prototype.writeEarlyHints) {
+    shimmer.wrap(http.ServerResponse.prototype, 'writeEarlyHints', wrapInformationalResponse)
+  }
   return http
 })
 
@@ -212,6 +222,23 @@ function wrapAppendOrRemoveHeader (originalMethod) {
   }
 }
 
+function wrapInformationalResponse (originalMethod) {
+  return function wrappedInformationalResponse (...args) {
+    if (!startInformationalResponseCh.hasSubscribers) {
+      return Reflect.apply(originalMethod, this, args)
+    }
+
+    const abortController = new AbortController()
+    startInformationalResponseCh.publish({ res: this, abortController })
+
+    if (abortController.signal.aborted) {
+      return
+    }
+
+    return Reflect.apply(originalMethod, this, args)
+  }
+}
+
 function wrapEnd (end) {
   return function wrappedEnd (...args) {
     if (!startWriteHeadCh.hasSubscribers) {

package/packages/datadog-instrumentations/src/http2/server.js

@@ -1,18 +1,26 @@
 'use strict'
 
-// Old instrumentation temporarily replaced with compatibility mode only instrumentation.
-// See https://github.com/DataDog/dd-trace-js/issues/312
-
 const {
   channel,
   addHook,
 } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { FOREIGN_HTTP2_SERVER } = require('../../../dd-trace/src/constants')
 
 const startServerCh = channel('apm:http2:server:request:start')
 const errorServerCh = channel('apm:http2:server:request:error')
+const adoptServerCh = channel('apm:http2:server:request:adopt')
 const emitCh = channel('apm:http2:server:response:emit')
 
+const HTTP2_HEADER_METHOD = ':method'
+const HTTP2_HEADER_PATH = ':path'
+const HTTP2_HEADER_STATUS = ':status'
+
+// Streams whose server span was already created from the 'stream' event. The
+// compatibility layer synthesizes 'request' from that same stream, so the
+// 'request' branch consults this set to avoid creating a second span.
+const tracedStreams = new WeakSet()
+
 addHook({ name: 'http2' }, http2 => {
   shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
   shimmer.wrap(http2, 'createServer', wrapCreateServer)
@@ -36,34 +44,152 @@ function wrapResponseEmit (originalEmit, ctx) {
   }
 }
 
+function wrapStreamEmit (originalEmit, ctx) {
+  // Named `emit`/arity-1 mirrors the stream method so the per-stream wrap skips
+  // its name/length rewrite. `this` is the Http2Stream; the plugin finishes on
+  // 'close', the same finish signal as the compatibility response.
+  return function emit (eventName) {
+    ctx.eventName = eventName
+    return emitCh.runStores(ctx, originalEmit, this, ...arguments)
+  }
+}
+
 function wrapEmit (originalEmit) {
   // Named `emit` mirrors the server method so the one-time wrap skips its name
   // rewrite; rest params keep the per-event forwarding allocation-free.
   return function emit (...args) {
-    if (!startServerCh.hasSubscribers) {
+    // A server owned by another instrumentation (e.g. @grpc/grpc-js) drives its
+    // own span lifecycle over the raw 'stream' API, so tracing it here would add
+    // a spurious web.request span on top of that integration's span and steal
+    // the top frame. Skip it entirely; the mark is set at server creation, so
+    // this is one property read on servers we do trace.
+    if (!startServerCh.hasSubscribers || this[FOREIGN_HTTP2_SERVER]) {
       return Reflect.apply(originalEmit, this, args)
     }
 
     const eventName = args[0]
-    if (eventName === 'request') {
+    if (eventName === 'stream') {
+      // The compatibility layer synthesizes 'request' from an internal 'stream'
+      // listener it registers exactly once when a 'request' listener is added,
+      // so `listenerCount('stream')` exceeds one only when the application also
+      // registered a raw-stream listener. Owning the span here for that case
+      // keeps it active while the application's stream listener runs; the
+      // synthesized 'request' that fires nested below then reuses it. A
+      // request-only server (no raw-stream listener) is left to the 'request'
+      // branch so the compatibility response keeps its richer req/res.
+      const requestListenerCount = this.listenerCount('request')
+      if (requestListenerCount === 0 || this.listenerCount('stream') > 1) {
+        const stream = args[1]
+        const headers = args[2]
+        const ctx = createStreamAdapter(stream, headers)
+        // Only a mixed server (a 'request' listener is present) synthesizes a
+        // real request off this stream and adopts the span later, so only then
+        // does the context need keying on the stream. A raw-stream-only server
+        // never adopts; leaving the flag unset keeps the stream->context write
+        // off its hot path.
+        ctx.adoptable = requestListenerCount !== 0
+        tracedStreams.add(stream)
+
+        return traceServerRequest(ctx, () => {
+          shimmer.wrap(stream, 'emit', emit => wrapStreamEmit(emit, ctx))
+          return Reflect.apply(originalEmit, this, args)
+        })
+      }
+    } else if (eventName === 'request') {
       const req = args[1]
       const res = args[2]
       res.req = req
 
-      const ctx = { req, res }
-      return startServerCh.runStores(ctx, () => {
-        shimmer.wrap(res, 'emit', emit => wrapResponseEmit(emit, ctx))
-
-        try {
+      // A mixed server (raw-stream + 'request' listeners) already created the
+      // span from the 'stream' event above; the stream's single 'close' is the
+      // sole finish source, so skip creating a second span. The synthesized
+      // request/response are the real objects a user's 'request' handler and
+      // the finish `hooks.request` expect, so hand them to the existing
+      // stream-backed context rather than leaving it on the throwaway adapter.
+      if (tracedStreams.has(req.stream)) {
+        adoptServerCh.publish({ req, res })
+      } else {
+        const ctx = { req, res }
+        return traceServerRequest(ctx, () => {
+          shimmer.wrap(res, 'emit', emit => wrapResponseEmit(emit, ctx))
           return Reflect.apply(originalEmit, this, args)
-        } catch (error) {
-          ctx.error = error
-          errorServerCh.publish(ctx)
-
-          throw error
-        }
-      })
+        })
+      }
     }
+
     return Reflect.apply(originalEmit, this, args)
   }
 }
+
+// Enter the request context and run `emitEvent` (the original `emit`, wrapped to
+// publish per-event for the matching response/stream), publishing any synchronous
+// throw from a user handler before letting it propagate.
+/**
+ * @param {StreamRequestContext | { req: object, res: object }} ctx
+ * @param {() => unknown} emitEvent
+ */
+function traceServerRequest (ctx, emitEvent) {
+  return startServerCh.runStores(ctx, () => {
+    try {
+      return emitEvent()
+    } catch (error) {
+      ctx.error = error
+      errorServerCh.publish(ctx)
+      throw error
+    }
+  })
+}
+
+/**
+ * The minimal req/res pair the shared web lifecycle (`web.js`) keys on, built
+ * from a core-API `Http2Stream`. The fields below are exactly the surface
+ * `web.js` / `url.js` / `ip_extractor.js` read for a stream-backed request; a
+ * new read added there must be mirrored here or it resolves to `undefined` on
+ * the core path only.
+ *
+ * @typedef {object} StreamRequestContext
+ * @property {object} req
+ * @property {import('node:http2').ServerHttp2Stream} req.stream branch key in `web.js`/`url.js`
+ * @property {import('node:http2').IncomingHttpHeaders} req.headers raw pseudo-header map
+ * @property {string} [req.method]
+ * @property {string} [req.url]
+ * @property {import('node:net').Socket} [req.socket] peer address source (OTel)
+ * @property {object} res
+ * @property {object} res.req back-reference used by `wrapResponseEmit`/finish
+ * @property {number} res.statusCode read at finish from `stream.sentHeaders`
+ * @property {(name: string) => string | number | string[] | undefined} res.getHeader response-header tagging
+ */
+
+// Present the core-API stream + pseudo-header map as the minimal req/res pair
+// the shared web lifecycle (`web.js`) consumes. The response status and headers
+// are getters because `stream.sentHeaders` is empty until `stream.respond()`
+// runs in the user handler; a snapshot taken here would always be `undefined`.
+/**
+ * @param {import('node:http2').ServerHttp2Stream} stream
+ * @param {import('node:http2').IncomingHttpHeaders} headers
+ * @returns {StreamRequestContext}
+ */
+function createStreamAdapter (stream, headers) {
+  const req = {
+    stream,
+    headers,
+    method: headers[HTTP2_HEADER_METHOD],
+    url: headers[HTTP2_HEADER_PATH],
+    socket: stream.session?.socket,
+  }
+  const res = {
+    req,
+    get statusCode () {
+      // A stream aborted before `stream.respond()` has no `:status`. The
+      // compatibility `Http2ServerResponse.statusCode` defaults to 200 in that
+      // case, so match it rather than report `undefined` (which `validateStatus`
+      // would treat as an error and which drops the `http.status_code` tag).
+      return stream.sentHeaders?.[HTTP2_HEADER_STATUS] ?? 200
+    },
+    getHeader (name) {
+      return stream.sentHeaders?.[name]
+    },
+  }
+
+  return { req, res }
+}