dd-trace 5.96.0 → 5.98.0

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

@@ -0,0 +1,318 @@
+'use strict'
+
+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': () => ({}),
+  'dd:afterEach': () => null,
+  'dd:addTags': () => null,
+  'dd:log': () => null,
+}
+
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isPlainObject (value) {
+  if (!value || typeof value !== 'object') return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
+/**
+ * Cypress allows setupNodeEvents to return partial config fragments that it
+ * diffs and merges into the resolved config. Preserve that behavior here so
+ * the wrapper does not drop user-provided config updates.
+ *
+ * @param {object} config Cypress resolved config object
+ * @param {unknown} updatedConfig value returned from setupNodeEvents
+ * @returns {object} resolved config with returned overrides applied
+ */
+function mergeReturnedConfig (config, updatedConfig) {
+  if (!isPlainObject(updatedConfig) || updatedConfig === config) {
+    return config
+  }
+
+  const mergedConfig = { ...config }
+
+  for (const [key, value] of Object.entries(updatedConfig)) {
+    mergedConfig[key] = isPlainObject(value) && isPlainObject(mergedConfig[key])
+      ? mergeReturnedConfig(mergedConfig[key], value)
+      : value
+  }
+
+  return mergedConfig
+}
+
+/**
+ * Creates a temporary wrapper support file under os.tmpdir() that loads
+ * dd-trace's browser-side hooks before the user's original support file.
+ * Returns the wrapper path (for cleanup) or undefined if injection was skipped.
+ *
+ * @param {object} config Cypress resolved config object
+ * @returns {string|undefined} wrapper file path, or undefined if skipped
+ */
+function injectSupportFile (config) {
+  const originalSupportFile = config.supportFile
+  if (!originalSupportFile || originalSupportFile === false) return
+
+  try {
+    const content = fs.readFileSync(originalSupportFile, 'utf8')
+    // Naive check: skip lines starting with // or * to avoid matching commented-out imports.
+    const hasActiveDdTraceImport = content.split('\n').some(line => {
+      const trimmed = line.trim()
+      return trimmed.includes('dd-trace/ci/cypress/support') &&
+        !trimmed.startsWith('//') && !trimmed.startsWith('*')
+    })
+    if (hasActiveDdTraceImport) return
+  } catch {
+    return
+  }
+
+  const ddSupportFile = require.resolve('../../../ci/cypress/support')
+  const wrapperFile = path.join(os.tmpdir(), `dd-cypress-support-${process.pid}.mjs`)
+
+  // Always use ESM: it can import both CJS and ESM support files.
+  const wrapperContent =
+    `import ${JSON.stringify(ddSupportFile)}\nimport ${JSON.stringify(originalSupportFile)}\n`
+
+  try {
+    fs.writeFileSync(wrapperFile, wrapperContent)
+    config.supportFile = wrapperFile
+    return wrapperFile
+  } catch {
+    // Can't write wrapper - skip injection
+  }
+}
+
+/**
+ * Registers dd-trace's Cypress hooks (before:run, after:spec, after:run, tasks)
+ * 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
+ * @param {Function[]} userAfterSpecHandlers user's after:spec handlers collected from wrappedOn
+ * @param {Function[]} userAfterRunHandlers user's after:run handlers collected from wrappedOn
+ * @returns {object} the config object (possibly modified)
+ */
+function registerDdTraceHooks (on, config, userAfterSpecHandlers, userAfterRunHandlers) {
+  const wrapperFile = injectSupportFile(config)
+
+  const cleanupWrapper = () => {
+    if (wrapperFile) {
+      try { fs.unlinkSync(wrapperFile) } catch { /* best effort */ }
+    }
+  }
+
+  const registerAfterRunWithCleanup = () => {
+    on('after:run', (results) => {
+      const chain = userAfterRunHandlers.reduce(
+        (p, h) => p.then(() => h(results)),
+        Promise.resolve()
+      )
+      return chain.finally(cleanupWrapper)
+    })
+  }
+
+  const registerNoopHandlers = () => {
+    for (const h of userAfterSpecHandlers) on('after:spec', h)
+    registerAfterRunWithCleanup()
+    on('task', noopTask)
+  }
+
+  if (!setupNodeEventsCh.hasSubscribers) {
+    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,
+  }
+
+  setupNodeEventsCh.publish(payload)
+
+  if (!payload.registered) {
+    registerNoopHandlers()
+    return config
+  }
+
+  return payload.configPromise || config
+}
+
+/**
+ * @param {Function|undefined} originalSetupNodeEvents
+ * @returns {Function}
+ */
+function wrapSetupNodeEvents (originalSetupNodeEvents) {
+  return function ddSetupNodeEvents (on, config) {
+    const userAfterSpecHandlers = []
+    const userAfterRunHandlers = []
+
+    const wrappedOn = (event, handler) => {
+      if (event === 'after:spec') {
+        userAfterSpecHandlers.push(handler)
+      } else if (event === 'after:run') {
+        userAfterRunHandlers.push(handler)
+      } else {
+        on(event, handler)
+      }
+    }
+
+    const maybePromise = originalSetupNodeEvents
+      ? originalSetupNodeEvents.call(this, wrappedOn, config)
+      : undefined
+
+    if (maybePromise && typeof maybePromise.then === 'function') {
+      return maybePromise.then((result) => {
+        return registerDdTraceHooks(
+          on,
+          mergeReturnedConfig(config, result),
+          userAfterSpecHandlers,
+          userAfterRunHandlers
+        )
+      })
+    }
+
+    return registerDdTraceHooks(
+      on,
+      mergeReturnedConfig(config, maybePromise),
+      userAfterSpecHandlers,
+      userAfterRunHandlers
+    )
+  }
+}
+
+/**
+ * @param {object} config
+ * @returns {object}
+ */
+function wrapConfig (config) {
+  if (!config || config[DD_CONFIG_WRAPPED]) return config
+  config[DD_CONFIG_WRAPPED] = true
+
+  if (config.e2e) {
+    config.e2e.setupNodeEvents = wrapSetupNodeEvents(config.e2e.setupNodeEvents)
+  }
+  if (config.component) {
+    config.component.setupNodeEvents = wrapSetupNodeEvents(config.component.setupNodeEvents)
+  }
+
+  return config
+}
+
+/**
+ * @param {string} originalConfigFile absolute path to the original config file
+ * @returns {string} path to the generated wrapper file
+ */
+function createConfigWrapper (originalConfigFile) {
+  const wrapperFile = path.join(
+    path.dirname(originalConfigFile),
+    `.dd-cypress-config-${process.pid}.mjs`
+  )
+
+  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'))
+
+  return wrapperFile
+}
+
+/**
+ * Wraps the Cypress config file for a CLI start() call. When an explicit
+ * configFile is provided, creates a temp wrapper that imports the original
+ * and passes it through wrapConfig. This handles ESM configs (.mjs) and
+ * plain-object configs (without defineConfig) that can't be intercepted
+ * via the defineConfig shimmer.
+ *
+ * @param {object|undefined} options
+ * @returns {{ options: object|undefined, cleanup: Function }}
+ */
+function wrapCliConfigFileOptions (options) {
+  const noop = { options, cleanup: () => {} }
+
+  if (!options) return noop
+
+  const projectRoot = typeof options.project === 'string' ? options.project : process.cwd()
+  let configFilePath
+
+  if (options.configFile === false) {
+    // configFile: false means "no config file" — respect Cypress's semantics
+    return noop
+  } else if (typeof options.configFile === 'string') {
+    configFilePath = path.isAbsolute(options.configFile)
+      ? options.configFile
+      : path.resolve(projectRoot, options.configFile)
+  } else {
+    // No explicit --config-file: resolve the default cypress.config.{js,ts,cjs,mjs}
+    for (const ext of ['.js', '.ts', '.cjs', '.mjs']) {
+      const candidate = path.join(projectRoot, `cypress.config${ext}`)
+      if (fs.existsSync(candidate)) {
+        configFilePath = candidate
+        break
+      }
+    }
+  }
+
+  // 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
+
+  try {
+    const wrapperFile = createConfigWrapper(configFilePath)
+
+    return {
+      options: { ...options, configFile: wrapperFile },
+      cleanup: () => {
+        try { fs.unlinkSync(wrapperFile) } catch { /* best effort */ }
+      },
+    }
+  } catch {
+    // Config directory may be read-only — fall back to no wrapping.
+    // The defineConfig shimmer will still handle configs that use defineConfig.
+    return noop
+  }
+}
+
+module.exports = {
+  wrapCliConfigFileOptions,
+  wrapConfig,
+}

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

@@ -1,11 +1,93 @@
 'use strict'
 
+const shimmer = require('../../datadog-shimmer')
 const { DD_MAJOR } = require('../../../version')
 const { addHook } = require('./helpers/instrument')
+const {
+  wrapCliConfigFileOptions,
+  wrapConfig,
+} = require('./cypress-config')
 
-// No handler because this is only useful for testing.
-// Cypress plugin does not patch any library.
+// Wrap defineConfig() so configs are instrumented when loaded in Cypress's
+// config child process. This covers both CLI and programmatic usage with CJS configs.
 addHook({
   name: 'cypress',
-  versions: DD_MAJOR >= 6 ? ['>=10.2.0'] : ['>=6.7.0'],
-}, lib => lib)
+  versions: ['>=10.2.0'],
+}, (cypress) => {
+  if (typeof cypress.defineConfig === 'function') {
+    shimmer.wrap(cypress, 'defineConfig', (defineConfig) => function (config) {
+      wrapConfig(config)
+      return defineConfig(config)
+    })
+  }
+  return cypress
+})
+
+// Wrap the CLI entry points (cypress run / cypress open) to handle config files
+// that can't be intercepted via the defineConfig shimmer: ESM configs (.mjs)
+// and plain-object configs (without defineConfig).
+function getCliStartWrapper (start) {
+  return function ddTraceCliStart (options) {
+    const { options: wrappedOptions, cleanup } = wrapCliConfigFileOptions(options)
+    const result = start.call(this, wrappedOptions)
+
+    if (result && typeof result.then === 'function') {
+      return result.finally(cleanup)
+    }
+
+    cleanup()
+    return result
+  }
+}
+
+/**
+ * Wraps `start` on an object (or its `.default`) if present.
+ *
+ * @param {object} mod module exports
+ * @returns {object} mod
+ */
+function wrapStartOnModule (mod) {
+  const target = mod.default || mod
+  if (typeof target.start === 'function') {
+    shimmer.wrap(target, 'start', getCliStartWrapper)
+  }
+  return mod
+}
+
+// Hook the CLI entry points where Cypress resolves and executes `run`/`open`.
+// Cypress 10-14: lib/exec/{run,open}.js as separate files.
+// Cypress 15-15.10: dist/exec/{run,open}.js as separate files.
+// Cypress >=15.11: bundled into dist/cli-<hash>.js exporting runModule/openModule.
+for (const file of ['lib/exec/run.js', 'lib/exec/open.js', 'dist/exec/run.js', 'dist/exec/open.js']) {
+  addHook({
+    name: 'cypress',
+    versions: ['>=10.2.0'],
+    file,
+  }, wrapStartOnModule)
+}
+
+// Cypress >=15.11 bundles run/open into a single CLI chunk (dist/cli-<hash>.js).
+// The chunk exports runModule and openModule, each with a start() method.
+addHook({
+  name: 'cypress',
+  versions: ['>=10.2.0'],
+  filePattern: 'dist/cli.*',
+}, (cliChunk) => {
+  if (cliChunk.runModule?.start) {
+    shimmer.wrap(cliChunk.runModule, 'start', getCliStartWrapper)
+  }
+  if (cliChunk.openModule?.start) {
+    shimmer.wrap(cliChunk.openModule, 'start', getCliStartWrapper)
+  }
+  return cliChunk
+})
+
+// Cypress <10 uses the old pluginsFile approach. No auto-instrumentation;
+// users must use the manual dd-trace/ci/cypress/plugin setup.
+// This hook is kept so the plugin system registers Cypress for version tracking.
+if (DD_MAJOR < 6) {
+  addHook({
+    name: 'cypress',
+    versions: ['>=6.7.0 <10.2.0'],
+  }, lib => lib)
+}

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

