dd-trace 2.11.0 → 2.12.0

package/LICENSE-3rdparty.csv

@@ -6,7 +6,6 @@ require,@datadog/sketches-js,Apache license 2.0,Copyright 2020 Datadog Inc.
 require,@types/node,MIT,Copyright Authors
 require,crypto-randomuuid,MIT,Copyright 2021 Node.js Foundation and contributors
 require,diagnostics_channel,MIT,Copyright 2021 Simon D.
-require,form-data,MIT,Copyright 2012 Felix Geisendörfer and contributors
 require,ignore,MIT,Copyright 2013 Kael Zhang and contributors
 require,import-in-the-middle,Apache license 2.0,Copyright 2021 Datadog Inc.
 require,koalas,MIT,Copyright 2013-2017 Brian Woodward

package/index.d.ts

@@ -313,10 +313,10 @@ export declare interface TracerOptions {
   };
 
   /**
-   * Experimental features can be enabled all at once by using true or individually using key / value pairs.
+   * Experimental features can be enabled individually using key / value pairs.
    * @default {}
    */
-  experimental?: boolean | {
+  experimental?: {
     b3?: boolean
     traceparent?: boolean
 
@@ -1216,7 +1216,7 @@ declare namespace plugins {
 
   /**
    * This plugin automatically instruments the
-   * [mysql2](https://github.com/brianmario/mysql2) module.
+   * [mysql2](https://github.com/sidorares/node-mysql2) module.
    */
   interface mysql2 extends mysql {}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -59,15 +59,14 @@
   },
   "dependencies": {
     "@datadog/native-appsec": "^1.2.1",
-    "@datadog/native-metrics": "^1.4.0",
-    "@datadog/pprof": "^0.5.1",
+    "@datadog/native-metrics": "^1.4.1",
+    "@datadog/pprof": "^1.0.0",
     "@datadog/sketches-js": "^1.0.5",
     "@types/node": ">=12",
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
-    "form-data": "^3.0.0",
     "ignore": "^5.2.0",
-    "import-in-the-middle": "^1.2.1",
+    "import-in-the-middle": "^1.3.0",
     "koalas": "^1.0.2",
     "limiter": "^1.1.4",
     "lodash.kebabcase": "^4.1.1",

package/packages/datadog-core/src/storage/async_hooks.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { createHook, executionAsyncId } = require('async_hooks')
+const { executionAsyncId } = require('async_hooks')
 const AsyncResourceStorage = require('./async_resource')
 
 class AsyncHooksStorage extends AsyncResourceStorage {
@@ -17,10 +17,10 @@ class AsyncHooksStorage extends AsyncResourceStorage {
   }
 
   _createHook () {
-    return createHook({
-      init: this._init.bind(this),
+    return {
+      ...super._createHook(),
       destroy: this._destroy.bind(this)
-    })
+    }
   }
 
   _init (asyncId, type, triggerAsyncId, resource) {

package/packages/datadog-core/src/storage/async_resource.js

@@ -1,12 +1,16 @@
 'use strict'
 
 const { createHook, executionAsyncResource } = require('async_hooks')
+const { channel } = require('diagnostics_channel')
+
+const beforeCh = channel('dd-trace:storage:before')
+const afterCh = channel('dd-trace:storage:after')
 
 class AsyncResourceStorage {
   constructor () {
     this._ddResourceStore = Symbol('ddResourceStore')
     this._enabled = false
-    this._hook = this._createHook()
+    this._hook = createHook(this._createHook())
   }
 
   disable () {
@@ -48,9 +52,15 @@ class AsyncResourceStorage {
   }
 
   _createHook () {
-    return createHook({
-      init: this._init.bind(this)
-    })
+    return {
+      init: this._init.bind(this),
+      before () {
+        beforeCh.publish()
+      },
+      after () {
+        afterCh.publish()
+      }
+    }
   }
 
   _enable () {

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

@@ -7,70 +7,23 @@ const {
 } = require('./helpers/instrument')
 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 finishCh = channel('apm:couchbase:query:finish')
-  const errorCh = channel('apm:couchbase:query:error')
-
-  Bucket.prototype._maybeInvoke = wrapMaybeInvoke(Bucket.prototype._maybeInvoke)
-  Bucket.prototype.query = wrapQuery(Bucket.prototype.query)
-
-  shimmer.wrap(Bucket.prototype, '_n1qlReq', _n1qlReq => function (host, q, adhoc, emitter) {
-    if (!startCh.hasSubscribers) {
-      return _n1qlReq.apply(this, arguments)
-    }
-
-    if (!emitter || !emitter.once) return _n1qlReq.apply(this, arguments)
-
-    const n1qlQuery = q && q.statement
-
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ resource: n1qlQuery, bucket: this })
-
-      emitter.once('rows', asyncResource.bind(() => {
-        finishCh.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)
-
-        throw err
-      }
-    })
-  })
-
-  Bucket.prototype.upsert = wrap('apm:couchbase:upsert', Bucket.prototype.upsert)
-  Bucket.prototype.insert = wrap('apm:couchbase:insert', Bucket.prototype.insert)
-  Bucket.prototype.replace = wrap('apm:couchbase:replace', Bucket.prototype.replace)
-  Bucket.prototype.append = wrap('apm:couchbase:append', Bucket.prototype.append)
-  Bucket.prototype.prepend = wrap('apm:couchbase:prepend', Bucket.prototype.prepend)
-
-  return Bucket
-})
-
-addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.5'] }, Cluster => {
-  Cluster.prototype._maybeInvoke = wrapMaybeInvoke(Cluster.prototype._maybeInvoke)
-  Cluster.prototype.query = wrapQuery(Cluster.prototype.query)
-
-  return Cluster
-})
-
-function findCallbackIndex (args) {
-  for (let i = args.length - 1; i >= 2; i--) {
+function findCallbackIndex (args, lowerbound = 2) {
+  for (let i = args.length - 1; i >= lowerbound; i--) {
     if (typeof args[i] === 'function') return i
   }
   return -1
 }
 
+// handles n1ql and string queries
+function getQueryResource (q) {
+  return q && (typeof q === 'string' ? q : q.statement)
+}
+
+function wrapAllNames (names, action) {
+  names.forEach(name => action(name))
+}
+
+// semver >=2 <3
 function wrapMaybeInvoke (_maybeInvoke) {
   const wrapped = function (fn, args) {
     if (!Array.isArray(args)) return _maybeInvoke.apply(this, arguments)
@@ -106,7 +59,7 @@ function wrap (prefix, fn) {
   const finishCh = channel(prefix + ':finish')
   const errorCh = channel(prefix + ':error')
 
-  const wrapped = function (key, value, options, callback) {
+  const wrapped = function () {
     if (!startCh.hasSubscribers) {
       return fn.apply(this, arguments)
     }
@@ -121,7 +74,7 @@ function wrap (prefix, fn) {
     return asyncResource.runInAsyncScope(() => {
       const cb = callbackResource.bind(arguments[callbackIndex])
 
-      startCh.publish({ bucket: this })
+      startCh.publish({ bucket: { name: this.name || this._name } })
 
       arguments[callbackIndex] = asyncResource.bind(function (error, result) {
         if (error) {
@@ -143,3 +96,155 @@ function wrap (prefix, fn) {
   }
   return shimmer.wrap(fn, wrapped)
 }
+
+// semver >=3
+
+function wrapCBandPromise (fn, name, startData, thisArg, args) {
+  const startCh = channel(`apm:couchbase:${name}:start`)
+  const finishCh = channel(`apm:couchbase:${name}:finish`)
+  const errorCh = channel(`apm:couchbase:${name}:error`)
+
+  if (!startCh.hasSubscribers) return fn.apply(thisArg, args)
+
+  const asyncResource = new AsyncResource('bound-anonymous-fn')
+  const callbackResource = new AsyncResource('bound-anonymous-fn')
+
+  return asyncResource.runInAsyncScope(() => {
+    startCh.publish(startData)
+
+    try {
+      const cbIndex = findCallbackIndex(args, 1)
+      if (cbIndex >= 0) {
+        // v3 offers callback or promises event handling
+        // NOTE: this does not work with v3.2.0-3.2.1 cluster.query, as there is a bug in the couchbase source code
+        const cb = callbackResource.bind(args[cbIndex])
+        args[cbIndex] = asyncResource.bind(function (error, result) {
+          if (error) {
+            errorCh.publish(error)
+          }
+          finishCh.publish({ result })
+          return cb.apply(thisArg, arguments)
+        })
+      }
+      const res = fn.apply(thisArg, args)
+
+      // semver >=3 will always return promise by default
+      res.then(
+        asyncResource.bind((result) => finishCh.publish({ result })),
+        asyncResource.bind((err) => errorCh.publish(err)))
+      return res
+    } catch (e) {
+      e.stack
+      errorCh.publish(e)
+      throw e
+    }
+  })
+}
+
+function wrapWithName (name) {
+  return function (operation) {
+    return function () { // no arguments used by us
+      return wrapCBandPromise(operation, name, {
+        collection: { name: this._name || '_default' },
+        bucket: { name: this._scope._bucket._name }
+      }, this, arguments)
+    }
+  }
+}
+
+function wrapV3Query (query) {
+  return function (q) {
+    const resource = getQueryResource(q)
+    return wrapCBandPromise(query, 'query', { resource }, this, arguments)
+  }
+}
+
+// semver >=2 <3
+addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.5'] }, Bucket => {
+  const startCh = channel('apm:couchbase:query:start')
+  const finishCh = channel('apm:couchbase:query:finish')
+  const errorCh = channel('apm:couchbase:query:error')
+
+  Bucket.prototype._maybeInvoke = wrapMaybeInvoke(Bucket.prototype._maybeInvoke)
+  Bucket.prototype.query = wrapQuery(Bucket.prototype.query)
+
+  shimmer.wrap(Bucket.prototype, '_n1qlReq', _n1qlReq => function (host, q, adhoc, emitter) {
+    if (!startCh.hasSubscribers) {
+      return _n1qlReq.apply(this, arguments)
+    }
+
+    if (!emitter || !emitter.once) return _n1qlReq.apply(this, arguments)
+
+    const n1qlQuery = getQueryResource(q)
+
+    const asyncResource = new AsyncResource('bound-anonymous-fn')
+    return asyncResource.runInAsyncScope(() => {
+      startCh.publish({ resource: n1qlQuery, bucket: { name: this.name || this._name } })
+
+      emitter.once('rows', asyncResource.bind(() => {
+        finishCh.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)
+
+        throw err
+      }
+    })
+  })
+
+  wrapAllNames(['upsert', 'insert', 'replace', 'append', 'prepend'], name => {
+    Bucket.prototype[name] = wrap(`apm:couchbase:${name}`, Bucket.prototype[name])
+  })
+
+  return Bucket
+})
+
+addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.5'] }, Cluster => {
+  Cluster.prototype._maybeInvoke = wrapMaybeInvoke(Cluster.prototype._maybeInvoke)
+  Cluster.prototype.query = wrapQuery(Cluster.prototype.query)
+
+  return Cluster
+})
+
+// semver >=3 <3.2.0
+
+addHook({ name: 'couchbase', file: 'lib/collection.js', versions: ['>=3.0.0 <3.2.0'] }, Collection => {
+  wrapAllNames(['upsert', 'insert', 'replace'], name => {
+    shimmer.wrap(Collection.prototype, name, wrapWithName(name))
+  })
+
+  return Collection
+})
+
+addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['>=3.0.0 <3.2.0'] }, Cluster => {
+  shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)
+  return Cluster
+})
+
+// semver >=3.2.0
+
+addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.0'] }, collection => {
+  const Collection = collection.Collection
+
+  wrapAllNames(['upsert', 'insert', 'replace'], name => {
+    shimmer.wrap(Collection.prototype, name, wrapWithName(name))
+  })
+
+  return collection
+})
+
+addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['3.2.0 - 3.2.1', '>=3.2.2'] }, cluster => {
+  const Cluster = cluster.Cluster
+
+  shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)
+  return cluster
+})

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

@@ -17,12 +17,15 @@ const patchedTypes = new WeakSet()
 /** CHANNELS */
 
 // execute channels
-const startResolveCh = channel('apm:graphql:resolve:start')
 const startExecuteCh = channel('apm:graphql:execute:start')
 const finishExecuteCh = channel('apm:graphql:execute:finish')
+const executeErrorCh = channel('apm:graphql:execute:error')
+
+// resolve channels
+const startResolveCh = channel('apm:graphql:resolve:start')
 const finishResolveCh = channel('apm:graphql:resolve:finish')
 const updateFieldCh = channel('apm:graphql:resolve:updateField')
-const executeErrorCh = channel('apm:graphql:execute:error')
+const resolveErrorCh = channel('apm:graphql:resolve:error')
 
 // parse channels
 const parseStartCh = channel('apm:graphql:parser:start')
@@ -124,7 +127,9 @@ function wrapValidate (validate) {
       let errors
       try {
         errors = validate.apply(this, arguments)
-        validateErrorCh.publish(errors && errors[0])
+        if (errors && errors[0]) {
+          validateErrorCh.publish(errors && errors[0])
+        }
         return errors
       } catch (err) {
         err.stack
@@ -177,7 +182,12 @@ function wrapExecute (execute) {
         return callInAsyncScope(exe, asyncResource, this, arguments, (err, res) => {
           if (finishResolveCh.hasSubscribers) finishResolvers(context)
 
-          executeErrorCh.publish(err || (res && res.errors && res.errors[0]))
+          const error = err || (res && res.errors && res.errors[0])
+
+          if (error) {
+            executeErrorCh.publish(error)
+          }
+
           finishExecuteCh.publish({ res, args })
         })
       })
@@ -331,7 +341,9 @@ function finishResolvers ({ fields }) {
     const field = fields[key]
     const asyncResource = field.asyncResource
     asyncResource.runInAsyncScope(() => {
-      executeErrorCh.publish(field.error)
+      if (field.error) {
+        resolveErrorCh.publish(field.error)
+      }
       finishResolveCh.publish(field.finishTime)
     })
   })

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-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)