dd-trace 4.48.0 → 4.50.0

package/packages/datadog-core/src/utils/src/parse-tags.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const digitRegex = /^\d+$/
+
+/**
+ * Converts a flat object of tags into a nested object. For example:
+ *   { 'a.b.c': 'value' } -> { a: { b: { c: 'value' } } }
+ * Also supports array-keys. For example:
+ *   { 'a.0.b': 'value' } -> { a: [{ b: 'value' }] }
+ *
+ * @param {Object} tags - Key/value pairs of tags
+ * @returns Object - Parsed tags
+ */
+module.exports = tags => {
+  const parsedTags = {}
+  for (const [tag, value] of Object.entries(tags)) {
+    const keys = tag.split('.')
+    let current = parsedTags
+    let depth = 0
+    for (const key of keys) {
+      if (!current[key]) {
+        if (depth === keys.length - 1) {
+          current[key] = value
+          break
+        }
+        current[key] = keys[depth + 1]?.match(digitRegex) ? [] : {}
+      }
+      current = current[key]
+      depth++
+    }
+  }
+  return parsedTags
+}

package/packages/datadog-esbuild/index.js

@@ -96,7 +96,9 @@ module.exports.setup = function (build) {
 
       let pathToPackageJson
       try {
-        pathToPackageJson = require.resolve(`${extracted.pkg}/package.json`, { paths: [args.resolveDir] })
+        // we can't use require.resolve('pkg/package.json') as ESM modules don't make the file available
+        pathToPackageJson = require.resolve(`${extracted.pkg}`, { paths: [args.resolveDir] })
+        pathToPackageJson = extractPackageAndModulePath(pathToPackageJson).pkgJson
       } catch (err) {
         if (err.code === 'MODULE_NOT_FOUND') {
           if (!internal) {
@@ -111,7 +113,7 @@ module.exports.setup = function (build) {
         }
       }
 
-      const packageJson = require(pathToPackageJson)
+      const packageJson = JSON.parse(fs.readFileSync(pathToPackageJson).toString())
 
       if (DEBUG) console.log(`RESOLVE: ${args.path}@${packageJson.version}`)
 

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

@@ -25,6 +25,70 @@ addHook({ name: 'amqplib', file: 'lib/defs.js', versions: [MIN_VERSION] }, defs
   return defs
 })
 
+addHook({ name: 'amqplib', file: 'lib/channel_model.js', versions: [MIN_VERSION] }, x => {
+  shimmer.wrap(x.Channel.prototype, 'get', getMessage => function (queue, options) {
+    return getMessage.apply(this, arguments).then(message => {
+      if (message === null) {
+        return message
+      }
+      startCh.publish({ method: 'basic.get', message, fields: message.fields, queue })
+      // finish right away
+      finishCh.publish()
+      return message
+    })
+  })
+  shimmer.wrap(x.Channel.prototype, 'consume', consume => function (queue, callback, options) {
+    if (!startCh.hasSubscribers) {
+      return consume.apply(this, arguments)
+    }
+    arguments[1] = (message, ...args) => {
+      if (message === null) {
+        return callback(message, ...args)
+      }
+      startCh.publish({ method: 'basic.deliver', message, fields: message.fields, queue })
+      const result = callback(message, ...args)
+      finishCh.publish()
+      return result
+    }
+    return consume.apply(this, arguments)
+  })
+  return x
+})
+
+addHook({ name: 'amqplib', file: 'lib/callback_model.js', versions: [MIN_VERSION] }, channel => {
+  shimmer.wrap(channel.Channel.prototype, 'get', getMessage => function (queue, options, callback) {
+    if (!startCh.hasSubscribers) {
+      return getMessage.apply(this, arguments)
+    }
+    arguments[2] = (error, message, ...args) => {
+      if (error !== null || message === null) {
+        return callback(error, message, ...args)
+      }
+      startCh.publish({ method: 'basic.get', message, fields: message.fields, queue })
+      const result = callback(error, message, ...args)
+      finishCh.publish()
+      return result
+    }
+    return getMessage.apply(this, arguments)
+  })
+  shimmer.wrap(channel.Channel.prototype, 'consume', consume => function (queue, callback) {
+    if (!startCh.hasSubscribers) {
+      return consume.apply(this, arguments)
+    }
+    arguments[1] = (message, ...args) => {
+      if (message === null) {
+        return callback(message, ...args)
+      }
+      startCh.publish({ method: 'basic.deliver', message, fields: message.fields, queue })
+      const result = callback(message, ...args)
+      finishCh.publish()
+      return result
+    }
+    return consume.apply(this, arguments)
+  })
+  return channel
+})
+
 addHook({ name: 'amqplib', file: 'lib/channel.js', versions: [MIN_VERSION] }, channel => {
   shimmer.wrap(channel.Channel.prototype, 'sendImmediately', sendImmediately => function (method, fields) {
     return instrument(sendImmediately, this, arguments, methods[method], fields)
@@ -33,15 +97,11 @@ addHook({ name: 'amqplib', file: 'lib/channel.js', versions: [MIN_VERSION] }, ch
   shimmer.wrap(channel.Channel.prototype, 'sendMessage', sendMessage => function (fields) {
     return instrument(sendMessage, this, arguments, 'basic.publish', fields, arguments[2])
   })
-
-  shimmer.wrap(channel.BaseChannel.prototype, 'dispatchMessage', dispatchMessage => function (fields, message) {
-    return instrument(dispatchMessage, this, arguments, 'basic.deliver', fields, message)
-  })
   return channel
 })
 
 function instrument (send, channel, args, method, fields, message) {
-  if (!startCh.hasSubscribers) {
+  if (!startCh.hasSubscribers || method === 'basic.get') {
     return send.apply(channel, args)
   }
 

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

@@ -13,19 +13,38 @@ const childProcessChannel = dc.tracingChannel('datadog:child_process:execution')
 
 // ignored exec method because it calls to execFile directly
 const execAsyncMethods = ['execFile', 'spawn']
-const execSyncMethods = ['execFileSync', 'spawnSync']
 
 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
+}
+
+function returnSpawnSyncError (error, context) {
+  context.result = {
+    error,
+    status: null,
+    signal: null,
+    output: null,
+    stdout: null,
+    stderr: null,
+    pid: 0
+  }
+
+  return context.result
+}
+
 names.forEach(name => {
   addHook({ name }, childProcess => {
     if (!patched) {
       patched = true
-      shimmer.massWrap(childProcess, execAsyncMethods, wrapChildProcessAsyncMethod())
-      shimmer.massWrap(childProcess, execSyncMethods, wrapChildProcessSyncMethod())
-      shimmer.wrap(childProcess, 'execSync', wrapChildProcessSyncMethod(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))
     }
 
     return childProcess
@@ -34,17 +53,21 @@ names.forEach(name => {
 
 function normalizeArgs (args, shell) {
   const childProcessInfo = {
-    command: args[0]
+    command: args[0],
+    file: args[0]
   }
 
   if (Array.isArray(args[1])) {
     childProcessInfo.command = childProcessInfo.command + ' ' + args[1].join(' ')
+    childProcessInfo.fileArgs = args[1]
+
     if (args[2] !== null && typeof args[2] === 'object') {
       childProcessInfo.options = args[2]
     }
   } else if (args[1] !== null && typeof args[1] === 'object') {
     childProcessInfo.options = args[1]
   }
+
   childProcessInfo.shell = shell ||
     childProcessInfo.options?.shell === true ||
     typeof childProcessInfo.options?.shell === 'string'
@@ -52,7 +75,21 @@ function normalizeArgs (args, shell) {
   return childProcessInfo
 }
 
-function wrapChildProcessSyncMethod (shell = false) {
+function createContextFromChildProcessInfo (childProcessInfo) {
+  const context = {
+    command: childProcessInfo.command,
+    file: childProcessInfo.file,
+    shell: childProcessInfo.shell
+  }
+
+  if (childProcessInfo.fileArgs) {
+    context.fileArgs = childProcessInfo.fileArgs
+  }
+
+  return context
+}
+
+function wrapChildProcessSyncMethod (returnError, shell = false) {
   return function wrapMethod (childProcessMethod) {
     return function () {
       if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
@@ -63,14 +100,30 @@ function wrapChildProcessSyncMethod (shell = false) {
 
       const innerResource = new AsyncResource('bound-anonymous-fn')
       return innerResource.runInAsyncScope(() => {
-        return childProcessChannel.traceSync(
-          childProcessMethod,
-          {
-            command: childProcessInfo.command,
-            shell: childProcessInfo.shell
-          },
-          this,
-          ...arguments)
+        const context = createContextFromChildProcessInfo(childProcessInfo)
+        const abortController = new AbortController()
+
+        childProcessChannel.start.publish({ ...context, abortController })
+
+        try {
+          if (abortController.signal.aborted) {
+            const error = abortController.signal.reason || new Error('Aborted')
+            // expected behaviors on error are different
+            return returnError(error, context)
+          }
+
+          const result = childProcessMethod.apply(this, arguments)
+          context.result = result
+
+          return result
+        } catch (err) {
+          context.error = err
+          childProcessChannel.error.publish(context)
+
+          throw err
+        } finally {
+          childProcessChannel.end.publish(context)
+        }
       })
     }
   }
@@ -84,18 +137,52 @@ function wrapChildProcessCustomPromisifyMethod (customPromisifyMethod, shell) {
 
     const childProcessInfo = normalizeArgs(arguments, shell)
 
-    return childProcessChannel.tracePromise(
-      customPromisifyMethod,
-      {
-        command: childProcessInfo.command,
-        shell: childProcessInfo.shell
-      },
-      this,
-      ...arguments)
+    const context = createContextFromChildProcessInfo(childProcessInfo)
+
+    const { start, end, asyncStart, asyncEnd, error } = childProcessChannel
+    const abortController = new AbortController()
+
+    start.publish({
+      ...context,
+      abortController
+    })
+
+    let result
+    if (abortController.signal.aborted) {
+      result = Promise.reject(abortController.signal.reason || new Error('Aborted'))
+    } else {
+      try {
+        result = customPromisifyMethod.apply(this, arguments)
+      } catch (error) {
+        error.publish({ ...context, error })
+        throw error
+      } finally {
+        end.publish(context)
+      }
+    }
+
+    function reject (err) {
+      context.error = err
+      error.publish(context)
+      asyncStart.publish(context)
+
+      asyncEnd.publish(context)
+      return Promise.reject(err)
+    }
+
+    function resolve (result) {
+      context.result = result
+      asyncStart.publish(context)
+
+      asyncEnd.publish(context)
+      return result
+    }
+
+    return Promise.prototype.then.call(result, resolve, reject)
   }
 }
 
-function wrapChildProcessAsyncMethod (shell = false) {
+function wrapChildProcessAsyncMethod (ChildProcess, shell = false) {
   return function wrapMethod (childProcessMethod) {
     function wrappedChildProcessMethod () {
       if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
@@ -112,9 +199,31 @@ function wrapChildProcessAsyncMethod (shell = false) {
 
       const innerResource = new AsyncResource('bound-anonymous-fn')
       return innerResource.runInAsyncScope(() => {
-        childProcessChannel.start.publish({ command: childProcessInfo.command, shell: childProcessInfo.shell })
+        const context = createContextFromChildProcessInfo(childProcessInfo)
+        const abortController = new AbortController()
+
+        childProcessChannel.start.publish({ ...context, abortController })
+
+        let childProcess
+        if (abortController.signal.aborted) {
+          childProcess = new ChildProcess()
+          childProcess.on('error', () => {}) // Original method does not crash when non subscribers
+
+          process.nextTick(() => {
+            const error = abortController.signal.reason || new Error('Aborted')
+            childProcess.emit('error', error)
+
+            const cb = arguments[arguments.length - 1]
+            if (typeof cb === 'function') {
+              cb(error)
+            }
+
+            childProcess.emit('close')
+          })
+        } else {
+          childProcess = childProcessMethod.apply(this, arguments)
+        }
 
-        const childProcess = childProcessMethod.apply(this, arguments)
         if (childProcess) {
           let errorExecuted = false
 
@@ -129,8 +238,7 @@ function wrapChildProcessAsyncMethod (shell = false) {
               childProcessChannel.error.publish()
             }
             childProcessChannel.asyncEnd.publish({
-              command: childProcessInfo.command,
-              shell: childProcessInfo.shell,
+              ...context,
               result: code
             })
           })

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

@@ -29,7 +29,7 @@ function wrapResponseJson (json) {
         obj = arguments[1]
       }
 
-      responseJsonChannel.publish({ req: this.req, body: obj })
+      responseJsonChannel.publish({ req: this.req, res: this, body: obj })
     }
 
     return json.apply(this, arguments)

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

@@ -0,0 +1,40 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const handlebarsCompileCh = channel('datadog:handlebars:compile:start')
+const handlebarsRegisterPartialCh = channel('datadog:handlebars:register-partial:start')
+
+function wrapCompile (compile) {
+  return function wrappedCompile (source) {
+    if (handlebarsCompileCh.hasSubscribers) {
+      handlebarsCompileCh.publish({ source })
+    }
+
+    return compile.apply(this, arguments)
+  }
+}
+
+function wrapRegisterPartial (registerPartial) {
+  return function wrappedRegisterPartial (name, partial) {
+    if (handlebarsRegisterPartialCh.hasSubscribers) {
+      handlebarsRegisterPartialCh.publish({ partial })
+    }
+
+    return registerPartial.apply(this, arguments)
+  }
+}
+
+addHook({ name: 'handlebars', file: 'dist/cjs/handlebars/compiler/compiler.js', versions: ['>=4.0.0'] }, compiler => {
+  shimmer.wrap(compiler, 'compile', wrapCompile)
+  shimmer.wrap(compiler, 'precompile', wrapCompile)
+
+  return compiler
+})
+
+addHook({ name: 'handlebars', file: 'dist/cjs/handlebars/base.js', versions: ['>=4.0.0'] }, base => {
+  shimmer.wrap(base.HandlebarsEnvironment.prototype, 'registerPartial', wrapRegisterPartial)
+
+  return base
+})

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

@@ -51,6 +51,7 @@ module.exports = {
   'generic-pool': () => require('../generic-pool'),
   graphql: () => require('../graphql'),
   grpc: () => require('../grpc'),
+  handlebars: () => require('../handlebars'),
   hapi: () => require('../hapi'),
   http: () => require('../http'),
   http2: () => require('../http2'),
@@ -79,6 +80,7 @@ module.exports = {
   'mongodb-core': () => require('../mongodb-core'),
   mongoose: () => require('../mongoose'),
   mquery: () => require('../mquery'),
+  multer: () => require('../multer'),
   mysql: () => require('../mysql'),
   mysql2: () => require('../mysql2'),
   net: () => require('../net'),
@@ -90,6 +92,7 @@ module.exports = {
   'node:http2': () => require('../http2'),
   'node:https': () => require('../http'),
   'node:net': () => require('../net'),
+  'node:url': () => require('../url'),
   nyc: () => require('../nyc'),
   oracledb: () => require('../oracledb'),
   openai: () => require('../openai'),
@@ -103,6 +106,7 @@ module.exports = {
   'promise-js': () => require('../promise-js'),
   promise: () => require('../promise'),
   protobufjs: () => require('../protobufjs'),
+  pug: () => require('../pug'),
   q: () => require('../q'),
   qs: () => require('../qs'),
   redis: () => require('../redis'),
@@ -114,6 +118,7 @@ module.exports = {
   sharedb: () => require('../sharedb'),
   tedious: () => require('../tedious'),
   undici: () => require('../undici'),
+  url: () => require('../url'),
   vitest: { esmFirst: true, fn: () => require('../vitest') },
   when: () => require('../when'),
   winston: () => require('../winston'),

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

@@ -22,6 +22,15 @@ const disabledInstrumentations = new Set(
   DD_TRACE_DISABLED_INSTRUMENTATIONS ? DD_TRACE_DISABLED_INSTRUMENTATIONS.split(',') : []
 )
 
+// Check for DD_TRACE_<INTEGRATION>_ENABLED environment variables
+for (const [key, value] of Object.entries(process.env)) {
+  const match = key.match(/^DD_TRACE_(.+)_ENABLED$/)
+  if (match && (value.toLowerCase() === 'false' || value === '0')) {
+    const integration = match[1].toLowerCase()
+    disabledInstrumentations.add(integration)
+  }
+}
+
 const loadChannel = channel('dd-trace:instrumentation:load')
 
 // Globals

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

@@ -127,6 +127,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
       if (repositoryRoot) {
         this.testSourceFile = getTestSuitePath(context.testPath, repositoryRoot)
+        this.repositoryRoot = repositoryRoot
       }
 
       this.isEarlyFlakeDetectionEnabled = this.testEnvironmentOptions._ddIsEarlyFlakeDetectionEnabled
@@ -667,10 +668,13 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
          * controls whether coverage is reported.
         */
         if (environment.testEnvironmentOptions?._ddTestCodeCoverageEnabled) {
+          const root = environment.repositoryRoot || environment.rootDir
+
           const coverageFiles = getCoveredFilenamesFromCoverage(environment.global.__coverage__)
-            .map(filename => getTestSuitePath(filename, environment.rootDir))
+            .map(filename => getTestSuitePath(filename, root))
+
           asyncResource.runInAsyncScope(() => {
-            testSuiteCodeCoverageCh.publish({ coverageFiles, testSuite: environment.testSuite })
+            testSuiteCodeCoverageCh.publish({ coverageFiles, testSuite: environment.testSourceFile })
           })
         }
         testSuiteFinishCh.publish({ status, errorMessage })