dd-trace 2.6.0 → 2.8.0

package/packages/datadog-instrumentations/src/find-my-way.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+
+const routeChannel = channel('apm:find-my-way:request:route')
+
+function wrapOn (on) {
+  return function onWithTrace (method, path, opts) {
+    const index = typeof opts === 'function' ? 2 : 3
+    const handler = arguments[index]
+    const wrapper = function (req) {
+      routeChannel.publish({ req, route: path })
+
+      return handler.apply(this, arguments)
+    }
+
+    if (typeof handler === 'function') {
+      arguments[index] = wrapper
+    }
+
+    return on.apply(this, arguments)
+  }
+}
+
+addHook({ name: 'find-my-way', versions: ['>=1'] }, Router => {
+  shimmer.wrap(Router.prototype, 'on', wrapOn)
+
+  return Router
+})

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -0,0 +1,100 @@
+'use strict'
+
+const {
+  channel,
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const requestStartCh = channel('apm:google-cloud-pubsub:request:start')
+const requestFinishCh = channel('apm:google-cloud-pubsub:request:finish')
+const requestErrorCh = channel('apm:google-cloud-pubsub:request:error')
+
+const receiveStartCh = channel(`apm:google-cloud-pubsub:receive:start`)
+const receiveFinishCh = channel('apm:google-cloud-pubsub:receive:finish')
+const receiveErrorCh = channel('apm:google-cloud-pubsub:receive:error')
+
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
+  const PubSub = obj.PubSub
+  const Subscription = obj.Subscription
+
+  shimmer.wrap(PubSub.prototype, 'request', request => function (cfg = { reqOpts: {} }, cb) {
+    if (!requestStartCh.hasSubscribers) {
+      return request.apply(this, arguments)
+    }
+
+    const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
+    const outerAsyncResource = new AsyncResource('bound-anonymous-fn')
+
+    return innerAsyncResource.runInAsyncScope(() => {
+      let messages = []
+      if (cfg.reqOpts && cfg.method === 'publish') {
+        messages = cfg.reqOpts.messages
+      }
+
+      requestStartCh.publish({ cfg, projectId: this.projectId, messages })
+      cb = outerAsyncResource.bind(cb)
+
+      const fn = () => {
+        arguments[1] = innerAsyncResource.bind(function (error) {
+          if (error) {
+            requestErrorCh.publish(error)
+          }
+          requestFinishCh.publish(undefined)
+          return cb.apply(this, arguments)
+        })
+        return request.apply(this, arguments)
+      }
+
+      try {
+        return fn.apply(this, arguments)
+      } catch (e) {
+        requestErrorCh.publish(e)
+        throw e
+      }
+    })
+  })
+
+  shimmer.wrap(Subscription.prototype, 'emit', emit => function (eventName, message) {
+    if (eventName !== 'message' || !message) return emit.apply(this, arguments)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    return asyncResource.runInAsyncScope(() => {
+      try {
+        return emit.apply(this, arguments)
+      } catch (err) {
+        receiveErrorCh.publish({ err, message })
+        throw err
+      }
+    })
+  })
+
+  return obj
+})
+
+addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/lease-manager.js' }, (obj) => {
+  const LeaseManager = obj.LeaseManager
+
+  shimmer.wrap(LeaseManager.prototype, '_dispense', dispense => function (message) {
+    if (receiveStartCh.hasSubscribers) {
+      receiveStartCh.publish({ message })
+    }
+    return dispense.apply(this, arguments)
+  })
+
+  shimmer.wrap(LeaseManager.prototype, 'remove', remove => function (message) {
+    receiveFinishCh.publish({ message })
+    return remove.apply(this, arguments)
+  })
+
+  shimmer.wrap(LeaseManager.prototype, 'clear', clear => function () {
+    for (const message of this._messages) {
+      receiveFinishCh.publish({ message })
+    }
+    return clear.apply(this, arguments)
+  })
+
+  return obj
+})

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

