dd-trace 2.11.0 → 2.12.1

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

@@ -6,8 +6,31 @@ const errorCh = channel('ci:mocha:test:error')
 const skipCh = channel('ci:mocha:test:skip')
 const testFinishCh = channel('ci:mocha:test:finish')
 const parameterizedTestCh = channel('ci:mocha:test:parameterize')
+
+const testRunStartCh = channel('ci:mocha:run:start')
 const testRunFinishCh = channel('ci:mocha:run:finish')
 
+const testSuiteStartCh = channel('ci:mocha:test-suite:start')
+const testSuiteFinishCh = channel('ci:mocha:test-suite:finish')
+const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
+
+// TODO: remove when root hooks and fixtures are implemented
+const patched = new WeakSet()
+
+const testToAr = new WeakMap()
+const originalFns = new WeakMap()
+const testSuiteToAr = new WeakMap()
+
+function getTestStatus (test) {
+  if (test.pending) {
+    return 'skip'
+  }
+  if (test.state !== 'failed' && !test.timedOut) {
+    return 'pass'
+  }
+  return 'fail'
+}
+
 function isRetry (test) {
   return test._currentRetry !== undefined && test._currentRetry !== 0
 }
@@ -23,12 +46,6 @@ function getTestAsyncResource (test) {
   return testToAr.get(originalFn)
 }
 
