dd-trace 5.97.0 → 5.99.0

package/packages/datadog-instrumentations/src/cypress-config.js

@@ -4,9 +4,21 @@ const fs = require('fs')
 const os = require('os')
 const path = require('path')
 const { pathToFileURL } = require('url')
+const { channel } = require('./helpers/instrument')
 
 const DD_CONFIG_WRAPPED = Symbol('dd-trace.cypress.config.wrapped')
 
+const setupNodeEventsCh = channel('ci:cypress:setup-node-events')
+
+// Ensure the cypress plugin is loaded so it can subscribe to our channel.
+// Normally, plugins are loaded when their npm module is required (via addHook),
+// but plain-object configs don't require('cypress'), so the plugin would never
+// be instantiated in the Cypress Config Manager child process.
+const loadCh = channel('dd-trace:instrumentation:load')
+if (loadCh.hasSubscribers) {
+  loadCh.publish({ name: 'cypress' })
+}
+
 const noopTask = {
   'dd:testSuiteStart': () => null,
   'dd:beforeEach': () => ({}),
@@ -93,8 +105,9 @@ function injectSupportFile (config) {
 
 /**
  * Registers dd-trace's Cypress hooks (before:run, after:spec, after:run, tasks)
- * and injects the support file. Handles chaining with user-registered handlers
- * for after:spec/after:run so both the user's code and dd-trace's run in sequence.
+ * and injects the support file. Communicates with the plugin layer via
+ * the `ci:cypress:setup-node-events` diagnostic channel, avoiding direct
+ * tracer references in the instrumentation layer.
  *
  * @param {Function} on Cypress event registration function
  * @param {object} config Cypress resolved config object
@@ -111,8 +124,6 @@ function registerDdTraceHooks (on, config, userAfterSpecHandlers, userAfterRunHa
     }
   }
 
-  const tracer = global._ddtrace
-
   const registerAfterRunWithCleanup = () => {
     on('after:run', (results) => {
       const chain = userAfterRunHandlers.reduce(
@@ -129,49 +140,32 @@ function registerDdTraceHooks (on, config, userAfterSpecHandlers, userAfterRunHa
     on('task', noopTask)
   }
 
-  if (!tracer || !tracer._initialized) {
+  if (!setupNodeEventsCh.hasSubscribers) {
     registerNoopHandlers()
     return config
   }
 
-  const NoopTracer = require('../../../packages/dd-trace/src/noop/tracer')
-
-  if (tracer._tracer instanceof NoopTracer) {
-    registerNoopHandlers()
-    return config
+  // Publish to the plugin layer via diagnostic channel.
+  // The subscriber sets `payload.registered = true` and optionally
+  // `payload.configPromise` when it handles the event.
+  const payload = {
+    on,
+    config,
+    userAfterSpecHandlers,
+    userAfterRunHandlers,
+    cleanupWrapper,
+    registered: false,
+    configPromise: undefined,
   }
 
-  const cypressPlugin = require('../../../packages/datadog-plugin-cypress/src/cypress-plugin')
+  setupNodeEventsCh.publish(payload)
 
-  if (cypressPlugin._isInit) {
-    for (const h of userAfterSpecHandlers) on('after:spec', h)
-    registerAfterRunWithCleanup()
+  if (!payload.registered) {
+    registerNoopHandlers()
     return config
   }
 
-  on('before:run', cypressPlugin.beforeRun.bind(cypressPlugin))
-
-  on('after:spec', (spec, results) => {
-    const chain = userAfterSpecHandlers.reduce(
-      (p, h) => p.then(() => h(spec, results)),
-      Promise.resolve()
-    )
-    return chain.then(() => cypressPlugin.afterSpec(spec, results))
-  })
-
-  on('after:run', (results) => {
-    const chain = userAfterRunHandlers.reduce(
-      (p, h) => p.then(() => h(results)),
-      Promise.resolve()
-    )
-    return chain
-      .then(() => cypressPlugin.afterRun(results))
-      .finally(cleanupWrapper)
-  })
-
-  on('task', cypressPlugin.getTasks())
-
-  return Promise.resolve(cypressPlugin.init(tracer, config)).then(() => config)
+  return payload.configPromise || config
 }
 
 /**
@@ -235,32 +229,139 @@ function wrapConfig (config) {
   return config
 }
 
+/**
+ * Returns `true` if the nearest package.json walking up from `filePath`
+ * sets `"type": "module"`. Used to decide whether ambiguous extensions
+ * (`.js`, `.ts`) are loaded as ESM or CJS.
+ *
+ * @param {string} filePath absolute path to a file under the project
+ * @returns {boolean}
+ */
+function isUnderEsmPackage (filePath) {
+  let dir = path.dirname(filePath)
+  while (true) {
+    const candidate = path.join(dir, 'package.json')
+    try {
+      const pkg = JSON.parse(fs.readFileSync(candidate, 'utf8'))
+      return pkg && pkg.type === 'module'
+    } catch { /* no package.json at this level */ }
+    const parent = path.dirname(dir)
+    if (parent === dir) return false
+    dir = parent
+  }
+}
+
 /**
  * @param {string} originalConfigFile absolute path to the original config file
  * @returns {string} path to the generated wrapper file
  */
 function createConfigWrapper (originalConfigFile) {
+  // Decide the wrapper's module mode (ESM vs CJS). It must match how
+  // Cypress would interpret the user's original config so that (1) Cypress
+  // keeps the loader it would have used (notably the ts-node registration
+  // for `.ts` configs), and (2) the wrapper body parses in that mode.
+  const originalExt = path.extname(originalConfigFile)
+  const isEsm = originalExt === '.mjs' || originalExt === '.mts' ||
+    (originalExt !== '.cjs' && originalExt !== '.cts' && isUnderEsmPackage(originalConfigFile))
+
+  // Preserve `.ts`/`.cts`/`.mts` so Cypress keeps ts-node registered for
+  // the wrapper. For plain JS originals, pick the extension that encodes
+  // the chosen module mode directly.
+  let wrapperExt
+  if (originalExt === '.ts' || originalExt === '.cts' || originalExt === '.mts') {
+    wrapperExt = originalExt
+  } else {
+    wrapperExt = isEsm ? '.mjs' : '.cjs'
+  }
+
   const wrapperFile = path.join(
     path.dirname(originalConfigFile),
-    `.dd-cypress-config-${process.pid}.mjs`
+    `.dd-cypress-config-${process.pid}${wrapperExt}`
   )
 
   const cypressConfigPath = require.resolve('./cypress-config')
 
-  // Always use ESM: it can import both CJS and ESM configs, so it works
-  // regardless of the original file's extension or "type": "module" in package.json.
-  // Import cypress-config.js directly (CJS default = module.exports object).
-  fs.writeFileSync(wrapperFile, [
-    `import originalConfig from ${JSON.stringify(pathToFileURL(originalConfigFile).href)}`,
-    `import cypressConfig from ${JSON.stringify(pathToFileURL(cypressConfigPath).href)}`,
-    '',
-    'export default cypressConfig.wrapConfig(originalConfig)',
-    '',
-  ].join('\n'))
-
+  // ESM body: `import` default-interops a CJS module (cypress-config.js)
+  //   by exposing its `module.exports` as the default binding, and handles
+  //   both CJS and ESM user configs transparently.
+  // CJS body: avoids top-level `import` — older Cypress transpiles `.ts`
+  //   configs through CJS ts-node, where `require('file://...')` is not
+  //   supported. Guards against ES-module-default shape so TS-authored
+  //   configs using `export default` still work.
+  const body = isEsm
+    ? [
+        `import originalConfig from ${JSON.stringify(pathToFileURL(originalConfigFile).href)}`,
+        `import cypressConfig from ${JSON.stringify(pathToFileURL(cypressConfigPath).href)}`,
+        '',
+        'export default cypressConfig.wrapConfig(originalConfig)',
+        '',
+      ].join('\n')
+    : [
+        `const cypressConfig = require(${JSON.stringify(cypressConfigPath)})`,
+        `const originalExports = require(${JSON.stringify(originalConfigFile)})`,
+        'const originalConfig = originalExports && originalExports.__esModule',
+        '  ? originalExports.default',
+        '  : originalExports',
+        'module.exports = cypressConfig.wrapConfig(originalConfig)',
+        '',
+      ].join('\n')
+
+  fs.writeFileSync(wrapperFile, body)
   return wrapperFile
 }
 
+/**
+ * @param {string} projectRoot
+ * @returns {boolean}
+ */
+function isTypeScript6OrNewer (projectRoot) {
+  try {
+    // eslint-disable-next-line n/no-unpublished-require
+    const packageJsonPath = require.resolve('typescript/package.json', { paths: [projectRoot] })
+    const { version } = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+    const major = Number(String(version).split('.')[0])
+    return major >= 6
+  } catch {
+    return false
+  }
+}
+
+/**
+ * @param {string} projectRoot
+ * @param {string} configFilePath
+ * @returns {() => void}
+ */
+function configureTsNodeForTypeScript6 (projectRoot, configFilePath) {
+  const configExt = path.extname(configFilePath)
+  if (configExt !== '.ts' && configExt !== '.cts' && configExt !== '.mts') return () => {}
+  if (!isTypeScript6OrNewer(projectRoot)) return () => {}
+
+  /* eslint-disable eslint-rules/eslint-process-env */
+  const previousCompilerOptions = process.env.TS_NODE_COMPILER_OPTIONS
+  let compilerOptions = {}
+  if (previousCompilerOptions) {
+    try {
+      compilerOptions = JSON.parse(previousCompilerOptions)
+    } catch {
+      compilerOptions = {}
+    }
+  }
+
+  process.env.TS_NODE_COMPILER_OPTIONS = JSON.stringify({
+    ...compilerOptions,
+    ignoreDeprecations: '6.0',
+  })
+
+  return () => {
+    if (previousCompilerOptions === undefined) {
+      delete process.env.TS_NODE_COMPILER_OPTIONS
+    } else {
+      process.env.TS_NODE_COMPILER_OPTIONS = previousCompilerOptions
+    }
+  }
+  /* eslint-enable eslint-rules/eslint-process-env */
+}
+
 /**
  * Wraps the Cypress config file for a CLI start() call. When an explicit
  * configFile is provided, creates a temp wrapper that imports the original
@@ -297,17 +398,16 @@ function wrapCliConfigFileOptions (options) {
     }
   }
 
-  // Skip .ts files — Cypress transpiles them internally via its own loader.
-  // The ESM wrapper can't import .ts directly. The defineConfig shimmer
-  // handles .ts configs since they're transpiled to CJS by Cypress.
-  if (!configFilePath || !fs.existsSync(configFilePath) || path.extname(configFilePath) === '.ts') return noop
+  if (!configFilePath || !fs.existsSync(configFilePath)) return noop
 
   try {
     const wrapperFile = createConfigWrapper(configFilePath)
+    const restoreTsNodeCompilerOptions = configureTsNodeForTypeScript6(projectRoot, configFilePath)
 
     return {
       options: { ...options, configFile: wrapperFile },
       cleanup: () => {
+        restoreTsNodeCompilerOptions()
         try { fs.unlinkSync(wrapperFile) } catch { /* best effort */ }
       },
     }

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

