dd-trace 6.1.0 → 6.3.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.d.ts

@@ -2514,6 +2514,13 @@ declare namespace tracer {
      * This plugin automatically instruments the
      * [graphql](https://github.com/graphql/graphql-js) module.
      *
+     * It also instruments [mercurius](https://github.com/mercurius-js/mercurius)
+     * (the Fastify GraphQL adapter): every request through `app.graphql` /
+     * `reply.graphql` opens a top-level `graphql.request` span that parents the
+     * `graphql.parse`/`graphql.validate`/`graphql.execute` spans and carries the
+     * request text. This span is produced even when mercurius serves the query
+     * from its JIT-compiled path, where `graphql.execute` does not run.
+     *
      * The `graphql` integration uses the operation name as the span resource name.
      * If no operation name is set, the resource name will always be just `query`,
      * `mutation` or `subscription`.

package/initialize.mjs

@@ -75,8 +75,10 @@ export const resolve = brokenLoaders ? undefined : hookResolve
 
 if (isMainThread) {
   const require = Module.createRequire(import.meta.url)
-  require('./init.js')
-  if (Module.register) {
+  const initialized = require('./init.js')
+  // Only register the loader hook when instrumentation initialized. On a bailout the
+  // loader has nothing to instrument and can keep a short-lived process from exiting.
+  if (Module.register && initialized) {
     // The loader builds its own include/exclude matcher in `initialize`, so no
     // options need to cross the registration boundary.
     Module.register('./loader-hook.mjs', import.meta.url)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.1.0",
+  "version": "6.3.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -23,7 +23,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",
@@ -191,18 +191,17 @@
     "@stylistic/eslint-plugin": "^5.10.0",
     "@types/mocha": "^10.0.10",
     "@types/node": "^18.19.106",
-    "@types/sinon": "^21.0.1",
+    "@types/sinon": "^22.0.0",
     "axios": "^1.18.1",
     "benchmark": "^2.1.4",
     "body-parser": "^2.3.0",
     "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",
@@ -230,6 +229,7 @@
     "semifies": "^1.0.0",
     "semver": "^7.8.5",
     "sinon": "^22.0.0",
+    "source-map-support": "^0.5.21",
     "test-exclude": "^8.0.0",
     "tiktoken": "^1.0.21",
     "typescript": "^6.0.3",

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/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'),
@@ -48,6 +48,7 @@ module.exports = {
   '@langchain/core': { esmFirst: true, fn: () => require('../langchain') },
   '@node-redis/client': () => require('../redis'),
   '@opensearch-project/opensearch': () => require('../opensearch'),
+  '@opentelemetry/sdk-trace': () => require('../otel-sdk-trace'),
   '@opentelemetry/sdk-trace-node': () => require('../otel-sdk-trace'),
   '@prisma/client': { esmFirst: true, fn: () => require('../prisma') },
   './runtime/library.js': () => require('../prisma'),
@@ -105,6 +106,7 @@ module.exports = {
   lodash: () => require('../lodash'),
   mariadb: () => require('../mariadb'),
   memcached: () => require('../memcached'),
+  mercurius: () => require('../mercurius'),
   'microgateway-core': () => require('../microgateway-core'),
   mocha: () => require('../mocha'),
   'mocha-each': () => require('../mocha'),

package/packages/datadog-instrumentations/src/helpers/rewriter/index.js

@@ -37,6 +37,10 @@ for (const matcher of [matcherCjs, matcherEsm]) {
   matcher.addTransform('waitForAsyncEnd', waitForAsyncEnd)
 }
 
+// Keep the marker split: source-map scanners can read a contiguous token in
+// string literals as this file's own inline map.
+const SOURCE_MAP_PREFIX = '//# sourceMapping' + 'URL=data:application/json;base64,'
+
 function rewrite (content, filename, format) {
   if (!content) return content
   if (!filename.includes('node_modules')) return content
@@ -66,7 +70,7 @@ function rewrite (content, filename, format) {
 
     const inlineMap = Buffer.from(map).toString('base64')
 
-    return code + '\n' + `//# sourceMappingURL=data:application/json;base64,${inlineMap}`
+    return code + '\n' + SOURCE_MAP_PREFIX + inlineMap
   } catch (e) {
     log.error(e)
   }

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/index.js

@@ -8,6 +8,7 @@ module.exports = [
   ...require('./graphql'),
   ...require('./langchain'),
   ...require('./langgraph'),
+  ...require('./mercurius'),
   ...require('./modelcontextprotocol-sdk'),
   ...require('./playwright'),
   ...require('./aws-durable-execution-sdk-js'),

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/mercurius.js

@@ -0,0 +1,31 @@
+'use strict'
+
+// Mercurius funnels every GraphQL request through the named async function
+// `fastifyGraphQl` (decorated as both `app.graphql` and, via `reply.graphql`,
+// the per-request entry point). Wrapping that one function gives a single
+// top-level span per operation regardless of how the query reaches mercurius
+// — HTTP POST/GET, batched queries, or a programmatic `app.graphql()` call —
+// and regardless of whether the query runs through graphql's `execute` (cold)
+// or a JIT-compiled query (warm), where no `graphql.execute` span fires.
+//
+// The function name and signature `(source, context, variables, operationName)`
+// are stable across the supported major range (verified against 10.x and 16.x),
+// so a `functionName` match needs no per-version file paths.
+module.exports = [
+  {
+    module: {
+      // Floor at 13: it is the oldest major whose fastify-plugin peer (^4)
+      // accepts fastify 4, which installs and runs on the oldest supported Node
+      // (18). 15+ requires Node 20 and fastify 5, covered on the latest-Node CI
+      // leg. The `fastifyGraphQl` funnel is unchanged across this whole range.
+      name: 'mercurius',
+      versionRange: '>=13',
+      filePath: 'index.js',
+    },
+    functionQuery: {
+      functionName: 'fastifyGraphQl',
+      kind: 'Async',
+    },
+    channelName: 'apm:graphql:request',
+  },
+]

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/rewriter/transforms.js

@@ -8,6 +8,10 @@
 // the library, replace the custom registration with the built-in option and
 // remove the entry here.
 
+const assert = require('node:assert')
+
+const clone = require('../../../../../vendor/dist/rfdc')({ proto: false, circles: false })
+
 const { parse, query } = require('./compiler')
 
 module.exports = { waitForAsyncEnd }
@@ -28,20 +32,30 @@ function waitForAsyncEnd (_state, node) {
     return
   }
 
-  const returnIndex = statements.findIndex(statement => (
-    statement.type === 'ReturnStatement' && statement.argument?.name === 'result'
-  ))
+  const returnIndex = statements.findIndex(statement =>
+    statement.type === 'ReturnStatement' && statement.argument
+  )
 
-  if (returnIndex === -1) return
+  // The generated fulfillment handler always ends in a return; a miss means the
+  // upstream template changed and the caller's try/catch falls back to the
+  // unwrapped source.
+  assert(returnIndex !== -1, 'waitForAsyncEnd: no return statement to wait on')
 
   const waitStatements = parse(`
     function wrapper () {
       const __apm$asyncEndPromise = __apm$ctx.asyncEndPromise;
       if (__apm$asyncEndPromise && typeof __apm$asyncEndPromise.then === 'function') {
-        return __apm$asyncEndPromise.then(() => result, () => result);
+        return __apm$asyncEndPromise.then(() => __apm$result, () => __apm$result);
       }
     }
   `).body[0].body.body
 
+  // Resolve to whatever the fulfillment handler returns (its return argument),
+  // so a subscriber that reassigned `__apm$ctx.result` in `asyncEnd` still wins.
+  const returnArgument = statements[returnIndex].argument
+  const { arguments: onSettled } = waitStatements[1].consequent.body[0].argument
+  onSettled[0].body = clone(returnArgument)
+  onSettled[1].body = clone(returnArgument)
+
   statements.splice(returnIndex, 0, ...waitStatements)
 }

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/mercurius.js

@@ -0,0 +1,11 @@
+// AUTO-GENERATED by dd-compile
+// Orchestrion rewriter handles the actual instrumentation via JSON config.
+// This file registers the module hooks for the rewriter to process.
+
+'use strict'
+
+const { addHook, getHooks } = require('./helpers/instrument')
+
+for (const hook of getHooks('mercurius')) {
+  addHook(hook, exports => exports)
+}

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

@@ -1,7 +1,254 @@
 'use strict'
 
-const { addHook, getHooks } = require('./helpers/instrument')
+const { tracingChannel } = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel, getHooks } = require('./helpers/instrument')
 
 for (const hook of getHooks('@modelcontextprotocol/sdk')) {
   addHook(hook, exports => exports)
 }
+
+const serverRequestCh = tracingChannel('apm:mcp:server:request')
+const clientRequestInjectCh = channel('apm:mcp:client:request:inject')
+const serverToolRegisteredCh = channel('apm:mcp:server:tool:registered')
+
+const DISTRIBUTED_TRACE_META_KEY = '_dd_trace_context'
+const TRACED_METHOD_PREFIX = /^(?:tools|resources|prompts)\//
+
+// Maps Protocol instance → Map<requestId, ctx>. Shares the ctx object between
+// _onrequest (span start, in the correct HTTP async context), the SDK request
+// handler wrapper (result/error capture), and the SDK cleanup path (span finish).
+const pendingContexts = new WeakMap()
+const wrappedAbortControllerMaps = new WeakSet()
+const wrappedRequestHandlerMaps = new WeakSet()
+const wrappedRequestHandlers = new WeakSet()
+
+function addTraceContextToRequest (request, traceContext) {
+  return {
+    ...request,
+    params: {
+      ...request.params,
+      _meta: {
+        ...request.params?._meta,
+        [DISTRIBUTED_TRACE_META_KEY]: traceContext,
+      },
+    },
+  }
+}
+
+function getPendingContext (protocol, requestId) {
+  return pendingContexts.get(protocol)?.get(requestId)
+}
+
+function finishServerRequest (protocol, requestId) {
+  const pending = pendingContexts.get(protocol)
+  const ctx = pending?.get(requestId)
+  if (!ctx) return
+
+  pending.delete(requestId)
+  serverRequestCh.asyncEnd.publish(ctx)
+}
+
+function wrapRequestHandler (protocol, handler) {
+  if (wrappedRequestHandlers.has(handler)) return handler
+
+  const wrappedHandler = function requestHandlerWithTrace (request, extra) {
+    const ctx = getPendingContext(protocol, extra?.requestId)
+    if (!ctx) return handler.apply(this, arguments)
+
+    let result
+    try {
+      result = handler.apply(this, arguments)
+    } catch (err) {
+      ctx.error = err
+      throw err
+    }
+
+    if (result && typeof result.then === 'function') {
+      result.then(result => {
+        ctx.result = result
+      }, err => {
+        ctx.error = err
+      })
+      return result
+    }
+
+    ctx.result = result
+    return result
+  }
+
+  wrappedRequestHandlers.add(wrappedHandler)
+  return wrappedHandler
+}
+
+function wrapRequestHandlers (protocol) {
+  const handlers = protocol._requestHandlers
+  if (!handlers || wrappedRequestHandlerMaps.has(handlers)) return
+
+  wrappedRequestHandlerMaps.add(handlers)
+  shimmer.wrap(handlers, 'set', function (original) {
+    return function setRequestHandlerWithTrace (method, handler) {
+      if (typeof handler === 'function') {
+        return original.call(this, method, wrapRequestHandler(protocol, handler))
+      }
+
+      return original.apply(this, arguments)
+    }
+  })
+}
+
+function wrapAbortControllers (protocol) {
+  const controllers = protocol._requestHandlerAbortControllers
+  if (!controllers || wrappedAbortControllerMaps.has(controllers)) return
+
+  wrappedAbortControllerMaps.add(controllers)
+  shimmer.wrap(controllers, 'delete', function (original) {
+    return function deleteAbortControllerWithTrace (requestId) {
+      finishServerRequest(protocol, requestId)
+      return original.apply(this, arguments)
+    }
+  })
+  shimmer.wrap(controllers, 'clear', function (original) {
+    return function clearAbortControllersWithTrace () {
+      for (const requestId of this.keys()) {
+        finishServerRequest(protocol, requestId)
+      }
+      return original.apply(this, arguments)
+    }
+  })
+}
+
+function wrapProtocol (Protocol) {
+  // Inject trace context into MCP request metadata so out-of-process MCP servers
+  // can parent server spans to the client operation span.
+  shimmer.wrap(Protocol.prototype, 'request', function (original) {
+    return function requestWithTraceContext (request, resultSchema, options) {
+      if (!clientRequestInjectCh.hasSubscribers || !TRACED_METHOD_PREFIX.test(request?.method)) {
+        return original.apply(this, arguments)
+      }
+
+      const ctx = {}
+      clientRequestInjectCh.publish(ctx)
+
+      if (!ctx.traceContext) {
+        return original.apply(this, arguments)
+      }
+
+      return original.call(this, addTraceContextToRequest(request, ctx.traceContext), resultSchema, options)
+    }
+  })
+
+  // Start spans in _onrequest — this runs inside the express POST /mcp handler's
+  // async context, so ALS correctly parents server spans under the HTTP span.
+  shimmer.wrap(Protocol.prototype, '_onrequest', function (original) {
+    return function _onrequestWithTrace (request, extra) {
+      if (!serverRequestCh.hasSubscribers || !TRACED_METHOD_PREFIX.test(request.method)) {
+        return original.call(this, request, extra)
+      }
+
+      wrapAbortControllers(this)
+      const ctx = { request, extra }
+      serverRequestCh.start.runStores(ctx, () => {
+        let pending = pendingContexts.get(this)
+        if (!pending) {
+          pending = new Map()
+          pendingContexts.set(this, pending)
+        }
+        pending.set(request.id, ctx)
+
+        try {
+          original.call(this, request, extra)
+        } catch (err) {
+          ctx.error = err
+          finishServerRequest(this, request.id)
+          throw err
+        }
+
+        // The SDK registers an AbortController only when it actually dispatches a handler.
+        // If none was registered (MethodNotFound path), no handler will run and our
+        // SDK cleanup hook will never fire — finish the span immediately.
+        if (!this._requestHandlerAbortControllers?.has(request.id)) {
+          ctx.error = { name: 'McpError', message: 'Method not found' }
+          finishServerRequest(this, request.id)
+        }
+      })
+    }
+  })
+
+  // The SDK's handler closure Zod-parses the request, stripping the JSON-RPC `id`.
+  // Use `extra.requestId` (the SDK's fullExtra field) to correlate with the pending ctx.
+  shimmer.wrap(Protocol.prototype, 'setRequestHandler', function (original) {
+    return function setRequestHandlerWithTrace () {
+      wrapRequestHandlers(this)
+      return original.apply(this, arguments)
+    }
+  })
+
+  return Protocol
+}
+
+function wrapMcpServer (McpServer) {
+  // Both public registration methods (tool/registerTool) delegate here — one hook covers both.
+  // Publishes to serverToolRegisteredCh so tracing.js can build a WeakMap of tool → name
+  // for O(1) lookup in McpServerToolCallPlugin (executeToolHandler receives the tool object,
+  // not the name string).
+  shimmer.wrap(McpServer.prototype, '_createRegisteredTool', function (original) {
+    return function (name) {
+      const result = original.apply(this, arguments)
+      if (serverToolRegisteredCh.hasSubscribers) {
+        const tool = this._registeredTools?.[name]
+        if (tool) {
+          serverToolRegisteredCh.publish({ tool, name })
+          shimmer.wrap(tool, 'update', function (update) {
+            return function updateWithTrace (updates) {
+              const result = update.apply(this, arguments)
+              if (updates && Object.hasOwn(updates, 'name')) {
+                serverToolRegisteredCh.publish({ tool, name: updates.name || undefined })
+              }
+              return result
+            }
+          })
+        }
+      }
+      return result
+    }
+  })
+
+  return McpServer
+}
+
+addHook({
+  name: '@modelcontextprotocol/sdk',
+  versions: ['>=1.27.1'],
+  file: 'dist/cjs/shared/protocol.js',
+}, exports => {
+  wrapProtocol(exports.Protocol)
+  return exports
+})
+
+addHook({
+  name: '@modelcontextprotocol/sdk',
+  versions: ['>=1.27.1'],
+  file: 'dist/esm/shared/protocol.js',
+}, exports => {
+  wrapProtocol(exports.Protocol)
+  return exports
+})
+
+addHook({
+  name: '@modelcontextprotocol/sdk',
+  versions: ['>=1.27.1'],
+  file: 'dist/cjs/server/mcp.js',
+}, exports => {
+  wrapMcpServer(exports.McpServer)
+  return exports
+})
+
+addHook({
+  name: '@modelcontextprotocol/sdk',
+  versions: ['>=1.27.1'],
+  file: 'dist/esm/server/mcp.js',
+}, exports => {
+  wrapMcpServer(exports.McpServer)
+  return exports
+})

package/packages/datadog-instrumentations/src/otel-sdk-trace.js

@@ -16,6 +16,21 @@ if (isOtelSdkEnabled()) {
     })
     return mod
   })
+
+  // As of @opentelemetry/sdk-node 0.220.0, NodeSDK builds its provider from
+  // @opentelemetry/sdk-trace's TracerProvider instead of sdk-trace-node's
+  // NodeTracerProvider, so the hook above no longer intercepts it. Wrap this
+  // export too, otherwise DD_TRACE_OTEL_ENABLED spans never reach the tracer.
+  addHook({
+    name: '@opentelemetry/sdk-trace',
+    file: 'build/src/TracerProvider.js',
+    versions: ['*'],
+  }, (mod) => {
+    shimmer.wrap(mod, 'TracerProvider', () => {
+      return tracer.TracerProvider
+    })
+    return mod
+  })
 }
 
 function isOtelSdkEnabled () {