-// TODO: remove when root hooks and fixtures are implemented
-const patched = new WeakSet()
-
-const testToAr = new WeakMap()
-const originalFns = new WeakMap()
-
 function mochaHook (Runner) {
   if (patched.has(Runner)) return Runner
 
@@ -39,6 +56,59 @@ function mochaHook (Runner) {
       return run.apply(this, arguments)
     }
 
+    const testRunAsyncResource = new AsyncResource('bound-anonymous-fn')
+
+    this.once('end', testRunAsyncResource.bind(function () {
+      let status = 'pass'
+      if (this.stats) {
+        status = this.stats.failures === 0 ? 'pass' : 'fail'
+      } else if (this.failures !== 0) {
+        status = 'fail'
+      }
+      testRunFinishCh.publish(status)
+    }))
+
+    this.once('start', testRunAsyncResource.bind(function () {
+      const processArgv = process.argv.slice(2).join(' ')
+      const command = `mocha ${processArgv}`
+      testRunStartCh.publish(command)
+    }))
+
+    this.on('suite', function (suite) {
+      if (suite.root) {
+        return
+      }
+      const asyncResource = new AsyncResource('bound-anonymous-fn')
+
+      testSuiteToAr.set(suite, asyncResource)
+
+      asyncResource.runInAsyncScope(() => {
+        testSuiteStartCh.publish(suite)
+      })
+    })
+
+    this.on('suite end', function (suite) {
+      if (suite.root) {
+        return
+      }
+      let status = 'pass'
+      if (suite.pending) {
+        status = 'skip'
+      } else {
+        suite.eachTest(test => {
+          if (test.state === 'failed' || test.timedOut) {
+            status = 'fail'
+          }
+        })
+      }
+
+      const asyncResource = testSuiteToAr.get(suite)
+      asyncResource.runInAsyncScope(() => {
+        // get suite status
+        testSuiteFinishCh.publish(status)
+      })
+    })
+
     this.on('test', (test) => {
       if (isRetry(test)) {
         return
@@ -52,14 +122,7 @@ function mochaHook (Runner) {
 
     this.on('test end', (test) => {
       const asyncResource = getTestAsyncResource(test)
-      let status
-      if (test.pending) {
-        status = 'skip'
-      } else if (test.state !== 'failed' && !test.timedOut) {
-        status = 'pass'
-      } else {
-        status = 'fail'
-      }
+      const status = getTestStatus(test)
 
       // if there are afterEach to be run, we don't finish the test yet
       if (!test.parent._afterEach.length) {
@@ -75,9 +138,10 @@ function mochaHook (Runner) {
       if (test && hook.parent._afterEach.includes(hook)) { // only if it's an afterEach
         const isLastAfterEach = hook.parent._afterEach.indexOf(hook) === hook.parent._afterEach.length - 1
         if (isLastAfterEach) {
+          const status = getTestStatus(test)
           const asyncResource = getTestAsyncResource(test)
           asyncResource.runInAsyncScope(() => {
-            testFinishCh.publish('pass')
+            testFinishCh.publish(status)
           })
         }
       }
@@ -100,6 +164,15 @@ function mochaHook (Runner) {
           } else {
             errorCh.publish(err)
           }
+          // we propagate the error to the suite
+          const testSuiteAsyncResource = testSuiteToAr.get(test.parent)
+          if (testSuiteAsyncResource) {
+            const testSuiteError = new Error(`Test "${test.fullTitle()}" failed with message "${err.message}"`)
+            testSuiteError.stack = err.stack
+            testSuiteAsyncResource.runInAsyncScope(() => {
+              testSuiteErrorCh.publish(testSuiteError)
+            })
+          }
         })
       }
     })
@@ -127,9 +200,6 @@ function mochaHook (Runner) {
     if (!testRunFinishCh.hasSubscribers) {
       return runTests.apply(this, arguments)
     }
-    this.once('end', AsyncResource.bind(() => {
-      testRunFinishCh.publish()
-    }))
     return runTests.apply(this, arguments)
   })
 

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 const handlers = ['use', 'pre']
 const methods = ['del', 'get', 'head', 'opts', 'post', 'put', 'patch']
 
@@ -9,14 +9,14 @@ const handleChannel = channel('apm:restify:request:handle')
 const routeChannel = channel('apm:restify:request:route')
 
 function wrapSetupRequest (setupRequest) {
-  return function setupRequestWithTrace (req, res) {
+  return function (req, res) {
     handleChannel.publish({ req, res })
     return setupRequest.apply(this, arguments)
   }
 }
 
 function wrapMethod (method) {
-  return function methodWithTrace (path) {
+  return function (path) {
     const middleware = wrapMiddleware(Array.prototype.slice.call(arguments, 1))
 
     return method.apply(this, [path].concat(middleware))
@@ -24,7 +24,7 @@ function wrapMethod (method) {
 }
 
 function wrapHandler (method) {
-  return function methodWithTrace () {
+  return function () {
     return method.apply(this, wrapMiddleware(arguments))
   }
 }
@@ -37,10 +37,6 @@ function wrapFn (fn) {
   if (Array.isArray(fn)) return wrapMiddleware(fn)
 
   return function (req, res, next) {
-    if (typeof next === 'function') {
-      arguments[2] = AsyncResource.bind(next)
-    }
-
     if (req.route) {
       routeChannel.publish({ req, route: req.route })
     }

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

@@ -49,12 +49,12 @@ function createWrapRouterMethod (name) {
 
         try {
           return original.apply(this, arguments)
-        } catch (e) {
-          errorChannel.publish(e)
+        } catch (error) {
+          errorChannel.publish({ req, error })
           nextChannel.publish({ req })
           exitChannel.publish({ req })
 
-          throw e
+          throw error
         }
       })
     })
@@ -91,7 +91,7 @@ function createWrapRouterMethod (name) {
   function wrapNext (req, next) {
     return function (error) {
       if (error) {
-        errorChannel.publish(error)
+        errorChannel.publish({ req, error })
       }
 
       nextChannel.publish({ req })

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

@@ -11,11 +11,11 @@ class CouchBasePlugin extends Plugin {
 
   addSubs (func, start, finish = defaultFinish) {
     this.addSub(`apm:couchbase:${func}:start`, start)
-    this.addSub(`apm:couchbase:${func}:error`, errorHandler)
+    this.addSub(`apm:couchbase:${func}:error`, this.addError)
     this.addSub(`apm:couchbase:${func}:finish`, finish)
   }
 
-  startSpan (operation, customTags, store, bucket) {
+  startSpan (operation, customTags, store, { bucket, collection }) {
     const tags = {
       'db.type': 'couchbase',
       'component': 'couchbase',
@@ -32,7 +32,8 @@ class CouchBasePlugin extends Plugin {
       tags
     })
 
-    span.setTag('couchbase.bucket.name', bucket.name || bucket._name)
+    if (bucket) span.setTag(`couchbase.bucket.name`, bucket.name)
+    if (collection) span.setTag(`couchbase.collection.name`, collection.name)
 
     analyticsSampler.sample(span, this.config.measured)
     return span
@@ -43,7 +44,8 @@ class CouchBasePlugin extends Plugin {
 
     this.addSubs('query', ({ resource, bucket }) => {
       const store = storage.getStore()
-      const span = this.startSpan('query', { 'span.type': 'sql', 'resource.name': resource }, store, bucket)
+      const span = this.startSpan('query', { 'span.type': 'sql', 'resource.name': resource },
+        store, { bucket })
       this.enter(span, store)
     })
 
@@ -54,9 +56,9 @@ class CouchBasePlugin extends Plugin {
     this._addCommandSubs('prepend')
   }
   _addCommandSubs (name) {
-    this.addSubs(name, ({ bucket }) => {
+    this.addSubs(name, ({ bucket, collection }) => {
       const store = storage.getStore()
-      const span = this.startSpan(name, {}, store, bucket)
+      const span = this.startSpan(name, {}, store, { bucket, collection })
       this.enter(span, store)
     })
   }
@@ -66,8 +68,4 @@ function defaultFinish () {
   storage.getStore().span.finish()
 }
 
-function errorHandler (error) {
-  storage.getStore().span.setTag('error', error)
-}
-
 module.exports = CouchBasePlugin

package/packages/datadog-plugin-graphql/src/resolve.js

@@ -77,6 +77,8 @@ class GraphQLResolvePlugin extends Plugin {
       })
     })
 
+    this.addSub('apm:graphql:resolve:error', this.addError)
+
     this.addSub('apm:graphql:resolve:finish', finishTime => {
       const span = storage.getStore().span
       span.finish(finishTime)

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

@@ -17,7 +17,7 @@ class HttpServerPlugin extends Plugin {
       const store = storage.getStore()
       const span = web.startSpan(this.tracer, this.config, req, res, 'http.request')
 
-      this.enter(span, store)
+      this.enter(span, { ...store, req })
 
       const context = web.getContext(req)
 
@@ -32,12 +32,7 @@ class HttpServerPlugin extends Plugin {
     })
 
     this.addSub('apm:http:server:request:error', (error) => {
-      const span = storage.getStore().span
-      span.addTags({
-        'error.type': error.name,
-        'error.msg': error.message,
-        'error.stack': error.stack
-      })
+      web.addError(error)
     })
 
     this.addSub('apm:http:server:request:finish', ({ req }) => {
@@ -45,7 +40,7 @@ class HttpServerPlugin extends Plugin {
 
       if (!context || !context.res) return // Not created by a http.Server instance.
 
-      web.wrapRes(context, context.req, context.res, context.res.end)()
+      web.finishAll(context)
     })
   }
 

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

@@ -16,7 +16,12 @@ const {
   getTestParametersString,
   getCodeOwnersFileEntries,
   getCodeOwnersForFilename,
-  getTestCommonTags
+  getTestCommonTags,
+  getTestSessionCommonTags,
+  getTestSuiteCommonTags,
+  TEST_SUITE_ID,
+  TEST_SESSION_ID,
+  TEST_COMMAND
 } = require('../../dd-trace/src/plugins/util/test')
 
 function getTestSpanMetadata (tracer, test, sourceRoot) {
@@ -42,11 +47,63 @@ class MochaPlugin extends Plugin {
   constructor (...args) {
     super(...args)
 
+    this._testSuites = new WeakMap()
     this._testNameToParams = {}
     this.testEnvironmentMetadata = getTestEnvironmentMetadata('mocha', this.config)
     this.sourceRoot = process.cwd()
     this.codeOwnersEntries = getCodeOwnersFileEntries(this.sourceRoot)
 
+    this.addSub('ci:mocha:run:start', (command) => {
+      if (!this.config.isAgentlessEnabled) {
+        return
+      }
+      const childOf = getTestParentSpan(this.tracer)
+      const testSessionSpanMetadata = getTestSessionCommonTags(command, this.tracer._version)
+
+      this.command = command
+      this.testSessionSpan = this.tracer.startSpan('mocha.test_session', {
+        childOf,
+        tags: {
+          ...this.testEnvironmentMetadata,
+          ...testSessionSpanMetadata
+        }
+      })
+    })
+
+    this.addSub('ci:mocha:test-suite:start', (suite) => {
+      if (!this.config.isAgentlessEnabled) {
+        return
+      }
+      const store = storage.getStore()
+      const testSuiteMetadata = getTestSuiteCommonTags(this.command, this.tracer._version, suite.fullTitle())
+      const testSuiteSpan = this.tracer.startSpan('mocha.test_suite', {
+        childOf: this.testSessionSpan,
+        tags: {
+          ...this.testEnvironmentMetadata,
+          ...testSuiteMetadata
+        }
+      })
+      this.enter(testSuiteSpan, store)
+      this._testSuites.set(suite, testSuiteSpan)
+    })
+
+    this.addSub('ci:mocha:test-suite:finish', (status) => {
+      if (!this.config.isAgentlessEnabled) {
+        return
+      }
+      const span = storage.getStore().span
+      span.setTag(TEST_STATUS, status)
+      span.finish()
+    })
+
+    this.addSub('ci:mocha:test-suite:error', (err) => {
+      if (!this.config.isAgentlessEnabled) {
+        return
+      }
+      const span = storage.getStore().span
+      span.setTag('error', err)
+    })
+
     this.addSub('ci:mocha:test:start', (test) => {
       const store = storage.getStore()
       const span = this.startTestSpan(test)
@@ -89,12 +146,31 @@ class MochaPlugin extends Plugin {
       this._testNameToParams[name] = params
     })
 
-    this.addSub('ci:mocha:run:finish', () => {
+    this.addSub('ci:mocha:run:finish', (status) => {
+      if (this.testSessionSpan) {
+        this.testSessionSpan.setTag(TEST_STATUS, status)
+        this.testSessionSpan.finish()
+        finishAllTraceSpans(this.testSessionSpan)
+      }
       this.tracer._exporter._writer.flush()
     })
   }
 
   startTestSpan (test) {
+    const testSuiteTags = {}
+    const testSuiteSpan = this._testSuites.get(test.parent)
+
+    if (testSuiteSpan) {
+      const testSuiteId = testSuiteSpan.context()._spanId.toString('hex')
+      testSuiteTags[TEST_SUITE_ID] = testSuiteId
+    }
+
+    if (this.testSessionSpan) {
+      const testSessionId = this.testSessionSpan.context()._traceId.toString('hex')
+      testSuiteTags[TEST_SESSION_ID] = testSessionId
+      testSuiteTags[TEST_COMMAND] = this.command
+    }
+
     const { childOf, ...testSpanMetadata } = getTestSpanMetadata(this.tracer, test, this.sourceRoot)
 
     const testParametersString = getTestParametersString(this._testNameToParams, test.title)
@@ -112,7 +188,8 @@ class MochaPlugin extends Plugin {
         childOf,
         tags: {
           ...this.testEnvironmentMetadata,
-          ...testSpanMetadata
+          ...testSpanMetadata,
+          ...testSuiteTags
         }
       })
     testSpan.context()._trace.origin = CI_APP_ORIGIN

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

@@ -21,7 +21,7 @@ class NextPlugin extends Plugin {
         childOf,
         tags: {
           'service.name': this.config.service || this.tracer._service,
-          'resource.name': 'test',
+          'resource.name': req.method,
           'span.type': 'web',
           'span.kind': 'server',
           'http.method': req.method

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

@@ -16,11 +16,18 @@ class RouterPlugin extends WebPlugin {
     this._contexts = new WeakMap()
 
     this.addSub(`apm:${this.constructor.name}:middleware:enter`, ({ req, name, route }) => {
-      const store = storage.getStore()
-      const context = this._createContext(req, route)
-      const span = this._getMiddlewareSpan(context, store, name)
+      const childOf = this._getActive(req) || this._getStoreSpan()
 
-      this.enter(span, store)
+      if (!childOf) return
+
+      const span = this._getMiddlewareSpan(name, childOf)
+      const context = this._createContext(req, route, childOf)
+
+      if (childOf !== span) {
+        context.middleware.push(span)
+      }
+
+      this.enter(span)
 
       web.patch(req)
       web.setRoute(req, context.route)
@@ -42,7 +49,17 @@ class RouterPlugin extends WebPlugin {
       context.middleware.pop().finish()
     })
 
-    this.addSub(`apm:${this.constructor.name}:middleware:error`, this.addError)
+    this.addSub(`apm:${this.constructor.name}:middleware:error`, ({ req, error }) => {
+      web.addError(req, error)
+
+      if (!this.config.middleware) return
+
+      const span = this._getActive(req)
+
+      if (!span) return
+
+      span.setTag('error', error)
+    })
 
     this.addSub(`apm:http:server:request:finish`, ({ req }) => {
       const context = this._contexts.get(req)
@@ -57,9 +74,22 @@ class RouterPlugin extends WebPlugin {
     })
   }
 
-  _getMiddlewareSpan (context, store, name) {
-    const childOf = store && store.span
+  _getActive (req) {
+    const context = this._contexts.get(req)
+
+    if (!context) return
+    if (context.middleware.length === 0) return context.span
+
+    return context.middleware[context.middleware.length - 1]
+  }
+
+  _getStoreSpan () {
+    const store = storage.getStore()
+
+    return store && store.span
+  }
 
+  _getMiddlewareSpan (name, childOf) {
     if (this.config.middleware === false) {
       return childOf
     }
@@ -71,14 +101,12 @@ class RouterPlugin extends WebPlugin {
       }
     })
 
-    context.middleware.push(span)
-
     analyticsSampler.sample(span, this.config.measured)
 
     return span
   }
 
-  _createContext (req, route) {
+  _createContext (req, route, span) {
     let context = this._contexts.get(req)
 
     if (!route || route === '/' || route === '*') {
@@ -96,6 +124,7 @@ class RouterPlugin extends WebPlugin {
       }
     } else {
       context = {
+        span,
         stack: [route],
         route,
         middleware: []