dd-trace 5.73.0 → 5.74.0

package/LICENSE-3rdparty.csv

@@ -50,6 +50,7 @@ dev,@stylistic/eslint-plugin,MIT,Copyright OpenJS Foundation and other contribut
 dev,axios,MIT,Copyright 2014-present Matt Zabriskie
 dev,benchmark,MIT,Copyright 2010-2016 Mathias Bynens Robert Kieffer John-David Dalton
 dev,body-parser,MIT,Copyright 2014 Jonathan Ong 2014-2015 Douglas Christopher Wilson
+dev,bun,MIT,Copyright contributors
 dev,chai,MIT,Copyright 2017 Chai.js Assertion Library
 dev,eslint,MIT,Copyright JS Foundation and other contributors https://js.foundation
 dev,eslint-plugin-cypress,MIT,Copyright (c) 2019 Cypress.io

package/index.d.ts

@@ -134,6 +134,11 @@ interface Tracer extends opentracing.Tracer {
 
   dogstatsd: tracer.DogStatsD;
 
+  /**
+   * Data Streams manual checkpointer API.
+   */
+  dataStreamsCheckpointer: tracer.DataStreamsCheckpointer;
+
   /**
    * LLM Observability SDK
    */
@@ -1026,6 +1031,29 @@ declare namespace tracer {
     flush(): void
   }
 
+  /**
+   * Manual Data Streams Monitoring checkpointer API.
+   */
+  export interface DataStreamsCheckpointer {
+    /**
+     * Sets a produce checkpoint and injects the DSM context into the provided carrier.
+     * @param type The streaming technology (e.g., kafka, kinesis, sns).
+     * @param target The target of data (topic, exchange, stream name).
+     * @param carrier The carrier object to inject DSM context into.
+     */
+    setProduceCheckpoint (type: string, target: string, carrier: any): void;
+
+    /**
+     * Sets a consume checkpoint and extracts DSM context from the provided carrier.
+     * @param type The streaming technology (e.g., kafka, kinesis, sns).
+     * @param source The source of data (topic, exchange, stream name).
+     * @param carrier The carrier object to extract DSM context from.
+     * @param manualCheckpoint Whether this checkpoint was manually set. Defaults to true.
+     * @returns The DSM context associated with the current pathway.
+     */
+    setConsumeCheckpoint (type: string, source: string, carrier: any, manualCheckpoint?: boolean): any;
+  }
+
   export interface EventTrackingV2 {
     /**
      * 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.73.0",
+  "version": "5.74.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -32,6 +32,8 @@
     "test:trace:core:ci": "npm run test:trace:core -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/**/*.js\"",
     "test:trace:guardrails": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/dd-trace/test/guardrails/**/*.spec.js\"",
     "test:trace:guardrails:ci": "nyc --no-clean --include \"packages/dd-trace/src/guardrails/**/*.js\" -- npm run test:trace:guardrails",
+    "test:esbuild": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-esbuild/test/**/*.spec.js\"",
+    "test:esbuild:ci": "nyc --no-clean --include \"packages/datadog-esbuild/test/**/*.js\" -- npm run test:esbuild",
     "test:instrumentations": "mocha -r 'packages/dd-trace/test/setup/mocha.js' \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\"",
     "test:instrumentations:ci": "yarn services && nyc --no-clean --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS)).js\" --include \"packages/datadog-instrumentations/src/@($(echo $PLUGINS))/**/*.js\" -- npm run test:instrumentations",
     "test:instrumentations:misc": "mocha -r 'packages/dd-trace/test/setup/mocha.js' 'packages/datadog-instrumentations/test/*/**/*.spec.js'",
@@ -158,7 +160,7 @@
   },
   "peerDependencies": {
     "@openfeature/core": "^1.9.0",
-    "@openfeature/server-sdk": "~1.19.0"
+    "@openfeature/server-sdk": "~1.20.0"
   },
   "peerDependenciesMeta": {
     "@openfeature/core": {
@@ -174,7 +176,7 @@
     "@eslint/js": "^9.29.0",
     "@msgpack/msgpack": "^3.1.2",
     "@openfeature/core": "^1.8.1",
-    "@openfeature/server-sdk": "~1.19.0",
+    "@openfeature/server-sdk": "~1.20.0",
     "@stylistic/eslint-plugin": "^5.0.0",
     "@types/chai": "^4.3.16",
     "@types/mocha": "^10.0.10",
@@ -184,6 +186,7 @@
     "axios": "^1.12.2",
     "benchmark": "^2.1.4",
     "body-parser": "^2.2.0",
+    "bun": "1.3.1",
     "chai": "^4.5.0",
     "eslint": "^9.29.0",
     "eslint-plugin-cypress": "^5.1.0",

package/packages/datadog-core/src/utils/src/set.js

@@ -5,7 +5,11 @@ module.exports = function set (object, path, value) {
   while (true) {
     const nextIndex = path.indexOf('.', index + 1)
     if (nextIndex === -1) {
-      object[path.slice(index + 1)] = value
+      if (index === -1) {
+        object[path] = value
+      } else {
+        object[path.slice(index + 1)] = value
+      }
       return
     }
     object = object[path.slice(index + 1, nextIndex)] ??= {}

package/packages/datadog-esbuild/index.js

@@ -8,6 +8,12 @@ const extractPackageAndModulePath = require(
   '../datadog-instrumentations/src/helpers/extract-package-and-module-path.js'
 )
 
+const { pathToFileURL, fileURLToPath } = require('url')
+const { processModule, isESMFile } = require('./src/utils.js')
+
+const ESM_INTERCEPTED_SUFFIX = '._dd_esbuild_intercepted'
+const INTERNAL_ESM_INTERCEPTED_PREFIX = '/_dd_esm_internal_/'
+
 let rewriter
 
 for (const hook of Object.values(hooks)) {
@@ -30,7 +36,6 @@ for (const instrumentation of Object.values(instrumentations)) {
   }
 }
 
-const INSTRUMENTED = Object.keys(instrumentations)
 const RAW_BUILTINS = require('module').builtinModules
 const CHANNEL = 'dd-trace:bundler:load'
 const path = require('path')
@@ -47,14 +52,6 @@ for (const builtin of RAW_BUILTINS) {
 const DEBUG = !!process.env.DD_TRACE_DEBUG
 const DD_IAST_ENABLED = process.env.DD_IAST_ENABLED?.toLowerCase() === 'true' || process.env.DD_IAST_ENABLED === '1'
 
-// We don't want to handle any built-in packages
-// Those packages will still be handled via RITM
-// Attempting to instrument them would fail as they have no package.json file
-for (const pkg of INSTRUMENTED) {
-  if (builtins.has(pkg) || pkg.startsWith('node:')) continue
-  modulesOfInterest.add(pkg)
-}
-
 module.exports.name = 'datadog-esbuild'
 
 function isESMBuild (build) {
@@ -123,7 +120,8 @@ ${build.initialOptions.banner.js}`
     build.initialOptions.external.push('@openfeature/core')
   }
 
-  if (isESMBuild(build)) {
+  const esmBuild = isESMBuild(build)
+  if (esmBuild) {
     if (!build.initialOptions.banner.js.includes('import { createRequire as $dd_createRequire } from \'module\'')) {
       build.initialOptions.banner.js = `import { createRequire as $dd_createRequire } from 'module';
 import { fileURLToPath as $dd_fileURLToPath } from 'url';
@@ -157,6 +155,9 @@ ${build.initialOptions.banner.js}`
     console.warn('Warning: No git metadata available - skipping injection')
   }
 
+  // first time is intercepted, proxy should be created, next time the original should be loaded
+  const interceptedESMModules = new Set()
+
   build.onResolve({ filter: /.*/ }, args => {
     if (externalModules.has(args.path)) {
       // Internal Node.js packages will still be instrumented via require()
@@ -175,7 +176,7 @@ ${build.initialOptions.banner.js}`
 
     let fullPathToModule
     try {
-      fullPathToModule = dotFriendlyResolve(args.path, args.resolveDir)
+      fullPathToModule = dotFriendlyResolve(args.path, args.resolveDir, args.kind === 'import-statement')
     } catch (err) {
       if (DEBUG) {
         console.warn(`Warning: Unable to find "${args.path}".` +
@@ -205,8 +206,25 @@ ${build.initialOptions.banner.js}`
     if (args.namespace === 'file' && (
       modulesOfInterest.has(args.path) || modulesOfInterest.has(`${extracted.pkg}/${extracted.path}`))
     ) {
+      // Internal module like http/fs is imported and the build output is ESM
+      if (internal && args.kind === 'import-statement' && esmBuild && !interceptedESMModules.has(fullPathToModule)) {
+        fullPathToModule = `${INTERNAL_ESM_INTERCEPTED_PREFIX}${fullPathToModule}${ESM_INTERCEPTED_SUFFIX}`
+
+        return {
+          path: fullPathToModule,
+          pluginData: {
+            pkg: extracted?.pkg,
+            path: extracted?.path,
+            full: fullPathToModule,
+            raw: args.path,
+            pkgOfInterest: true,
+            kind: args.kind,
+            internal,
+            isESM: true
+          }
+        }
+      }
       // The file namespace is used when requiring files from disk in userland
-
       let pathToPackageJson
       try {
         // we can't use require.resolve('pkg/package.json') as ESM modules don't make the file available
@@ -228,6 +246,11 @@ ${build.initialOptions.banner.js}`
 
       const packageJson = JSON.parse(fs.readFileSync(pathToPackageJson).toString())
 
+      const isESM = isESMFile(fullPathToModule, pathToPackageJson, packageJson)
+      if (isESM && !interceptedESMModules.has(fullPathToModule)) {
+        fullPathToModule += ESM_INTERCEPTED_SUFFIX
+      }
+
       if (DEBUG) console.log(`RESOLVE: ${args.path}@${packageJson.version}`)
 
       // https://esbuild.github.io/plugins/#on-resolve-arguments
@@ -240,13 +263,15 @@ ${build.initialOptions.banner.js}`
           full: fullPathToModule,
           raw: args.path,
           pkgOfInterest: true,
-          internal
+          kind: args.kind,
+          internal,
+          isESM
         }
       }
     }
   })
 
-  build.onLoad({ filter: /.*/ }, args => {
+  build.onLoad({ filter: /.*/ }, async args => {
     if (args.pluginData?.pkgOfInterest) {
       const data = args.pluginData
 
@@ -257,26 +282,63 @@ ${build.initialOptions.banner.js}`
         : data.pkg
 
       // Read the content of the module file of interest
-      const fileCode = fs.readFileSync(args.path, 'utf8')
+      let contents
+
+      if (data.isESM) {
+        if (args.path.endsWith(ESM_INTERCEPTED_SUFFIX)) {
+          args.path = args.path.slice(0, -1 * ESM_INTERCEPTED_SUFFIX.length)
+
+          if (data.internal) {
+            args.path = args.path.slice(INTERNAL_ESM_INTERCEPTED_PREFIX.length)
+          }
+
+          interceptedESMModules.add(args.path)
+
+          const setters = await processModule({
+            path: args.path,
+            internal: data.internal,
+            context: { format: 'module' }
+          })
+
+          const iitmPath = require.resolve('import-in-the-middle/lib/register.js')
+          const toRegister = data.internal ? args.path : pathToFileURL(args.path)
+          // Mimic a Module object (https://tc39.es/ecma262/#sec-module-namespace-objects).
+          contents = `
+import { register } from ${JSON.stringify(iitmPath)};
+import * as namespace from ${JSON.stringify(args.path)};
+const _ = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+const set = {};
+const get = {};
+
+${Array.from(setters.values()).join(';\n')};
+
+register(${JSON.stringify(toRegister)}, _, set, get, ${JSON.stringify(data.raw)});
+`
+        } else {
+          contents = fs.readFileSync(args.path, 'utf8')
+        }
+      } else {
+        const fileCode = fs.readFileSync(args.path, 'utf8')
+        contents = `
+        (function() {
+          ${fileCode}
+        })(...arguments);
+        {
+          const dc = require('dc-polyfill');
+          const ch = dc.channel('${CHANNEL}');
+          const mod = module.exports
+          const payload = {
+            module: mod,
+            version: '${data.version}',
+            package: '${data.pkg}',
+            path: '${pkgPath}'
+          };
+          ch.publish(payload);
+          module.exports = payload.module;
+      }
+      `
+      }
 
-      const contents = `
-      (function() {
-        ${fileCode}
-      })(...arguments);
-      {
-        const dc = require('dc-polyfill');
-        const ch = dc.channel('${CHANNEL}');
-        const mod = module.exports
-        const payload = {
-          module: mod,
-          version: '${data.version}',
-          package: '${data.pkg}',
-          path: '${pkgPath}'
-        };
-        ch.publish(payload);
-        module.exports = payload.module;
-    }
-    `
       // https://esbuild.github.io/plugins/#on-load-results
       return {
         contents,
@@ -284,7 +346,6 @@ ${build.initialOptions.banner.js}`
         resolveDir: path.dirname(args.path)
       }
     }
-
     if (DD_IAST_ENABLED && args.pluginData?.applicationFile) {
       const ext = path.extname(args.path).toLowerCase()
       const isJs = /^\.(js|mjs|cjs)$/.test(ext)
@@ -303,12 +364,19 @@ ${build.initialOptions.banner.js}`
 }
 
 // @see https://github.com/nodejs/node/issues/47000
-function dotFriendlyResolve (path, directory) {
+function dotFriendlyResolve (path, directory, usesImportStatement) {
   if (path === '.') {
     path = './'
   } else if (path === '..') {
     path = '../'
   }
+  let conditions
+  if (usesImportStatement) {
+    conditions = new Set(['import', 'node'])
+  }
 
-  return require.resolve(path, { paths: [directory] })
+  if (path.startsWith('file://')) {
+    path = fileURLToPath(path)
+  }
+  return require.resolve(path, { paths: [directory], conditions })
 }

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

@@ -0,0 +1,198 @@
+'use strict'
+
+// The content of this file is copied from the `import-in-the-middle` package with minor modifications (https://www.npmjs.com/package/import-in-the-middle)
+const { pathToFileURL, fileURLToPath } = require('node:url')
+const fs = require('node:fs')
+const path = require('node:path')
+const { NODE_MAJOR, NODE_MINOR } = require('../../../version.js')
+
+const getExportsImporting = (url) => import(url).then(Object.keys)
+const getExports = NODE_MAJOR >= 20 || (NODE_MAJOR === 18 && NODE_MINOR >= 19)
+  ? require('import-in-the-middle/lib/get-exports.js')
+  : getExportsImporting
+
+function isStarExportLine (line) {
+  return /^\* from /.test(line)
+}
+
+function isBareSpecifier (specifier) {
+  // Relative and absolute paths are not bare specifiers.
+  if (
+    specifier.startsWith('.') ||
+    specifier.startsWith('/')) {
+    return false
+  }
+
+  // Valid URLs are not bare specifiers. (file:, http:, node:, etc.)
+
+  if (URL.hasOwnProperty('canParse')) {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    return !URL.canParse(specifier)
+  }
+
+  try {
+    // eslint-disable-next-line no-new
+    new URL(specifier)
+    return false
+  } catch {
+    return true
+  }
+}
+
+function resolve (specifier, context) {
+  // This comes from an import, that is why import makes preference
+  const conditions = ['import']
+
+  if (specifier.startsWith('file://')) {
+    specifier = fileURLToPath(specifier)
+  }
+
+  const resolved = require.resolve(specifier, { conditions, paths: [fileURLToPath(context.parentURL)] })
+
+  return {
+    url: pathToFileURL(resolved),
+    format: isESMFile(resolved) ? 'module' : 'commonjs'
+  }
+}
+
+function getSource (url, { format }) {
+  return {
+    source: fs.readFileSync(fileURLToPath(url), 'utf8'),
+    format
+  }
+}
+
+/**
+ * Generates the pieces of code for the proxy module before the path
+ *
+ * @param {Object} moduleData { path, internal, context, excludeDefault }
+ * @returns {Promise<Map>}
+ */
+async function processModule ({ path, internal, context, excludeDefault }) {
+  let exportNames, srcUrl
+  if (internal) {
+    // we can not read and parse of internal modules
+    exportNames = await getExportsImporting(path)
+  } else {
+    srcUrl = pathToFileURL(path)
+    exportNames = await getExports(srcUrl, context, getSource)
+  }
+
+  const starExports = new Set()
+  const setters = new Map()
+
+  const addSetter = (name, setter, isStarExport = false) => {
+    if (setters.has(name)) {
+      if (isStarExport) {
+        // If there's already a matching star export, delete it
+        if (starExports.has(name)) {
+          setters.delete(name)
+        }
+        // and return so this is excluded
+        return
+      }
+
+      // if we already have this export but it is from a * export, overwrite it
+      if (starExports.has(name)) {
+        starExports.delete(name)
+        setters.set(name, setter)
+      }
+    } else {
+      // Store export * exports so we know they can be overridden by explicit
+      // named exports
+      if (isStarExport) {
+        starExports.add(name)
+      }
+
+      setters.set(name, setter)
+    }
+  }
+
+  for (const n of exportNames) {
+    if (n === 'default' && excludeDefault) continue
+
+    if (isStarExportLine(n) === true) {
+      // export * from 'wherever'
+      const [, modFile] = n.split('* from ')
+
+      // Relative paths need to be resolved relative to the parent module
+      const newSpecifier = isBareSpecifier(modFile) ? modFile : new URL(modFile, srcUrl).href
+      // We need to call `parentResolve` to resolve bare specifiers to a full
+      // URL. We also need to call `parentResolve` for all sub-modules to get
+      // the `format`. We can't rely on the parents `format` to know if this
+      // sub-module is ESM or CJS!
+
+      const result = resolve(newSpecifier, { parentURL: srcUrl })
+
+      // eslint-disable-next-line no-await-in-loop
+      const subSetters = await processModule({
+        path: fileURLToPath(result.url),
+        context: { ...context, format: result.format },
+        excludeDefault: true
+      })
+
+      for (const [name, setter] of subSetters.entries()) {
+        addSetter(name, setter, true)
+      }
+    } else {
+      const variableName = `$${n.replaceAll(/[^a-zA-Z0-9_$]/g, '_')}`
+      const objectKey = JSON.stringify(n)
+      const reExportedName = n === 'default' ? n : objectKey
+
+      addSetter(n, `
+      let ${variableName}
+      try {
+        ${variableName} = _[${objectKey}] = namespace[${objectKey}]
+      } catch (err) {
+        if (!(err instanceof ReferenceError)) throw err
+      }
+      export { ${variableName} as ${reExportedName} }
+      set[${objectKey}] = (v) => {
+        ${variableName} = v
+        return true
+      }
+      get[${objectKey}] = () => ${variableName}
+      `)
+    }
+  }
+
+  return setters
+}
+
+/**
+ * Determines if a file is a ESM module or CommonJS
+ *
+ * @param {string} fullPathToModule File to analize
+ * @param {string} [modulePackageJsonPath] Path of the package.json
+ * @param {Object} [packageJson] The content of the module package.json
+ * @returns {boolean}
+ */
+function isESMFile (fullPathToModule, modulePackageJsonPath, packageJson = {}) {
+  if (fullPathToModule.endsWith('.mjs')) return true
+  if (fullPathToModule.endsWith('.cjs')) return false
+
+  const pathParts = fullPathToModule.split(path.sep)
+  do {
+    pathParts.pop()
+
+    const packageJsonPath = [...pathParts, 'package.json'].join(path.sep)
+    if (packageJsonPath === modulePackageJsonPath) {
+      return packageJson.type === 'module'
+    }
+
+    try {
+      const packageJsonContent = fs.readFileSync(packageJsonPath).toString()
+      const packageJson = JSON.parse(packageJsonContent)
+      return packageJson.type === 'module'
+    } catch {
+      // file does not exit, continue
+    }
+  } while (pathParts.length > 0)
+
+  return packageJson.type === 'module'
+}
+
+module.exports = {
+  processModule,
+  isESMFile
+}

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

@@ -37,5 +37,6 @@ addHook({
   name: 'express-session',
   versions: ['>=1.5.0']
 }, session => {
+  if (session.default) return session
   return shimmer.wrapFunction(session, wrapSession)
 })

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

@@ -3,8 +3,18 @@
 const { createWrapRouterMethod } = require('./router')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel, tracingChannel } = require('./helpers/instrument')
+const {
+  setRouterMountPath,
+  markAppMounted,
+  normalizeRoutePaths,
+  wrapRouteMethodsAndPublish,
+  extractMountPaths,
+  hasRouterCycle,
+  collectRoutesFromRouter
+} = require('./helpers/router-helper')
 
 const handleChannel = channel('apm:express:request:handle')
+const routeAddedChannel = channel('apm:express:route:added')
 
 function wrapHandle (handle) {
   return function handleWithTrace (req, res) {
@@ -56,8 +66,80 @@ function wrapResponseRender (render) {
   }
 }
 
+function wrapAppAll (all) {
+  return function wrappedAll (path, ...otherArgs) {
+    if (!routeAddedChannel.hasSubscribers) return all.call(this, path, ...otherArgs)
+
+    const paths = normalizeRoutePaths(path)
+
+    for (const p of paths) {
+      routeAddedChannel.publish({ method: '*', path: p })
+    }
+
+    return all.call(this, path, ...otherArgs)
+  }
+}
+
+// Wrap app.route() to instrument Route object
+function wrapAppRoute (route) {
+  return function wrappedRoute (path, ...otherArgs) {
+    const routeObj = route.call(this, path, ...otherArgs)
+
+    if (!routeAddedChannel.hasSubscribers) return routeObj
+
+    const paths = normalizeRoutePaths(path)
+
+    if (!paths.length) return routeObj
+
+    wrapRouteMethodsAndPublish(routeObj, paths, ({ method, path }) => {
+      routeAddedChannel.publish({ method, path })
+    })
+
+    return routeObj
+  }
+}
+
+function wrapAppUse (use) {
+  return function wrappedUse (...args) {
+    if (!args.length) return use.call(this)
+
+    // Get mount argument and use it to register each router against the exact paths Express will use.
+    const { mountPaths, startIdx } = extractMountPaths(args[0])
+    const pathsToRegister = mountPaths.length ? mountPaths : ['/']
+
+    for (let i = startIdx; i < args.length; i++) {
+      const router = args[i]
+
+      if (!router || typeof router !== 'function') continue
+
+      markAppMounted(router)
+
+      // Avoid enumerating routes for routers that contain cycles.
+      // Express will refuse those at runtime, but collecting them here could loop forever.
+      let skipCollection = false
+      if (routeAddedChannel.hasSubscribers) {
+        skipCollection = hasRouterCycle(router)
+      }
+
+      for (const mountPath of pathsToRegister) {
+        const normalizedMountPath = mountPath || '/'
+        setRouterMountPath(router, normalizedMountPath)
+
+        if (!skipCollection && routeAddedChannel.hasSubscribers) {
+          collectRoutesFromRouter(router, normalizedMountPath)
+        }
+      }
+    }
+
+    return use.apply(this, args)
+  }
+}
+
 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)
+  shimmer.wrap(express.application, 'use', wrapAppUse)
 
   shimmer.wrap(express.response, 'json', wrapResponseJson)
   shimmer.wrap(express.response, 'jsonp', wrapResponseJson)