@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,89 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+const handlers = ['use', 'pre']
+const methods = ['del', 'get', 'head', 'opts', 'post', 'put', 'patch']
+
+const handleChannel = channel('apm:restify:request:handle')
+const errorChannel = channel('apm:restify:middleware:error')
+const enterChannel = channel('apm:restify:middleware:enter')
+const exitChannel = channel('apm:restify:middleware:exit')
+const finishChannel = channel('apm:restify:middleware:finish')
+const nextChannel = channel('apm:restify:middleware:next')
+
+function wrapSetupRequest (setupRequest) {
+  return function (req, res) {
+    handleChannel.publish({ req, res })
+    return setupRequest.apply(this, arguments)
+  }
+}
+
+function wrapMethod (method) {
+  return function (path, ...middlewares) {
+    const wrappedMiddlewares = middlewares.map(wrapFn)
+
+    return method.apply(this, [path, ...wrappedMiddlewares])
+  }
+}
+
+function wrapHandler (method) {
+  return function (...middlewares) {
+    return method.apply(this, middlewares.map(wrapFn))
+  }
+}
+
+function wrapFn (fn) {
+  if (Array.isArray(fn)) return fn.map(wrapFn)
+
+  return shimmer.wrapFunction(fn, fn => function (req, res, next) {
+    if (typeof next === 'function') {
+      arguments[2] = wrapNext(req, next)
+    }
+
+    const route = req.route && req.route.path
+
+    enterChannel.publish({ req, route })
+
+    try {
+      const result = fn.apply(this, arguments)
+      if (typeof result?.then === 'function') {
+        return result.then(function (result) {
+          nextChannel.publish({ req })
+          finishChannel.publish({ req })
+          return result
+        }).catch(function (error) {
+          errorChannel.publish({ req, error })
+          nextChannel.publish({ req })
+          finishChannel.publish({ req })
+          throw error
+        })
+      }
+      return result
+    } catch (error) {
+      errorChannel.publish({ req, error })
+      nextChannel.publish({ req })
+      finishChannel.publish({ req })
+      throw error
+    } finally {
+      exitChannel.publish({ req })
+    }
+  })
+}
+
+function wrapNext (req, next) {
+  return shimmer.wrapFunction(next, next => function () {
+    nextChannel.publish({ req })
+    finishChannel.publish({ req })
+
+    next.apply(this, arguments)
+  })
+}
+
+addHook({ name: 'restify', versions: ['>=3'], file: 'lib/server.js' }, Server => {
+  shimmer.wrap(Server.prototype, '_setupRequest', wrapSetupRequest)
+  shimmer.massWrap(Server.prototype, handlers, wrapHandler)
+  shimmer.massWrap(Server.prototype, methods, wrapMethod)
+
+  return Server
+})

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

