@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-instrumentations/src/helpers/rewriter/orchestrion/transforms.js

@@ -0,0 +1,322 @@
+'use strict'
+
+const { parse, query, traverse } = require('./compiler')
+
+const tracingChannelPredicate = (node) => (
+  node.specifiers?.[0]?.local?.name === 'tr_ch_apm_tracingChannel' ||
+    node.declarations?.[0]?.id?.properties?.[0]?.value?.name === 'tr_ch_apm_tracingChannel'
+)
+
+const transforms = module.exports = {
+  tracingChannelImport ({ dcModule, sourceType }, node) {
+    if (node.body.some(tracingChannelPredicate)) return
+
+    const index = node.body.findIndex(child => child.directive === 'use strict')
+    const code = sourceType === 'module'
+      ? `import { tracingChannel as tr_ch_apm_tracingChannel } from "${dcModule}"`
+      : `const {tracingChannel: tr_ch_apm_tracingChannel} = require("${dcModule}")`
+
+    node.body.splice(index + 1, 0, parse(code, { sourceType }).body[0])
+  },
+
+  tracingChannelDeclaration (state, node) {
+    const { channelName, module: { name } } = state
+    const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
+
+    if (node.body.some(child => child.declarations?.[0]?.id?.name === channelVariable)) return
+
+    transforms.tracingChannelImport(state, node)
+
+    const index = node.body.findIndex(tracingChannelPredicate)
+    const code = `
+      const ${channelVariable} = tr_ch_apm_tracingChannel("orchestrion:${name}:${channelName}")
+    `
+
+    node.body.splice(index + 1, 0, parse(code).body[0])
+  },
+
+  traceAsyncIterator: traceAny,
+  traceCallback: traceAny,
+  traceIterator: traceAny,
+  tracePromise: traceAny,
+  traceSync: traceAny,
+}
+
+function traceAny (state, node, _parent, ancestry) {
+  const program = ancestry[ancestry.length - 1]
+
+  if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+    traceInstanceMethod(state, node, program)
+  } else {
+    traceFunction(state, node, program)
+  }
+}
+
+function traceFunction (state, node, program) {
+  transforms.tracingChannelDeclaration(state, program)
+
+  node.body = wrap(state, {
+    type: 'FunctionExpression',
+    params: node.params,
+    body: node.body,
+    async: node.async,
+    expression: false,
+    generator: node.generator,
+  }, program)
+
+  // The original function no longer contains any calls to `await` or `yield` as
+  // the function body is copied to the internal wrapped function, so we set
+  // these to false to avoid altering the return value of the wrapper. The old
+  // values are instead copied to the new AST node above.
+  node.generator = false
+  node.async = false
+
+  wrapSuper(state, node)
+}
+
+function traceInstanceMethod (state, node, program) {
+  const { functionQuery, operator } = state
+  const { methodName } = functionQuery
+
+  const classBody = node.body
+
+  // If the method exists on the class, we return as it will be patched later
+  // while traversing child nodes later on.
+  if (classBody.body.some(({ key }) => key.name === methodName)) return
+
+  // Method doesn't exist on the class so we assume an instance method and
+  // wrap it in the constructor instead.
+  let ctor = classBody.body.find(({ kind }) => kind === 'constructor')
+
+  transforms.tracingChannelDeclaration(state, program)
+
+  if (!ctor) {
+    ctor = parse(
+      node.superClass
+        ? 'class A { constructor (...args) { super(...args) } }'
+        : 'class A { constructor () {} }'
+    ).body[0].body.body[0] // Extract constructor from dummy class body.
+
+    classBody.body.unshift(ctor)
+  }
+
+  const ctorBody = parse(`
+    const __apm$${methodName} = this["${methodName}"]
+    this["${methodName}"] = function () {}
+  `).body
+
+  // Extract only right-hand side function of line 2.
+  const fn = ctorBody[1].expression.right
+
+  fn.async = operator === 'tracePromise'
+  fn.body = wrap(state, { type: 'Identifier', name: `__apm$${methodName}` }, program)
+
+  wrapSuper(state, fn)
+
+  ctor.value.body.body.push(...ctorBody)
+}
+
+function wrap (state, node, program) {
+  const { channelName, operator } = state
+
+  if (operator === 'traceAsyncIterator') return wrapIterator(state, node, program)
+  if (operator === 'traceCallback') return wrapCallback(state, node)
+  if (operator === 'traceIterator') return wrapIterator(state, node, program)
+
+  const async = operator === 'tracePromise' ? 'async' : ''
+  const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
+  const wrapper = parse(`
+    function wrapper () {
+      const __apm$traced = ${async} () => {
+        const __apm$wrapped = () => {};
+        return __apm$wrapped.apply(this, arguments);
+      };
+      if (!${channelVariable}.hasSubscribers) return __apm$traced();
+      return ${channelVariable}.${operator}(__apm$traced, {
+        arguments,
+        self: this,
+        moduleVersion: "1.0.0"
+      });
+    }
+  `).body[0].body // Extract only block statement of function body.
+
+  // Replace the right-hand side assignment of `const __apm$wrapped = () => {}`.
+  query(wrapper, '[id.name=__apm$wrapped]')[0].init = node
+
+  return wrapper
+}
+
+function wrapSuper (_state, node) {
+  const members = new Set()
+
+  traverse(
+    node.body,
+    '[object.type=Super]',
+    (node, parent) => {
+      const { name } = node.property
+
+      let child
+
+      if (parent.callee) {
+        // This is needed because for generator functions we have to move the
+        // original function to a nested wrapped function, but we can't use an
+        // arrow function because arrow function cannot be generator functions,
+        // and `super` cannot be called from a nested function, so we have to
+        // rewrite any `super` call to not use the keyword.
+        const { expression } = parse(`__apm$super['${name}'].call(this)`).body[0]
+
+        parent.callee = child = expression.callee
+        parent.arguments.unshift(...expression.arguments)
+      } else {
+        parent.expression = child = parse(`__apm$super['${name}']`).body[0]
+      }
+
+      child.computed = parent.callee.computed
+      child.optional = parent.callee.optional
+
+      members.add(name)
+    }
+  )
+
+  for (const name of members) {
+    const member = parse(`
+      class Wrapper {
+        wrapper () {
+          __apm$super['${name}'] = super['${name}']
+        }
+      }
+    `).body[0].body.body[0].value.body.body[0]
+
+    node.body.body.unshift(member)
+  }
+
+  if (members.size > 0) {
+    node.body.body.unshift(parse('const __apm$super = {}').body[0])
+  }
+}
+
+function wrapCallback (state, node) {
+  const { channelName, functionQuery: { callbackIndex = -1 } } = state
+  const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
+  const wrapper = parse(`
+    function wrapper () {
+      const __apm$cb = Array.prototype.at.call(arguments, ${callbackIndex});
+      const __apm$ctx = {
+        arguments,
+        self: this,
+        moduleVersion: "1.0.0"
+      };
+      const __apm$traced = () => {
+        const __apm$wrapped = () => {};
+        return __apm$wrapped.apply(this, arguments);
+      };
+
+      if (!${channelVariable}.start.hasSubscribers) return __apm$traced();
+
+      function __apm$wrappedCb(err, res) {
+        if (err) {
+          __apm$ctx.error = err;
+          ${channelVariable}.error.publish(__apm$ctx);
+        } else {
+          __apm$ctx.result = res;
+        }
+
+        ${channelVariable}.asyncStart.runStores(__apm$ctx, () => {
+          try {
+            if (__apm$cb) {
+              return __apm$cb.apply(this, arguments);
+            }
+          } finally {
+            ${channelVariable}.asyncEnd.publish(__apm$ctx);
+          }
+        });
+      }
+
+      if (typeof __apm$cb !== 'function') {
+        return __apm$traced();
+      }
+      Array.prototype.splice.call(arguments, ${callbackIndex}, 1, __apm$wrappedCb);
+
+      return ${channelVariable}.start.runStores(__apm$ctx, () => {
+        try {
+          return __apm$traced();
+        } catch (err) {
+          __apm$ctx.error = err;
+          ${channelVariable}.error.publish(__apm$ctx);
+          throw err;
+        } finally {
+          ${channelVariable}.end.publish(__apm$ctx);
+        }
+      });
+    }
+  `).body[0].body // Extract only block statement of function body.
+
+  // Replace the right-hand side assignment of `const __apm$wrapped = () => {}`.
+  query(wrapper, '[id.name=__apm$wrapped]')[0].init = node
+
+  return wrapper
+}
+
+function wrapIterator (state, node, program) {
+  const { channelName, operator } = state
+  const baseChannel = channelName.replaceAll(':', '_')
+  const channelVariable = 'tr_ch_apm$' + baseChannel
+  const nextChannel = baseChannel + '_next'
+  const traceMethod = operator === 'traceAsyncIterator' ? 'tracePromise' : 'traceSync'
+  const traceNext = `tr_ch_apm$${nextChannel}.${traceMethod}`
+
+  transforms.tracingChannelDeclaration({ ...state, channelName: nextChannel }, program)
+
+  const wrapper = parse(`
+    function wrapper () {
+      const __apm$traced = () => {
+        const __apm$wrapped = () => {};
+        return __apm$wrapped.apply(this, arguments);
+      };
+
+      if (!${channelVariable}.start.hasSubscribers) return __apm$traced();
+
+      {
+        const wrap = iter => {
+          const { next: iterNext, return: iterReturn, throw: iterThrow } = iter;
+
+          iter.next = (...args) => ${traceNext}(iterNext, ctx, iter, ...args);
+          iter.return = (...args) => ${traceNext}(iterReturn, ctx, iter, ...args);
+          iter.throw = (...args) => ${traceNext}(iterThrow, ctx, iter, ...args);
+
+          return iter;
+        };
+        const ctx = {
+          arguments,
+          self: this,
+          moduleVersion: "1.0.0"
+        };
+        const iter = ${channelVariable}.traceSync(__apm$traced, ctx);
+
+        if (typeof iter.then !== 'function') return wrap(iter);
+
+        return iter.then(result => {
+          ctx.result = result;
+
+          ${channelVariable}.asyncStart.publish(ctx);
+          ${channelVariable}.asyncEnd.publish(ctx);
+
+          return wrap(result);
+        }, err => {
+          ctx.error = err;
+
+          ${channelVariable}.error.publish(ctx);
+          ${channelVariable}.asyncStart.publish(ctx);
+          ${channelVariable}.asyncEnd.publish(ctx);
+
+          return Promise.reject(err);
+        });
+      };
+    }
+  `).body[0].body // Extract only block statement of function body.
+
+  // Replace the right-hand side assignment of `const __apm$wrapped = () => {}`.
+  query(wrapper, '[id.name=__apm$wrapped]')[0].init = node
+
+  return wrapper
+}

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

@@ -0,0 +1,238 @@
+'use strict'
+
+const shimmer = require('../../../datadog-shimmer')
+const { channel } = require('./instrument')
+
+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)
+
+  for (const method of METHODS) {
+    if (typeof route[method] !== 'function') continue
+
+    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/helpers/shared-utils.js

@@ -0,0 +1,9 @@
+'use strict'
+
+function isRelativeRequire (moduleName) {
+  return moduleName.startsWith('./') || moduleName.startsWith('../')
+}
+
+module.exports = {
+  isRelativeRequire,
+}