@@ -0,0 +1,210 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+
+const handleChannel = channel('apm:hapi:request:handle')
+const routeChannel = channel('apm:hapi:request:route')
+const errorChannel = channel('apm:hapi:request:error')
+const enterChannel = channel('apm:hapi:extension:enter')
+
+function wrapServer (server) {
+  return function (options) {
+    const app = server.apply(this, arguments)
+
+    if (!app) return app
+
+    if (typeof app.ext === 'function') {
+      app.ext = wrapExt(app.ext)
+    }
+
+    if (typeof app.start === 'function') {
+      app.start = wrapStart(app.start)
+    }
+
+    return app
+  }
+}
+
+function wrapStart (start) {
+  return function () {
+    if (this && typeof this.ext === 'function') {
+      this.ext('onPreResponse', onPreResponse)
+    }
+
+    return start.apply(this, arguments)
+  }
+}
+
+function wrapExt (ext) {
+  return function (events, method, options) {
+    if (typeof events === 'object') {
+      arguments[0] = wrapEvents(events)
+    } else {
+      arguments[1] = wrapExtension(method)
+    }
+
+    return ext.apply(this, arguments)
+  }
+}
+
+function wrapDispatch (dispatch) {
+  return function (options) {
+    const handler = dispatch.apply(this, arguments)
+
+    if (typeof handler !== 'function') return handler
+
+    return function (req, res) {
+      handleChannel.publish({ req, res })
+
+      return handler.apply(this, arguments)
+    }
+  }
+}
+
+function wrapLifecycle (lifecycle) {
+  return function () {
+    const result = lifecycle.apply(this, arguments)
+
+    if (Array.isArray(result)) return result.map(wrapHandler)
+
+    return result
+  }
+}
+
+function wrapRebuild (rebuild) {
+  return function (event) {
+    const result = rebuild.apply(this, arguments)
+
+    if (this && Array.isArray(this._cycle)) {
+      this._cycle = this._cycle.map(wrapHandler)
+    }
+
+    return result
+  }
+}
+
+function wrapExtension (method) {
+  return [].concat(method).map(wrapHandler)
+}
+
+function wrapEvents (events) {
+  return [].concat(events).map(event => {
+    if (!event || !event.method) return event
+
+    return Object.assign({}, event, {
+      method: wrapExtension(event.method)
+    })
+  })
+}
+
+function wrapHandler (handler) {
+  if (typeof handler !== 'function') return handler
+
+  return function (request, h) {
+    const req = request && request.raw && request.raw.req
+
+    if (!req) return handler.apply(this, arguments)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+    return asyncResource.runInAsyncScope(() => {
+      enterChannel.publish({ req })
+
+      return handler.apply(this, arguments)
+    })
+  }
+}
+
+function onPreResponse (request, h) {
+  if (!request || !request.raw) return reply(request, h)
+
+  const req = request.raw.req
+
+  if (request.response instanceof Error) {
+    errorChannel.publish(request.response)
+  }
+
+  if (request.route) {
+    routeChannel.publish({ req, route: request.route.path })
+  }
+
+  return reply(request, h)
+}
+
+function reply (request, h) {
+  if (h.continue) {
+    return typeof h.continue === 'function'
+      ? h.continue()
+      : h.continue
+  } else if (typeof h === 'function') {
+    return h()
+  }
+}
+
+addHook({ name: '@hapi/hapi', versions: ['>=17.9'] }, hapi => {
+  shimmer.massWrap(hapi, ['server', 'Server'], wrapServer)
+
+  return hapi
+})
+
+addHook({ name: '@hapi/hapi', versions: ['>=17.9'], file: 'lib/core.js' }, Core => {
+  shimmer.wrap(Core.prototype, '_dispatch', wrapDispatch)
+
+  return Core
+})
+
+addHook({ name: '@hapi/hapi', versions: ['>=17.9'], file: 'lib/route.js' }, Route => {
+  shimmer.wrap(Route.prototype, 'rebuild', wrapRebuild)
+
+  return Route
+})
+
+addHook({ name: 'hapi', versions: ['>=17'] }, hapi => {
+  shimmer.massWrap(hapi, ['server', 'Server'], wrapServer)
+
+  return hapi
+})
+
+addHook({ name: 'hapi', versions: ['2 - 7.1', '8 - 16'] }, hapi => {
+  shimmer.wrap(hapi.Server.prototype, 'start', wrapStart)
+  shimmer.wrap(hapi.Server.prototype, 'ext', wrapExt)
+
+  return hapi
+})
+
+addHook({ name: 'hapi', versions: ['^7.2'] }, hapi => {
+  shimmer.wrap(hapi, 'createServer', wrapServer)
+
+  return hapi
+})
+
+addHook({ name: 'hapi', versions: ['7.2 - 16'], file: 'lib/connection.js' }, Connection => {
+  shimmer.wrap(Connection.prototype, '_dispatch', wrapDispatch)
+
+  return Connection
+})
+
+addHook({ name: 'hapi', versions: ['>=17'], file: 'lib/core.js' }, Core => {
+  shimmer.wrap(Core.prototype, '_dispatch', wrapDispatch)
+
+  return Core
+})
+
+addHook({ name: 'hapi', versions: ['2 - 7.1'], file: 'lib/server.js' }, Server => {
+  shimmer.wrap(Server.prototype, '_dispatch', wrapDispatch)
+
+  return Server
+})
+
+addHook({ name: 'hapi', versions: ['>=10.4'], file: 'lib/route.js' }, Route => {
+  shimmer.wrap(Route.prototype, 'rebuild', wrapRebuild)
+
+  return Route
+})
+
+addHook({ name: 'hapi', versions: ['2 - 10.3'], file: 'lib/route.js' }, Route => {
+  shimmer.wrap(Route.prototype, 'lifecycle', wrapLifecycle)
+
+  return Route
+})

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

