dd-trace 2.7.1 → 2.9.1

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

@@ -8,8 +8,7 @@ const {
 const shimmer = require('../../datadog-shimmer')
 
 const startCh = channel('apm:redis:command:start')
-const asyncEndCh = channel('apm:redis:command:async-end')
-const endCh = channel('apm:redis:command:end')
+const finishCh = channel('apm:redis:command:finish')
 const errorCh = channel('apm:redis:command:error')
 
 addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1'] }, redis => {
@@ -21,16 +20,18 @@ addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js',
     const name = command[0]
     const args = command.slice(1)
 
-    start(this, name, args)
-
-    const res = addCommand.apply(this, arguments)
     const asyncResource = new AsyncResource('bound-anonymous-fn')
-    const onResolve = asyncResource.bind(() => finish(asyncEndCh, errorCh))
-    const onReject = asyncResource.bind(err => finish(asyncEndCh, errorCh, err))
+    return asyncResource.runInAsyncScope(() => {
+      start(this, name, args)
+
+      const res = addCommand.apply(this, arguments)
+      const onResolve = asyncResource.bind(() => finish(finishCh, errorCh))
+      const onReject = asyncResource.bind(err => finish(finishCh, errorCh, err))
+
+      res.then(onResolve, onReject)
 
-    res.then(onResolve, onReject)
-    endCh.publish(undefined)
-    return res
+      return res
+    })
   })
   return redis
 })
@@ -41,23 +42,23 @@ addHook({ name: 'redis', versions: ['>=2.6 <4'] }, redis => {
 
     if (!options.callback) return internalSendCommand.apply(this, arguments)
 
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
+    const cb = callbackResource.bind(options.callback)
 
-    const cb = asyncResource.bind(options.callback)
+    return asyncResource.runInAsyncScope(() => {
+      start(this, options.command, options.args)
 
-    start(this, options.command, options.args)
+      options.callback = asyncResource.bind(wrapCallback(finishCh, errorCh, cb))
 
-    options.callback = AsyncResource.bind(wrapCallback(asyncEndCh, errorCh, cb))
+      try {
+        return internalSendCommand.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
 
-    try {
-      return internalSendCommand.apply(this, arguments)
-    } catch (err) {
-      errorCh.publish(err)
-
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+        throw err
+      }
+    })
   })
   return redis
 })
@@ -68,29 +69,30 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
       return sendCommand.apply(this, arguments)
     }
 
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-    start(this, command, args)
-
-    if (typeof callback === 'function') {
-      const cb = asyncResource.bind(callback)
-      arguments[2] = AsyncResource.bind(wrapCallback(asyncEndCh, errorCh, cb))
-    } else if (Array.isArray(args) && typeof args[args.length - 1] === 'function') {
-      const cb = asyncResource.bind(args[args.length - 1])
-      args[args.length - 1] = AsyncResource.bind(wrapCallback(asyncEndCh, errorCh, cb))
-    } else {
-      arguments[2] = AsyncResource.bind(wrapCallback(asyncEndCh, errorCh))
-    }
-
-    try {
-      return sendCommand.apply(this, arguments)
-    } catch (err) {
-      errorCh.publish(err)
-
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+    return asyncResource.runInAsyncScope(() => {
+      start(this, command, args)
+
+      if (typeof callback === 'function') {
+        const cb = callbackResource.bind(callback)
+        arguments[2] = asyncResource.bind(wrapCallback(finishCh, errorCh, cb))
+      } else if (Array.isArray(args) && typeof args[args.length - 1] === 'function') {
+        const cb = callbackResource.bind(args[args.length - 1])
+        args[args.length - 1] = asyncResource.bind(wrapCallback(finishCh, errorCh, cb))
+      } else {
+        arguments[2] = asyncResource.bind(wrapCallback(finishCh, errorCh))
+      }
+
+      try {
+        return sendCommand.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
+
+        throw err
+      }
+    })
   })
   return redis
 })
@@ -101,18 +103,18 @@ function start (client, command, args) {
   startCh.publish({ db, command, args, connectionOptions })
 }
 
