dd-trace 5.87.0 → 5.89.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.87.0",
+  "version": "5.89.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -16,6 +16,8 @@
     "lint": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && eslint . --concurrency=auto --max-warnings 0",
     "lint:fix": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && eslint . --concurrency=auto --max-warnings 0 --fix",
     "lint:inspect": "npx @eslint/config-inspector@latest",
+    "lint:codeowners": "codeowners-audit",
+    "lint:codeowners:ci": "codeowners-audit --glob='**/*.spec.js'",
     "release:proposal": "node scripts/release/proposal",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
     "test": "echo '\nError: The root \"npm test\" command is intentionally disabled.\n\nInstead, run specific test suites:\n  - npm run test:trace:core\n  - npm run test:appsec\n  - etc.\n\nOr run individual test files:\n  npx mocha path/to/test.spec.js\n\nSee CONTRIBUTING.md (Testing section) for more details.\n' && exit 1",
@@ -59,6 +61,7 @@
     "test:integration": "mocha --timeout 60000 \"integration-tests/*.spec.js\"",
     "test:integration:aiguard": "mocha --timeout 60000 \"integration-tests/aiguard/*.spec.js\"",
     "test:integration:appsec": "mocha --timeout 60000 \"integration-tests/appsec/*.spec.js\"",
+    "test:integration:bun": "mocha --timeout 60000 \"integration-tests/bun/*.spec.js\"",
     "test:integration:cucumber": "mocha --timeout 60000 \"integration-tests/cucumber/*.spec.js\"",
     "test:integration:cypress": "mocha --timeout 60000 \"integration-tests/cypress/*.spec.js\"",
     "test:integration:debugger": "mocha --timeout 60000 \"integration-tests/debugger/*.spec.js\"",
@@ -131,20 +134,23 @@
   ],
   "dependencies": {
     "dc-polyfill": "^0.1.10",
-    "import-in-the-middle": "^2.0.6"
+    "import-in-the-middle": "^3.0.0"
   },
   "optionalDependencies": {
-    "@datadog/libdatadog": "0.7.0",
-    "@datadog/native-appsec": "10.3.0",
+    "@datadog/libdatadog": "0.8.1",
+    "@datadog/native-appsec": "11.0.1",
     "@datadog/native-iast-taint-tracking": "4.1.0",
     "@datadog/native-metrics": "3.1.1",
-    "@datadog/openfeature-node-server": "^0.3.3",
-    "@datadog/pprof": "5.13.3",
+    "@datadog/openfeature-node-server": "^1.1.0",
+    "@datadog/pprof": "5.13.4",
     "@datadog/wasm-js-rewriter": "5.0.1",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
-    "@opentelemetry/api-logs": "<1.0.0"
+    "@opentelemetry/api-logs": "<1.0.0",
+    "oxc-parser": "^0.115.0"
   },
   "devDependencies": {
+    "@actions/core": "^3.0.0",
+    "@actions/github": "^9.0.0",
     "@babel/helpers": "^7.28.6",
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.39.2",
@@ -158,19 +164,21 @@
     "axios": "^1.13.4",
     "benchmark": "^2.1.4",
     "body-parser": "^2.2.2",
-    "bun": "1.3.8",
+    "bun": "1.3.10",
+    "codeowners-audit": "^2.0.0",
     "eslint": "^9.39.2",
-    "eslint-plugin-cypress": "^5.2.1",
+    "eslint-plugin-cypress": "^6.1.0",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-jsdoc": "^62.5.0",
     "eslint-plugin-mocha": "^11.2.0",
     "eslint-plugin-n": "^17.23.2",
     "eslint-plugin-promise": "^7.2.1",
-    "eslint-plugin-unicorn": "^62.0.0",
+    "eslint-plugin-unicorn": "^63.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",
     "globals": "^17.2.0",
     "graphql": "*",
+    "husky": "^9.1.7",
     "jszip": "^3.10.1",
     "mocha": "^11.6.0",
     "mocha-junit-reporter": "^2.2.1",
@@ -190,7 +198,6 @@
     "typescript": "^5.9.2",
     "workerpool": "^10.0.0",
     "yaml": "^2.8.0",
-    "husky": "^9.1.7",
     "yarn-deduplicate": "^6.0.2"
   }
 }

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

