dd-trace 5.96.0 → 5.97.0

package/index.d.ts

@@ -130,6 +130,11 @@ interface Tracer extends opentracing.Tracer {
 
   appsec: tracer.Appsec;
 
+  /**
+   * Profiling API for attaching custom labels to profiler samples.
+   */
+  profiling: tracer.Profiling;
+
   TracerProvider: tracer.opentelemetry.TracerProvider;
 
   dogstatsd: tracer.DogStatsD;
@@ -1570,6 +1575,35 @@ declare namespace tracer {
     trackUserLoginFailure(login: string, metadata?: any): void;
   }
 
+  export interface Profiling {
+    /**
+     * Declares the set of custom label keys that will be used with
+     * {@link runWithLabels}. This is used for profile upload metadata
+     * (so the Datadog UI knows which keys to index for filtering) and
+     * for pprof serialization optimization.
+     *
+     * @param keys Custom label key names.
+     */
+    setCustomLabelKeys(keys: Iterable<string>): void;
+
+    /**
+     * Runs a function with custom profiling labels attached to all wall profiler
+     * samples taken during its execution. Labels are key-value pairs that appear
+     * in the pprof output and can be used to filter flame graphs in the Datadog UI.
+     *
+     * Requires AsyncContextFrame (ACF) to be enabled. Supports nesting: inner
+     * calls merge labels with outer calls, with inner values taking precedence.
+     *
+     * When profiling is not enabled or ACF is not active, the function is still
+     * called but labels are silently dropped.
+     *
+     * @param labels Custom labels to attach to profiler samples.
+     * @param fn Function to execute with the labels.
+     * @returns The return value of fn.
+     */
+    runWithLabels<T>(labels: Record<string, string | number>, fn: () => T): T;
+  }
+
   export interface Appsec {
     /**
      * Links a successful login event to the current trace. Will link the passed user to the current trace with Appsec.setUser() internally.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.96.0",
+  "version": "5.97.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -11,6 +11,8 @@
     "bench": "node benchmark/index.js",
     "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",
+    "verify:config:types": "node scripts/generate-config-types.js --check",
     "type:check": "tsc --noEmit -p tsconfig.dev.json",
     "type:doc:build": "cd docs && yarn && yarn build",
     "type:doc:test": "cd docs && yarn && yarn test",
@@ -142,7 +144,7 @@
     "import-in-the-middle": "^3.0.1"
   },
   "optionalDependencies": {
-    "@datadog/libdatadog": "0.9.2",
+    "@datadog/libdatadog": "0.9.3",
     "@datadog/native-appsec": "11.0.1",
     "@datadog/native-iast-taint-tracking": "4.1.0",
     "@datadog/native-metrics": "3.1.1",
@@ -166,19 +168,19 @@
     "@types/mocha": "^10.0.10",
     "@types/node": "^18.19.106",
     "@types/sinon": "^21.0.0",
-    "axios": "^1.13.4",
+    "axios": "^1.15.0",
     "benchmark": "^2.1.4",
     "body-parser": "^2.2.2",
     "bun": "1.3.11",
     "codeowners-audit": "^2.9.0",
     "eslint": "^9.39.2",
-    "eslint-plugin-cypress": "^6.2.1",
+    "eslint-plugin-cypress": "^6.2.2",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^62.8.1",
+    "eslint-plugin-jsdoc": "^62.9.0",
     "eslint-plugin-mocha": "^11.2.0",
     "eslint-plugin-n": "^17.23.2",
     "eslint-plugin-promise": "^7.2.1",
-    "eslint-plugin-unicorn": "^63.0.0",
+    "eslint-plugin-unicorn": "^64.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",
     "globals": "^17.2.0",
@@ -200,7 +202,7 @@
     "semver": "^7.7.2",
     "sinon": "^21.0.3",
     "tiktoken": "^1.0.21",
-    "typescript": "^5.9.2",
+    "typescript": "^6.0.2",
     "workerpool": "^10.0.0",
     "yaml": "^2.8.3",
     "yarn-deduplicate": "^6.0.2"

package/packages/datadog-esbuild/index.js

@@ -2,7 +2,6 @@
 
 const { execSync } = require('node:child_process')
 const fs = require('node:fs')
-const RAW_BUILTINS = require('node:module').builtinModules
 const path = require('node:path')
 const { pathToFileURL, fileURLToPath } = require('node:url')
 
@@ -25,15 +24,27 @@ for (const hook of Object.values(hooks)) {
   }
 }
 
+function moduleOfInterestKey (name, file) {
+  return file ? `${name}/${file}` : name
+}
+
+const builtinModules = new Set(require('module').builtinModules)
+
+function addModuleOfInterest (name, file) {
+  if (!name) return
+
+  modulesOfInterest.add(moduleOfInterestKey(name, file))
+
+  if (builtinModules.has(name)) {
+    modulesOfInterest.add(moduleOfInterestKey(`node:${name}`, file))
+  }
+}
+
 const modulesOfInterest = new Set()
 
-for (const instrumentation of Object.values(instrumentations)) {
+for (const [name, instrumentation] of Object.entries(instrumentations)) {
   for (const entry of instrumentation) {
-    if (entry.file) {
-      modulesOfInterest.add(`${entry.name}/${entry.file}`) // e.g. "redis/my/file.js"
-    } else {
-      modulesOfInterest.add(entry.name) // e.g. "redis"
-    }
+    addModuleOfInterest(name, entry.file)
   }
 }
 
@@ -41,7 +52,7 @@ const CHANNEL = 'dd-trace:bundler:load'
 
 const builtins = new Set()
 
-for (const builtin of RAW_BUILTINS) {
+for (const builtin of builtinModules) {
   builtins.add(builtin)
   builtins.add(`node:${builtin}`)
 }
@@ -247,7 +258,7 @@ ${build.initialOptions.banner.js}`
       }
 
       try {
-        const packageJson = JSON.parse(fs.readFileSync(/** @type {string} */ (pathToPackageJson)).toString())
+        const packageJson = JSON.parse(fs.readFileSync(/** @type {string} */(pathToPackageJson)).toString())
 
         const isESM = isESMFile(fullPathToModule, pathToPackageJson, packageJson)
         if (isESM && !interceptedESMModules.has(fullPathToModule)) {

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

@@ -14,11 +14,6 @@ const childProcessChannel = dc.tracingChannel('datadog:child_process:execution')
 // ignored exec method because it calls to execFile directly
 const execAsyncMethods = ['execFile', 'spawn', 'fork']
 
-const names = ['child_process', 'node:child_process']
-
-// child_process and node:child_process returns the same object instance, we only want to add hooks once
-let patched = false
-
 function throwSyncError (error) {
   throw error
 }
@@ -37,19 +32,14 @@ function returnSpawnSyncError (error, context) {
   return context.result
 }
 
-for (const name of names) {
-  addHook({ name }, childProcess => {
-    if (!patched) {
-      patched = true
-      shimmer.massWrap(childProcess, execAsyncMethods, wrapChildProcessAsyncMethod(childProcess.ChildProcess))
-      shimmer.wrap(childProcess, 'execSync', wrapChildProcessSyncMethod(throwSyncError, true))
-      shimmer.wrap(childProcess, 'execFileSync', wrapChildProcessSyncMethod(throwSyncError))
-      shimmer.wrap(childProcess, 'spawnSync', wrapChildProcessSyncMethod(returnSpawnSyncError))
-    }
+addHook({ name: 'child_process' }, childProcess => {
+  shimmer.massWrap(childProcess, execAsyncMethods, wrapChildProcessAsyncMethod(childProcess.ChildProcess))
+  shimmer.wrap(childProcess, 'execSync', wrapChildProcessSyncMethod(throwSyncError, true))
+  shimmer.wrap(childProcess, 'execFileSync', wrapChildProcessSyncMethod(throwSyncError))
+  shimmer.wrap(childProcess, 'spawnSync', wrapChildProcessSyncMethod(returnSpawnSyncError))
 
-    return childProcess
-  })
-}
+  return childProcess
+})
 
 function normalizeArgs (args, shell) {
   const childProcessInfo = {

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

@@ -11,9 +11,8 @@ const cryptoCipherCh = channel('datadog:crypto:cipher:start')
 
 const hashMethods = ['createHash', 'createHmac', 'createSign', 'createVerify', 'sign', 'verify']
 const cipherMethods = ['createCipheriv', 'createDecipheriv']
-const names = ['crypto', 'node:crypto']
 
-addHook({ name: names }, crypto => {
+addHook({ name: 'crypto' }, crypto => {
   shimmer.massWrap(crypto, hashMethods, wrapCryptoMethod(cryptoHashCh))
   shimmer.massWrap(crypto, cipherMethods, wrapCryptoMethod(cryptoCipherCh))
   return crypto

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

@@ -61,6 +61,8 @@ const numRetriesByPickleId = new Map()
 const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
 const modifiedTestsByPickleId = new Map()
+// Pickle IDs for tests that are genuinely new (not in known tests list).
+const newTestPickleIds = new Set()
 
 let eventDataCollector = null
 let pickleByFile = {}
@@ -359,7 +361,7 @@ function wrapRun (pl, isLatestVersion, version) {
         }
 
         if (isKnownTestsEnabled && status !== 'skip') {
-          isNew = numRetries !== undefined
+          isNew = newTestPickleIds.has(this.pickle.id)
         }
 
         if (isNew || isModified) {
@@ -714,6 +716,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     if (isKnownTestsEnabled && !isAttemptToFix) {
       isNew = isNewTest(testSuitePath, pickle.name)
       if (isNew) {
+        newTestPickleIds.add(pickle.id)
         numRetriesByPickleId.set(pickle.id, 0)
       }
     }

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

@@ -0,0 +1,324 @@
+'use strict'
+
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { pathToFileURL } = require('url')
+
+const DD_CONFIG_WRAPPED = Symbol('dd-trace.cypress.config.wrapped')
+
+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. Handles chaining with user-registered handlers
+ * for after:spec/after:run so both the user's code and dd-trace's run in sequence.
+ *
+ * @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 tracer = global._ddtrace
+
+  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 (!tracer || !tracer._initialized) {
+    registerNoopHandlers()
+    return config
+  }
+
+  const NoopTracer = require('../../../packages/dd-trace/src/noop/tracer')
+
+  if (tracer._tracer instanceof NoopTracer) {
+    registerNoopHandlers()
+    return config
+  }
+
+  const cypressPlugin = require('../../../packages/datadog-plugin-cypress/src/cypress-plugin')
+
+  if (cypressPlugin._isInit) {
+    for (const h of userAfterSpecHandlers) on('after:spec', h)
+    registerAfterRunWithCleanup()
+    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)
+}
+
+/**
+ * @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))