@@ -1,7 +1,8 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { channel, addHook } = require('./helpers/instrument')
+const { addHook } = require('./helpers/instrument')
+const { createCallbackInstrumentor } = require('./helpers/callback-instrumentor')
 
 const rrtypes = {
   resolveAny: 'ANY',
@@ -20,78 +21,45 @@ const rrtypes = {
 const rrtypeMap = new WeakMap()
 
 addHook({ name: 'dns' }, dns => {
-  shimmer.wrap(dns, 'lookup', fn => wrap('apm:dns:lookup', fn, 2))
-  shimmer.wrap(dns, 'lookupService', fn => wrap('apm:dns:lookup_service', fn, 2))
-  shimmer.wrap(dns, 'resolve', fn => wrap('apm:dns:resolve', fn, 2))
-  shimmer.wrap(dns, 'reverse', fn => wrap('apm:dns:reverse', fn, 2))
+  const lookup = createCallbackInstrumentor('apm:dns:lookup', { captureResult: true })
+  const lookupService = createCallbackInstrumentor('apm:dns:lookup_service', { captureResult: true })
+  const resolve = createCallbackInstrumentor('apm:dns:resolve', { captureResult: true })
+  const reverse = createCallbackInstrumentor('apm:dns:reverse', { captureResult: true })
 
-  patchResolveShorthands(dns)
+  shimmer.wrap(dns, 'lookup', lookup(buildArgsContext()))
+  shimmer.wrap(dns, 'lookupService', lookupService(buildArgsContext()))
+  shimmer.wrap(dns, 'resolve', resolve(buildArgsContext()))
+  shimmer.wrap(dns, 'reverse', reverse(buildArgsContext()))
+
+  patchResolveShorthands(dns, resolve)
 
   if (dns.Resolver) {
-    shimmer.wrap(dns.Resolver.prototype, 'resolve', fn => wrap('apm:dns:resolve', fn, 2))
-    shimmer.wrap(dns.Resolver.prototype, 'reverse', fn => wrap('apm:dns:reverse', fn, 2))
+    shimmer.wrap(dns.Resolver.prototype, 'resolve', resolve(buildArgsContext()))
+    shimmer.wrap(dns.Resolver.prototype, 'reverse', reverse(buildArgsContext()))
 
-    patchResolveShorthands(dns.Resolver.prototype)
+    patchResolveShorthands(dns.Resolver.prototype, resolve)
   }
 
   return dns
 })
 
-function patchResolveShorthands (prototype) {
+function patchResolveShorthands (prototype, resolve) {
   for (const method of Object.keys(rrtypes)) {
     if (prototype[method]) {
       rrtypeMap.set(prototype[method], rrtypes[method])
-      shimmer.wrap(prototype, method, fn => wrap('apm:dns:resolve', fn, 2, rrtypes[method]))
+      shimmer.wrap(prototype, method, resolve(buildArgsContext(rrtypes[method])))
     }
   }
 }
 
-function wrap (prefix, fn, expectedArgs, rrtype) {
-  const startCh = channel(prefix + ':start')
-  const finishCh = channel(prefix + ':finish')
-  const errorCh = channel(prefix + ':error')
-
-  const wrapped = function () {
-    const cb = arguments[arguments.length - 1]
-    if (
-      !startCh.hasSubscribers ||
-      arguments.length < expectedArgs ||
-      typeof cb !== 'function'
-    ) {
-      return fn.apply(this, arguments)
-    }
-
-    const args = [...arguments]
-    args.pop() // gets rid of the callback
+function buildArgsContext (rrtype) {
+  return function (_, args) {
+    if (args.length < 2) return
+    const captured = [...args]
+    captured.pop() // remove the callback
     if (rrtype) {
-      args.push(rrtype)
+      captured.push(rrtype)
     }
-
-    const ctx = { args }
-
-    return startCh.runStores(ctx, () => {
-      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function (error, result, ...args) {
-        if (error) {
-          ctx.error = error
-          errorCh.publish(ctx)
-        }
-
-        ctx.result = result
-        finishCh.runStores(ctx, cb, this, error, result, ...args)
-      })
-
-      try {
-        return fn.apply(this, arguments)
-      // TODO deal with promise versions when we support `dns/promises`
-      } catch (error) {
-        void error.stack // trigger getting the stack at the original throwing point
-        ctx.error = error
-        errorCh.publish(ctx)
-
-        throw error
-      }
-    })
+    return { args: captured }
   }
-
-  return wrapped
 }

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

@@ -129,7 +129,7 @@ function wrapValidate (validate) {
       try {
         errors = validate.apply(this, arguments)
         if (errors && errors[0]) {
-          ctx.error = errors && errors[0]
+          ctx.error = errors[0]
           validateErrorCh.publish(ctx)
         }
         return errors

package/packages/datadog-instrumentations/src/helpers/callback-instrumentor.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const shimmer = require('../../../datadog-shimmer')
+const { channel } = require('./instrument')
+
+/**
+ * Create a shimmer-compatible instrumentor for callback-style APIs whose work is offloaded to the
+ * libuv worker thread pool (e.g. zlib.gzip, crypto.pbkdf2, dns.lookup). Builds a set of three
+ * diagnostic channels at the given prefix (`<prefix>:start`, `:finish`, `:error`) and returns a
+ * factory that produces shimmer wrappers driven by a caller-supplied `buildContext` function.
+ *
+ * The returned wrapper:
+ *  - calls through unmodified when there are no subscribers or the last argument is not a callback;
+ *  - invokes `buildContext(thisArg, args)` to construct the context object; a return of `undefined`
+ *    also causes a bypass, letting callers enforce additional guards (e.g. minimum argument count);
+ *  - publishes `:start` via `runStores`, wraps the callback to publish `:error` (on truthy error),
+ *    optionally set `ctx.result` to the callback's first non-error argument, and publish `:finish`
+ *    via `runStores`; publishes `:error` if the original call throws synchronously.
+ *
+ * @param {string} prefix
+ * @param {object} [options]
+ * @param {boolean} [options.captureResult=false] set `ctx.result` to the callback's first
+ *   non-error argument before publishing `:finish`. Plugins that tag spans from the call's
+ *   return value (e.g. the DNS lookup plugin) rely on this.
+ * @returns {(buildContext: (thisArg: unknown, args: IArguments) => object | undefined) =>
+ *   (fn: Function) => Function}
+ */
+function createCallbackInstrumentor (prefix, { captureResult = false } = {}) {
+  const startCh = channel(prefix + ':start')
+  const finishCh = channel(prefix + ':finish')
+  const errorCh = channel(prefix + ':error')
+
+  return function instrument (buildContext) {
+    return function wrap (fn) {
+      return function () {
+        const lastIndex = arguments.length - 1
+        const cb = arguments[lastIndex]
+        if (!startCh.hasSubscribers || typeof cb !== 'function') {
+          return fn.apply(this, arguments)
+        }
+
+        const ctx = buildContext(this, arguments)
+        if (ctx === undefined) {
+          return fn.apply(this, arguments)
+        }
+
+        return startCh.runStores(ctx, () => {
+          arguments[lastIndex] = shimmer.wrapFunction(cb, cb => function (error, ...rest) {
+            if (error) {
+              ctx.error = error
+              errorCh.publish(ctx)
+            }
+            if (captureResult) {
+              ctx.result = rest[0]
+            }
+            return finishCh.runStores(ctx, cb, this, error, ...rest)
+          })
+
+          try {
+            return fn.apply(this, arguments)
+          } catch (error) {
+            void error.stack // trigger getting the stack at the original throwing point
+            ctx.error = error
+            errorCh.publish(ctx)
+
+            throw error
+          }
+        })
+      }
+    }
+  }
+}
+
+module.exports = { createCallbackInstrumentor }

package/packages/datadog-instrumentations/src/helpers/check-require-cache.js

@@ -97,7 +97,10 @@ module.exports.checkForPotentialConflicts = function () {
 }
 
 module.exports.flushStartupLogs = function (log) {
+  // Some callers pass `./log/writer` (simple pass-through) while others pass the main `./log`
+  // module (which supports lazy delegate functions). Invoke closures here so both work.
   while (warnings.length) {
-    log.warn(warnings.shift())
+    const entry = warnings.shift()
+    log.warn(typeof entry === 'function' ? entry() : entry)
   }
 }

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

@@ -12,11 +12,13 @@ module.exports = {
   net: () => require('../net'),
   url: () => require('../url'),
   vm: () => require('../vm'),
+  zlib: () => require('../zlib'),
   // Non Node.js modules
   '@anthropic-ai/sdk': { esmFirst: true, fn: () => require('../anthropic') },
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
   '@langchain/langgraph': { esmFirst: true, fn: () => require('../langgraph') },
+  '@modelcontextprotocol/sdk': () => require('../modelcontextprotocol-sdk'),
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@azure/event-hubs': () => require('../azure-event-hubs'),

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

@@ -1,5 +1,13 @@
 'use strict'
 
+/**
+ * This file is meant to be only thin wrappers over core
+ * parsing/traversing/generating functionality with the goal to eventually move
+ * them out of the project. No other code should be added to this file such as
+ * helpers etc, and the API should be kept exactly as an external API would be
+ * expected to be.
+ */
+
 const log = require('../../../../dd-trace/src/log')
 
 // eslint-disable-next-line camelcase, no-undef
@@ -24,14 +32,13 @@ const compiler = {
     } catch (e) {
       log.error(e)
 
-      // Fallback for when OXC is not available.
       const meriyah = require('../../../../../vendor/dist/meriyah')
 
-      compiler.parse = (sourceText, { range, sourceType } = {}) => {
+      compiler.parse = (sourceText, { range, isModule } = {}) => {
         return meriyah.parse(sourceText.toString(), {
           loc: range,
           ranges: range,
-          module: sourceType === 'module',
+          module: isModule,
         })
       }
     }

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

@@ -5,4 +5,5 @@ module.exports = [
   ...require('./bullmq'),
   ...require('./langchain'),
   ...require('./langgraph'),
+  ...require('./modelcontextprotocol-sdk'),
 ]

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

@@ -0,0 +1,59 @@
+'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.
+
+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',
+  },
+]

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

@@ -14,11 +14,13 @@ const transforms = module.exports = {
     if (node.body.some(tracingChannelPredicate)) return
 
     const index = node.body.findIndex(child => child.directive === 'use strict')
-    const code = sourceType === 'module'
+    const code = isModuleSourceType(sourceType)
       ? `import { tracingChannel as tr_ch_apm_tracingChannel } from "${dcModule}"`
       : `const {tracingChannel: tr_ch_apm_tracingChannel} = require("${dcModule}")`
 
-    node.body.splice(index + 1, 0, parse(code, { sourceType }).body[0])
+    node.body.splice(index + 1, 0, parse(code, {
+      isModule: isModuleSourceType(sourceType),
+    }).body[0])
   },
 
   tracingChannelDeclaration (state, node) {
@@ -51,6 +53,13 @@ function traceAny (state, node, _parent, ancestry) {
   }
 }
 
+/**
+ * @param {string} sourceType
+ */
+function isModuleSourceType (sourceType) {
+  return sourceType === 'module' || sourceType === 'esm'
+}
+
 function traceFunction (state, node, program) {
   transforms.tracingChannelDeclaration(state, program)