dd-trace 2.7.1 → 2.8.0

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

@@ -10,8 +10,7 @@ const shimmer = require('../../datadog-shimmer')
 addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
   const startCh = channel('apm:memcached:command:start')
   const startWithArgsCh = channel('apm:memcached:command:start:with-args')
-  const asyncEndCh = channel('apm:memcached:command:async-end')
-  const endCh = channel('apm:memcached:command:end')
+  const finishCh = channel('apm:memcached:command:finish')
   const errorCh = channel('apm:memcached:command:error')
 
   shimmer.wrap(Memcached.prototype, 'command', command => function (queryCompiler, server) {
@@ -19,34 +18,37 @@ addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
       return command.apply(this, arguments)
     }
 
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
     const client = this
 
-    const wrappedQueryCompiler = function () {
+    const wrappedQueryCompiler = asyncResource.bind(function () {
       const query = queryCompiler.apply(this, arguments)
-      const callback = asyncResource.bind(query.callback)
+      const callback = callbackResource.bind(query.callback)
 
-      query.callback = AsyncResource.bind(function (err) {
+      query.callback = asyncResource.bind(function (err) {
         if (err) {
           errorCh.publish(err)
         }
-        asyncEndCh.publish(undefined)
+        finishCh.publish()
 
         return callback.apply(this, arguments)
       })
       startWithArgsCh.publish({ client, server, query })
 
       return query
-    }
+    })
+
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish()
 
-    startCh.publish(undefined)
+      arguments[0] = wrappedQueryCompiler
 
-    arguments[0] = wrappedQueryCompiler
+      const result = command.apply(this, arguments)
 
-    const result = command.apply(this, arguments)
-    endCh.publish(undefined)
-    return result
+      return result
+    })
   })
 
   return Memcached

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

@@ -4,12 +4,11 @@ const shimmer = require('../../datadog-shimmer')
 const testStartCh = channel('ci:mocha:test:start')
 const errorCh = channel('ci:mocha:test:error')
 const skipCh = channel('ci:mocha:test:skip')
-const testEndCh = channel('ci:mocha:test:end')
-const testAsyncEndCh = channel('ci:mocha:test:async-end')
-const suiteEndCh = channel('ci:mocha:suite:end')
+const testFinishCh = channel('ci:mocha:test:finish')
+const suiteFinishCh = channel('ci:mocha:suite:finish')
 const hookErrorCh = channel('ci:mocha:hook:error')
 const parameterizedTestCh = channel('ci:mocha:test:parameterize')
-const testRunEndCh = channel('ci:mocha:run:end')
+const testRunFinishCh = channel('ci:mocha:run:finish')
 
 // TODO: remove when root hooks and fixtures are implemented
 const patched = new WeakSet()
