dd-trace 6.14.0 → 6.16.0

package/README.md

@@ -93,6 +93,21 @@ Regardless of where you open the issue, someone at Datadog will try to help.
 
 If you would like to trace your bundled application then please read this page on [bundling and dd-trace](https://docs.datadoghq.com/tracing/trace_collection/automatic_instrumentation/dd_libraries/nodejs/#bundling). It includes information on how to use our ESBuild plugin and includes caveats for other bundlers.
 
+Next.js 15.5 or newer applications that use Turbopack can wrap their existing configuration:
+
+```javascript
+const { withDatadogTurbopack } = require('dd-trace/next')
+
+const nextConfig = { reactStrictMode: true }
+
+module.exports = withDatadogTurbopack(nextConfig)
+```
+
+Preload `dd-trace/init` before the application loads. The wrapper instruments CommonJS dependencies and supported
+source-rewrite targets in Node.js bundles.
+
+The wrapper does not instrument client or edge bundles. It also excludes generic ESM export replacement, linked
+workspaces, Prisma clients outside `node_modules`, and Yarn Plug'n'Play packages.
 
 ## Security Vulnerabilities
 

package/ci/test-optimization-validation/framework-adapters/cucumber.js

@@ -282,7 +282,9 @@ function readProfileDefinitions (filename) {
 
 function getJavascriptProfileDefinitions (source) {
   const syntax = maskJavascriptCommentsAndStrings(source)
-  const exports = [...syntax.matchAll(/^\s*(?:module\s*\.\s*exports\s*=|export\s+default)\s*\{/gm)]
+  const exports = [...syntax.matchAll(
+    /(?:^|\S[\t\v\f\p{Zs}\uFEFF]*[\n\r\u2028\u2029])\s*(?:module\s*\.\s*exports\s*=|export\s+default)\s*\{/gu
+  )]
   if (exports.length === 0) return new Map()
   if (exports.length !== 1) throw new Error('configuration must export one literal profile object')
 
@@ -492,7 +494,7 @@ function getYamlStringProfileDefinition (source) {
   const value = source.trimStart()
   const quote = value[0]
   if (quote !== '"' && quote !== "'") {
-    const comment = /\s+#/.exec(value)
+    const comment = /[ \t]#/.exec(value)
     const definition = value.slice(0, comment?.index ?? value.length).trimEnd()
     return definition || undefined
   }

package/ci/test-optimization-validation/package-check.js

@@ -88,7 +88,10 @@ function getFailureDetail (result) {
 }
 
 function sanitizeLine (value) {
-  return sanitizeString(String(value)).replaceAll(/\p{Cc}+/gu, ' ').trim().slice(0, 1000).replace(/\.+$/, '')
+  const line = sanitizeString(String(value)).replaceAll(/\p{Cc}+/gu, ' ').trim().slice(0, 1000)
+  let end = line.length
+  while (end > 0 && line[end - 1] === '.') end--
+  return line.slice(0, end)
 }
 
 module.exports = { checkInstalledPackage, getInstalledPackageFailure }

package/ci/test-optimization-validation/scenarios/ci-wiring.js

@@ -442,7 +442,7 @@ function hasUnavailableRemoteCiCommand (ci) {
   })) return true
 
   return evidence.some(item => {
-    const reference = /^\s*uses:\s*["']?([^"'\s]+)["']?\s*$/im.exec(item)?.[1]
+    const reference = /^[ \t]*uses:[ \t]*["']?([^"'\s]+)["']?[ \t]*$/im.exec(item)?.[1]
     return reference && !reference.startsWith('./')
   })
 }

package/index.d.ts

@@ -466,6 +466,13 @@ declare namespace tracer {
      * Maximum number of traces matching this rule to sample per second.
      */
     maxPerSecond?: number
+
+    /**
+     * When `true`, a trace chunk rejected by this rule is fully dropped:
+     * it is excluded from client-side stats and never sent to the Agent.
+     * @default false
+     */
+    discard?: boolean
   }
 
   /**
@@ -650,6 +657,7 @@ declare namespace tracer {
      * Sampling rules to apply to priority sampling. Each rule matches against a trace's
      * `service`, `name`, `resource`, and `tags`, and applies the rule's `sampleRate`. Use a
      * `sampleRate` of `0` to drop matching traces (for example to filter out unwanted resources).
+     * Specify `"discard": true` to fully drop it from stats as well.
      * If not specified, will defer to global sampling rate for all spans.
      * @default []
      * @env DD_TRACE_SAMPLING_RULES
@@ -3279,6 +3287,10 @@ declare namespace tracer {
   }
 
   export namespace opentelemetry {
+    export interface MeterProvider {
+      shutdown(callback?: (error: Error | null) => void): void;
+    }
+
     /**
      * A registry for creating named {@link Tracer}s.
      */

package/next.d.ts

@@ -0,0 +1,27 @@
+import type { NextConfig } from 'next'
+
+type NextConfigValue = NextConfig | undefined
+
+export function withDatadogTurbopack<TArguments extends unknown[]> (
+  nextConfig: (...args: TArguments) => Promise<NextConfigValue>
+): (...args: TArguments) => Promise<NextConfig>
+
+export function withDatadogTurbopack<TArguments extends unknown[]> (
+  nextConfig: (...args: TArguments) => NextConfigValue
+): (...args: TArguments) => NextConfig
+
+export function withDatadogTurbopack<TArguments extends unknown[]> (
+  nextConfig: (...args: TArguments) => NextConfigValue | Promise<NextConfigValue>
+): (...args: TArguments) => NextConfig | Promise<NextConfig>
+
+export function withDatadogTurbopack (
+  nextConfig: Promise<NextConfigValue>
+): (phase?: string) => Promise<NextConfig>
+
+export function withDatadogTurbopack (
+  nextConfig?: NextConfigValue
+): (phase?: string) => NextConfig
+
+export function withDatadogTurbopack (
+  nextConfig: NextConfigValue | Promise<NextConfigValue>
+): (phase?: string) => NextConfig | Promise<NextConfig>

package/next.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./packages/datadog-turbopack')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.14.0",
+  "version": "6.16.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -22,12 +22,11 @@
     "type:check": "tsc --noEmit -p tsconfig.dev.json",
     "type:doc:build": "cd docs && yarn && yarn build",
     "type:doc:test": "cd docs && yarn && yarn test",
-    "lint": "node scripts/check_licenses.js && node scripts/check-agents-md-size.js && node scripts/check-no-coverage-artifacts.js && node scripts/check-no-mcr-images.js && node scripts/check-docker-image-shas.js && eslint . --concurrency=auto --max-warnings 0 && npm run verify:carrier-fields && npm run lint:codeowners:ci && npm run verify-exercised-tests",
+    "lint": "bash ./scripts/lint.sh",
     "lint:fix": "node scripts/check_licenses.js && node scripts/check-agents-md-size.js && node scripts/check-no-coverage-artifacts.js && node scripts/check-no-mcr-images.js && node scripts/check-docker-image-shas.js && eslint . --concurrency=auto --max-warnings 0 --fix",
     "verify:carrier-fields": "node scripts/verify-carrier-fields.mjs",
     "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/**' --glob='packages/dd-trace/src/guardrails/**'",
     "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",
@@ -47,6 +46,8 @@
     "test:trace:guardrails:ci": "node scripts/c8-ci.js test:trace:guardrails",
     "test:esbuild": "mocha \"packages/datadog-esbuild/test/**/*.spec.js\"",
     "test:esbuild:ci": "node scripts/c8-ci.js test:esbuild",
+    "test:turbopack": "mocha \"packages/datadog-turbopack/test/**/*.spec.js\"",
+    "test:turbopack:ci": "node scripts/c8-ci.js test:turbopack",
     "test:webpack": "mocha \"packages/datadog-webpack/test/**/*.spec.js\"",
     "test:webpack:ci": "node scripts/c8-ci.js test:webpack",
     "test:instrumentations": "mocha --fail-zero \"packages/datadog-instrumentations/test/@(${PLUGINS}).spec.js\"",
@@ -91,6 +92,7 @@
     "test:integration:electron": "mocha \"integration-tests/electron/*.spec.js\"",
     "test:integration:esbuild": "mocha --timeout 60000 \"integration-tests/esbuild/*.spec.js\"",
     "test:integration:esbuild:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/esbuild/*.spec.js\"",
+    "test:integration:turbopack": "mocha --timeout 60000 \"integration-tests/turbopack/*.spec.js\"",
     "test:integration:webpack": "mocha --timeout 60000 \"integration-tests/webpack/*.spec.js\"",
     "test:integration:openfeature": "mocha --timeout 60000 \"integration-tests/openfeature/*.spec.js\"",
     "test:integration:openfeature:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/openfeature/*.spec.js\"",
@@ -150,6 +152,8 @@
     "ci/**/*",
     "cypress/**/*",
     "esbuild.js",
+    "next.js",
+    "next.d.ts",
     "webpack.js",
     "ext/**/*",
     "index.d.ts",
@@ -179,12 +183,12 @@
   ],
   "dependencies": {
     "dc-polyfill": "^0.1.11",
-    "import-in-the-middle": "^3.3.2",
+    "import-in-the-middle": "3.5.1",
     "opentracing": ">=0.14.7"
   },
   "optionalDependencies": {
-    "@datadog/libdatadog": "^0.20.0",
-    "@datadog/libdatadog-extras": "^0.20.0",
+    "@datadog/libdatadog": "^0.21.0",
+    "@datadog/libdatadog-extras": "^0.21.0",
     "@datadog/native-appsec": "11.0.2",
     "@datadog/native-iast-taint-tracking": "4.2.1",
     "@datadog/native-metrics": "4.0.0",
@@ -198,9 +202,9 @@
     "@actions/core": "^3.0.1",
     "@actions/github": "^9.1.1",
     "@babel/helpers": "^8.0.0",
-    "@eslint/eslintrc": "^3.3.6",
+    "@eslint/eslintrc": "^3.3.7",
     "@eslint/js": "^10.0.1",
-    "@eslint/plugin-kit": "^0.7.2",
+    "@eslint/plugin-kit": "^0.7.3",
     "@datadog/openfeature-node-server": "2.2.0",
     "@msgpack/msgpack": "^3.1.3",
     "@openfeature/core": "^1.12.0",
@@ -220,16 +224,16 @@
     "eslint": "^10.9.1",
     "eslint-plugin-cypress": "^7.0.1",
     "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-jsdoc": "^64.2.1",
+    "eslint-plugin-jsdoc": "^64.3.5",
     "eslint-plugin-mocha": "^12.0.2",
     "eslint-plugin-n": "^18.3.0",
     "eslint-plugin-promise": "^7.3.0",
-    "eslint-plugin-regexp": "^3.1.0",
+    "eslint-plugin-regexp": "^3.2.0",
     "eslint-plugin-sonarjs": "^4.2.0",
     "eslint-plugin-unicorn": "^74.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",
-    "globals": "^17.11.0",
+    "globals": "^17.12.0",
     "graphql": "*",
     "husky": "^9.1.7",
     "istanbul-lib-coverage": "^3.2.2",
@@ -241,12 +245,12 @@
     "mocha": "^11.8.0",
     "mocha-junit-reporter": "^2.2.1",
     "mocha-multi-reporters": "^1.5.1",
-    "multer": "^2.2.0",
+    "multer": "^2.3.0",
     "nock": "^14.0.17",
     "node-preload": "^0.2.1",
     "nyc": "^18.0.0",
     "octokit": "^5.0.3",
-    "p-limit": "^7.3.1",
+    "p-limit": "^7.3.2",
     "proxyquire": "^2.1.3",
     "retry": "^0.13.1",
     "semifies": "^1.0.0",

package/packages/datadog-esbuild/index.js

@@ -8,8 +8,9 @@ const { pathToFileURL, fileURLToPath } = require('node:url')
 const instrumentations = require('../datadog-instrumentations/src/helpers/instrumentations')
 const extractPackageAndModulePath = require('../datadog-instrumentations/src/helpers/extract-package-and-module-path')
 const hooks = require('../datadog-instrumentations/src/helpers/hooks')
-const { processModule, isESMFile } = require('./src/utils')
 const log = require('./src/log')
+const { createEsmResolver } = require('./src/resolver')
+const { isESMFile, processModule } = require('./src/utils')
 
 const ESM_INTERCEPTED_SUFFIX = '._dd_esbuild_intercepted'
 const INTERNAL_ESM_INTERCEPTED_PREFIX = '/_dd_esm_internal_/'
@@ -166,6 +167,13 @@ ${build.initialOptions.banner.js}`
 
   // first time is intercepted, proxy should be created, next time the original should be loaded
   const interceptedESMModules = new Set()
+  let resolver
+
+  build.onEnd(async () => {
+    const activeResolver = resolver
+    resolver = undefined
+    await activeResolver?.close()
+  })
 
   build.onResolve({ filter: /.*/ }, args => {
     if (externalModules.has(args.path)) {
@@ -316,10 +324,15 @@ ${build.initialOptions.banner.js}`
 
           interceptedESMModules.add(args.path)
 
+          resolver ??= createEsmResolver()
           const setters = await processModule({
             path: args.path,
             internal: data.internal,
             context: { format: 'module' },
+            excludeDefault: false,
+            moduleSources: new Map(),
+            resolver,
+            transform: build.esbuild.transformSync,
           })
 
           const iitmPath = require.resolve('import-in-the-middle/lib/register.js')

package/packages/datadog-esbuild/src/resolver.js

@@ -0,0 +1,284 @@
+'use strict'
+
+const childProcess = require('node:child_process')
+const readline = require('node:readline')
+
+const { getEnvironmentVariables } = require('../../dd-trace/src/config/helper')
+
+const MAX_PENDING_REQUESTS = 1024
+const MAX_STDERR_LENGTH = 16 * 1024
+const LOAD_OPERATION = 0
+const RESOLVE_OPERATION = 1
+const RESOLVER_SOURCE = String.raw`
+import { createReadStream, createWriteStream } from 'node:fs'
+import readline from 'node:readline'
+
+const requests = createReadStream(null, { fd: 3, autoClose: false })
+const responses = createWriteStream(null, { fd: 4, autoClose: false })
+const lines = readline.createInterface({ input: requests })
+
+for await (const line of lines) {
+  let request
+  try {
+    request = JSON.parse(line)
+    const url = await import.meta.resolve(request.specifier, request.parentURL)
+    responses.write(JSON.stringify({ id: request.id, url }) + '\n')
+  } catch (error) {
+    responses.write(JSON.stringify({
+      error: {
+        code: error?.code,
+        message: String(error?.message ?? error),
+      },
+      id: request?.id,
+    }) + '\n')
+  }
+}
+responses.end()
+`
+
+/** @typedef {{ specifier: string, parentURL: string }} StarReexport */
+
+/**
+ * @typedef {{ exportNames: Iterable<string>, starReexports?: StarReexport[] }} ModuleExports
+ */
+
+/**
+ * @typedef {Set<string>|ModuleExports} GetExportsValue
+ */
+
+/**
+ * @typedef {[typeof LOAD_OPERATION, URL, object] | [typeof RESOLVE_OPERATION, string, object]} GetExportsOperation
+ */
+
+/**
+ * @typedef {{ done: false, value: GetExportsOperation } | { done: true, value: GetExportsValue }} GetExportsResult
+ */
+
+/**
+ * @typedef {{
+ *   next: (value?: unknown) => GetExportsResult,
+ *   throw: (error?: unknown) => GetExportsResult,
+ * }} GetExportsGenerator
+ */
+
+class EsmResolver {
+  #child
+  #closed = false
+  #closedPromise
+  #failure
+  #nextId = 0
+  #pending = new Map()
+  #readline
+  #rejectClosed
+  #request
+  #resolveClosed
+  #stderr = ''
+
+  constructor () {
+    this.#closedPromise = new Promise((resolve, reject) => {
+      this.#resolveClosed = resolve
+      this.#rejectClosed = reject
+    })
+    // Mark lifecycle failures handled immediately. close() still returns the original promise.
+    this.#closedPromise.catch(() => {})
+  }
+
+  /**
+   * @param {string} specifier
+   * @param {URL|string} parentURL
+   * @returns {Promise<string>}
+   */
+  resolve (specifier, parentURL) {
+    if (this.#closed) return Promise.reject(this.#failure ?? new Error('The ESM resolver is closed'))
+    if (this.#pending.size >= MAX_PENDING_REQUESTS) {
+      return Promise.reject(new Error(`The ESM resolver has more than ${MAX_PENDING_REQUESTS} pending requests`))
+    }
+
+    try {
+      this.#start()
+    } catch (error) {
+      this.#failure = error
+      this.#closed = true
+      this.#resolveClosed()
+      return Promise.reject(error)
+    }
+    const id = this.#nextId++
+    return new Promise((resolve, reject) => {
+      this.#pending.set(id, { reject, resolve })
+      this.#request.write(`${JSON.stringify({ id, parentURL: String(parentURL), specifier })}\n`, error => {
+        if (error) this.#rejectRequest(id, error)
+      })
+    })
+  }
+
+  /** @returns {Promise<void>} */
+  close () {
+    if (!this.#closed) {
+      this.#closed = true
+      if (this.#child) this.#request.end()
+      else this.#resolveClosed()
+    }
+    return this.#closedPromise
+  }
+
+  #start () {
+    if (this.#child) return
+    const env = getEnvironmentVariables()
+    env.DD_CIVISIBILITY_ENABLED = 'false'
+    env.DD_INSTRUMENTATION_TELEMETRY_ENABLED = 'false'
+    env.DD_TRACE_ENABLED = 'false'
+    this.#child = childProcess.spawn(process.execPath, [
+      '--no-warnings',
+      '--experimental-import-meta-resolve',
+      '--input-type=module',
+      '--eval',
+      RESOLVER_SOURCE,
+    ], {
+      env,
+      stdio: ['ignore', 'ignore', 'pipe', 'pipe', 'pipe'],
+    })
+    this.#request = this.#child.stdio[3]
+    this.#readline = readline.createInterface({ input: this.#child.stdio[4] })
+    this.#readline.on('line', this.#handleLine)
+    this.#request.once('error', this.#handleError)
+    this.#child.stdio[4].once('error', this.#handleError)
+    this.#child.stderr.on('data', this.#handleStderr)
+    this.#child.once('error', this.#handleError)
+    this.#child.once('close', this.#handleClose)
+  }
+
+  /** @param {string} line */
+  #handleLine = (line) => {
+    let response
+    try {
+      response = JSON.parse(line)
+    } catch (error) {
+      this.#fail(new Error(`The ESM resolver returned malformed JSON: ${error.message}`))
+      return
+    }
+
+    const id = response?.id
+    if (!Number.isSafeInteger(id) || !this.#pending.has(id)) {
+      this.#fail(new Error('The ESM resolver returned an unknown request identifier'))
+      return
+    }
+    if (typeof response.url === 'string' && response.error === undefined) {
+      const request = this.#pending.get(id)
+      this.#pending.delete(id)
+      request.resolve(response.url)
+      return
+    }
+    if (typeof response.error?.message !== 'string' || response.url !== undefined) {
+      this.#rejectRequest(id, new Error('The ESM resolver returned a malformed response'))
+      return
+    }
+
+    const error = /** @type {Error & { code?: string }} */ (new Error(response.error.message))
+    if (typeof response.error.code === 'string') error.code = response.error.code
+    this.#rejectRequest(id, error)
+  }
+
+  /** @param {Buffer|string} chunk */
+  #handleStderr = (chunk) => {
+    if (this.#stderr.length >= MAX_STDERR_LENGTH) return
+    this.#stderr += String(chunk).slice(0, MAX_STDERR_LENGTH - this.#stderr.length)
+  }
+
+  /** @param {Error} error */
+  #handleError = (error) => {
+    this.#fail(error)
+  }
+
+  /**
+   * @param {number|null} code
+   * @param {string|null} signal
+   */
+  #handleClose = (code, signal) => {
+    this.#readline?.close()
+    this.#closed = true
+    let error = this.#failure
+    if (!error && (code !== 0 || this.#pending.size > 0)) {
+      const reason = signal ? `signal ${signal}` : `status ${code}`
+      const stderr = this.#stderr.trim()
+      error = new Error(`The ESM resolver exited with ${reason}${stderr ? `: ${stderr}` : ''}`)
+      this.#failure = error
+    }
+    if (error) {
+      this.#rejectAll(error)
+      this.#rejectClosed(error)
+    } else {
+      this.#resolveClosed()
+    }
+  }
+
+  /**
+   * @param {number} id
+   * @param {Error} error
+   */
+  #rejectRequest (id, error) {
+    const request = this.#pending.get(id)
+    if (!request) return
+    this.#pending.delete(id)
+    request.reject(error)
+  }
+
+  /** @param {Error} error */
+  #fail (error) {
+    if (this.#failure) return
+    this.#failure = error
+    this.#closed = true
+    this.#rejectAll(error)
+    this.#request?.destroy()
+    this.#child?.kill()
+  }
+
+  /** @param {Error} error */
+  #rejectAll (error) {
+    for (const request of this.#pending.values()) request.reject(error)
+    this.#pending.clear()
+  }
+}
+
+/** @returns {EsmResolver} */
+function createEsmResolver () {
+  return new EsmResolver()
+}
+
+/**
+ * Drives the generator returned by import-in-the-middle >=3.1.0 export discovery.
+ *
+ * @param {GetExportsGenerator} exportsGenerator
+ * @param {(url: URL, context: object) => { source: string, format: string }} getSource
+ * @param {(specifier: string, context: object) => Promise<{ format: string, url: URL }>} resolve
+ * @returns {Promise<ModuleExports>}
+ */
+async function driveGetExportsGenerator (exportsGenerator, getSource, resolve) {
+  let next = exportsGenerator.next()
+  while (next.done === false) {
+    let result
+    let failure
+    let threw = false
+
+    try {
+      const operation = next.value
+      const operationType = operation[0]
+
+      if (operationType === LOAD_OPERATION) {
+        result = getSource(operation[1], operation[2])
+      } else if (operationType === RESOLVE_OPERATION) {
+        // eslint-disable-next-line no-await-in-loop
+        result = await resolve(operation[1], operation[2])
+      } else {
+        throw new Error(`Unsupported import-in-the-middle getExports operation: ${operationType}`)
+      }
+    } catch (error) {
+      threw = true
+      failure = error
+    }
+
+    next = threw ? exportsGenerator.throw(failure) : exportsGenerator.next(result)
+  }
+  return next.value instanceof Set ? { exportNames: next.value } : next.value
+}
+
+module.exports = { createEsmResolver, driveGetExportsGenerator }