dd-trace 5.23.1 → 5.25.0

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/avsc.js

@@ -0,0 +1,37 @@
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+
+const dc = require('dc-polyfill')
+const serializeChannel = dc.channel('apm:avsc:serialize-start')
+const deserializeChannel = dc.channel('apm:avsc:deserialize-end')
+
+function wrapSerialization (Type) {
+  shimmer.wrap(Type.prototype, 'toBuffer', original => function () {
+    if (!serializeChannel.hasSubscribers) {
+      return original.apply(this, arguments)
+    }
+    serializeChannel.publish({ messageClass: this })
+    return original.apply(this, arguments)
+  })
+}
+
+function wrapDeserialization (Type) {
+  shimmer.wrap(Type.prototype, 'fromBuffer', original => function () {
+    if (!deserializeChannel.hasSubscribers) {
+      return original.apply(this, arguments)
+    }
+    const result = original.apply(this, arguments)
+    deserializeChannel.publish({ messageClass: result })
+    return result
+  })
+}
+
+addHook({
+  name: 'avsc',
+  versions: ['>=5.0.0']
+}, avro => {
+  wrapDeserialization(avro.Type)
+  wrapSerialization(avro.Type)
+
+  return avro
+})

package/packages/datadog-instrumentations/src/azure-functions.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const {
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const dc = require('dc-polyfill')
+
+const azureFunctionsChannel = dc.tracingChannel('datadog:azure-functions:invoke')
+
+addHook({ name: '@azure/functions', versions: ['>=4'] }, azureFunction => {
+  const { app } = azureFunction
+
+  shimmer.wrap(app, 'deleteRequest', wrapHandler)
+  shimmer.wrap(app, 'http', wrapHandler)
+  shimmer.wrap(app, 'get', wrapHandler)
+  shimmer.wrap(app, 'patch', wrapHandler)
+  shimmer.wrap(app, 'post', wrapHandler)
+  shimmer.wrap(app, 'put', wrapHandler)
+
+  return azureFunction
+})
+
+// The http methods are overloaded so we need to check which type of argument was passed in order to wrap the handler
+// The arguments are either an object with a handler property or the handler function itself
+function wrapHandler (method) {
+  return function (name, arg) {
+    if (typeof arg === 'object' && arg.hasOwnProperty('handler')) {
+      const options = arg
+      shimmer.wrap(options, 'handler', handler => traceHandler(handler, name, method.name))
+    } else if (typeof arg === 'function') {
+      const handler = arg
+      arguments[1] = shimmer.wrapFunction(handler, handler => traceHandler(handler, name, method.name))
+    }
+    return method.apply(this, arguments)
+  }
+}
+
+function traceHandler (handler, functionName, methodName) {
+  return function (...args) {
+    const httpRequest = args[0]
+    const invocationContext = args[1]
+    return azureFunctionsChannel.tracePromise(
+      handler,
+      { functionName, httpRequest, invocationContext, methodName },
+      this, ...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) {
@@ -61,14 +98,33 @@ function wrapChildProcessSyncMethod (shell = false) {
 
       const childProcessInfo = normalizeArgs(arguments, shell)
 
-      return childProcessChannel.traceSync(
-        childProcessMethod,
-        {
-          command: childProcessInfo.command,
-          shell: childProcessInfo.shell
-        },
-        this,
-        ...arguments)
+      const innerResource = new AsyncResource('bound-anonymous-fn')
+      return innerResource.runInAsyncScope(() => {
+        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)
+        }
+      })
     }
   }
 }
@@ -81,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) {
@@ -101,11 +191,39 @@ function wrapChildProcessAsyncMethod (shell = false) {
 
       const childProcessInfo = normalizeArgs(arguments, shell)
 
+      const cb = arguments[arguments.length - 1]
+      if (typeof cb === 'function') {
+        const callbackResource = new AsyncResource('bound-anonymous-fn')
+        arguments[arguments.length - 1] = callbackResource.bind(cb)
+      }
+
       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
 
@@ -120,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

@@ -3,6 +3,7 @@
 const { createWrapRouterMethod } = require('./router')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel } = require('./helpers/instrument')
+const tracingChannel = require('dc-polyfill').tracingChannel
 
 const handleChannel = channel('apm:express:request:handle')
 
@@ -35,6 +36,27 @@ function wrapResponseJson (json) {
   }
 }
 