@@ -2,45 +2,11 @@
 
 const { channel, tracingChannel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
-const { addHook } = require('./helpers/instrument')
-
-const toolCreationChannel = channel('dd-trace:vercel-ai:tool')
-
-const TRACED_FUNCTIONS = {
-  generateText: wrapWithTracer,
-  streamText: wrapWithTracer,
-  generateObject: wrapWithTracer,
-  streamObject: wrapWithTracer,
-  embed: wrapWithTracer,
-  embedMany: wrapWithTracer,
-  tool: wrapTool,
-}
+const { addHook, getHooks } = require('./helpers/instrument')
 
 const vercelAiTracingChannel = tracingChannel('dd-trace:vercel-ai')
 const vercelAiSpanSetAttributesChannel = channel('dd-trace:vercel-ai:span:setAttributes')
 
-const noopTracer = {
-  startActiveSpan () {
-    const fn = arguments[arguments.length - 1]
-
-    const span = {
-      spanContext () { return { traceId: '', spanId: '', traceFlags: 0 } },
-      setAttribute () { return this },
-      setAttributes () { return this },
-      addEvent () { return this },
-      addLink () { return this },
-      addLinks () { return this },
-      setStatus () { return this },
-      updateName () { return this },
-      end () { return this },
-      isRecording () { return false },
-      recordException () { return this },
-    }
-
-    return fn(span)
-  },
-}
-
 const tracers = new WeakSet()
 
 function wrapTracer (tracer) {
@@ -63,21 +29,27 @@ function wrapTracer (tracer) {
 
       arguments[arguments.length - 1] = shimmer.wrapFunction(cb, function (originalCb) {
         return function (span) {
-          shimmer.wrap(span, 'end', function (spanEnd) {
+          // the below is necessary in the case that the span is vercel ai's noopSpan.
+          // while we don't want to patch the noopSpan more than once, we do want to treat each as a
+          // fresh instance. However, this is really not necessary for non-noop spans, but not sure
+          // how to differentiate.
+          const freshSpan = Object.create(span) // TODO: does this cause memory leaks?
+
+          shimmer.wrap(freshSpan, 'end', function (spanEnd) {
             return function () {
               vercelAiTracingChannel.asyncEnd.publish(ctx)
               return spanEnd.apply(this, arguments)
             }
           })
 
-          shimmer.wrap(span, 'setAttributes', function (setAttributes) {
+          shimmer.wrap(freshSpan, 'setAttributes', function (setAttributes) {
             return function (attributes) {
               vercelAiSpanSetAttributesChannel.publish({ ctx, attributes })
               return setAttributes.apply(this, arguments)
             }
           })
 
-          shimmer.wrap(span, 'recordException', function (recordException) {
+          shimmer.wrap(freshSpan, 'recordException', function (recordException) {
             return function (exception) {
               ctx.error = exception
               vercelAiTracingChannel.error.publish(ctx)
@@ -85,7 +57,7 @@ function wrapTracer (tracer) {
             }
           })
 
-          return originalCb.apply(this, arguments)
+          return originalCb.call(this, freshSpan)
         }
       })
 
@@ -98,58 +70,50 @@ function wrapTracer (tracer) {
   })
 }
 
-function wrapWithTracer (fn) {
-  return function () {
-    const options = arguments[0]
-
-    const experimentalTelemetry = options.experimental_telemetry
-    if (experimentalTelemetry?.isEnabled === false) {
-      return fn.apply(this, arguments)
-    }
-
-    if (experimentalTelemetry == null) {
-      options.experimental_telemetry = { isEnabled: true, tracer: noopTracer }
-    } else {
-      experimentalTelemetry.isEnabled = true
-      experimentalTelemetry.tracer ??= noopTracer
-    }
-
-    wrapTracer(options.experimental_telemetry.tracer)
-
-    return fn.apply(this, arguments)
+for (const hook of getHooks('ai')) {
+  if (hook.file === 'dist/index.js') {
+    // if not removed, the below hook will never match correctly
+    // however, it is still needed in the orchestrion definition
+    hook.file = null
   }
-}
-
-function wrapTool (tool) {
-  return function () {
-    const args = arguments[0]
-    toolCreationChannel.publish(args)
-
-    return tool.apply(this, arguments)
-  }
-}
 
-// CJS exports
-addHook({
-  name: 'ai',
-  versions: ['>=4.0.0'],
-}, exports => {
-  for (const [fnName, patchingFn] of Object.entries(TRACED_FUNCTIONS)) {
-    exports = shimmer.wrap(exports, fnName, patchingFn, { replaceGetter: true })
-  }
+  addHook(hook, exports => {
+    const getTracerChannel = tracingChannel('orchestrion:ai:getTracer')
+    getTracerChannel.subscribe({
+      end (ctx) {
+        const { arguments: args, result: tracer } = ctx
+        const { isEnabled } = args[0] ?? {}
 
-  return exports
-})
-
-// ESM exports
-addHook({
-  name: 'ai',
-  versions: ['>=4.0.0'],
-  file: 'dist/index.mjs',
-}, exports => {
-  for (const [fnName, patchingFn] of Object.entries(TRACED_FUNCTIONS)) {
-    exports = shimmer.wrap(exports, fnName, patchingFn, { replaceGetter: true })
-  }
+        if (isEnabled !== false) {
+          wrapTracer(tracer)
+        }
+      },
+    })
+
+    /**
+     * We patch this function to ensure that the telemetry attributes/tags are set always,
+     * even when telemetry options are not specified. This is to ensure easy use of this integration.
+     *
+     * If it is explicitly disabled, however, we will not change the options.
+     */
+    const selectTelemetryAttributesChannel = tracingChannel('orchestrion:ai:selectTelemetryAttributes')
+    selectTelemetryAttributesChannel.subscribe({
+      start (ctx) {
+        const { arguments: args } = ctx
+        const options = args[0]
+
+        if (options.telemetry?.isEnabled !== false) {
+          args[0] = {
+            ...options,
+            telemetry: {
+              ...options.telemetry,
+              isEnabled: true,
+            },
+          }
+        }
+      },
+    })
 
-  return exports
-})
+    return exports
+  })
+}

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

@@ -26,31 +26,37 @@ function Hook (modules, hookOptions, onrequire) {
     const parts = [moduleBaseDir, moduleName].filter(Boolean)
     const filename = path.join(...parts)
 
-    if (this._patched[filename] && patched.has(moduleExports)) {
-      return patched.get(moduleExports)
-    }
-
     let defaultWrapResult
 
+    const wrappedOnrequire = (moduleExports, ...args) => {
+      if (this._patched[filename] && patched.has(moduleExports)) {
+        return patched.get(moduleExports)
+      }
+
+      const result = onrequire(moduleExports, ...args)
+      if (result && (typeof result === 'object' || typeof result === 'function')) {
+        patched.set(moduleExports, result)
+        patched.set(result, result)
+      }
+
+      return result
+    }
+
     if (
       isIitm &&
       moduleExports.default &&
       (typeof moduleExports.default === 'object' ||
       typeof moduleExports.default === 'function')
     ) {
-      defaultWrapResult = onrequire(moduleExports.default, moduleName, moduleBaseDir, moduleVersion, isIitm)
+      defaultWrapResult = wrappedOnrequire(moduleExports.default, moduleName, moduleBaseDir, moduleVersion, isIitm)
     }
 
-    const newExports = onrequire(moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm)
+    const newExports = wrappedOnrequire(moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm)
 
     if (defaultWrapResult) newExports.default = defaultWrapResult
 
     this._patched[filename] = true
-    if (newExports &&
-      (typeof newExports === 'object' ||
-      typeof newExports === 'function')) {
-      patched.set(moduleExports, newExports)
-    }
+
     return newExports
   }
 

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

@@ -1,95 +1,45 @@
 'use strict'
 
-/*
-This rewriter is basically a JavaScript version of Orchestrion-JS. The goal is
-not to replace Orchestrion-JS, but rather to make it easier and faster to write
-new integrations in the short-term, especially as many changes to the rewriter
-will be needed as all the patterns we need have not been identified yet. This
-will avoid the back and forth of having to make Rust changes to an external
-library for every integration change or addition that requires something new.
-
-In the meantime, we'll work concurrently on a change to Orchestrion-JS that
-adds an "arbitrary transform" or "plugin" system that can be used from
-JavaScript, in order to enable quick iteration while still using Orchestrion-JS.
-Once that's done we'll use that, so that we can remove this JS approach and
-return to using Orchestrion-JS.
-
-The long term goal is to backport any additional features we add to the JS
-rewriter (or using the plugin system in Orchestrion-JS once we're using that)
-to Orchestrion-JS  once we're confident that the implementation is fairly
-complete and has all features we need.
-
-Here is a list of the additions and changes in this rewriter compared to
-Orchestrion-JS that will need to be backported:
-
-(NOTE: Please keep this list up-to-date whenever new features are added)
-
-- Supports an `astQuery` field to filter AST nodes with an esquery query. This
-  is mostly meant to be used when experimenting or if what needs to be queried
-  is not a function. We'll see over time if something like this is needed to be
-  backported or if it can be replaced by simpler queries.
-- Supports replacing methods of child class instances in the base constructor.
-*/
-
 const { readFileSync } = require('fs')
 const { join } = require('path')
-const semifies = require('../../../../../vendor/dist/semifies')
 const log = require('../../../../dd-trace/src/log')
-const { getEnvironmentVariable } = require('../../../../dd-trace/src/config/helper')
-const transforms = require('./transforms')
-const { generate, parse, traverse } = require('./compiler')
 const instrumentations = require('./instrumentations')
+const { create } = require('./orchestrion')
 
-const NODE_OPTIONS = getEnvironmentVariable('NODE_OPTIONS')
-
-const supported = {}
+/** @type {Record<string, string>} map of module base name to version */
+const moduleVersions = {}
 const disabled = new Set()
-
-// TODO: Source maps without `--enable-source-maps`.
-const enableSourceMaps = NODE_OPTIONS?.includes('--enable-source-maps') ||
-  process.execArgv?.some(arg => arg.includes('--enable-source-maps'))
-
-let SourceMapGenerator
+const matcher = create(instrumentations, 'dc-polyfill')
 
 function rewrite (content, filename, format) {
   if (!content) return content
+  if (!filename.includes('node_modules')) return content
 
-  try {
-    let ast
-
-    filename = filename.replace('file://', '')
-
-    for (const inst of instrumentations) {
-      const { astQuery, functionQuery = {}, module: { name, versionRange, filePath } } = inst
-      const { kind } = functionQuery
-      const operator = kind === 'Async' ? 'tracePromise' : kind === 'Callback' ? 'traceCallback' : 'traceSync'
-      const transform = transforms[operator]
+  filename = filename.replace('file://', '')
 
-      if (disabled.has(name)) continue
-      if (!filename.endsWith(`${name}/${filePath}`)) continue
-      if (!transform) continue
-      if (!satisfies(filename, filePath, versionRange)) continue
+  const moduleType = format === 'module' ? 'esm' : 'cjs'
+  const [modulePath] = filename.split('/node_modules/').reverse()
+  const moduleParts = modulePath.split('/')
+  const splitIndex = moduleParts[0].startsWith('@') ? 2 : 1
+  const moduleName = moduleParts.slice(0, splitIndex).join('/')
+  const filePath = moduleParts.slice(splitIndex).join('/')
+  const version = getVersion(filename, filePath)
 
-      ast ??= parse(content.toString(), { loc: true, ranges: true, module: format === 'module' })
+  if (disabled.has(moduleName)) return content
 
-      const query = astQuery || fromFunctionQuery(functionQuery)
-      const state = { ...inst, format, functionQuery, operator }
+  const transformer = matcher.getTransformer(moduleName, version, filePath)
 
-      traverse(ast, query, (...args) => transform(state, ...args))
-    }
+  if (!transformer) return content
 
-    if (ast) {
-      if (!enableSourceMaps) return generate(ast)
+  try {
+    // TODO: pass existing sourcemap as input for remapping
+    const { code, map } = transformer.transform(content, moduleType)
 
-      // TODO: Can we use the same version of `source-map` that DI uses?
-      SourceMapGenerator ??= require('../../../../../vendor/dist/@datadog/source-map').SourceMapGenerator
+    if (!map) return code
 
-      const sourceMap = new SourceMapGenerator({ file: filename })
-      const code = generate(ast, { sourceMap })
-      const map = Buffer.from(sourceMap.toString()).toString('base64')
+    const inlineMap = Buffer.from(map).toString('base64')
 
-      return code + '\n' + `//# sourceMappingURL=data:application/json;base64,${map}`
-    }
+    return code + '\n' + `//# sourceMappingURL=data:application/json;base64,${inlineMap}`
   } catch (e) {
     log.error(e)
   }
@@ -101,53 +51,20 @@ function disable (instrumentation) {
   disabled.add(instrumentation)
 }
 
-function satisfies (filename, filePath, versions) {
+function getVersion (filename, filePath) {
   const [basename] = filename.split(filePath)
 
-  if (supported[basename] === undefined) {
+  if (!moduleVersions[basename]) {
     try {
       const pkg = JSON.parse(readFileSync(
         join(basename, 'package.json'), 'utf8'
       ))
 
-      supported[basename] = semifies(pkg.version, versions)
-    } catch {
-      supported[basename] = false
-    }
-  }
-
-  return supported[basename]
-}
-
-// TODO: Support index
-function fromFunctionQuery (functionQuery) {
-  const { methodName, functionName, expressionName, className } = functionQuery
-  const queries = []
-
-  if (className) {
-    queries.push(
-      `[id.name="${className}"]`,
-      `[id.name="${className}"] > ClassExpression`,
-      `[id.name="${className}"] > ClassBody > [key.name="${methodName}"] > [async]`,
-      `[id.name="${className}"] > ClassExpression > ClassBody > [key.name="${methodName}"] > [async]`
-    )
-  } else if (methodName) {
-    queries.push(
-      `ClassBody > [key.name="${methodName}"] > [async]`,
-      `Property[key.name="${methodName}"] > [async]`
-    )
-  }
-
-  if (functionName) {
-    queries.push(`FunctionDeclaration[id.name="${functionName}"][async]`)
-  } else if (expressionName) {
-    queries.push(
-      `FunctionExpression[id.name="${expressionName}"][async]`,
-      `ArrowFunctionExpression[id.name="${expressionName}"][async]`
-    )
+      moduleVersions[basename] = pkg.version
+    } catch {}
   }
 
-  return queries.join(', ')
+  return moduleVersions[basename]
 }
 
 module.exports = { rewrite, disable }

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

@@ -0,0 +1,103 @@
+'use strict'
+
+module.exports = [
+  // getTracer - for patching tracer
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=4.0.0',
+      filePath: 'dist/index.js',
+    },
+    functionQuery: {
+      functionName: 'getTracer',
+      kind: 'Sync',
+    },
+    channelName: 'getTracer',
+  },
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=4.0.0',
+      filePath: 'dist/index.mjs',
+    },
+    functionQuery: {
+      functionName: 'getTracer',
+      kind: 'Sync',
+    },
+    channelName: 'getTracer',
+  },
+  // selectTelemetryAttributes - makes sure we set isEnabled properly
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=4.0.0 <6.0.0',
+      filePath: 'dist/index.js',
+    },
+    functionQuery: {
+      functionName: 'selectTelemetryAttributes',
+      kind: 'Sync',
+    },
+    channelName: 'selectTelemetryAttributes',
+  },
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=4.0.0 <6.0.0',
+      filePath: 'dist/index.mjs',
+    },
+    functionQuery: {
+      functionName: 'selectTelemetryAttributes',
+      kind: 'Sync',
+    },
+    channelName: 'selectTelemetryAttributes',
+  },
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=6.0.0',
+      filePath: 'dist/index.js',
+    },
+    functionQuery: {
+      functionName: 'selectTelemetryAttributes',
+      kind: 'Async',
+    },
+    channelName: 'selectTelemetryAttributes',
+  },
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=6.0.0',
+      filePath: 'dist/index.mjs',
+    },
+    functionQuery: {
+      functionName: 'selectTelemetryAttributes',
+      kind: 'Async',
+    },
+    channelName: 'selectTelemetryAttributes',
+  },
+  // tool
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=4.0.0',
+      filePath: 'dist/index.js',
+    },
+    functionQuery: {
+      functionName: 'tool',
+      kind: 'Sync',
+    },
+    channelName: 'tool',
+  },
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=4.0.0',
+      filePath: 'dist/index.mjs',
+    },
+    functionQuery: {
+      functionName: 'tool',
+      kind: 'Sync',
+    },
+    channelName: 'tool',
+  },
+]