@@ -0,0 +1,237 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const {
+  channel,
+  addHook,
+} = require('./helpers/instrument')
+
+const circularBufferConstructor = Symbol('circularBufferConstructor')
+const inFlightDeliveries = Symbol('inFlightDeliveries')
+
+const patched = new WeakSet()
+
+const startSendCh = channel('apm:rhea:send:start')
+const encodeSendCh = channel('apm:rhea:send:encode')
+const errorSendCh = channel('apm:rhea:send:error')
+const finishSendCh = channel('apm:rhea:send:finish')
+
+const startReceiveCh = channel('apm:rhea:receive:start')
+const dispatchReceiveCh = channel('apm:rhea:receive:dispatch')
+const errorReceiveCh = channel('apm:rhea:receive:error')
+const finishReceiveCh = channel('apm:rhea:receive:finish')
+
+const contexts = new WeakMap() // key: delivery Fn, val: context
+
+addHook({ name: 'rhea', versions: ['>=1'] }, rhea => {
+  shimmer.wrap(rhea.message, 'encode', encode => function (msg) {
+    encodeSendCh.publish(msg)
+    return encode.apply(this, arguments)
+  })
+
+  return rhea
+})
+
+addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
+  const Sender = obj.Sender
+  const Receiver = obj.Receiver
+  shimmer.wrap(Sender.prototype, 'send', send => function (msg, tag, format) {
+    if (!canTrace(this)) {
+      // we can't handle disconnects or ending spans, so we can't safely instrument
+      return send.apply(this, arguments)
+    }
+
+    const { host, port } = getHostAndPort(this.connection)
+
+    const targetAddress = this.options && this.options.target &&
+      this.options.target.address
+      ? this.options.target.address
+      : undefined
+
+    const ctx = { targetAddress, host, port, msg, connection: this.connection }
+    return startSendCh.runStores(ctx, () => {
+      const delivery = send.apply(this, arguments)
+      contexts.set(delivery, ctx)
+
+      addToInFlightDeliveries(this.connection, delivery)
+      try {
+        return delivery
+      } catch (err) {
+        ctx.error = err
+        errorSendCh.publish(ctx)
+
+        throw err
+      }
+    })
+  })
+
+  shimmer.wrap(Receiver.prototype, 'dispatch', dispatch => function (eventName, msgObj) {
+    if (!canTrace(this)) {
+      // we can't handle disconnects or ending spans, so we can't safely instrument
+      return dispatch.apply(this, arguments)
+    }
+
+    if (eventName === 'message' && msgObj) {
+      const ctx = { msgObj, connection: this.connection }
+      return startReceiveCh.runStores(ctx, () => {
+        if (msgObj.delivery) {
+          contexts.set(msgObj.delivery, ctx)
+          msgObj.delivery.update = wrapDeliveryUpdate(msgObj.delivery, msgObj.delivery.update)
+          addToInFlightDeliveries(this.connection, msgObj.delivery)
+        }
+        try {
+          return dispatch.apply(this, arguments)
+        } catch (err) {
+          ctx.error = err
+          errorReceiveCh.publish(ctx)
+
+          throw err
+        }
+      })
+    }
+
+    return dispatch.apply(this, arguments)
+  })
+  return obj
+})
+
+addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/connection.js' }, Connection => {
+  shimmer.wrap(Connection.prototype, 'dispatch', dispatch => function (eventName, obj) {
+    if (eventName === 'disconnected') {
+      const error = obj.error || this.saved_error
+      if (this[inFlightDeliveries]) {
+        for (const delivery of this[inFlightDeliveries]) {
+          const ctx = contexts.get(delivery)
+
+          if (!ctx) continue
+
+          ctx.error = error
+          errorReceiveCh.publish(ctx)
+          exports.beforeFinish(delivery, null)
+          finishReceiveCh.publish(ctx)
+        }
+      }
+    }
+    return dispatch.apply(this, arguments)
+  })
+  return Connection
+})
+
+addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/session.js' }, (Session) => {
+  patchCircularBuffer(Session.prototype, Session)
+  return Session
+})
+
+function canTrace (link) {
+  return link.connection && link.session && link.session.outgoing
+}
+
+function getHostAndPort (connection) {
+  let host
+  let port
+  if (connection && connection.options) {
+    host = connection.options.host
+    port = connection.options.port
+  }
+  return { host, port }
+}
+
+function wrapDeliveryUpdate (obj, update) {
+  const ctx = contexts.get(obj)
+  if (obj && ctx) {
+    const cb = update
+    return shimmer.wrapFunction(cb, cb => function wrappedUpdate (settled, stateData) {
+      ctx.state = getStateFromData(stateData)
+      dispatchReceiveCh.runStores(ctx, () => {
+        return cb.apply(this, arguments)
+      })
+    })
+  }
+  return function wrappedUpdate (settled, stateData) {
+    return update.apply(this, arguments)
+  }
+}
+
+function patchCircularBuffer (proto, Session) {
+  Object.defineProperty(proto, 'outgoing', {
+    configurable: true,
+    // eslint-disable-next-line getter-return
+    get () {},
+    set (outgoing) {
+      delete proto.outgoing // removes the setter on the prototype
+      this.outgoing = outgoing // assigns on the instance, like normal
+      if (outgoing) {
+        let CircularBuffer
+        if (outgoing.deliveries) {
+          CircularBuffer = outgoing.deliveries.constructor
+        }
+        if (CircularBuffer && !patched.has(CircularBuffer.prototype)) {
+          shimmer.wrap(CircularBuffer.prototype, 'pop_if', popIf => function (fn) {
+            arguments[0] = shimmer.wrapFunction(fn, fn => function (entry) {
+              const ctx = contexts.get(entry)
+
+              if (!ctx) return fn(entry)
+
+              const shouldPop = fn(entry)
+
+              if (shouldPop) {
+                const remoteState = entry.remote_state
+                const state = remoteState && remoteState.constructor
+                  ? entry.remote_state.constructor.composite_type
+                  : undefined
+                ctx.state = state
+                exports.beforeFinish(entry, state)
+                finishSendCh.publish(ctx)
+              }
+
+              return shouldPop
+            })
+            return popIf.apply(this, arguments)
+          })
+          patched.add(CircularBuffer.prototype)
+          const Session = proto.constructor
+          if (Session) {
+            Session[circularBufferConstructor] = CircularBuffer
+          }
+        }
+      }
+    },
+  })
+}
+
+function addToInFlightDeliveries (connection, delivery) {
+  let deliveries = connection[inFlightDeliveries]
+  if (!deliveries) {
+    deliveries = new Set()
+    connection[inFlightDeliveries] = deliveries
+  }
+  deliveries.add(delivery)
+}
+
+function beforeFinish (delivery, state) {
+  const ctx = contexts.get(delivery)
+  if (ctx) {
+    if (state) {
+      ctx.state = state
+      dispatchReceiveCh.publish(ctx)
+    }
+    if (ctx.connection && ctx.connection[inFlightDeliveries]) {
+      ctx.connection[inFlightDeliveries].delete(delivery)
+    }
+  }
+}
+
+function getStateFromData (stateData) {
+  if (stateData && stateData.descriptor && stateData.descriptor) {
+    switch (stateData.descriptor.value) {
+      case 0x24: return 'accepted'
+      case 0x25: return 'rejected'
+      case 0x26: return 'released'
+      case 0x27: return 'modified'
+    }
+  }
+}
+
+module.exports.inFlightDeliveries = inFlightDeliveries
+module.exports.beforeFinish = beforeFinish
+module.exports.contexts = contexts

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

