dd-trace 5.73.0 → 5.75.0

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

@@ -259,7 +259,7 @@ function wrapRun (pl, isLatestVersion, version) {
     testStartCh.runStores(ctx, () => {})
     const promises = {}
     try {
-      this.eventBroadcaster.on('envelope', shimmer.wrapFunction(null, () => async (testCase) => {
+      this.eventBroadcaster.on('envelope', async (testCase) => {
         // Only supported from >=8.0.0
         if (testCase?.testCaseFinished) {
           const { testCaseFinished: { willBeRetried } } = testCase
@@ -289,7 +289,7 @@ function wrapRun (pl, isLatestVersion, version) {
             testStartCh.runStores(newCtx, () => {})
           }
         }
-      }))
+      })
       let promise
 
       testFnCh.runStores(ctx, () => {

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)

package/packages/datadog-instrumentations/src/helpers/router-helper.js

@@ -0,0 +1,238 @@
+'use strict'
+
+const { channel } = require('./instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const routerMountPaths = new WeakMap() // to track mount paths for router instances
+const layerMatchers = new WeakMap() // to store layer matchers
+const appMountedRouters = new WeakSet() // to track routers mounted via app.use()
+
+const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
+
+const routeAddedChannel = channel('apm:express:route:added')
+
+/**
+ * Joins two URL path segments into a single path
+ *
+ * @param {string} base - The base path
+ * @param {string} path - The path to append
+ * @returns {string|null} The joined path  or null if the combination would create an invalid route in Express
+ */
+function joinPath (base, path) {
+  if (!base || base === '/') return path || '/'
+  if (!path || path === '/') return base
+
+  // Express does not normalize paths without leading slashes.
+  // If either path doesn't start with '/', we should skip this combination.
+  // Allow only empty string for path
+  if (path !== '' && !path.startsWith('/')) return null
+  if (!base.startsWith('/')) return null
+
+  // Handle duplicate slashes when base ends with / and path starts with /
+  if (base.endsWith('/') && path.startsWith('/')) {
+    return base + path.slice(1)
+  }
+
+  return base + path
+}
+
+// Normalize route definitions coming from Express into a string representation
+function normalizeRoutePath (path) {
+  if (path == null) return null
+  if (typeof path === 'string') return path
+  if (path instanceof RegExp) return path.toString()
+
+  return String(path)
+}
+
+// Recursively publish every route reachable from the router.
+function collectRoutesFromRouter (router, prefix) {
+  if (!router?.stack?.length) return
+
+  for (const layer of router.stack) {
+    if (layer.route) {
+      // This layer has a direct route
+      const route = layer.route
+
+      const fullPaths = getRouteFullPaths(route, prefix)
+
+      for (const fullPath of fullPaths) {
+        for (const [method, enabled] of Object.entries(route.methods || {})) {
+          if (!enabled) continue
+          routeAddedChannel.publish({
+            method: normalizeMethodName(method),
+            path: fullPath
+          })
+        }
+      }
+    } else if (layer.handle?.stack?.length) {
+      // This layer contains a nested router
+      // Extract mount path from layer
+      const mountPath = typeof layer.path === 'string'
+        ? layer.path
+        : getLayerMatchers(layer)?.[0]?.path || ''
+
+      const nestedPrefix = joinPath(prefix, mountPath)
+      if (nestedPrefix === null) continue
+
+      // Set the mount path for the nested router
+      setRouterMountPath(layer.handle, nestedPrefix)
+      markAppMounted(layer.handle)
+      // Recursively collect from nested routers
+      collectRoutesFromRouter(layer.handle, nestedPrefix)
+    }
+  }
+}
+
+// Flatten any route definition into an array of normalized path strings.
+function normalizeRoutePaths (path) {
+  if (path == null) return []
+
+  if (Array.isArray(path) === false) {
+    const normalized = normalizeRoutePath(path)
+    return [normalized]
+  }
+
+  const paths = path.flat(Infinity)
+  const result = []
+  for (const _path of paths) {
+    const normalized = normalizeRoutePath(_path)
+    if (normalized !== null) {
+      result.push(normalized)
+    }
+  }
+
+  return result
+}
+
+function setRouterMountPath (router, mountPath) {
+  if (!router || typeof mountPath !== 'string') return
+  const existing = routerMountPaths.get(router)
+  if (existing) {
+    existing.add(mountPath)
+  } else {
+    routerMountPaths.set(router, new Set([mountPath]))
+  }
+}
+
+function getRouterMountPaths (router) {
+  const paths = routerMountPaths.get(router)
+  if (!paths) return []
+  return [...paths]
+}
+
+function setLayerMatchers (layer, matchers) {
+  layerMatchers.set(layer, matchers)
+}
+
+function getLayerMatchers (layer) {
+  return layerMatchers.get(layer)
+}
+
+function normalizeMethodName (method) {
+  return method === '_all' || method === 'all' ? '*' : method
+}
+
+function getRouteFullPaths (route, prefix) {
+  if (!route) return []
+
+  const routePaths = normalizeRoutePaths(route.path)
+  const pathsToPublish = routePaths.length ? routePaths : ['']
+
+  return pathsToPublish
+    .map(routePath => joinPath(prefix, routePath))
+    .filter(path => path !== null) // Filter out invalid path combinations
+}
+
+function markAppMounted (router) {
+  if (router) appMountedRouters.add(router)
+}
+
+function isAppMounted (router) {
+  return appMountedRouters.has(router)
+}
+
+/**
+ * Normalise the optional mount argument provided to app.use()/router.use().
+ * Express accepts strings, regex, arrays (possibly nested), or
+ * no mount path at all; this helper returns the flattened set of paths along
+ * with the index where actual middleware arguments start.
+ */
+function extractMountPaths (path) {
+  const hasMount = typeof path === 'string' || path instanceof RegExp || Array.isArray(path)
+
+  if (!hasMount) {
+    return { mountPaths: ['/'], startIdx: 0 }
+  }
+
+  const paths = normalizeRoutePaths(path)
+  return {
+    mountPaths: paths.length ? paths : ['/'],
+    startIdx: 1
+  }
+}
+
+/**
+ * Detect cycle router graphs.
+ */
+function hasRouterCycle (router, stack = new Set()) {
+  if (!router?.stack?.length) return false
+  if (stack.has(router)) return true
+
+  stack.add(router)
+
+  for (const layer of router.stack) {
+    if (!layer?.route && layer?.handle?.stack?.length) {
+      const hasCycle = hasRouterCycle(layer.handle, stack)
+      if (hasCycle) {
+        return true
+      }
+    }
+  }
+
+  stack.delete(router)
+  return false
+}
+
+function wrapRouteMethodsAndPublish (route, paths, publish) {
+  if (!route || !paths.length) return
+
+  const filteredPaths = paths.filter(Boolean)
+  if (!filteredPaths.length) return
+
+  const uniquePaths = new Set(filteredPaths)
+
+  METHODS.forEach(method => {
+    if (typeof route[method] !== 'function') return
+
+    shimmer.wrap(route, method, (originalMethod) => function wrappedRouteMethod (...args) {
+      const normalizedMethod = normalizeMethodName(method)
+
+      for (const path of uniquePaths) {
+        publish({
+          method: normalizedMethod,
+          path
+        })
+      }
+
+      return originalMethod.apply(this, args)
+    })
+  })
+}
+
+module.exports = {
+  setRouterMountPath,
+  getRouterMountPaths,
+  joinPath,
+  setLayerMatchers,
+  getLayerMatchers,
+  markAppMounted,
+  isAppMounted,
+  normalizeRoutePath,
+  normalizeRoutePaths,
+  getRouteFullPaths,
+  wrapRouteMethodsAndPublish,
+  extractMountPaths,
+  hasRouterCycle,
+  collectRoutesFromRouter
+}

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

@@ -1335,7 +1335,7 @@ addHook({
       }
       const returnedValue = requireModuleOrMock.apply(this, arguments)
       if (process.exitCode === 1) {
-        if (this.loggedReferenceErrors.size > 0) {
+        if (this.loggedReferenceErrors?.size > 0) {
           const errorMessage = [...this.loggedReferenceErrors][0]
           testSuiteErrorCh.publish({
             errorMessage,
@@ -1427,6 +1427,7 @@ function enqueueWrapper (enqueue) {
       if (worker && !wrappedWorkers.has(worker)) {
         shimmer.wrap(worker._child, 'send', sendWrapper)
         shimmer.wrap(worker, '_onMessage', onMessageWrapper)
+        worker._child.removeAllListeners('message')
         worker._child.on('message', worker._onMessage.bind(worker))
         wrappedWorkers.add(worker)
       }

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

@@ -82,12 +82,7 @@ function createWrapQueryCallback (options) {
 
       const cb = arguments[arguments.length - 1]
       const ctx = { sql, conf: options }
-
-      if (typeof cb !== 'function') {
-        arguments.length += 1
-      }
-
-      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function (err) {
+      const wrapper = (cb) => function (err) {
         if (err) {
           ctx.error = err
           errorCh.publish(ctx)
@@ -96,7 +91,14 @@ function createWrapQueryCallback (options) {
         return typeof cb === 'function'
           ? finishCh.runStores(ctx, cb, this, ...arguments)
           : finishCh.publish(ctx)
-      })
+      }
+
+      if (typeof cb === 'function') {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, wrapper)
+      } else {
+        arguments.length += 1
+        arguments[arguments.length - 1] = wrapper()
+      }
 
       return startCh.runStores(ctx, query, this, ...arguments)
     }