@@ -13,8 +13,7 @@ const shimmer = require('../../../datadog-shimmer')
 const log = require('../../../dd-trace/src/log')
 
 const startClientCh = channel('apm:http:client:request:start')
-const asyncEndClientCh = channel('apm:http:client:request:async-end')
-const endClientCh = channel('apm:http:client:request:end')
+const finishClientCh = channel('apm:http:client:request:finish')
 const errorClientCh = channel('apm:http:client:request:error')
 
 addHook({ name: 'https' }, hookFn)
@@ -36,7 +35,6 @@ function patch (http, methodName) {
       if (!startClientCh.hasSubscribers) {
         return request.apply(this, arguments)
       }
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
 
       let args
 
@@ -46,57 +44,59 @@ function patch (http, methodName) {
         log.error(e)
         return request.apply(this, arguments)
       }
-      startClientCh.publish({ args, http })
-
-      const ar = new AsyncResource('bound-anonymous-fn')
 
-      let finished = false
-      let callback = args.callback
+      const callbackResource = new AsyncResource('bound-anonymous-fn')
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
 
-      if (callback) {
-        callback = asyncResource.bind(callback)
-      }
+      return asyncResource.runInAsyncScope(() => {
+        startClientCh.publish({ args, http })
 
-      const options = args.options
-      const req = ar.bind(request).call(this, options, callback)
-      const emit = req.emit
+        let finished = false
+        let callback = args.callback
 
-      const finish = (req, res) => {
-        if (!finished) {
-          finished = true
-          asyncEndClientCh.publish({ req, res })
+        if (callback) {
+          callback = callbackResource.bind(callback)
         }
-      }
 
-      req.emit = function (eventName, arg) {
-        ar.runInAsyncScope(() => {
-          switch (eventName) {
-            case 'response': {
-              const res = arg
-              const listener = ar.bind(() => finish(req, res))
-              res.on('end', listener)
-              res.on('error', listener)
-              break
-            }
-            case 'connect':
-            case 'upgrade':
-              finish(req, arg)
-              break
-            case 'error':
-              errorClientCh.publish(arg)
-            case 'abort': // deprecated and replaced by `close` in node 17
-            case 'timeout':
-            case 'close':
-              finish(req)
+        const options = args.options
+        const req = request.call(this, options, callback)
+        const emit = req.emit
+
+        const finish = (req, res) => {
+          if (!finished) {
+            finished = true
+            finishClientCh.publish({ req, res })
           }
-        })
+        }
 
-        return emit.apply(this, arguments)
-      }
+        req.emit = function (eventName, arg) {
+          asyncResource.runInAsyncScope(() => {
+            switch (eventName) {
+              case 'response': {
+                const res = arg
+                const listener = asyncResource.bind(() => finish(req, res))
+                res.on('end', listener)
+                res.on('error', listener)
+                break
+              }
+              case 'connect':
+              case 'upgrade':
+                finish(req, arg)
+                break
+              case 'error':
+                errorClientCh.publish(arg)
+              case 'abort': // deprecated and replaced by `close` in node 17
+              case 'timeout':
+              case 'close':
+                finish(req)
+            }
+          })
 
-      endClientCh.publish(undefined)
+          return emit.apply(this, arguments)
+        }
 
-      return req
+        return req
+      })
     }
   }
 

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

@@ -2,14 +2,14 @@
 
 const {
   channel,
-  addHook
+  addHook,
+  AsyncResource
 } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 const startServerCh = channel('apm:http:server:request:start')
-const endServerCh = channel('apm:http:server:request:end')
 const errorServerCh = channel('apm:http:server:request:error')
-const asyncEndServerCh = channel('apm:http:server:request:async-end')
+const finishServerCh = channel('apm:http:server:request:finish')
 
 addHook({ name: 'https' }, http => {
   // http.ServerResponse not present on https
@@ -30,7 +30,7 @@ function wrapResponseEmit (emit) {
     }
 
     if (eventName === 'finish') {
-      asyncEndServerCh.publish({ req: this.req })
+      finishServerCh.publish({ req: this.req })
     }
 
     return emit.apply(this, arguments)
@@ -44,17 +44,19 @@ function wrapEmit (emit) {
 
     if (eventName === 'request') {
       res.req = req
-      startServerCh.publish({ req, res })
 
-      try {
-        return emit.apply(this, arguments)
-      } catch (err) {
-        errorServerCh.publish(err)
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+      return asyncResource.runInAsyncScope(() => {
+        startServerCh.publish({ req, res })
 
-        throw err
-      } finally {
-        endServerCh.publish(undefined)
-      }
+        try {
+          return emit.apply(this, arguments)
+        } catch (err) {
+          errorServerCh.publish(err)
+
+          throw err
+        }
+      })
     }
     return emit.apply(this, arguments)
   }

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

@@ -8,8 +8,7 @@ const {
 const shimmer = require('../../datadog-shimmer')
 
 const startCh = channel('apm:ioredis:command:start')
-const asyncEndCh = channel('apm:ioredis:command:async-end')
-const endCh = channel('apm:ioredis:command:end')
+const finishCh = channel('apm:ioredis:command:finish')
 const errorCh = channel('apm:ioredis:command:error')
 
 addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
@@ -23,30 +22,30 @@ addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
     const db = options.db
     const connectionOptions = { host: options.host, port: options.port }
 
-    startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
-
     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(() => {
+      startCh.publish({ db, command: command.name, args: command.args, connectionOptions, connectionName })
+
+      const onResolve = asyncResource.bind(() => finish(finishCh, errorCh))
+      const onReject = asyncResource.bind(err => finish(finishCh, errorCh, err))
 
-    command.promise.then(onResolve, onReject)
+      command.promise.then(onResolve, onReject)
 
-    try {
-      return sendCommand.apply(this, arguments)
-    } catch (err) {
-      errorCh.publish(err)
+      try {
+        return sendCommand.apply(this, arguments)
+      } catch (err) {
+        errorCh.publish(err)
 
-      throw err
-    } finally {
-      endCh.publish(undefined)
-    }
+        throw err
+      }
+    })
   })
   return Redis
 })
 