@@ -0,0 +1,326 @@
+'use strict'
+
+const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
+const pathToRegExp = require('../../../vendor/dist/path-to-regexp')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+
+const {
+  getRouterMountPaths,
+  joinPath,
+  getLayerMatchers,
+  setLayerMatchers,
+  isAppMounted,
+  setRouterMountPath,
+  extractMountPaths,
+  getRouteFullPaths,
+  wrapRouteMethodsAndPublish,
+  collectRoutesFromRouter,
+} = require('./helpers/router-helper')
+
+function isFastStar (layer, matchers) {
+  return layer.regexp?.fast_star ?? matchers.some(matcher => matcher.path === '*')
+}
+
+function isFastSlash (layer, matchers) {
+  return layer.regexp?.fast_slash ?? matchers.some(matcher => matcher.path === '/')
+}
+
+// TODO: Move this function to a shared file between Express and Router
+function createWrapRouterMethod (name) {
+  const enterChannel = channel(`apm:${name}:middleware:enter`)
+  const exitChannel = channel(`apm:${name}:middleware:exit`)
+  const finishChannel = channel(`apm:${name}:middleware:finish`)
+  const errorChannel = channel(`apm:${name}:middleware:error`)
+  const nextChannel = channel(`apm:${name}:middleware:next`)
+  const routeAddedChannel = channel(`apm:${name}:route:added`)
+
+  const regexpCache = Object.create(null)
+
+  function wrapLayerHandle (layer, original) {
+    original._name = original._name || layer.name
+
+    return shimmer.wrapFunction(original, original => function () {
+      if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
+
+      const matchers = getLayerMatchers(layer)
+      const lastIndex = arguments.length - 1
+      const name = original._name || original.name
+      const req = arguments[arguments.length > 3 ? 1 : 0]
+      const next = arguments[lastIndex]
+
+      if (typeof next === 'function') {
+        arguments[lastIndex] = wrapNext(req, next)
+      }
+
+      let route
+
+      if (matchers) {
+        // Try to guess which path actually matched
+        for (const matcher of matchers) {
+          if (matcher.test(layer)) {
+            route = matcher.path
+
+            break
+          }
+        }
+      }
+
+      enterChannel.publish({ name, req, route, layer })
+
+      try {
+        return original.apply(this, arguments)
+      } catch (error) {
+        errorChannel.publish({ req, error })
+        nextChannel.publish({ req })
+        finishChannel.publish({ req })
+
+        throw error
+      } finally {
+        exitChannel.publish({ req })
+      }
+    })
+  }
+
+  function wrapStack (layers, matchers) {
+    for (const layer of layers) {
+      if (layer.__handle) { // express-async-errors
+        layer.__handle = wrapLayerHandle(layer, layer.__handle)
+      } else {
+        layer.handle = wrapLayerHandle(layer, layer.handle)
+      }
+
+      setLayerMatchers(layer, matchers)
+
+      if (layer.route) {
+        for (const method of METHODS) {
+          if (typeof layer.route.stack === 'function') {
+            layer.route.stack = [{ handle: layer.route.stack }]
+          }
+
+          layer.route[method] = wrapMethod(layer.route[method])
+        }
+      }
+    }
+  }
+
+  function wrapNext (req, next) {
+    return shimmer.wrapFunction(next, next => function (error) {
+      if (error && error !== 'route' && error !== 'router') {
+        errorChannel.publish({ req, error })
+      }
+
+      nextChannel.publish({ req })
+      finishChannel.publish({ req })
+
+      next.apply(this, arguments)
+    })
+  }
+
+  function extractMatchers (fn) {
+    const arg = Array.isArray(fn) ? fn.flat(Infinity) : [fn]
+
+    if (typeof arg[0] === 'function') {
+      return []
+    }
+
+    return arg.map(pattern => ({
+      path: pattern instanceof RegExp ? `(${pattern})` : pattern,
+      test: layer => {
+        const matchers = getLayerMatchers(layer)
+        return !isFastStar(layer, matchers) &&
+          !isFastSlash(layer, matchers) &&
+          cachedPathToRegExp(pattern).test(layer.path)
+      },
+    }))
+  }
+
+  function cachedPathToRegExp (pattern) {
+    const maybeCached = regexpCache[pattern]
+    if (maybeCached) {
+      return maybeCached
+    }
+    const regexp = pathToRegExp(pattern)
+    regexpCache[pattern] = regexp
+    return regexp
+  }
+
+  function wrapMethod (original) {
+    return shimmer.wrapFunction(original, original => function methodWithTrace (...args) {
+      let offset = 0
+      if (this.stack) {
+        offset = Array.isArray(this.stack) ? this.stack.length : 1
+      }
+      const router = original.apply(this, args)
+
+      if (typeof this.stack === 'function') {
+        this.stack = [{ handle: this.stack }]
+      }
+
+      if (routeAddedChannel.hasSubscribers) {
+        routeAddedChannel.publish({ topOfStackFunc: methodWithTrace, layer: this.stack?.at(-1) })
+      }
+
+      const fn = args[0]
+
+      // Publish only if this router was mounted by app.use() (prevents early '/sub/...')
+      if (routeAddedChannel.hasSubscribers && isAppMounted(this) && this.stack?.length > offset) {
+        // Handle nested router mounting for 'use' method
+        if (original.name === 'use' && args.length >= 2) {
+          const { mountPaths, startIdx } = extractMountPaths(fn)
+
+          if (mountPaths.length) {
+            const parentPaths = getRouterMountPaths(this)
+
+            for (let i = startIdx; i < args.length; i++) {
+              const nestedRouter = args[i]
+
+              if (!nestedRouter || typeof nestedRouter !== 'function') continue
+
+              for (const parentPath of parentPaths) {
+                for (const normalizedMountPath of mountPaths) {
+                  const fullMountPath = joinPath(parentPath, normalizedMountPath)
+                  if (fullMountPath === null) continue
+
+                  setRouterMountPath(nestedRouter, fullMountPath)
+                  collectRoutesFromRouter(nestedRouter, fullMountPath)
+                }
+              }
+            }
+          }
+        }
+
+        const mountPaths = getRouterMountPaths(this)
+
+        if (mountPaths.length) {
+          const layer = this.stack.at(-1)
+
+          if (layer?.route) {
+            const route = layer.route
+
+            const fullPaths = mountPaths.flatMap(mountPath => getRouteFullPaths(route, mountPath))
+
+            wrapRouteMethodsAndPublish(route, fullPaths, (payload) => {
+              routeAddedChannel.publish(payload)
+            })
+          }
+        }
+      }
+
+      if (this.stack?.length > offset) {
+        wrapStack(this.stack.slice(offset), extractMatchers(fn))
+      }
+
+      return router
+    })
+  }
+
+  return wrapMethod
+}
+
+const wrapRouterMethod = createWrapRouterMethod('router')
+
+addHook({ name: 'router', versions: ['>=1 <2'] }, Router => {
+  shimmer.wrap(Router.prototype, 'use', wrapRouterMethod)
+  shimmer.wrap(Router.prototype, 'route', wrapRouterMethod)
+
+  return Router
+})
+
+const queryParserReadCh = channel('datadog:query:read:finish')
+
+addHook({ name: 'router', versions: ['>=2'] }, Router => {
+  const WrappedRouter = shimmer.wrapFunction(Router, function (originalRouter) {
+    return function wrappedMethod () {
+      const router = originalRouter.apply(this, arguments)
+
+      shimmer.wrap(router, 'handle', function wrapHandle (originalHandle) {
+        return function wrappedHandle (req, res, next) {
+          const abortController = new AbortController()
+
+          if (queryParserReadCh.hasSubscribers && req) {
+            queryParserReadCh.publish({ req, res, query: req.query, abortController })
+
+            if (abortController.signal.aborted) return
+          }
+
+          return originalHandle.apply(this, arguments)
+        }
+      })
+
+      return router
+    }
+  })
+
+  shimmer.wrap(WrappedRouter.prototype, 'use', wrapRouterMethod)
+  shimmer.wrap(WrappedRouter.prototype, 'route', wrapRouterMethod)
+
+  return WrappedRouter
+})
+
+const routerParamStartCh = channel('datadog:router:param:start')
+const visitedParams = new WeakSet()
+
+function wrapHandleRequest (original) {
+  return function wrappedHandleRequest (req, res, next) {
+    if (routerParamStartCh.hasSubscribers && !visitedParams.has(req.params) && Object.keys(req.params).length) {
+      visitedParams.add(req.params)
+
+      const abortController = new AbortController()
+
+      routerParamStartCh.publish({
+        req,
+        res,
+        params: req?.params,
+        abortController,
+      })
+
+      if (abortController.signal.aborted) return
+    }
+
+    return original.apply(this, arguments)
+  }
+}
+
+addHook({
+  name: 'router', file: 'lib/layer.js', versions: ['>=2'],
+}, Layer => {
+  shimmer.wrap(Layer.prototype, 'handleRequest', wrapHandleRequest)
+  return Layer
+})
+
+function wrapParam (original) {
+  return function wrappedProcessParams () {
+    arguments[1] = shimmer.wrapFunction(arguments[1], (originalFn) => {
+      return function wrappedFn (req, res) {
+        if (routerParamStartCh.hasSubscribers && Object.keys(req.params).length && !visitedParams.has(req.params)) {
+          visitedParams.add(req.params)
+
+          const abortController = new AbortController()
+
+          routerParamStartCh.publish({
+            req,
+            res,
+            params: req?.params,
+            abortController,
+          })
+
+          if (abortController.signal.aborted) return
+        }
+
+        return originalFn.apply(this, arguments)
+      }
+    })
+
+    return original.apply(this, arguments)
+  }
+}
+
+addHook({
+  name: 'router', versions: ['>=2'],
+}, router => {
+  shimmer.wrap(router.prototype, 'param', wrapParam)
+  return router
+})
+
+module.exports = { createWrapRouterMethod }