dd-trace 5.53.0 → 5.55.0

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
@@ -49,21 +48,17 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
       ? this.options.target.address
       : undefined
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startSendCh.publish({ targetAddress, host, port, msg })
+    const ctx = { targetAddress, host, port, msg, connection: this.connection }
+    return startSendCh.runStores(ctx, () => {
       const delivery = send.apply(this, arguments)
-      const context = {
-        asyncResource,
-        connection: this.connection
-      }
-      contexts.set(delivery, context)
+      contexts.set(delivery, ctx)
 
       addToInFlightDeliveries(this.connection, delivery)
       try {
         return delivery
       } catch (err) {
-        errorSendCh.publish(err)
+        ctx.error = err
+        errorSendCh.publish(ctx)
 
         throw err
       }
@@ -77,23 +72,18 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
     }
 
     if (eventName === 'message' && msgObj) {
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-      return asyncResource.runInAsyncScope(() => {
-        startReceiveCh.publish({ msgObj, connection: this.connection })
-
+      const ctx = { msgObj, connection: this.connection }
+      return startReceiveCh.runStores(ctx, () => {
         if (msgObj.delivery) {
-          const context = {
-            asyncResource,
-            connection: this.connection
-          }
-          contexts.set(msgObj.delivery, context)
+          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) {
-          errorReceiveCh.publish(err)
+          ctx.error = err
+          errorReceiveCh.publish(ctx)
 
           throw err
         }
@@ -111,16 +101,14 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/connection.js' }, Connecti
       const error = obj.error || this.saved_error
       if (this[inFlightDeliveries]) {
         this[inFlightDeliveries].forEach(delivery => {
-          const context = contexts.get(delivery)
-          const asyncResource = context && context.asyncResource
+          const ctx = contexts.get(delivery)
 
-          if (!asyncResource) return
+          if (!ctx) return
 
-          asyncResource.runInAsyncScope(() => {
-            errorReceiveCh.publish(error)
-            exports.beforeFinish(delivery, null)
-            finishReceiveCh.publish()
-          })
+          ctx.error = error
+          errorReceiveCh.publish(ctx)
+          exports.beforeFinish(delivery, null)
+          finishReceiveCh.publish(ctx)
         })
       }
     }
@@ -149,15 +137,15 @@ function getHostAndPort (connection) {
 }
 
 function wrapDeliveryUpdate (obj, update) {
-  const context = contexts.get(obj)
-  const asyncResource = context.asyncResource
-  if (obj && asyncResource) {
-    const cb = asyncResource.bind(update)
-    return shimmer.wrapFunction(cb, cb => AsyncResource.bind(function wrappedUpdate (settled, stateData) {
-      const state = getStateFromData(stateData)
-      dispatchReceiveCh.publish({ state })
-      return cb.apply(this, arguments)
-    }))
+  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)
@@ -167,7 +155,8 @@ function wrapDeliveryUpdate (obj, update) {
 function patchCircularBuffer (proto, Session) {
   Object.defineProperty(proto, 'outgoing', {
     configurable: true,
-    get () { return undefined },
+    // 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
@@ -178,27 +167,25 @@ function patchCircularBuffer (proto, Session) {
         }
         if (CircularBuffer && !patched.has(CircularBuffer.prototype)) {
           shimmer.wrap(CircularBuffer.prototype, 'pop_if', popIf => function (fn) {
-            arguments[0] = shimmer.wrapFunction(fn, fn => AsyncResource.bind(function (entry) {
-              const context = contexts.get(entry)
-              const asyncResource = context && context.asyncResource
+            arguments[0] = shimmer.wrapFunction(fn, fn => function (entry) {
+              const ctx = contexts.get(entry)
 
-              if (!asyncResource) return fn(entry)
+              if (!ctx) return fn(entry)
 
-              const shouldPop = asyncResource.runInAsyncScope(() => 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
-                asyncResource.runInAsyncScope(() => {
-                  exports.beforeFinish(entry, state)
-                  finishSendCh.publish()
-                })
+                ctx.state = state
+                exports.beforeFinish(entry, state)
+                finishSendCh.publish(ctx)
               }
 
               return shouldPop
-            }))
+            })
             return popIf.apply(this, arguments)
           })
           patched.add(CircularBuffer.prototype)
@@ -222,13 +209,14 @@ function addToInFlightDeliveries (connection, delivery) {
 }
 
 function beforeFinish (delivery, state) {
-  const context = contexts.get(delivery)
-  if (context) {
+  const ctx = contexts.get(delivery)
+  if (ctx) {
     if (state) {
-      dispatchReceiveCh.publish({ state })
+      ctx.state = state
+      dispatchReceiveCh.publish(ctx)
     }
-    if (context.connection && context.connection[inFlightDeliveries]) {
-      context.connection[inFlightDeliveries].delete(delivery)
+    if (ctx.connection && ctx.connection[inFlightDeliveries]) {
+      ctx.connection[inFlightDeliveries].delete(delivery)
     }
   }
 }

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

@@ -1,10 +1,18 @@
 'use strict'
 
-const METHODS = require('http').METHODS.map(v => v.toLowerCase()).concat('all')
+const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
 const pathToRegExp = require('path-to-regexp')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel } = require('./helpers/instrument')
 
+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`)
@@ -12,6 +20,7 @@ function createWrapRouterMethod (name) {
   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 layerMatchers = new WeakMap()
   const regexpCache = Object.create(null)
@@ -36,16 +45,16 @@ function createWrapRouterMethod (name) {
 
       if (matchers) {
         // Try to guess which path actually matched
-        for (let i = 0; i < matchers.length; i++) {
-          if (matchers[i].test(layer)) {
-            route = matchers[i].path
+        for (const matcher of matchers) {
+          if (matcher.test(layer)) {
+            route = matcher.path
 
             break
           }
         }
       }
 
-      enterChannel.publish({ name, req, route })
+      enterChannel.publish({ name, req, route, layer })
 
       try {
         return original.apply(this, arguments)
@@ -61,8 +70,8 @@ function createWrapRouterMethod (name) {
     })
   }
 
-  function wrapStack (stack, offset, matchers) {
-    [].concat(stack).slice(offset).forEach(layer => {
+  function wrapStack (layers, matchers) {
+    for (const layer of layers) {
       if (layer.__handle) { // express-async-errors
         layer.__handle = wrapLayerHandle(layer, layer.__handle)
       } else {
@@ -80,7 +89,7 @@ function createWrapRouterMethod (name) {
           layer.route[method] = wrapMethod(layer.route[method])
         })
       }
-    })
+    }
   }
 
   function wrapNext (req, next) {
@@ -97,7 +106,7 @@ function createWrapRouterMethod (name) {
   }
 
   function extractMatchers (fn) {
-    const arg = flatten([].concat(fn))
+    const arg = Array.isArray(fn) ? fn : [fn]
 
     if (typeof arg[0] === 'function') {
       return []
@@ -114,26 +123,6 @@ function createWrapRouterMethod (name) {
     }))
   }
 
-  function isFastStar (layer, matchers) {
-    if (layer.regexp?.fast_star !== undefined) {
-      return layer.regexp.fast_star
-    }
-
-    return matchers.some(matcher => matcher.path === '*')
-  }
-
-  function isFastSlash (layer, matchers) {
-    if (layer.regexp?.fast_slash !== undefined) {
-      return layer.regexp.fast_slash
-    }
-
-    return matchers.some(matcher => matcher.path === '/')
-  }
-
-  function flatten (arr) {
-    return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flatten(val)) : acc.concat(val), [])
-  }
-
   function cachedPathToRegExp (pattern) {
     const maybeCached = regexpCache[pattern]
     if (maybeCached) {
@@ -146,14 +135,23 @@ function createWrapRouterMethod (name) {
 
   function wrapMethod (original) {
     return shimmer.wrapFunction(original, original => function methodWithTrace (fn) {
-      const offset = this.stack ? [].concat(this.stack).length : 0
+      let offset = 0
+      if (this.stack) {
+        offset = Array.isArray(this.stack) ? this.stack.length : 1
+      }
       const router = original.apply(this, arguments)
 
       if (typeof this.stack === 'function') {
         this.stack = [{ handle: this.stack }]
       }
 
-      wrapStack(this.stack, offset, extractMatchers(fn))
+      if (routeAddedChannel.hasSubscribers) {
+        routeAddedChannel.publish({ topOfStackFunc: methodWithTrace, layer: this.stack[0] })
+      }
+
+      if (this.stack.length > offset) {
+        wrapStack(this.stack.slice(offset), extractMatchers(fn))
+      }
 
       return router
     })
@@ -207,7 +205,7 @@ const visitedParams = new WeakSet()
 
 function wrapHandleRequest (original) {
   return function wrappedHandleRequest (req, res, next) {
-    if (routerParamStartCh.hasSubscribers && Object.keys(req.params).length && !visitedParams.has(req.params)) {
+    if (routerParamStartCh.hasSubscribers && !visitedParams.has(req.params) && Object.keys(req.params).length) {
       visitedParams.add(req.params)
 
       const abortController = new AbortController()

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

@@ -37,7 +37,7 @@ addHook({ name: 'tedious', versions: ['>=1.0.0'] }, tedious => {
         if (error) {
           errorCh.publish(error)
         }
-        finishCh.publish(undefined)
+        finishCh.publish()
 
         return cb.apply(this, arguments)
       }, null, request)
@@ -63,7 +63,6 @@ function getQueryOrProcedure (request) {
     return [request.parametersByName.statement.value, request.parametersByName.statement, 'value']
   } else if (request.parametersByName.stmt) {
     return [request.parametersByName.stmt.value, request.parametersByName.stmt, 'value']
-  } else {
-    return [request.sqlTextOrProcedure, request, 'sqlTextOrProcedure']
   }
+  return [request.sqlTextOrProcedure, request, 'sqlTextOrProcedure']
 }