@@ -38,59 +37,58 @@ function mochaHook (Runner) {
   patched.add(Runner)
 
   shimmer.wrap(Runner.prototype, 'runTest', runTest => function () {
-    if (!testStartCh.hasSubscribers) {
+    if (!testStartCh.hasSubscribers || isRetry(this.test)) {
       return runTest.apply(this, arguments)
     }
 
-    if (!isRetry(this.test)) {
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
       testStartCh.publish(this.test)
-    }
-
-    this.once('test end', AsyncResource.bind(() => {
-      let status
 
-      if (this.test.pending) {
-        status = 'skipped'
-      } else if (this.test.state !== 'failed' && !this.test.timedOut) {
-        status = 'pass'
-      } else {
-        status = 'fail'
+      this.once('test end', AsyncResource.bind(() => {
+        let status
+
+        if (this.test.pending) {
+          status = 'skipped'
+        } else if (this.test.state !== 'failed' && !this.test.timedOut) {
+          status = 'pass'
+        } else {
+          status = 'fail'
+        }
+
+        testFinishCh.publish(status)
+      }))
+
+      this.once('fail', AsyncResource.bind((test, err) => {
+        errorCh.publish(err)
+      }))
+
+      this.once('pending', AsyncResource.bind((test) => {
+        skipCh.publish(test)
+      }))
+
+      try {
+        return runTest.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
+        throw err
       }
-
-      testAsyncEndCh.publish(status)
-    }))
-
-    this.once('fail', AsyncResource.bind((test, err) => {
-      errorCh.publish(err)
-    }))
-
-    this.once('pending', AsyncResource.bind((test) => {
-      skipCh.publish(test)
-    }))
-
-    try {
-      return runTest.apply(this, arguments)
-    } catch (err) {
-      errorCh.publish(err)
-      throw err
-    } finally {
-      testEndCh.publish(undefined)
-    }
+    })
   })
 
   shimmer.wrap(Runner.prototype, 'runTests', runTests => function () {
-    if (!suiteEndCh.hasSubscribers) {
+    if (!suiteFinishCh.hasSubscribers) {
       return runTests.apply(this, arguments)
     }
     this.once('end', AsyncResource.bind(() => {
-      testRunEndCh.publish(undefined)
+      testRunFinishCh.publish()
     }))
     runTests.apply(this, arguments)
     const suite = arguments[0]
     // We call `getAllTestsInSuite` with the root suite so every skipped test
     // should already have an associated test span.
     const tests = getAllTestsInSuite(suite)
-    suiteEndCh.publish(tests)
+    suiteFinishCh.publish(tests)
   })
 
   shimmer.wrap(Runner.prototype, 'fail', fail => function (hook, error) {

package/packages/datadog-instrumentations/src/moleculer/client.js

@@ -0,0 +1,46 @@
+'use strict'
+
+const { channel, addHook, AsyncResource } = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const startChannel = channel('apm:moleculer:call:start')
+const finishChannel = channel('apm:moleculer:call:finish')
+const errorChannel = channel('apm:moleculer:call:error')
+
+function wrapCall (call) {
+  return function (actionName, params, opts) {
+    const callResource = new AsyncResource('bound-anonymous-fn')
+
+    opts = arguments[2] = opts || {}
+    opts.meta = opts.meta || {}
+
+    arguments.length = Math.max(3, arguments.length)
+
+    return callResource.runInAsyncScope(() => {
+      startChannel.publish({ actionName, params, opts })
+
+      const promise = call.apply(this, arguments)
+      const broker = this
+      const ctx = promise.ctx
+
+      return promise
+        .then(
+          result => {
+            finishChannel.publish({ broker, ctx })
+            return result
+          },
+          error => {
+            errorChannel.publish(error)
+            finishChannel.publish({ broker, ctx })
+            throw error
+          }
+        )
+    })
+  }
+}
+
+addHook({ name: 'moleculer', versions: ['>=0.14'] }, moleculer => {
+  shimmer.wrap(moleculer.ServiceBroker.prototype, 'call', wrapCall)
+
+  return moleculer
+})

package/packages/datadog-instrumentations/src/moleculer/server.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const { channel, addHook, AsyncResource } = require('../helpers/instrument')
+const shimmer = require('../../../datadog-shimmer')
+
+const startChannel = channel('apm:moleculer:action:start')
+const finishChannel = channel('apm:moleculer:action:finish')
+const errorChannel = channel('apm:moleculer:action:error')
+
+function wrapRegisterMiddlewares (registerMiddlewares) {
+  return function (userMiddlewares) {
+    if (this.middlewares && this.middlewares.add) {
+      this.middlewares.add(createMiddleware())
+    }
+
+    return registerMiddlewares.apply(this, arguments)
+  }
+}
+
+function createMiddleware () {
+  return {
+    name: 'Datadog',
+
+    localAction (next, action) {
+      const broker = this
+
+      return function datadogMiddleware (ctx) {
+        const actionResource = new AsyncResource('bound-anonymous-fn')
+
+        return actionResource.runInAsyncScope(() => {
+          startChannel.publish({ action, ctx, broker })
+
+          try {
+            return next(ctx).then(
+              result => {
+                finishChannel.publish()
+                return result
+              },
+              error => {
+                errorChannel.publish(error)
+                finishChannel.publish()
+                throw error
+              }
+            )
+          } catch (e) {
+            errorChannel.publish(e)
+            finishChannel.publish()
+          }
+        })
+      }
+    }
+  }
+}
+
+addHook({ name: 'moleculer', versions: ['>=0.14'] }, moleculer => {
+  shimmer.wrap(moleculer.ServiceBroker.prototype, 'registerMiddlewares', wrapRegisterMiddlewares)
+
+  return moleculer
+})

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

@@ -0,0 +1,4 @@
+'use strict'
+
+require('./moleculer/client')
+require('./moleculer/server')

package/packages/datadog-instrumentations/src/mongodb-core.js

@@ -8,8 +8,7 @@ const {
 const shimmer = require('../../datadog-shimmer')
 
 const startCh = channel(`apm:mongodb:query:start`)
-const endCh = channel(`apm:mongodb:query:end`)
-const asyncEndCh = channel(`apm:mongodb:query:async-end`)
+const finishCh = channel(`apm:mongodb:query:finish`)
 const errorCh = channel(`apm:mongodb:query:error`)
 
 addHook({ name: 'mongodb-core', versions: ['2 - 3.1.9'] }, Server => {
@@ -79,8 +78,7 @@ function wrapUnifiedCommand (command, operation, name) {
     if (!startCh.hasSubscribers) {
       return command.apply(this, arguments)
     }
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return instrument(asyncResource, operation, command, this, arguments, server, ns, ops, { name })
+    return instrument(operation, command, this, arguments, server, ns, ops, { name })
   }
   return shimmer.wrap(command, wrapped)
 }
@@ -90,7 +88,6 @@ function wrapConnectionCommand (command, operation, name) {
     if (!startCh.hasSubscribers) {
       return command.apply(this, arguments)
     }
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
     const hostParts = typeof this.address === 'string' ? this.address.split(':') : ''
     const options = hostParts.length === 2
       ? { host: hostParts[0], port: hostParts[1] }
@@ -98,7 +95,7 @@ function wrapConnectionCommand (command, operation, name) {
     const topology = { s: { options } }
 
     ns = `${ns.db}.${ns.collection}`
-    return instrument(asyncResource, operation, command, this, arguments, topology, ns, ops, { name })
+    return instrument(operation, command, this, arguments, topology, ns, ops, { name })
   }
   return shimmer.wrap(command, wrapped)
 }
@@ -108,11 +105,10 @@ function wrapQuery (query, operation, name) {
     if (!startCh.hasSubscribers) {
       return query.apply(this, arguments)
     }
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
     const pool = this.server.s.pool
     const ns = this.ns
     const ops = this.cmd
-    return instrument(asyncResource, operation, query, this, arguments, pool, ns, ops)
+    return instrument(operation, query, this, arguments, pool, ns, ops)
   }
 
   return shimmer.wrap(query, wrapped)
@@ -123,10 +119,9 @@ function wrapCursor (cursor, operation, name) {
     if (!startCh.hasSubscribers) {
       return cursor.apply(this, arguments)
     }
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
     const pool = this.server.s.pool
     const ns = this.ns
-    return instrument(asyncResource, operation, cursor, this, arguments, pool, ns, {}, { name })
+    return instrument(operation, cursor, this, arguments, pool, ns, {}, { name })
   }
   return shimmer.wrap(cursor, wrapped)
 }
@@ -136,44 +131,45 @@ function wrapCommand (command, operation, name) {
     if (!startCh.hasSubscribers) {
       return command.apply(this, arguments)
     }
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return instrument(asyncResource, operation, command, this, arguments, this, ns, ops, { name })
+    return instrument(operation, command, this, arguments, this, ns, ops, { name })
   }
   return shimmer.wrap(command, wrapped)
 }
 
-function instrument (ar, operation, command, ctx, args, server, ns, ops, options = {}) {
+function instrument (operation, command, ctx, args, server, ns, ops, options = {}) {
   const name = options.name || (ops && Object.keys(ops)[0])
   const index = args.length - 1
   let callback = args[index]
 
   if (typeof callback !== 'function') return command.apply(ctx, args)
 
-  callback = ar.bind(callback)
-
   const serverInfo = server && server.s && server.s.options
+  const callbackResource = new AsyncResource('bound-anonymous-fn')
+  const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-  startCh.publish({ ns, ops, options: serverInfo, name })
+  callback = callbackResource.bind(callback)
 
-  args[index] = AsyncResource.bind(function (err, res) {
-    if (err) {
-      errorCh.publish(err)
-    }
+  return asyncResource.runInAsyncScope(() => {
+    startCh.publish({ ns, ops, options: serverInfo, name })
 
-    asyncEndCh.publish(undefined)
+    args[index] = asyncResource.bind(function (err, res) {
+      if (err) {
+        errorCh.publish(err)
+      }
 
-    if (callback) {
-      return callback.apply(this, arguments)
-    }
-  })
+      finishCh.publish()
 
-  try {
-    return command.apply(ctx, args)
-  } catch (err) {
-    errorCh.publish(err)
+      if (callback) {
+        return callback.apply(this, arguments)
+      }
+    })
 
-    throw err
-  } finally {
-    endCh.publish(undefined)
-  }
+    try {
+      return command.apply(ctx, args)
+    } catch (err) {
+      errorCh.publish(err)
+
+      throw err
+    }
+  })
 }

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

@@ -9,12 +9,10 @@ const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connection => {
   const startCh = channel('apm:mysql:query:start')
-  const asyncEndCh = channel('apm:mysql:query:async-end')
-  const endCh = channel('apm:mysql:query:end')
+  const finishCh = channel('apm:mysql:query:finish')
   const errorCh = channel('apm:mysql:query:error')
 
   shimmer.wrap(Connection.prototype, 'query', query => function () {
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
     if (!startCh.hasSubscribers) {
       return query.apply(this, arguments)
     }
@@ -22,37 +20,40 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
     const sql = arguments[0].sql ? arguments[0].sql : arguments[0]
     const conf = this.config
 
-    startCh.publish({ sql, conf })
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-    try {
-      const res = query.apply(this, arguments)
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ sql, conf })
 
-      if (res._callback) {
-        const cb = asyncResource.bind(res._callback)
-        res._callback = AsyncResource.bind(function (error, result) {
-          if (error) {
-            errorCh.publish(error)
-          }
-          asyncEndCh.publish(result)
+      try {
+        const res = query.apply(this, arguments)
 
-          return cb.apply(this, arguments)
-        })
-      } else {
-        const cb = AsyncResource.bind(function () {
-          asyncEndCh.publish(undefined)
-        })
-        res.on('end', cb)
-      }
+        if (res._callback) {
+          const cb = callbackResource.bind(res._callback)
+          res._callback = asyncResource.bind(function (error, result) {
+            if (error) {
+              errorCh.publish(error)
+            }
+            finishCh.publish(result)
 
-      return res
-    } catch (err) {
-      err.stack // trigger getting the stack at the original throwing point
-      errorCh.publish(err)
+            return cb.apply(this, arguments)
+          })
+        } else {
+          const cb = asyncResource.bind(function () {
+            finishCh.publish(undefined)
+          })
+          res.on('end', cb)
+        }
 
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+        return res
+      } catch (err) {
+        err.stack // trigger getting the stack at the original throwing point
+        errorCh.publish(err)
+
+        throw err
+      }
+    })
   })
 
   return Connection

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

@@ -9,8 +9,7 @@ const shimmer = require('../../datadog-shimmer')
 
 addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connection => {
   const startCh = channel('apm:mysql2:query:start')
-  const asyncEndCh = channel('apm:mysql2:query:async-end')
-  const endCh = channel('apm:mysql2:query:end')
+  const finishCh = channel('apm:mysql2:query:finish')
   const errorCh = channel('apm:mysql2:query:error')
 
   shimmer.wrap(Connection.prototype, 'addCommand', addCommand => function (cmd) {
@@ -42,24 +41,26 @@ addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connec
   }
 
   function wrapExecute (cmd, execute, asyncResource, config) {
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
+
     return asyncResource.bind(function executeWithTrace (packet, connection) {
       const sql = cmd.statement ? cmd.statement.query : cmd.sql
 
       startCh.publish({ sql, conf: config })
 
       if (this.onResult) {
-        const onResult = asyncResource.bind(this.onResult)
+        const onResult = callbackResource.bind(this.onResult)
 
-        this.onResult = AsyncResource.bind(function (error) {
+        this.onResult = asyncResource.bind(function (error) {
           if (error) {
             errorCh.publish(error)
           }
-          asyncEndCh.publish(undefined)
+          finishCh.publish(undefined)
           onResult.apply(this, arguments)
         }, 'bound-anonymous-fn', this)
       } else {
-        this.on('error', AsyncResource.bind(error => errorCh.publish(error)))
-        this.on('end', AsyncResource.bind(() => asyncEndCh.publish(undefined)))
+        this.on('error', asyncResource.bind(error => errorCh.publish(error)))
+        this.on('end', asyncResource.bind(() => finishCh.publish(undefined)))
       }
 
       this.execute = execute
@@ -68,8 +69,6 @@ addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['>=1'] }, Connec
         return execute.apply(this, arguments)
       } catch (err) {
         errorCh.publish(err)
-      } finally {
-        endCh.publish(undefined)
       }
     }, cmd)
   }

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

@@ -8,13 +8,11 @@ const {
 const shimmer = require('../../datadog-shimmer')
 
 const startICPCh = channel('apm:net:ipc:start')
-const asyncICPEndCh = channel('apm:net:ipc:async-end')
-const endICPCh = channel('apm:net:ipc:end')
+const finishICPCh = channel('apm:net:ipc:finish')
 const errorICPCh = channel('apm:net:ipc:error')
 
 const startTCPCh = channel('apm:net:tcp:start')
-const asyncTCPEndCh = channel('apm:net:tcp:async-end')
-const endTCPCh = channel('apm:net:tcp:end')
+const finishTCPCh = channel('apm:net:tcp:finish')
 const errorTCPCh = channel('apm:net:tcp:error')
 
 const connectionCh = channel(`apm:net:tcp:connection`)
@@ -33,31 +31,32 @@ addHook({ name: 'net' }, net => {
 
     if (!options) return connect.apply(this, arguments)
 
+    const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
 
     if (typeof callback === 'function') {
-      arguments[lastIndex] = asyncResource.bind(callback)
+      arguments[lastIndex] = callbackResource.bind(callback)
     }
 
     const protocol = options.path ? 'ipc' : 'tcp'
 
-    if (protocol === 'ipc') {
-      startICPCh.publish({ options })
-      setupListeners(this, 'ipc', asyncResource)
-    } else {
-      startTCPCh.publish({ options })
-      setupListeners(this, 'tcp', asyncResource)
-    }
+    return asyncResource.runInAsyncScope(() => {
+      if (protocol === 'ipc') {
+        startICPCh.publish({ options })
+        setupListeners(this, 'ipc', asyncResource)
+      } else {
+        startTCPCh.publish({ options })
+        setupListeners(this, 'tcp', asyncResource)
+      }
 
-    try {
-      return connect.apply(this, arguments)
-    } catch (err) {
-      protocol === 'ipc' ? errorICPCh.publish(err) : errorTCPCh.publish(err)
+      try {
+        return connect.apply(this, arguments)
+      } catch (err) {
+        protocol === 'ipc' ? errorICPCh.publish(err) : errorTCPCh.publish(err)
 
-      throw err
-    } finally {
-      protocol === 'ipc' ? endICPCh.publish(undefined) : endTCPCh.publish(undefined)
-    }
+        throw err
+      }
+    })
   })
 
   return net
@@ -84,17 +83,17 @@ function getOptions (args) {
   }
 }
 
-function setupListeners (socket, protocol, ar) {
+function setupListeners (socket, protocol, asyncResource) {
   const events = ['connect', 'error', 'close', 'timeout']
 
-  const wrapListener = AsyncResource.bind(function (error) {
+  const wrapListener = asyncResource.bind(function (error) {
     if (error) {
       protocol === 'ipc' ? errorICPCh.publish(error) : errorTCPCh.publish(error)
     }
-    protocol === 'ipc' ? asyncICPEndCh.publish(undefined) : asyncTCPEndCh.publish(undefined)
+    protocol === 'ipc' ? finishICPCh.publish(undefined) : finishTCPCh.publish(undefined)
   })
 
-  const localListener = AsyncResource.bind(function () {
+  const localListener = asyncResource.bind(function () {
     connectionCh.publish({ socket })
   })