dd-trace 2.7.0 → 2.9.0

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

@@ -5,7 +5,7 @@ const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 
 const enterChannel = channel('apm:connect:middleware:enter')
 const errorChannel = channel('apm:connect:middleware:error')
-const exitChannel = channel('apm:connect:middleware:exit')
+const nextChannel = channel('apm:connect:middleware:next')
 const handleChannel = channel('apm:connect:request:handle')
 
 function wrapConnect (connect) {
@@ -64,10 +64,10 @@ function wrapLayerHandle (layer) {
     const lastIndex = arguments.length - 1
     const name = original._name || original.name
     const req = arguments[arguments.length > 3 ? 1 : 0]
-    const next = AsyncResource.bind(arguments[lastIndex])
+    const next = arguments[lastIndex]
 
     if (typeof next === 'function') {
-      arguments[lastIndex] = wrapNext(req, middlewareResource.bind(next))
+      arguments[lastIndex] = wrapNext(req, next)
     }
 
     return middlewareResource.runInAsyncScope(() => {
@@ -79,7 +79,7 @@ function wrapLayerHandle (layer) {
         return original.apply(this, arguments)
       } catch (e) {
         errorChannel.publish(e)
-        exitChannel.publish({ req })
+        nextChannel.publish({ req })
 
         throw e
       }
@@ -93,7 +93,7 @@ function wrapNext (req, next) {
       errorChannel.publish(error)
     }
 
-    exitChannel.publish({ req })
+    nextChannel.publish({ req })
 
     next.apply(null, arguments)
   }

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

@@ -9,8 +9,7 @@ const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.5'] }, Bucket => {
   const startCh = channel('apm:couchbase:query:start')
-  const asyncEndCh = channel('apm:couchbase:query:async-end')
-  const endCh = channel('apm:couchbase:query:end')
+  const finishCh = channel('apm:couchbase:query:finish')
   const errorCh = channel('apm:couchbase:query:error')
 
   Bucket.prototype._maybeInvoke = wrapMaybeInvoke(Bucket.prototype._maybeInvoke)
@@ -25,27 +24,28 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.5'] }, Buck
 
     const n1qlQuery = q && q.statement
 
-    startCh.publish({ resource: n1qlQuery, bucket: this })
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ resource: n1qlQuery, bucket: this })
 
-    emitter.once('rows', AsyncResource.bind(() => {
-      asyncEndCh.publish(undefined)
-    }))
+      emitter.once('rows', asyncResource.bind(() => {
+        finishCh.publish(undefined)
+      }))
 
-    emitter.once('error', AsyncResource.bind((error) => {
-      errorCh.publish(error)
-      asyncEndCh.publish(undefined)
-    }))
+      emitter.once('error', asyncResource.bind((error) => {
+        errorCh.publish(error)
+        finishCh.publish(undefined)
+      }))
 
-    try {
-      return _n1qlReq.apply(this, arguments)
-    } catch (err) {
-      err.stack // trigger getting the stack at the original throwing point
-      errorCh.publish(err)
+      try {
+        return _n1qlReq.apply(this, arguments)
+      } catch (err) {
+        err.stack // trigger getting the stack at the original throwing point
+        errorCh.publish(err)
 
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+        throw err
+      }
+    })
   })
 
   Bucket.prototype.upsert = wrap('apm:couchbase:upsert', Bucket.prototype.upsert)