-function wrapCallback (asyncEndCh, errorCh, callback) {
+function wrapCallback (finishCh, errorCh, callback) {
   return function (err) {
-    finish(asyncEndCh, errorCh, err)
+    finish(finishCh, errorCh, err)
     if (callback) {
       return callback.apply(this, arguments)
     }
   }
 }
 
-function finish (asyncEndCh, errorCh, error) {
+function finish (finishCh, errorCh, error) {
   if (error) {
     errorCh.publish(error)
   }
-  asyncEndCh.publish(undefined)
+  finishCh.publish()
 }

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

@@ -13,8 +13,7 @@ const inFlightDeliveries = Symbol('inFlightDeliveries')
 const patched = new WeakSet()
 const dispatchCh = channel('apm:rhea:dispatch')
 const errorCh = channel('apm:rhea:error')
-const asyncEndCh = channel('apm:rhea:async-end')
-const endCh = channel('apm:rhea:end')
+const finishCh = channel('apm:rhea:finish')
 
 const contexts = new WeakMap()
 
@@ -35,24 +34,24 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
     const targetAddress = this.options && this.options.target &&
       this.options.target.address ? this.options.target.address : undefined
 
-    startSendCh.publish({ targetAddress, host, port, msg })
-    const delivery = send.apply(this, arguments)
     const asyncResource = new AsyncResource('bound-anonymous-fn')
-    const context = {
-      asyncResource
-    }
-    contexts.set(delivery, context)
+    return asyncResource.runInAsyncScope(() => {
+      startSendCh.publish({ targetAddress, host, port, msg })
+      const delivery = send.apply(this, arguments)
+      const context = {
+        asyncResource
+      }
+      contexts.set(delivery, context)
 
-    addToInFlightDeliveries(this.connection, delivery)
-    try {
-      return delivery
-    } catch (err) {
-      errorCh.publish(err)
+      addToInFlightDeliveries(this.connection, delivery)
+      try {
+        return delivery
+      } catch (err) {
+        errorCh.publish(err)
 
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+        throw err
+      }
+    })
   })
 
   shimmer.wrap(Receiver.prototype, 'dispatch', dispatch => function (eventName, msgObj) {
@@ -62,26 +61,26 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/link.js' }, obj => {
     }
 
     if (eventName === 'message' && msgObj) {
-      startReceiveCh.publish({ msgObj, connection: this.connection })
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+      return asyncResource.runInAsyncScope(() => {
+        startReceiveCh.publish({ msgObj, connection: this.connection })
 
-      if (msgObj.delivery) {
-        const asyncResource = new AsyncResource('bound-anonymous-fn')
-        const context = {
-          asyncResource
+        if (msgObj.delivery) {
+          const context = {
+            asyncResource
+          }
+          contexts.set(msgObj.delivery, context)
+          msgObj.delivery.update = wrapDeliveryUpdate(msgObj.delivery, msgObj.delivery.update)
+          addToInFlightDeliveries(this.connection, msgObj.delivery)
         }
-        contexts.set(msgObj.delivery, context)
-        msgObj.delivery.update = wrapDeliveryUpdate(msgObj.delivery, msgObj.delivery.update)
-        addToInFlightDeliveries(this.connection, msgObj.delivery)
-      }
-      try {
-        return dispatch.apply(this, arguments)
-      } catch (err) {
-        errorCh.publish(err)
+        try {
+          return dispatch.apply(this, arguments)
+        } catch (err) {
+          errorCh.publish(err)
 
-        throw err
-      } finally {
-        endCh.publish(undefined)
-      }
+          throw err
+        }
+      })
     }
 
     return dispatch.apply(this, arguments)
@@ -96,7 +95,10 @@ addHook({ name: 'rhea', versions: ['>=1'], file: 'lib/connection.js' }, Connecti
       if (this[inFlightDeliveries]) {
         this[inFlightDeliveries].forEach(delivery => {
           const context = contexts.get(delivery)
-          const asyncResource = context.asyncResource
+          const asyncResource = context && context.asyncResource
+
+          if (!asyncResource) return
+
           asyncResource.runInAsyncScope(() => {
             errorCh.publish(error)
             finish(delivery, null)
@@ -160,19 +162,19 @@ function patchCircularBuffer (proto, Session) {
           shimmer.wrap(CircularBuffer.prototype, 'pop_if', popIf => function (fn) {
             arguments[0] = AsyncResource.bind(function (entry) {
               const context = contexts.get(entry)
-              const asyncResource = context.asyncResource
-              let shouldPop
-              if (asyncResource) {
-                fn = asyncResource.bind(fn, this)
-                shouldPop = fn(entry)
-                if (shouldPop && asyncResource) {
-                  const remoteState = entry.remote_state
-                  const state = remoteState && remoteState.constructor
-                    ? entry.remote_state.constructor.composite_type : undefined
-                  asyncResource.runInAsyncScope(() => {
-                    return finish(entry, state)
-                  })
-                }
+              const asyncResource = context && context.asyncResource
+
+              if (!asyncResource) return fn(entry)
+
+              const shouldPop = asyncResource.runInAsyncScope(() => fn(entry))
+
+              if (shouldPop) {
+                const remoteState = entry.remote_state
+                const state = remoteState && remoteState.constructor
+                  ? entry.remote_state.constructor.composite_type : undefined
+                asyncResource.runInAsyncScope(() => {
+                  return finish(entry, state)
+                })
               }
 
               return shouldPop
@@ -205,7 +207,7 @@ function finish (delivery, state) {
     if (state) {
       dispatchCh.publish({ state })
     }
-    asyncEndCh.publish(undefined)
+    finishCh.publish(undefined)
     if (obj.connection && obj.connection[inFlightDeliveries]) {
       obj.connection[inFlightDeliveries].delete(delivery)
     }

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

@@ -8,7 +8,7 @@ const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 function createWrapRouterMethod (name) {
   const enterChannel = channel(`apm:${name}:middleware:enter`)
   const errorChannel = channel(`apm:${name}:middleware:error`)
-  const exitChannel = channel(`apm:${name}:middleware:exit`)
+  const nextChannel = channel(`apm:${name}:middleware:next`)
 
   const layerMatchers = new WeakMap()
   const regexpCache = Object.create(null)
@@ -24,10 +24,10 @@ function createWrapRouterMethod (name) {
       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(() => {
@@ -50,7 +50,7 @@ function createWrapRouterMethod (name) {
           return original.apply(this, arguments)
         } catch (e) {
           errorChannel.publish(e)
-          exitChannel.publish({ req })
+          nextChannel.publish({ req })
 
           throw e
         }
@@ -92,7 +92,7 @@ function createWrapRouterMethod (name) {
         errorChannel.publish(error)
       }
 
-      exitChannel.publish({ req })
+      nextChannel.publish({ req })
 
       next.apply(null, arguments)
     }

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

@@ -33,38 +33,38 @@ const READABLE_ACTION_NAMES = {
 
 addHook({ name: 'sharedb', versions: ['>=1'], file: 'lib/agent.js' }, Agent => {
   const startCh = channel('apm:sharedb:request:start')
-  const asyncEndCh = channel('apm:sharedb:request:async-end')
-  const endCh = channel('apm:sharedb:request:end')
+  const finishCh = channel('apm:sharedb:request:finish')
   const errorCh = channel('apm:sharedb:request:error')
 
   shimmer.wrap(Agent.prototype, '_handleMessage', origHandleMessageFn => function (request, callback) {
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
-    const action = request.a
 
+    const action = request.a
     const actionName = getReadableActionName(action)
 
-    startCh.publish({ actionName, request })
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ actionName, request })
 
-    callback = asyncResource.bind(callback)
+      callback = callbackResource.bind(callback)
 
-    arguments[1] = AsyncResource.bind(function (error, res) {
-      if (error) {
-        errorCh.publish(error)
-      }
-      asyncEndCh.publish({ request, res })
+      arguments[1] = asyncResource.bind(function (error, res) {
+        if (error) {
+          errorCh.publish(error)
+        }
+        finishCh.publish({ request, res })
 
-      return callback.apply(this, arguments)
-    })
+        return callback.apply(this, arguments)
+      })
 
-    try {
-      return origHandleMessageFn.apply(this, arguments)
-    } catch (error) {
-      errorCh.publish(error)
+      try {
+        return origHandleMessageFn.apply(this, arguments)
+      } catch (error) {
+        errorCh.publish(error)
 
-      throw error
-    } finally {
-      endCh.publish(undefined)
-    }
+        throw error
+      }
+    })
   })
   return Agent
 })

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

@@ -9,8 +9,7 @@ const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'tedious', versions: [ '>=1.0.0' ] }, tedious => {
   const startCh = channel('apm:tedious:request:start')
-  const asyncEndCh = channel('apm:tedious:request:async-end')
-  const endCh = channel('apm:tedious:request:end')
+  const finishCh = channel('apm:tedious:request:finish')
   const errorCh = channel('apm:tedious:request:error')
   shimmer.wrap(tedious.Connection.prototype, 'makeRequest', makeRequest => function (request) {
     if (!startCh.hasSubscribers) {
@@ -23,31 +22,32 @@ addHook({ name: 'tedious', versions: [ '>=1.0.0' ] }, tedious => {
       return makeRequest.apply(this, arguments)
     }
 
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
     const connectionConfig = this.config
 
-    startCh.publish({ queryOrProcedure, connectionConfig })
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ queryOrProcedure, connectionConfig })
 
-    const cb = asyncResource.bind(request.callback, request)
-    request.callback = AsyncResource.bind(function (error) {
-      if (error) {
-        errorCh.publish(error)
-      }
-      asyncEndCh.publish(undefined)
+      const cb = callbackResource.bind(request.callback, request)
+      request.callback = asyncResource.bind(function (error) {
+        if (error) {
+          errorCh.publish(error)
+        }
+        finishCh.publish(undefined)
 
-      return cb.apply(this, arguments)
-    }, null, request)
+        return cb.apply(this, arguments)
+      }, null, request)
 
-    try {
-      return makeRequest.apply(this, arguments)
-    } catch (error) {
-      errorCh.publish(error)
+      try {
+        return makeRequest.apply(this, arguments)
+      } catch (error) {
+        errorCh.publish(error)
 
-      throw error
-    } finally {
-      endCh.publish(undefined)
-    }
+        throw error
+      }
+    })
   })
 
   return tedious

package/packages/datadog-plugin-amqp10/src/index.js

@@ -42,16 +42,12 @@ class Amqp10Plugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:amqp10:send:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:amqp10:send:error`, err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub(`apm:amqp10:send:async-end`, () => {
+    this.addSub(`apm:amqp10:send:finish`, () => {
       const span = storage.getStore().span
       span.finish()
     })
@@ -85,9 +81,8 @@ class Amqp10Plugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:amqp10:receive:end`, () => {
+    this.addSub(`apm:amqp10:receive:finish`, () => {
       storage.getStore().span.finish()
-      this.exit()
     })
 
     this.addSub(`apm:amqp10:receive:error`, err => {

package/packages/datadog-plugin-amqplib/src/index.js

@@ -76,10 +76,9 @@ class AmqplibPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:amqplib:command:end`, () => {
+    this.addSub(`apm:amqplib:command:finish`, () => {
       const span = storage.getStore().span
       span.finish()
-      this.exit()
     })
 
     this.addSub(`apm:amqplib:command:error`, err => {

package/packages/datadog-plugin-cassandra-driver/src/index.js

@@ -43,15 +43,11 @@ class CassandraDriverPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub(`apm:cassandra:query:end`, () => {
-      this.exit()
-    })
-
     this.addSub(`apm:cassandra:query:error`, err => {
       storage.getStore().span.setTag('error', err)
     })
 
-    this.addSub(`apm:cassandra:query:async-end`, () => {
+    this.addSub(`apm:cassandra:query:finish`, () => {
       storage.getStore().span.finish()
     })
 

package/packages/datadog-plugin-couchbase/src/index.js

@@ -9,11 +9,10 @@ class CouchBasePlugin extends Plugin {
     return 'couchbase'
   }
 
-  addSubs (func, start, asyncEnd = defaultAsyncEnd) {
+  addSubs (func, start, finish = defaultFinish) {
     this.addSub(`apm:couchbase:${func}:start`, start)
-    this.addSub(`apm:couchbase:${func}:end`, this.exit.bind(this))
     this.addSub(`apm:couchbase:${func}:error`, errorHandler)
-    this.addSub(`apm:couchbase:${func}:async-end`, asyncEnd)
+    this.addSub(`apm:couchbase:${func}:finish`, finish)
   }
 
   startSpan (operation, customTags, store, bucket) {
@@ -63,7 +62,7 @@ class CouchBasePlugin extends Plugin {
   }
 }
 
-function defaultAsyncEnd () {
+function defaultFinish () {
   storage.getStore().span.finish()
 }
 

package/packages/datadog-plugin-cucumber/src/index.js

@@ -54,10 +54,6 @@ class CucumberPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub('ci:cucumber:run:end', () => {
-      this.exit()
-    })
-
     this.addSub('ci:cucumber:run-step:start', ({ resource }) => {
       const store = storage.getStore()
       const childOf = store ? store.span : store
@@ -71,11 +67,7 @@ class CucumberPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub('ci:cucumber:run-step:end', () => {
-      this.exit()
-    })
-
-    this.addSub('ci:cucumber:run:async-end', ({ isStep, status, skipReason, errorMessage }) => {
+    this.addSub('ci:cucumber:run:finish', ({ isStep, status, skipReason, errorMessage }) => {
       const span = storage.getStore().span
       const statusTag = isStep ? 'step.status' : TEST_STATUS
 

package/packages/datadog-plugin-dns/src/index.js

@@ -9,11 +9,10 @@ class DNSPlugin extends Plugin {
     return 'dns'
   }
 
-  addSubs (func, start, asyncEnd = defaultAsyncEnd) {
+  addSubs (func, start, finish = defaultFinish) {
     this.addSub(`apm:dns:${func}:start`, start)
-    this.addSub(`apm:dns:${func}:end`, this.exit.bind(this))
     this.addSub(`apm:dns:${func}:error`, errorHandler)
-    this.addSub(`apm:dns:${func}:async-end`, asyncEnd)
+    this.addSub(`apm:dns:${func}:finish`, finish)
   }
 
   startSpan (name, customTags, store) {
@@ -88,7 +87,7 @@ class DNSPlugin extends Plugin {
   }
 }
 
-function defaultAsyncEnd () {
+function defaultFinish () {
   storage.getStore().span.finish()
 }
 

package/packages/datadog-plugin-elasticsearch/src/index.js

@@ -34,16 +34,12 @@ class ElasticsearchPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub('apm:elasticsearch:query:end', () => {
-      this.exit()
-    })
-
     this.addSub('apm:elasticsearch:query:error', err => {
       const span = storage.getStore().span
       span.setTag('error', err)
     })
 
-    this.addSub('apm:elasticsearch:query:async-end', ({ params }) => {
+    this.addSub('apm:elasticsearch:query:finish', ({ params }) => {
       const span = storage.getStore().span
       this.config.hooks.query(span, params)
       span.finish()

package/packages/datadog-plugin-hapi/src/index.js

@@ -1,6 +1,37 @@
 'use strict'
 
-const route = require('./route')
-const server = require('./server')
+const { storage } = require('../../datadog-core')
+const RouterPlugin = require('../../datadog-plugin-router/src')
+const web = require('../../dd-trace/src/plugins/util/web')
 
-module.exports = [].concat(route, server)
+class HapiPlugin extends RouterPlugin {
+  static get name () {
+    return 'hapi'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this._requestSpans = new WeakMap()
+
+    this.addSub('apm:hapi:request:handle', ({ req }) => {
+      const store = storage.getStore()
+      const span = store && store.span
+
+      this.setFramework(req, 'hapi', this.config)
+      this._requestSpans.set(req, span)
+    })
+
+    this.addSub('apm:hapi:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
+    })
+
+    this.addSub(`apm:hapi:request:error`, this.addError)
+
+    this.addSub('apm:hapi:extension:enter', ({ req }) => {
+      this.enter(this._requestSpans.get(req))
+    })
+  }
+}
+
+module.exports = HapiPlugin

package/packages/datadog-plugin-http/src/client.js

@@ -54,9 +54,7 @@ class HttpClientPlugin extends Plugin {
       this.enter(span, store)
     })
 
-    this.addSub('apm:http:client:request:end', this.exit.bind(this))
-
-    this.addSub('apm:http:client:request:async-end', ({ req, res }) => {
+    this.addSub('apm:http:client:request:finish', ({ req, res }) => {
       const span = storage.getStore().span
       if (res) {
         span.setTag(HTTP_STATUS_CODE, res.statusCode)