dd-trace 6.15.0 → 6.17.0

package/packages/datadog-instrumentations/src/helpers/instrumentation-utils.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const { builtinModules } = require('node:module')
+
+const satisfies = require('../../../../vendor/dist/semifies')
+const { getValueFromEnvSources } = require('../../../dd-trace/src/config/helper')
+const { isRelativeRequire } = require('./shared-utils')
+
+/**
+ * @param {string|undefined} version
+ * @param {string[]|undefined} ranges
+ */
+function matchVersion (version, ranges) {
+  return !version || !ranges || ranges.some(range => satisfies(version, range))
+}
+
+/**
+ * @param {string} name
+ * @param {string} [file]
+ */
+function filename (name, file) {
+  return file ? `${name}/${file}` : name
+}
+
+/**
+ * @param {string} name
+ * @param {string|undefined} version
+ * @param {string} moduleName
+ * @param {{ file?: string, filePattern?: string, versions?: string[] }} instrumentation
+ */
+function matchesInstrumentation (name, version, moduleName, instrumentation) {
+  const { file, filePattern, versions } = instrumentation
+  let matchesFile = moduleName === filename(name, file)
+  if (!matchesFile && isRelativeRequire(name)) matchesFile = true
+  if (!matchesFile && filePattern) {
+    matchesFile = new RegExp(filename(name, filePattern)).test(moduleName)
+  }
+  return matchesFile && matchVersion(version, versions)
+}
+
+/**
+ * @returns {Set<string>}
+ */
+function getDisabledInstrumentations () {
+  const disabled = new Set(
+    getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')?.split(',').filter(Boolean)
+  )
+  if (disabled.size === 0) return disabled
+
+  const expanded = new Set(disabled)
+  const builtins = new Set(builtinModules)
+
+  for (const name of disabled) {
+    const prefixed = name.startsWith('node:')
+    if (!prefixed && !builtins.has(name)) continue
+
+    const counterpart = prefixed ? name.slice(5) : `node:${name}`
+    expanded.add(counterpart)
+  }
+
+  return expanded
+}
+
+module.exports = {
+  filename,
+  getDisabledInstrumentations,
+  matchesInstrumentation,
+  matchVersion,
+}

package/packages/datadog-instrumentations/src/helpers/pool-acquire.js

@@ -400,9 +400,6 @@ function getConnectionForAcquire (getConnection, pool, args, acquireCtx, start,
   }
 }
 
-/**
- * @returns {boolean}
- */
 function isPoolQueryAcquire () {
   return currentPoolQueryAcquire !== undefined
 }