+const responseRenderChannel = tracingChannel('datadog:express:response:render')
+
+function wrapResponseRender (render) {
+  return function wrappedRender (view, options, callback) {
+    if (!responseRenderChannel.start.hasSubscribers) {
+      return render.apply(this, arguments)
+    }
+
+    return responseRenderChannel.traceSync(
+      render,
+      {
+        req: this.req,
+        view,
+        options
+      },
+      this,
+      ...arguments
+    )
+  }
+}
+
 addHook({ name: 'express', versions: ['>=4'] }, express => {
   shimmer.wrap(express.application, 'handle', wrapHandle)
   shimmer.wrap(express.Router, 'use', wrapRouterMethod)
@@ -42,6 +64,7 @@ addHook({ name: 'express', versions: ['>=4'] }, express => {
 
   shimmer.wrap(express.response, 'json', wrapResponseJson)
   shimmer.wrap(express.response, 'jsonp', wrapResponseJson)
+  shimmer.wrap(express.response, 'render', wrapResponseRender)
 
   return express
 })
@@ -79,11 +102,21 @@ addHook({
 })
 
 const processParamsStartCh = channel('datadog:express:process_params:start')
-const wrapProcessParamsMethod = (requestPositionInArguments) => {
-  return (original) => {
-    return function () {
+function wrapProcessParamsMethod (requestPositionInArguments) {
+  return function wrapProcessParams (original) {
+    return function wrappedProcessParams () {
       if (processParamsStartCh.hasSubscribers) {
-        processParamsStartCh.publish({ req: arguments[requestPositionInArguments] })
+        const req = arguments[requestPositionInArguments]
+        const abortController = new AbortController()
+
+        processParamsStartCh.publish({
+          req,
+          res: req?.res,
+          abortController,
+          params: req?.params
+        })
+
+        if (abortController.signal.aborted) return
       }
 
       return original.apply(this, arguments)

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

@@ -5,6 +5,7 @@ const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 
 const errorChannel = channel('apm:fastify:middleware:error')
 const handleChannel = channel('apm:fastify:request:handle')
+const routeAddedChannel = channel('apm:fastify:route:added')
 
 const parsingResources = new WeakMap()
 
@@ -16,6 +17,7 @@ function wrapFastify (fastify, hasParsingEvents) {
 
     if (!app || typeof app.addHook !== 'function') return app
 
+    app.addHook('onRoute', onRoute)
     app.addHook('onRequest', onRequest)
     app.addHook('preHandler', preHandler)
 
@@ -86,8 +88,9 @@ function onRequest (request, reply, done) {
 
   const req = getReq(request)
   const res = getRes(reply)
+  const routeConfig = getRouteConfig(request)
 
-  handleChannel.publish({ req, res })
+  handleChannel.publish({ req, res, routeConfig })
 
   return done()
 }
@@ -142,6 +145,10 @@ function getRes (reply) {
   return reply && (reply.raw || reply.res || reply)
 }
 
+function getRouteConfig (request) {
+  return request?.routeOptions?.config
+}
+
 function publishError (error, req) {
   if (error) {
     errorChannel.publish({ error, req })
@@ -150,6 +157,10 @@ function publishError (error, req) {
   return error
 }
 
+function onRoute (routeOptions) {
+  routeAddedChannel.publish({ routeOptions, onRoute })
+}
+
 addHook({ name: 'fastify', versions: ['>=3'] }, fastify => {
   const wrapped = shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, true))
 

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

@@ -266,24 +266,44 @@ function createWrapFunction (prefix = '', override = '') {
       const lastIndex = arguments.length - 1
       const cb = typeof arguments[lastIndex] === 'function' && arguments[lastIndex]
       const innerResource = new AsyncResource('bound-anonymous-fn')
-      const message = getMessage(method, getMethodParamsRelationByPrefix(prefix)[operation], arguments, this)
+      const params = getMethodParamsRelationByPrefix(prefix)[operation]
+      const abortController = new AbortController()
+      const message = { ...getMessage(method, params, arguments, this), abortController }
+
+      const finish = innerResource.bind(function (error) {
+        if (error !== null && typeof error === 'object') { // fs.exists receives a boolean
+          errorChannel.publish(error)
+        }
+        finishChannel.publish()
+      })
 
       if (cb) {
         const outerResource = new AsyncResource('bound-anonymous-fn')
 
         arguments[lastIndex] = shimmer.wrapFunction(cb, cb => innerResource.bind(function (e) {
-          if (e !== null && typeof e === 'object') { // fs.exists receives a boolean
-            errorChannel.publish(e)
-          }
-
-          finishChannel.publish()
-
+          finish(e)
           return outerResource.runInAsyncScope(() => cb.apply(this, arguments))
         }))
       }
 
       return innerResource.runInAsyncScope(() => {
         startChannel.publish(message)
+
+        if (abortController.signal.aborted) {
+          const error = abortController.signal.reason || new Error('Aborted')
+
+          if (prefix === 'promises.') {
+            finish(error)
+            return Promise.reject(error)
+          } else if (name.includes('Sync') || !cb) {
+            finish(error)
+            throw error
+          } else if (cb) {
+            arguments[lastIndex](error)
+            return
+          }
+        }
+
         try {
           const result = original.apply(this, arguments)
           if (cb) return result

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

@@ -5,6 +5,7 @@ module.exports = {
   '@apollo/gateway': () => require('../apollo'),
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
+  '@azure/functions': () => require('../azure-functions'),
   '@cucumber/cucumber': () => require('../cucumber'),
   '@playwright/test': () => require('../playwright'),
   '@elastic/elasticsearch': () => require('../elasticsearch'),
@@ -27,6 +28,7 @@ module.exports = {
   aerospike: () => require('../aerospike'),
   amqp10: () => require('../amqp10'),
   amqplib: () => require('../amqplib'),
+  avsc: () => require('../avsc'),
   'aws-sdk': () => require('../aws-sdk'),
   bluebird: () => require('../bluebird'),
   'body-parser': () => require('../body-parser'),
@@ -77,6 +79,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'),
@@ -88,6 +91,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'),
@@ -100,6 +104,7 @@ module.exports = {
   playwright: () => require('../playwright'),
   'promise-js': () => require('../promise-js'),
   promise: () => require('../promise'),
+  protobufjs: () => require('../protobufjs'),
   q: () => require('../q'),
   qs: () => require('../qs'),
   redis: () => require('../redis'),
@@ -111,6 +116,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

@@ -850,7 +850,8 @@ addHook({
 }, jestConfigSyncWrapper)
 
 const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = [
-  'selenium-webdriver'
+  'selenium-webdriver',
+  'winston'
 ]
 
 function shouldBypassJestRequireEngine (moduleName) {