-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/jest.js

@@ -5,9 +5,9 @@ const shimmer = require('../../datadog-shimmer')
 
 const testStartCh = channel('ci:jest:test:start')
 const testSkippedCh = channel('ci:jest:test:skip')
-const testRunEndCh = channel('ci:jest:test:end')
+const testRunFinishCh = channel('ci:jest:test:finish')
 const testErrCh = channel('ci:jest:test:err')
-const testSuiteEnd = channel('ci:jest:test-suite:end')
+const testSuiteFinish = channel('ci:jest:test-suite:finish')
 
 const {
   getTestSuitePath,
@@ -48,13 +48,14 @@ function getWrappedEnvironment (BaseEnvironment) {
   return class DatadogEnvironment extends BaseEnvironment {
     constructor (config, context) {
       super(config, context)
-      this.testSuite = getTestSuitePath(context.testPath, config.rootDir)
+      const rootDir = config.globalConfig ? config.globalConfig.rootDir : config.rootDir
+      this.testSuite = getTestSuitePath(context.testPath, rootDir)
       this.nameToParams = {}
       this.global._ddtrace = global._ddtrace
     }
     async teardown () {
       super.teardown().finally(() => {
-        testSuiteEnd.publish()
+        testSuiteFinish.publish()
       })
     }
 
@@ -63,13 +64,7 @@ function getWrappedEnvironment (BaseEnvironment) {
         await super.handleTestEvent(event, state)
       }
 
-      let context
-      if (this.getVmContext) {
-        context = this.getVmContext()
-      } else {
-        context = this.context
-      }
-
+      const globalExpect = this.global.expect
       const setNameToParams = (name, params) => { this.nameToParams[name] = params }
 
       if (event.name === 'setup') {
@@ -92,7 +87,7 @@ function getWrappedEnvironment (BaseEnvironment) {
         asyncResources.set(event.test, asyncResource)
         asyncResource.runInAsyncScope(() => {
           testStartCh.publish({
-            name: context.expect.getState().currentTestName,
+            name: globalExpect.getState().currentTestName,
             suite: this.testSuite,
             runner: 'jest-circus',
             testParameters
@@ -110,14 +105,14 @@ function getWrappedEnvironment (BaseEnvironment) {
             const formattedError = formatJestError(event.test.errors[0])
             testErrCh.publish(formattedError)
           }
-          testRunEndCh.publish(status)
+          testRunFinishCh.publish(status)
           // restore in case it is retried
           event.test.fn = originalTestFns.get(event.test)
         })
       }
       if (event.name === 'test_skip' || event.name === 'test_todo') {
         testSkippedCh.publish({
-          name: context.expect.getState().currentTestName,
+          name: globalExpect.getState().currentTestName,
           suite: this.testSuite,
           runner: 'jest-circus'
         })
@@ -126,15 +121,25 @@ function getWrappedEnvironment (BaseEnvironment) {
   }
 }
 
+function getTestEnvironment (pkg) {
+  if (pkg.default) {
+    const wrappedTestEnvironment = getWrappedEnvironment(pkg.default)
+    pkg.default = wrappedTestEnvironment
+    pkg.TestEnvironment = wrappedTestEnvironment
+    return pkg
+  }
+  return getWrappedEnvironment(pkg)
+}
+
 addHook({
   name: 'jest-environment-node',
   versions: ['>=24.8.0']
-}, getWrappedEnvironment)
+}, getTestEnvironment)
 
 addHook({
   name: 'jest-environment-jsdom',
   versions: ['>=24.8.0']
-}, getWrappedEnvironment)
+}, getTestEnvironment)
 
 addHook({
   name: 'jest-jasmine2',
@@ -158,7 +163,7 @@ addHook({
             const formattedError = formatJestError(spec.result.failedExpectations[0].error)
             testErrCh.publish(formattedError)
           }
-          testRunEndCh.publish(specStatusToTestStatus[spec.result.status])
+          testRunFinishCh.publish(specStatusToTestStatus[spec.result.status])
           onComplete.apply(this, arguments)
         })
         arguments[0] = callback