@@ -103,8 +103,7 @@ function wrapQuery (query) {
 
 function wrap (prefix, fn) {
   const startCh = channel(prefix + ':start')
-  const endCh = channel(prefix + ':end')
-  const asyncEndCh = channel(prefix + ':async-end')
+  const finishCh = channel(prefix + ':finish')
   const errorCh = channel(prefix + ':error')
 
   const wrapped = function (key, value, options, callback) {
@@ -116,28 +115,31 @@ function wrap (prefix, fn) {
 
     if (callbackIndex < 0) return fn.apply(this, arguments)
 
-    const cb = arguments[callbackIndex]
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-    startCh.publish({ bucket: this })
+    return asyncResource.runInAsyncScope(() => {
+      const cb = callbackResource.bind(arguments[callbackIndex])
 
-    arguments[callbackIndex] = function (error, result) {
-      if (error) {
-        errorCh.publish(error)
-      }
-      asyncEndCh.publish(result)
-      return cb.apply(this, arguments)
-    }
+      startCh.publish({ bucket: this })
 
-    try {
-      return fn.apply(this, arguments)
-    } catch (error) {
-      error.stack // trigger getting the stack at the original throwing point
-      errorCh.publish(error)
+      arguments[callbackIndex] = asyncResource.bind(function (error, result) {
+        if (error) {
+          errorCh.publish(error)
+        }
+        finishCh.publish(result)
+        return cb.apply(this, arguments)
+      })
 
-      throw error
-    } finally {
-      endCh.publish(undefined)
-    }
+      try {
+        return fn.apply(this, arguments)
+      } catch (error) {
+        error.stack // trigger getting the stack at the original throwing point
+        errorCh.publish(error)
+
+        throw error
+      }
+    })
   }
   return shimmer.wrap(fn, wrapped)
 }

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

@@ -1,13 +1,11 @@
 'use strict'
 
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 const runStartCh = channel('ci:cucumber:run:start')
-const runEndCh = channel('ci:cucumber:run:end')
-const runAsyncEndCh = channel('ci:cucumber:run:async-end')
+const runFinishCh = channel('ci:cucumber:run:finish')
 const runStepStartCh = channel('ci:cucumber:run-step:start')
-const runStepEndCh = channel('ci:cucumber:run-step:end')
 const errorCh = channel('ci:cucumber:error')
 
 // TODO: remove in a later major version
@@ -49,23 +47,24 @@ function wrapRun (pl, isLatestVersion) {
       return run.apply(this, arguments)
     }
 
-    runStartCh.publish({ pickleName: this.pickle.name, pickleUri: this.pickle.uri })
-    try {
-      const promise = run.apply(this, arguments)
-      promise.finally(() => {
-        const result = this.getWorstStepResult()
-        const { status, skipReason, errorMessage } = isLatestVersion
-          ? getStatusFromResultLatest(result) : getStatusFromResult(result)
-
-        runAsyncEndCh.publish({ status, skipReason, errorMessage })
-      })
-      return promise
-    } catch (err) {
-      errorCh.publish(err)
-      throw err
-    } finally {
-      runEndCh.publish(undefined)
-    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      runStartCh.publish({ pickleName: this.pickle.name, pickleUri: this.pickle.uri })
+      try {
+        const promise = run.apply(this, arguments)
+        promise.finally(() => {
+          const result = this.getWorstStepResult()
+          const { status, skipReason, errorMessage } = isLatestVersion
+            ? getStatusFromResultLatest(result) : getStatusFromResult(result)
+
+          runFinishCh.publish({ status, skipReason, errorMessage })
+        })
+        return promise
+      } catch (err) {
+        errorCh.publish(err)
+        throw err
+      }
+    })
   })
   shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
     if (!runStepStartCh.hasSubscribers) {
@@ -80,23 +79,24 @@ function wrapRun (pl, isLatestVersion) {
       resource = testStep.isHook ? 'hook' : testStep.pickleStep.text
     }
 
-    runStepStartCh.publish({ resource })
-    try {
-      const promise = runStep.apply(this, arguments)
-
-      promise.then((result) => {
-        const { status, skipReason, errorMessage } = isLatestVersion
-          ? getStatusFromResultLatest(result) : getStatusFromResult(result)
-
-        runAsyncEndCh.publish({ isStep: true, status, skipReason, errorMessage })
-      })
-      return promise
-    } catch (err) {
-      errorCh.publish(err)
-      throw err
-    } finally {
-      runStepEndCh.publish(undefined)
-    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      runStepStartCh.publish({ resource })
+      try {
+        const promise = runStep.apply(this, arguments)
+
+        promise.then((result) => {
+          const { status, skipReason, errorMessage } = isLatestVersion
+            ? getStatusFromResultLatest(result) : getStatusFromResult(result)
+
+          runFinishCh.publish({ isStep: true, status, skipReason, errorMessage })
+        })
+        return promise
+      } catch (err) {
+        errorCh.publish(err)
+        throw err
+      }
+    })
   })
 }
 

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

