dd-trace 2.11.0 → 2.12.1

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.1",
   "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/connect.js

@@ -78,12 +78,12 @@ function wrapLayerHandle (layer) {
 
       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
       }
     })
   })
@@ -92,7 +92,7 @@ function wrapLayerHandle (layer) {
 function wrapNext (req, next) {
   return function (error) {
     if (error) {
-      errorChannel.publish(error)
+      errorChannel.publish({ req, error })
     }
 
     nextChannel.publish({ req })

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/fastify.js

@@ -6,7 +6,6 @@ const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const errorChannel = channel('apm:fastify:middleware:error')
 const handleChannel = channel('apm:fastify:request:handle')
 
-const requestResources = new WeakMap()
 const parsingResources = new WeakMap()
 
 function wrapFastify (fastify, hasParsingEvents) {
@@ -42,16 +41,13 @@ function wrapAddHook (addHook) {
 
     arguments[arguments.length - 1] = shimmer.wrap(fn, function (request, reply, done) {
       const req = getReq(request)
-      const requestResource = requestResources.get(req)
-
-      if (!requestResource) return fn.apply(this, arguments)
 
       try {
         if (typeof done === 'function') {
           done = arguments[arguments.length - 1]
 
           arguments[arguments.length - 1] = function (err) {
-            publishError(err, requestResource)
+            publishError(err, req)
 
             if (name === 'onRequest' || name === 'preParsing') {
               const parsingResource = new AsyncResource('bound-anonymous-fn')
@@ -71,13 +67,13 @@ function wrapAddHook (addHook) {
           const promise = fn.apply(this, arguments)
 
           if (promise && typeof promise.catch === 'function') {
-            return promise.catch(err => publishError(err, requestResource))
+            return promise.catch(err => publishError(err, req))
           }
 
           return promise
         }
       } catch (e) {
-        throw publishError(e, requestResource)
+        throw publishError(e, req)
       }
     })
 
@@ -90,14 +86,10 @@ function onRequest (request, reply, done) {
 
   const req = getReq(request)
   const res = getRes(reply)
-  const requestResource = new AsyncResource('bound-anonymous-fn')
 
-  requestResources.set(req, requestResource)
+  handleChannel.publish({ req, res })
 
-  return requestResource.runInAsyncScope(() => {
-    handleChannel.publish({ req, res })
-    return done()
-  })
+  return done()
 }
 
 function preHandler (request, reply, done) {
@@ -105,9 +97,8 @@ function preHandler (request, reply, done) {
   if (!reply || typeof reply.send !== 'function') return done()
 
   const req = getReq(request)
-  const requestResource = requestResources.get(req)
 
-  reply.send = wrapSend(reply.send, requestResource)
+  reply.send = wrapSend(reply.send, req)
 
   done()
 }
@@ -133,12 +124,10 @@ function preParsing (request, reply, payload, done) {
   parsingResource.runInAsyncScope(() => done())
 }
 
-function wrapSend (send, resource) {
-  return function sendWithTrace (payload) {
-    if (payload instanceof Error) {
-      resource.runInAsyncScope(() => {
-        errorChannel.publish(payload)
-      })
+function wrapSend (send, req) {
+  return function sendWithTrace (error) {
+    if (error instanceof Error) {
+      errorChannel.publish({ req, error })
     }
 
     return send.apply(this, arguments)
@@ -153,11 +142,9 @@ function getRes (reply) {
   return reply && (reply.raw || reply.res || reply)
 }
 
-function publishError (error, resource) {
+function publishError (error, req) {
   if (error) {
-    resource.runInAsyncScope(() => {
-      errorChannel.publish(error)
-    })
+    errorChannel.publish({ error, req })
   }
 
   return error

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/koa.js

@@ -126,13 +126,13 @@ function wrapMiddleware (fn, layer) {
 }
 
 function fulfill (ctx, error) {
-  if (error) {
-    errorChannel.publish(error)
-  }
-
   const req = ctx.req
   const route = ctx.routePath
 
+  if (error) {
+    errorChannel.publish({ req, error })
+  }
+
   // TODO: make sure that the parent class cannot override this in `enter`
   if (route) {
     routeChannel.publish({ req, route })