@@ -436,7 +433,6 @@ function runWithPoolQueryAcquire (acquire, method, receiver, args) {
 
 /**
  * @param {object} pool
- * @returns {boolean}
  */
 function takeDeferredPoolQueryAcquire (pool) {
   const acquire = deferredPoolQueryAcquireStorage?.getStore()
@@ -579,7 +575,6 @@ function setPoolAcquireCaptureWaitTime (capture, waitTime) {
  * @param {Record<string, unknown>} receiver
  * @param {string} acquireMethod
  * @param {unknown[]} args
- * @returns {boolean}
  */
 function dispatchesAcquireSynchronously (method, receiver, acquireMethod, args) {
   let dispatched = false
@@ -618,7 +613,6 @@ function acquireStart (pool, acquire) {
 
 /**
  * @param {number|undefined} start
- * @returns {number}
  */
 function acquireWait (start) {
   return start === undefined ? 0 : performance.now() - start

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

@@ -1,20 +1,20 @@
 'use strict'
 
-const { builtinModules } = require('module')
 const path = require('path')
 const { channel } = require('dc-polyfill')
-const satisfies = require('../../../../vendor/dist/semifies')
 const log = require('../../../dd-trace/src/log')
 const telemetry = require('../../../dd-trace/src/guardrails/telemetry')
 const { IS_SERVERLESS } = require('../../../dd-trace/src/serverless')
 const { getValueFromEnvSources } = require('../../../dd-trace/src/config/helper')
 const checkRequireCache = require('./check-require-cache')
 const Hook = require('./hook')
-const { isRelativeRequire } = require('./shared-utils')
+const {
+  filename,
+  getDisabledInstrumentations,
+  matchesInstrumentation,
+} = require('./instrumentation-utils')
 const rewriter = require('./rewriter')
 
-const DD_TRACE_DISABLED_INSTRUMENTATIONS =
-  getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')
 const DD_TRACE_DEBUG = getValueFromEnvSources('DD_TRACE_DEBUG')
 
 const hooks = require('./hooks')
@@ -22,9 +22,7 @@ const instrumentations = require('./instrumentations')
 const names = Object.keys(hooks)
 const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
 
-const disabledInstrumentations = new Set(
-  DD_TRACE_DISABLED_INSTRUMENTATIONS?.split(',')
-)
+const disabledInstrumentations = getDisabledInstrumentations()
 
 const loadChannel = channel('dd-trace:instrumentation:load')
 
@@ -37,6 +35,10 @@ if (!disabledInstrumentations.has('process')) {
   require('../process')
 }
 
+if (!disabledInstrumentations.has('console')) {
+  require('../console')
+}
+
 const debugEnabled = DD_TRACE_DEBUG
 checkRequireCache.checkForRequiredModules()
 if (debugEnabled) {
@@ -54,29 +56,6 @@ const instrumentedIntegrationsSuccess = new Map()
 /** @type {Set<string>} */
 const alreadyLoggedIncompatibleIntegrations = new Set()
 
-// Always disable prefixed and unprefixed node modules if one is disabled.
-if (disabledInstrumentations.size) {
-  const builtinsSet = new Set(builtinModules)
-  const disabledBuiltinCounterparts = []
-  for (const name of disabledInstrumentations) {
-    const hasPrefix = name.startsWith('node:')
-    if (hasPrefix || builtinsSet.has(name)) {
-      if (hasPrefix) {
-        const unprefixedName = name.slice(5)
-        if (!disabledInstrumentations.has(unprefixedName)) {
-          disabledBuiltinCounterparts.push(unprefixedName)
-        }
-      } else if (!disabledInstrumentations.has(`node:${name}`)) {
-        disabledBuiltinCounterparts.push(`node:${name}`)
-      }
-    }
-  }
-  for (const name of disabledBuiltinCounterparts) {
-    disabledInstrumentations.add(name)
-  }
-  builtinsSet.clear()
-}
-
 for (const name of names) {
   if (disabledInstrumentations.has(name)) continue
 
@@ -111,21 +90,9 @@ for (const name of names) {
       instrumentedNodeModules.set(name, moduleExports)
     }
 
-    for (const { file, versions, hook, filePattern, patchDefault } of instrumentations[name]) {
-      const fullFilename = filename(name, file)
-
-      let matchesFile = moduleName === fullFilename
-
-      if (!matchesFile && isRelativeRequire(name)) matchesFile = true
-
-      const fullFilePattern = filePattern && filename(name, filePattern)
-      if (fullFilePattern) {
-        // Some libraries include a hash in their filenames when installed,
-        // so our instrumentation has to include a '.*' to match them for more than a single version.
-        matchesFile ||= new RegExp(fullFilePattern).test(moduleName)
-      }
-
-      if (matchesFile && matchVersion(moduleVersion, versions)) {
+    for (const instrumentation of instrumentations[name]) {
+      if (matchesInstrumentation(name, moduleVersion, moduleName, instrumentation)) {
+        const { hook, patchDefault } = instrumentation
         // IITM invokes this callback for every module in the package. Only unwrap the namespace after its file and
         // version match, otherwise a default export from an unrelated internal module can replace that module.
         if (isIitm && patchDefault === !!moduleExports.default) {
@@ -188,26 +155,8 @@ function logAbortedIntegrations () {
   instrumentedIntegrationsSuccess.clear()
 }
 
-/**
- * @param {string|undefined} version
- * @param {string[]|undefined} ranges
- */
-function matchVersion (version, ranges) {
-  return !version || !ranges || ranges.some(range => satisfies(version, range))
-}
-
-/**
- * @param {string} name
- * @param {string} [file]
- * @returns {string}
- */
-function filename (name, file) {
-  return file ? `${name}/${file}` : name
-}
-
 module.exports = {
   filename,
   pathSepExpr,
   loadChannel,
-  matchVersion,
 }

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

@@ -1,9 +1,11 @@
 'use strict'
 
-const { readFileSync } = require('fs')
-const { join } = require('path')
-const { pathToFileURL } = require('url')
+const { readFileSync } = require('node:fs')
+const { join } = require('node:path')
+const { fileURLToPath, pathToFileURL } = require('node:url')
+
 const log = require('../../../../dd-trace/src/log')
+const { getDisabledInstrumentations } = require('../instrumentation-utils')
 const instrumentations = require('./instrumentations')
 const { getRewriteTarget } = require('./targets')
 
@@ -13,14 +15,20 @@ const { getRewriteTarget } = require('./targets')
  * @property {(moduleName: string, version: string|undefined, filePath: string) => Transformer|undefined} getTransformer
  *
  * @typedef {object} Transformer
- * @property {(source: string, moduleType: 'cjs'|'esm') => { code: string, map?: string }} transform
+ * @property {(source: string, moduleType: 'cjs'|'esm', sourceMap?: string|object) =>
+ *   { code: string, map?: string|object }} transform
+ *
+ * @typedef {(content: string|Buffer|ArrayBuffer|Uint8Array, filename: string, format?: string,
+ *   target?: { moduleName: string, filePath: string }, sourceMap?: string|object) =>
+ *   { code: string|Buffer|ArrayBuffer|Uint8Array, map?: string|object }} BundlerRewriter
  */
 
 /**
  * @type {Record<string, string>} map of module base name to version
  */
 const moduleVersions = {}
-const disabled = new Set()
+// Asynchronous loader workers have their own module graph and cannot receive disable() calls made on the main thread.
+const disabled = getDisabledInstrumentations()
 
 // Matchers are built on the first module that actually needs rewriting. The
 // vendored transformer is a quarter megabyte of bundle that an application
@@ -36,6 +44,20 @@ let matcherEsm
 // eslint-disable-next-line unicorn/no-useless-concat -- Keep the source-map marker non-contiguous.
 const SOURCE_MAP_PREFIX = '//# sourceMapping' + 'URL=data:application/json;base64,'
 
+/**
+ * Loader hooks hand `file://` URLs to the rewriter while CommonJS and bundler
+ * callers pass plain paths. `fileURLToPath` is the only correct conversion: a
+ * plain scheme strip leaves Windows paths rooted at `/C:/` and keeps
+ * percent-encoded characters undecoded, which breaks version resolution.
+ * Rewrite-target paths use forward slashes, including on Windows.
+ *
+ * @param {string} filename
+ */
+function normalizeFilename (filename) {
+  const path = filename.startsWith('file://') ? fileURLToPath(filename) : filename
+  return path.replaceAll('\\', '/')
+}
+
 /**
  * @param {string|Buffer|ArrayBuffer|Uint8Array} content
  * @param {string} filename
@@ -46,30 +68,39 @@ const SOURCE_MAP_PREFIX = '//# sourceMapping' + 'URL=data:application/json;base6
 function rewrite (content, filename, format, target) {
   if (!content) return content
 
-  target ||= getRewriteTarget(filename)
-  if (!target) return content
-
-  filename = filename.replace('file://', '')
+  try {
+    filename = normalizeFilename(filename)
+    target ||= getRewriteTarget(filename)
+    if (!target) return content
 
-  const moduleType = format === 'module' ? 'esm' : 'cjs'
-  const { moduleName, filePath } = target
-  const version = getVersion(filename, filePath)
+    const moduleType = format === 'module' ? 'esm' : 'cjs'
+    const { moduleName, filePath } = target
+    if (disabled.has(moduleName)) return content
 
-  if (disabled.has(moduleName)) return content
+    const version = getVersion(filename, filePath)
+    if (!version) return content
 
-  const transformer = getMatcher(moduleType).getTransformer(moduleName, version, filePath)
+    const transformer = getMatcher(moduleType).getTransformer(moduleName, version, filePath)
 
-  if (!transformer) return content
+    if (!transformer) return content
 
-  try {
     const source = getSourceText(content)
 
     // TODO: pass existing sourcemap as input for remapping
-    const { code, map } = transformer.transform(source, moduleType)
+    let { code, map } = transformer.transform(source, moduleType)
+
+    if (source.startsWith('#!') && !code.startsWith('#!')) {
+      // A shebang must be the entire first line, and JavaScript recognizes
+      // exactly four line terminators: \n, \r, \u2028 (line separator), and
+      // \u2029 (paragraph separator). Any of the four can end the shebang line.
+      const shebangEnd = source.search(/[\r\n\u2028\u2029]/)
+      code = (shebangEnd === -1 ? source : source.slice(0, shebangEnd)) + '\n' + code
+      map = shiftSourceMapLine(map)
+    }
 
     if (!map) return code
 
-    const inlineMap = Buffer.from(map).toString('base64')
+    const inlineMap = Buffer.from(typeof map === 'string' ? map : JSON.stringify(map)).toString('base64')
 
     return code + '\n' + SOURCE_MAP_PREFIX + inlineMap
   } catch (e) {
@@ -79,46 +110,79 @@ function rewrite (content, filename, format, target) {
   return content
 }
 
+/**
+ * @param {string} dcModule
+ * @returns {BundlerRewriter}
+ */
+function createBundlerRewriter (dcModule) {
+  const matcher = createMatcher(dcModule)
+
+  return function rewriteBundled (content, filename, format, target, sourceMap) {
+    if (!content) return { code: content, map: sourceMap }
+
+    try {
+      filename = normalizeFilename(filename)
+      target ||= getRewriteTarget(filename)
+      if (!target) return { code: content, map: sourceMap }
+
+      const moduleType = format === 'module' ? 'esm' : 'cjs'
+      const { moduleName, filePath } = target
+      const version = getVersion(filename, filePath)
+      if (!version) return { code: content, map: sourceMap }
+
+      const transformer = matcher.getTransformer(moduleName, version, filePath)
+      if (!transformer) return { code: content, map: sourceMap }
+
+      return transformer.transform(getSourceText(content), moduleType, sourceMap)
+    } catch (error) {
+      log.error(error)
+      return { code: content, map: sourceMap }
+    }
+  }
+}
+
 /**
  * @param {'cjs'|'esm'} moduleType
  * @returns {InstrumentationMatcher}
  */
 function getMatcher (moduleType) {
   if (moduleType === 'esm') {
-    matcherEsm ??= createMatcher(moduleType)
+    matcherEsm ??= createMatcher(getDcPolyfillSpecifier(moduleType))
 
     return matcherEsm
   }
 
-  matcherCjs ??= createMatcher(moduleType)
+  matcherCjs ??= createMatcher(getDcPolyfillSpecifier(moduleType))
 
   return matcherCjs
 }
 
 /**
- * @param {'cjs'|'esm'} moduleType
+ * @param {string|undefined} dcModule
  * @returns {InstrumentationMatcher}
  */
-function createMatcher (moduleType) {
+function createMatcher (dcModule) {
   const { create } = require('../../../../../vendor/dist/@apm-js-collab/code-transformer')
   const {
     awaitContextCallback,
-    awaitContextCallbackAtFunctionStart,
-    awaitContextCallbackAtTryStart,
     configureGraphqlFastPath,
     configureGraphqlJitCompileObject,
     configureGraphqlJitDeferredField,
     configureGraphqlJitExecute,
     configureGraphqlJitRuntime,
     configureMercuriusRequest,
+    publishDurableOrchestrationFailure,
     waitForAsyncEnd,
   } = require('./transforms')
+  const {
+    postgresQueryHandlers,
+    postgresQueryLifecycle,
+    postgresQueryPreparation,
+  } = require('./transforms/postgres')
 
-  const matcher = create(instrumentations, getDcPolyfillSpecifier(moduleType))
+  const matcher = create(instrumentations, dcModule)
 
   matcher.addTransform('awaitContextCallback', awaitContextCallback)
-  matcher.addTransform('awaitContextCallbackAtFunctionStart', awaitContextCallbackAtFunctionStart)
-  matcher.addTransform('awaitContextCallbackAtTryStart', awaitContextCallbackAtTryStart)
   matcher.addTransform('waitForAsyncEnd', waitForAsyncEnd)
   matcher.addTransform('configureGraphqlFastPath', configureGraphqlFastPath)
   matcher.addTransform('configureGraphqlJitCompileObject', configureGraphqlJitCompileObject)
@@ -126,6 +190,10 @@ function createMatcher (moduleType) {
   matcher.addTransform('configureGraphqlJitExecute', configureGraphqlJitExecute)
   matcher.addTransform('configureGraphqlJitRuntime', configureGraphqlJitRuntime)
   matcher.addTransform('configureMercuriusRequest', configureMercuriusRequest)
+  matcher.addTransform('publishDurableOrchestrationFailure', publishDurableOrchestrationFailure)
+  matcher.addTransform('postgresQueryHandlers', postgresQueryHandlers)
+  matcher.addTransform('postgresQueryLifecycle', postgresQueryLifecycle)
+  matcher.addTransform('postgresQueryPreparation', postgresQueryPreparation)
 
   return matcher
 }
@@ -159,7 +227,6 @@ function getDcPolyfillSpecifier (moduleType) {
  * Convert the source representations accepted by Node.js loader hooks to text.
  *
  * @param {string | ArrayBuffer | BufferView} source
- * @returns {string}
  */
 function getSourceText (source) {
   if (typeof source === 'string') return source
@@ -169,6 +236,19 @@ function getSourceText (source) {
   return Buffer.from(source).toString('utf8')
 }
 
+/**
+ * Account for a shebang restored ahead of the generated program. The transformer already maps original positions
+ * past the input shebang, so only the generated side needs an additional empty line.
+ *
+ * @param {string|object|undefined} map
+ */
+function shiftSourceMapLine (map) {
+  if (!map) return map
+  const sourceMap = typeof map === 'string' ? JSON.parse(map) : map
+  const shifted = { ...sourceMap, mappings: `;${sourceMap.mappings}` }
+  return typeof map === 'string' ? JSON.stringify(shifted) : shifted
+}
+
 function disable (instrumentation) {
   disabled.add(instrumentation)
 }
@@ -189,4 +269,4 @@ function getVersion (filename, filePath) {
   return moduleVersions[basename]
 }
 
-module.exports = { rewrite, disable }
+module.exports = { createBundlerRewriter, disable, rewrite }

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentation-registry.js

@@ -0,0 +1,39 @@
+'use strict'
+
+// activationName is the plugin-manager key published after a target is successfully rewritten.
+const registry = [
+  { instrumentations: require('./instrumentations/ai') },
+  { activationName: '@azure/cosmos', instrumentations: require('./instrumentations/azure-cosmos') },
+  { instrumentations: require('./instrumentations/azure-durable-functions') },
+  { activationName: 'bullmq', instrumentations: require('./instrumentations/bullmq') },
+  { instrumentations: require('./instrumentations/claude-agent-sdk') },
+  { instrumentations: require('./instrumentations/graphql') },
+  { instrumentations: require('./instrumentations/graphql-jit') },
+  { activationName: '@langchain/core', instrumentations: require('./instrumentations/langchain') },
+  { activationName: '@langchain/langgraph', instrumentations: require('./instrumentations/langgraph') },
+  { activationName: 'mercurius', instrumentations: require('./instrumentations/mercurius') },
+  { instrumentations: require('./instrumentations/modelcontextprotocol-sdk') },
+  { instrumentations: require('./instrumentations/openai-agents') },
+  { instrumentations: require('./instrumentations/playwright') },
+  { instrumentations: require('./instrumentations/postgres') },
+  { instrumentations: require('./instrumentations/webdriverio') },
+  { instrumentations: require('./instrumentations/aws-durable-execution-sdk-js') },
+  { instrumentations: require('./instrumentations/supabase') },
+]
+
+const activationNames = new Map()
+for (const { activationName, instrumentations } of registry) {
+  if (!activationName) continue
+  for (const { module } of instrumentations) activationNames.set(module.name, activationName)
+}
+
+const instrumentations = registry.flatMap(entry => entry.instrumentations)
+
+/**
+ * @param {string} moduleName
+ */
+function getRewriteActivationName (moduleName) {
+  return activationNames.get(moduleName)
+}
+
+module.exports = { getRewriteActivationName, instrumentations, registry }

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/azure-durable-functions.js

@@ -0,0 +1,17 @@
+'use strict'
+
+module.exports = [
+  {
+    module: {
+      name: 'durable-functions',
+      versionRange: '>=3 <4',
+      filePath: 'lib/src/orchestrations/TaskOrchestrationExecutor.js',
+    },
+    functionQuery: {
+      className: 'TaskOrchestrationExecutor',
+      methodName: 'execute',
+    },
+    transform: 'publishDurableOrchestrationFailure',
+    channelName: 'TaskOrchestrationExecutor_failure',
+  },
+]

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

@@ -1,18 +1,5 @@
 'use strict'
 
-module.exports = [
-  ...require('./ai'),
-  ...require('./azure-cosmos'),
-  ...require('./bullmq'),
-  ...require('./claude-agent-sdk'),
-  ...require('./graphql'),
-  ...require('./graphql-jit'),
-  ...require('./langchain'),
-  ...require('./langgraph'),
-  ...require('./mercurius'),
-  ...require('./modelcontextprotocol-sdk'),
-  ...require('./openai-agents'),
-  ...require('./playwright'),
-  ...require('./webdriverio'),
-  ...require('./aws-durable-execution-sdk-js'),
-]
+const { instrumentations } = require('../instrumentation-registry')
+
+module.exports = instrumentations

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

@@ -93,6 +93,18 @@ module.exports = [
     },
     channelName: 'createRootSuite',
   },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/runner/index.js',
+    },
+    functionQuery: {
+      functionName: 'filterForShard',
+      kind: 'Sync',
+    },
+    channelName: 'filterForShard',
+  },
   {
     module: {
       name: 'playwright-core',

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

@@ -0,0 +1,36 @@
+'use strict'
+
+const handlers = ['src/index.js', 'cjs/src/index.js'].map(filePath => ({
+  module: {
+    name: 'postgres',
+    versionRange: '>=3.0.0',
+    filePath,
+  },
+  astQuery: 'Program',
+  transform: 'postgresQueryHandlers',
+  channelName: 'query',
+}))
+
+const preparations = ['src/connection.js', 'cjs/src/connection.js'].map(filePath => ({
+  module: {
+    name: 'postgres',
+    versionRange: '>=3.0.0',
+    filePath,
+  },
+  astQuery: 'Program',
+  transform: 'postgresQueryPreparation',
+  channelName: 'query:prepare',
+}))
+
+const lifecycles = ['src/query.js', 'cjs/src/query.js'].map(filePath => ({
+  module: {
+    name: 'postgres',
+    versionRange: '>=3.0.0',
+    filePath,
+  },
+  astQuery: 'Program',
+  transform: 'postgresQueryLifecycle',
+  channelName: 'query',
+}))
+
+module.exports = [...handlers, ...preparations, ...lifecycles]