@@ -48,8 +48,7 @@ function patchResolveShorthands (prototype) {
 
 function wrap (prefix, fn, expectedArgs, rrtype) {
   const startCh = channel(prefix + ':start')
-  const endCh = channel(prefix + ':end')
-  const asyncEndCh = channel(prefix + ':async-end')
+  const finishCh = channel(prefix + ':finish')
   const errorCh = channel(prefix + ':error')
 
   const wrapped = function () {
@@ -67,27 +66,29 @@ function wrap (prefix, fn, expectedArgs, rrtype) {
     if (rrtype) {
       startArgs.push(rrtype)
     }
-    startCh.publish(startArgs)
 
-    arguments[arguments.length - 1] = function (error, result) {
-      if (error) {
-        errorCh.publish(error)
-      }
-      asyncEndCh.publish(result)
-      cb.apply(this, arguments)
-    }
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish(startArgs)
 
-    try {
-      return fn.apply(this, arguments)
+      arguments[arguments.length - 1] = asyncResource.bind(function (error, result) {
+        if (error) {
+          errorCh.publish(error)
+        }
+        finishCh.publish(result)
+        cb.apply(this, arguments)
+      })
+
+      try {
+        return fn.apply(this, arguments)
       // TODO deal with promise versions when we support `dns/promises`
-    } catch (error) {
-      error.stack // trigger getting the stack at the original throwing point
-      errorCh.publish(error)
+      } catch (error) {
+        error.stack // trigger getting the stack at the original throwing point
+        errorCh.publish(error)
 
-      throw error
-    } finally {
-      endCh.publish(undefined)
-    }
+        throw error
+      }
+    })
   }
 
   return shimmer.wrap(fn, wrapped)

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

@@ -8,8 +8,7 @@ const {
 const shimmer = require('../../datadog-shimmer')
 
 const startCh = channel('apm:elasticsearch:query:start')
-const asyncEndCh = channel('apm:elasticsearch:query:async-end')
-const endCh = channel('apm:elasticsearch:query:end')
+const finishCh = channel('apm:elasticsearch:query:finish')
 const errorCh = channel('apm:elasticsearch:query:error')
 
 addHook({ name: '@elastic/transport', file: 'lib/Transport.js', versions: ['>=8'] }, (exports) => {
@@ -36,43 +35,42 @@ function wrapRequest (request) {
     if (!params) return request.apply(this, arguments)
 
     const parentResource = new AsyncResource('bound-anonymous-fn')
-
-    startCh.publish({ params })
-
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-    try {
-      const lastIndex = arguments.length - 1
-      cb = arguments[lastIndex]
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ params })
 
-      if (typeof cb === 'function') {
-        cb = parentResource.bind(cb)
+      try {
+        const lastIndex = arguments.length - 1
+        cb = arguments[lastIndex]
 
-        arguments[lastIndex] = asyncResource.bind(function (error) {
-          finish(params, error)
-          return cb.apply(null, arguments)
-        })
-        return request.apply(this, arguments)
-      } else {
-        const promise = request.apply(this, arguments)
-        if (promise && typeof promise.then === 'function') {
-          const onResolve = asyncResource.bind(() => finish(params))
-          const onReject = asyncResource.bind(e => finish(params, e))
+        if (typeof cb === 'function') {
+          cb = parentResource.bind(cb)
 
-          promise.then(onResolve, onReject)
+          arguments[lastIndex] = asyncResource.bind(function (error) {
+            finish(params, error)
+            return cb.apply(null, arguments)
+          })
+          return request.apply(this, arguments)
         } else {
-          finish(params)
+          const promise = request.apply(this, arguments)
+          if (promise && typeof promise.then === 'function') {
+            const onResolve = asyncResource.bind(() => finish(params))
+            const onReject = asyncResource.bind(e => finish(params, e))
+
+            promise.then(onResolve, onReject)
+          } else {
+            finish(params)
+          }
+          return promise
         }
-        return promise
-      }
-    } catch (err) {
-      err.stack // trigger getting the stack at the original throwing point
-      errorCh.publish(err)
+      } catch (err) {
+        err.stack // trigger getting the stack at the original throwing point
+        errorCh.publish(err)
 
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+        throw err
+      }
+    })
   }
 }
 
@@ -80,5 +78,5 @@ function finish (params, error) {
   if (error) {
     errorCh.publish(error)
   }
-  asyncEndCh.publish({ params })
+  finishCh.publish({ params })
 }

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

@@ -1,6 +1,5 @@
 'use strict'
 
-const methods = require('methods').concat('all')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 
@@ -8,26 +7,28 @@ const errorChannel = channel('apm:fastify:middleware:error')
 const handleChannel = channel('apm:fastify:request:handle')
 
 const requestResources = new WeakMap()
+const parsingResources = new WeakMap()
 
-function wrapFastify (fastify) {
+function wrapFastify (fastify, hasParsingEvents) {
   if (typeof fastify !== 'function') return fastify
 
   return function fastifyWithTrace () {
     const app = fastify.apply(this, arguments)
 
-    if (!app) return app
+    if (!app || typeof app.addHook !== 'function') return app
 
-    if (typeof app.addHook === 'function') {
-      app.addHook('onRequest', onRequest)
-      app.addHook = wrapAddHook(app.addHook)
-      app.addHook('preHandler', preHandler)
-    }
+    app.addHook('onRequest', onRequest)
+    app.addHook('preHandler', preHandler)
 
-    methods.forEach(method => {
-      app[method] = wrapMethod(app[method])
-    })
+    if (hasParsingEvents) {
+      app.addHook('preParsing', preParsing)
+      app.addHook('preValidation', preValidation)
+    } else {
+      app.addHook('onRequest', preParsing)
+      app.addHook('preHandler', preValidation)
+    }
 
-    app.route = wrapRoute(app.route)
+    app.addHook = wrapAddHook(app.addHook)
 
     return app
   }
@@ -45,36 +46,39 @@ function wrapAddHook (addHook) {
 
       if (!requestResource) return fn.apply(this, arguments)
 
-      requestResource.runInAsyncScope(() => {
-        const hookResource = new AsyncResource('bound-anonymous-fn')
+      try {
+        if (typeof done === 'function') {
+          done = arguments[arguments.length - 1]
 
-        try {
-          if (typeof done === 'function') {
-            done = arguments[arguments.length - 1]
+          arguments[arguments.length - 1] = function (err) {
+            publishError(err, requestResource)
 
-            arguments[arguments.length - 1] = hookResource.bind(function (err) {
-              errorChannel.publish(err)
-              return done.apply(this, arguments)
-            })
+            if (name === 'onRequest' || name === 'preParsing') {
+              const parsingResource = new AsyncResource('bound-anonymous-fn')
 
-            return hookResource.bind(fn).apply(this, arguments)
-          } else {
-            const promise = hookResource.bind(fn).apply(this, arguments)
+              parsingResources.set(req, parsingResource)
 
-            if (promise && typeof promise.catch === 'function') {
-              return promise.catch(err => {
-                errorChannel.publish(err)
-                throw err
+              return parsingResource.runInAsyncScope(() => {
+                return done.apply(this, arguments)
               })
+            } else {
+              return done.apply(this, arguments)
             }
+          }
 
-            return promise
+          return fn.apply(this, arguments)
+        } else {
+          const promise = fn.apply(this, arguments)
+
+          if (promise && typeof promise.catch === 'function') {
+            return promise.catch(err => publishError(err, requestResource))
           }
-        } catch (e) {
-          errorChannel.publish(e)
-          throw e
+
+          return promise
         }
-      })
+      } catch (e) {
+        throw publishError(e, requestResource)
+      }
     })
 
     return addHook.apply(this, arguments)
@@ -86,11 +90,14 @@ function onRequest (request, reply, next) {
 
   const req = getReq(request)
   const res = getRes(reply)
+  const requestResource = new AsyncResource('bound-anonymous-fn')
 
-  requestResources.set(req, new AsyncResource('bound-anonymous-fn'))
-  handleChannel.publish({ req, res })
+  requestResources.set(req, requestResource)
 
-  return next()
+  return requestResource.runInAsyncScope(() => {
+    handleChannel.publish({ req, res })
+    return next()
+  })
 }
 
 function preHandler (request, reply, next) {
@@ -98,61 +105,39 @@ function preHandler (request, reply, next) {
   if (!reply || typeof reply.send !== 'function') return next()
 
   const req = getReq(request)
+  const requestResource = requestResources.get(req)
 
-  reply.send = requestResources.get(req).bind(wrapSend(reply.send))
+  reply.send = wrapSend(reply.send, requestResource)
 
   next()
 }
 
-function wrapSend (send) {
-  return function sendWithTrace (payload) {
-    if (payload instanceof Error) {
-      errorChannel.publish(payload)
-    }
-
-    return send.apply(this, arguments)
-  }
-}
-
-function wrapRoute (route) {
-  if (typeof route !== 'function') return route
+function preValidation (request, reply, next) {
+  const req = getReq(request)
+  const parsingResource = parsingResources.get(req)
 
-  return function routeWithTrace (opts) {
-    opts.handler = wrapHandler(opts.handler)
+  if (!parsingResource) return next()
 
-    return route.apply(this, arguments)
-  }
+  parsingResource.runInAsyncScope(() => next())
 }
 
-function wrapMethod (method) {
-  if (typeof method !== 'function') return method
-
-  return function methodWithTrace (url, opts, handler) {
-    const lastIndex = arguments.length - 1
-
-    handler = arguments[lastIndex]
-
-    if (typeof handler === 'function') {
-      arguments[lastIndex] = wrapHandler(handler)
-    } else if (handler) {
-      arguments[lastIndex].handler = wrapHandler(handler.handler)
-    }
+function preParsing (request, reply, next) {
+  const req = getReq(request)
+  const parsingResource = new AsyncResource('bound-anonymous-fn')
 
-    return method.apply(this, arguments)
-  }
+  parsingResources.set(req, parsingResource)
+  parsingResource.runInAsyncScope(() => next())
 }
 
-function wrapHandler (handler) {
-  if (!handler || typeof handler !== 'function' || handler.name === 'handlerWithTrace') {
-    return handler
-  }
-
-  return function handlerWithTrace (request, reply) {
-    const req = getReq(request)
+function wrapSend (send, resource) {
+  return function sendWithTrace (payload) {
+    if (payload instanceof Error) {
+      resource.runInAsyncScope(() => {
+        errorChannel.publish(payload)
+      })
+    }
 
-    return requestResources.get(req).runInAsyncScope(() => {
-      return handler.apply(this, arguments)
-    })
+    return send.apply(this, arguments)
   }
 }
 
@@ -164,16 +149,15 @@ function getRes (reply) {
   return reply && (reply.raw || reply.res || reply)
 }
 
-addHook({ name: 'fastify', versions: ['>=3.25.2'] }, fastify => {
-  const wrapped = shimmer.wrap(fastify, wrapFastify(fastify, false))
-
-  wrapped.fastify = wrapped
-  wrapped.default = wrapped
+function publishError (error, resource) {
+  resource.runInAsyncScope(() => {
+    errorChannel.publish(error)
+  })
 
-  return wrapped
-})
+  return error
+}
 
-addHook({ name: 'fastify', versions: ['3 - 3.25.1'] }, fastify => {
+addHook({ name: 'fastify', versions: ['>=3'] }, fastify => {
   const wrapped = shimmer.wrap(fastify, wrapFastify(fastify, true))
 
   wrapped.fastify = wrapped
@@ -182,6 +166,10 @@ addHook({ name: 'fastify', versions: ['3 - 3.25.1'] }, fastify => {
   return wrapped
 })
 
-addHook({ name: 'fastify', versions: ['1 - 2'] }, fastify => {
+addHook({ name: 'fastify', versions: ['2'] }, fastify => {
   return shimmer.wrap(fastify, wrapFastify(fastify, true))
 })
+
+addHook({ name: 'fastify', versions: ['1'] }, fastify => {
+  return shimmer.wrap(fastify, wrapFastify(fastify, false))
+})