@@ -18,9 +18,8 @@ const rrtypes = {
 }
 
 const rrtypeMap = new WeakMap()
-const names = ['dns', 'node:dns']
 
-addHook({ name: names }, dns => {
+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))

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

@@ -146,7 +146,7 @@ function wrapAppUse (use) {
   }
 }
 
-addHook({ name: 'express', versions: ['>=4'], file: ['lib/express.js'] }, express => {
+addHook({ name: 'express', versions: ['>=4'], file: 'lib/express.js' }, express => {
   shimmer.wrap(express.application, 'handle', wrapHandle)
   shimmer.wrap(express.application, 'all', wrapAppAll)
   shimmer.wrap(express.application, 'route', wrapAppRoute)
@@ -224,19 +224,19 @@ function wrapProcessParamsMethod (requestPositionInArguments) {
   }
 }
 
-addHook({ name: 'express', versions: ['>=4.0.0 <4.3.0'], file: ['lib/express.js'] }, express => {
+addHook({ name: 'express', versions: ['>=4.0.0 <4.3.0'], file: 'lib/express.js' }, express => {
   shimmer.wrap(express.Router, 'process_params', wrapProcessParamsMethod(1))
   return express
 })
 
-addHook({ name: 'express', versions: ['>=4.3.0 <5.0.0'], file: ['lib/express.js'] }, express => {
+addHook({ name: 'express', versions: ['>=4.3.0 <5.0.0'], file: 'lib/express.js' }, express => {
   shimmer.wrap(express.Router, 'process_params', wrapProcessParamsMethod(2))
   return express
 })
 
 const queryReadCh = channel('datadog:express:query:finish')
 
-addHook({ name: 'express', file: ['lib/request.js'], versions: ['>=5.0.0'] }, request => {
+addHook({ name: 'express', file: 'lib/request.js', versions: ['>=5.0.0'] }, request => {
   shimmer.wrap(request, 'query', function (originalGet) {
     return function wrappedGet () {
       const query = originalGet.call(this)

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

@@ -84,37 +84,35 @@ const paramsByFileHandleMethods = {
   writeFile: ['data', 'options'],
   writev: ['buffers', 'position'],
 }
-const names = ['fs', 'node:fs']
-for (const name of names) {
-  addHook({ name }, fs => {
-    const asyncMethods = Object.keys(paramsByMethod)
-    const syncMethods = asyncMethods.map(name => `${name}Sync`)
-
-    massWrap(fs, asyncMethods, createWrapFunction())
-    massWrap(fs, syncMethods, createWrapFunction())
-    massWrap(fs.promises, asyncMethods, createWrapFunction('promises.'))
-
-    wrap(fs.realpath, 'native', createWrapFunction('', 'realpath.native'))
-    wrap(fs.realpathSync, 'native', createWrapFunction('', 'realpath.native'))
-    wrap(fs.promises.realpath, 'native', createWrapFunction('', 'realpath.native'))
-
-    wrap(fs, 'createReadStream', wrapCreateStream)
-    wrap(fs, 'createWriteStream', wrapCreateStream)
-    if (fs.Dir) {
-      wrap(fs.Dir.prototype, 'close', createWrapFunction('dir.'))
-      wrap(fs.Dir.prototype, 'closeSync', createWrapFunction('dir.'))
-      wrap(fs.Dir.prototype, 'read', createWrapFunction('dir.'))
-      wrap(fs.Dir.prototype, 'readSync', createWrapFunction('dir.'))
-      wrap(fs.Dir.prototype, Symbol.asyncIterator, createWrapDirAsyncIterator())
-    }
+addHook({ name: 'fs' }, fs => {
+  const asyncMethods = Object.keys(paramsByMethod)
+  const syncMethods = asyncMethods.map(name => `${name}Sync`)
+
+  massWrap(fs, asyncMethods, createWrapFunction())
+  massWrap(fs, syncMethods, createWrapFunction())
+  massWrap(fs.promises, asyncMethods, createWrapFunction('promises.'))
+
+  wrap(fs.realpath, 'native', createWrapFunction('', 'realpath.native'))
+  wrap(fs.realpathSync, 'native', createWrapFunction('', 'realpath.native'))
+  wrap(fs.promises.realpath, 'native', createWrapFunction('', 'realpath.native'))
+
+  wrap(fs, 'createReadStream', wrapCreateStream)
+  wrap(fs, 'createWriteStream', wrapCreateStream)
+  if (fs.Dir) {
+    wrap(fs.Dir.prototype, 'close', createWrapFunction('dir.'))
+    wrap(fs.Dir.prototype, 'closeSync', createWrapFunction('dir.'))
+    wrap(fs.Dir.prototype, 'read', createWrapFunction('dir.'))
+    wrap(fs.Dir.prototype, 'readSync', createWrapFunction('dir.'))
+    wrap(fs.Dir.prototype, Symbol.asyncIterator, createWrapDirAsyncIterator())
+  }
 
-    wrap(fs, 'unwatchFile', createWatchWrapFunction())
-    wrap(fs, 'watch', createWatchWrapFunction())
-    wrap(fs, 'watchFile', createWatchWrapFunction())
+  wrap(fs, 'unwatchFile', createWatchWrapFunction())
+  wrap(fs, 'watch', createWatchWrapFunction())
+  wrap(fs, 'watchFile', createWatchWrapFunction())
+
+  return fs
+})
 
-    return fs
-  })
-}
 function isFirstMethodReturningFileHandle (original) {
   return !kHandle && original.name === 'open'
 }

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

@@ -171,7 +171,7 @@ function wrapExecute (execute) {
         args,
         docSource: documentSources.get(document),
         source,
-        fields: {},
+        fields: Object.create(null),
         abortController: new AbortController(),
       }
 

package/packages/datadog-instrumentations/src/helpers/bundler-register.js

@@ -45,45 +45,73 @@ if (!dc.unsubscribe) {
   dc.unsubscribe = (channel, cb) => {
     if (dc.channel(channel).hasSubscribers) {
       dc.channel(channel).unsubscribe(cb)
+      return true
     }
+    return false
   }
 }
 
-function doHook (payload) {
-  const hook = hooks[payload.package]
+/**
+ * @param {string} name
+ */
+function doHook (name) {
+  const hook = hooks[name] ?? hooks[`node:${name}`]
   if (!hook) {
-    log.error('esbuild-wrapped %s missing in list of hooks', payload.package)
+    log.error('esbuild-wrapped %s missing in list of hooks', name)
     return
   }
 
   const hookFn = hook.fn ?? hook
   if (typeof hookFn !== 'function') {
-    log.error('esbuild-wrapped hook %s is not a function', payload.package)
+    log.error('esbuild-wrapped hook %s is not a function', name)
     return
   }
 
   try {
     hookFn()
   } catch {
-    log.error('esbuild-wrapped %s hook failed', payload.package)
+    log.error('esbuild-wrapped %s hook failed', name)
   }
 }
 
-dc.subscribe(CHANNEL, (payload) => {
-  doHook(payload)
+/** @type {Set<string>} */
+const instrumentedNodeModules = new Set()
 
-  if (!instrumentations[payload.package]) {
-    log.error('esbuild-wrapped %s missing in list of instrumentations', payload.package)
+/** @typedef {{ package: string, module: unknown, version: string, path: string }} Payload */
+dc.subscribe(CHANNEL, (message) => {
+  const payload = /** @type {Payload} */ (message)
+  const name = payload.package
+
+  const isPrefixedWithNode = name.startsWith('node:')
+
+  const isNodeModule = isPrefixedWithNode || !hooks[name]
+
+  if (isNodeModule) {
+    const nodeName = isPrefixedWithNode ? name.slice(5) : name
+    // Used for node: prefixed modules to prevent double instrumentation.
+    if (instrumentedNodeModules.has(nodeName)) {
+      return
+    }
+    instrumentedNodeModules.add(nodeName)
+  }
+
+  doHook(name)
+
+  const instrumentation = instrumentations[name] ?? instrumentations[`node:${name}`]
+
+  if (!instrumentation) {
+    log.error('esbuild-wrapped %s missing in list of instrumentations', name)
     return
   }
 
-  for (const { name, file, versions, hook } of instrumentations[payload.package]) {
-    if (payload.path !== filename(name, file)) continue
-    if (!matchVersion(payload.version, versions)) continue
+  for (const { file, versions, hook } of instrumentation) {
+    if (payload.path !== filename(name, file) || !matchVersion(payload.version, versions)) {
+      continue
+    }
 
     try {
       loadChannel.publish({ name, version: payload.version, file })
-      payload.module = hook(payload.module, payload.version)
+      payload.module = hook(payload.module, payload.version) ?? payload.module
     } catch (e) {
       log.error('Error executing bundler hook', e)
     }