dd-trace 4.5.0 → 4.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "4.5.0",
+  "version": "4.7.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -70,7 +70,7 @@
     "@datadog/native-iast-rewriter": "2.0.1",
     "@datadog/native-iast-taint-tracking": "^1.5.0",
     "@datadog/native-metrics": "^2.0.0",
-    "@datadog/pprof": "2.2.3",
+    "@datadog/pprof": "3.0.0",
     "@datadog/sketches-js": "^2.1.0",
     "@opentelemetry/api": "^1.0.0",
     "@opentelemetry/core": "^1.14.0",
@@ -94,7 +94,7 @@
     "node-abort-controller": "^3.0.1",
     "opentracing": ">=0.12.1",
     "path-to-regexp": "^0.1.2",
-    "protobufjs": "^7.1.2",
+    "protobufjs": "^7.2.4",
     "retry": "^0.10.1",
     "semver": "^7.3.8"
   },

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

@@ -37,6 +37,7 @@ const patched = new WeakSet()
 
 let pickleByFile = {}
 const pickleResultByFile = {}
+let isSuitesSkipped = false
 
 function getSuiteStatusFromTestStatuses (testStatuses) {
   if (testStatuses.some(status => status === 'fail')) {
@@ -264,7 +265,9 @@ addHook({
     const { err, skippableSuites } = await skippableSuitesPromise
 
     if (!err) {
-      this.pickleIds = getPicklesToRun(this, skippableSuites)
+      const newPickleIds = getPicklesToRun(this, skippableSuites)
+      isSuitesSkipped = newPickleIds.length !== this.pickleIds.length
+      this.pickleIds = newPickleIds
     }
 
     pickleByFile = getPickleByFile(this)
@@ -292,7 +295,7 @@ addHook({
     asyncResource.runInAsyncScope(() => {
       sessionFinishCh.publish({
         status: success ? 'pass' : 'fail',
-        isSuitesSkipped: skippableSuites ? !!skippableSuites.length : false,
+        isSuitesSkipped,
         testCodeCoverageLinesTotal
       })
     })

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const types = require('./types')
-const { addHook, channel, AsyncResource } = require('../helpers/instrument')
+const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 const nodeMajor = parseInt(process.versions.node.split('.')[0])
@@ -10,8 +10,10 @@ const patched = new WeakSet()
 const instances = new WeakMap()
 
 const startChannel = channel('apm:grpc:client:request:start')
+const asyncStartChannel = channel('apm:grpc:client:request:asyncStart')
 const errorChannel = channel('apm:grpc:client:request:error')
 const finishChannel = channel('apm:grpc:client:request:finish')
+const emitChannel = channel('apm:grpc:client:request:emit')
 
 function createWrapMakeRequest (type) {
   return function wrapMakeRequest (makeRequest) {
@@ -101,45 +103,39 @@ function wrapMethod (method, path, type) {
   return wrapped
 }
 
-function wrapCallback (requestResource, parentResource, callback) {
+function wrapCallback (ctx, callback = () => { }) {
   return function (err) {
     if (err) {
-      requestResource.runInAsyncScope(() => {
-        errorChannel.publish(err)
-      })
+      ctx.error = err
+      errorChannel.publish(ctx)
     }
 
-    if (callback) {
-      return parentResource.runInAsyncScope(() => {
-        return callback.apply(this, arguments)
-      })
-    }
+    return asyncStartChannel.runStores(ctx, () => {
+      return callback.apply(this, arguments)
+      // No async end channel needed
+    })
   }
 }
 
-function wrapStream (call, requestResource, parentResource) {
-  if (!call || typeof call.emit !== 'function') return
-
-  shimmer.wrap(call, 'emit', emit => {
-    return function (eventName, ...args) {
-      requestResource.runInAsyncScope(() => {
-        switch (eventName) {
-          case 'error':
-            errorChannel.publish(args[0])
-
-            break
-          case 'status':
-            finishChannel.publish(args[0])
-
-            break
-        }
-      })
+function createWrapEmit (ctx) {
+  return function wrapEmit (emit) {
+    return function (event, arg1) {
+      switch (event) {
+        case 'error':
+          ctx.error = arg1
+          errorChannel.publish(ctx)
+          break
+        case 'status':
+          ctx.result = arg1
+          finishChannel.publish(ctx)
+          break
+      }
 
-      return parentResource.runInAsyncScope(() => {
+      return emitChannel.runStores(ctx, () => {
         return emit.apply(this, arguments)
       })
     }
-  })
+  }
 }
 
 function callMethod (client, method, args, path, metadata, type) {
@@ -147,25 +143,31 @@ function callMethod (client, method, args, path, metadata, type) {
 
   const length = args.length
   const callback = args[length - 1]
-  const parentResource = new AsyncResource('bound-anonymous-fn')
-  const requestResource = new AsyncResource('bound-anonymous-fn')
 
-  return requestResource.runInAsyncScope(() => {
-    startChannel.publish({ metadata, path, type })
+  const ctx = { metadata, path, type }
 
-    if (type === types.unary || type === types.client_stream) {
-      if (typeof callback === 'function') {
-        args[length - 1] = wrapCallback(requestResource, parentResource, callback)
-      } else {
-        args[length] = wrapCallback(requestResource, parentResource)
+  return startChannel.runStores(ctx, () => {
+    try {
+      if (type === types.unary || type === types.client_stream) {
+        if (typeof callback === 'function') {
+          args[length - 1] = wrapCallback(ctx, callback)
+        } else {
+          args[length] = wrapCallback(ctx)
+        }
       }
-    }
 
-    const call = method.apply(client, args)
+      const call = method.apply(client, args)
 
-    wrapStream(call, requestResource, parentResource)
+      if (call && typeof call.emit === 'function') {
+        shimmer.wrap(call, 'emit', createWrapEmit(ctx))
+      }
 
-    return call
+      return call
+    } catch (e) {
+      ctx.error = e
+      errorChannel.publish(ctx)
+    }
+    // No end channel needed
   })
 }
 

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

@@ -1,15 +1,17 @@
 'use strict'
 
 const types = require('./types')
-const { channel, addHook, AsyncResource } = require('../helpers/instrument')
+const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 const nodeMajor = parseInt(process.versions.node.split('.')[0])
 
 const startChannel = channel('apm:grpc:server:request:start')
+const asyncStartChannel = channel('apm:grpc:server:request:asyncStart')
 const errorChannel = channel('apm:grpc:server:request:error')
 const updateChannel = channel('apm:grpc:server:request:update')
 const finishChannel = channel('apm:grpc:server:request:finish')
+const emitChannel = channel('apm:grpc:server:request:emit')
 
 // https://github.com/grpc/grpc/blob/master/doc/statuscodes.md
 const OK = 0
@@ -33,28 +35,38 @@ function wrapHandler (func, name) {
     const type = types[this.type]
     const isStream = type !== 'unary'
 
-    const parentResource = new AsyncResource('bound-anonymous-fn')
-    const requestResource = new AsyncResource('bound-anonymous-fn')
-
-    return requestResource.runInAsyncScope(() => {
-      startChannel.publish({ name, metadata, type })
-
-      const onCancel = requestResource.bind(() => {
-        finishChannel.publish({ code: CANCELLED })
-      })
-
-      // Finish the span if the call was cancelled.
-      call.once('cancelled', onCancel)
+    const ctx = { name, metadata, type }
+
+    return startChannel.runStores(ctx, () => {
+      try {
+        const onCancel = () => {
+          ctx.code = CANCELLED
+          finishChannel.publish(ctx)
+        }
+
+        // Finish the span if the call was cancelled.
+        call.once('cancelled', onCancel)
+
+        if (isStream) {
+          wrapStream(call, ctx, onCancel)
+        } else {
+          arguments[1] = wrapCallback(callback, call, ctx, onCancel)
+        }
+
+        shimmer.wrap(call, 'emit', emit => {
+          return function () {
+            return emitChannel.runStores(ctx, () => {
+              return emit.apply(this, arguments)
+            })
+          }
+        })
 
-      if (isStream) {
-        wrapStream(call, requestResource, onCancel)
-      } else {
-        arguments[1] = wrapCallback(callback, call, requestResource, parentResource, onCancel)
+        return func.apply(this, arguments)
+      } catch (e) {
+        ctx.error = e
+        errorChannel.publish(ctx)
       }
-
-      shimmer.wrap(call, 'emit', emit => requestResource.bind(emit))
-
-      return func.apply(this, arguments)
+      // No end channel needed
     })
   }
 }
@@ -69,69 +81,66 @@ function wrapRegister (register) {
   }
 }
 
-function wrapStream (call, requestResource, onCancel) {
-  if (call.call && call.call.sendStatus) {
-    call.call.sendStatus = wrapSendStatus(call.call.sendStatus, requestResource)
-  }
-
-  shimmer.wrap(call, 'emit', emit => {
-    return function (eventName, ...args) {
-      switch (eventName) {
+function createWrapEmit (call, ctx, onCancel) {
+  return function wrapEmit (emit) {
+    return function (event, arg1) {
+      switch (event) {
         case 'error':
-          errorChannel.publish(args[0])
-          finishChannel.publish({ code: args[0].code })
-
+          ctx.error = arg1
+          errorChannel.publish(ctx)
+          ctx.code = arg1.code
+          finishChannel.publish(ctx)
           call.removeListener('cancelled', onCancel)
-
           break
-
-          // Finish the span of the response only if it was successful.
-          // Otherwise it'll be finished in the `error` listener.
         case 'finish':
           if (call.status) {
             updateChannel.publish(call.status)
           }
-
           if (!call.status || call.status.code === 0) {
-            finishChannel.publish()
+            finishChannel.publish(ctx)
           }
-
           call.removeListener('cancelled', onCancel)
-
           break
       }
 
       return emit.apply(this, arguments)
     }
-  })
+  }
 }
 
-function wrapCallback (callback, call, requestResource, parentResource, onCancel) {
-  return function (err, value, trailer, flags) {
-    requestResource.runInAsyncScope(() => {
-      if (err) {
-        errorChannel.publish(err)
-        finishChannel.publish(err)
-      } else {
-        finishChannel.publish({ code: OK, trailer })
-      }
+function wrapStream (call, ctx, onCancel) {
+  if (call.call && call.call.sendStatus) {
+    call.call.sendStatus = wrapSendStatus(call.call.sendStatus, ctx)
+  }
 
-      call.removeListener('cancelled', onCancel)
-    })
+  shimmer.wrap(call, 'emit', createWrapEmit(call, ctx, onCancel))
+}
 
-    if (callback) {
-      return parentResource.runInAsyncScope(() => {
-        return callback.apply(this, arguments)
-      })
+function wrapCallback (callback = () => {}, call, ctx, onCancel) {
+  return function (err, value, trailer, flags) {
+    if (err) {
+      ctx.error = err
+      errorChannel.publish(ctx)
+    } else {
+      ctx.code = OK
+      ctx.trailer = trailer
     }
+
+    finishChannel.publish(ctx)
+
+    call.removeListener('cancelled', onCancel)
+
+    return asyncStartChannel.runStores(ctx, () => {
+      return callback.apply(this, arguments)
+      // No async end channel needed
+    })
   }
 }
 
-function wrapSendStatus (sendStatus, requestResource) {
+function wrapSendStatus (sendStatus, ctx) {
   return function (status) {
-    requestResource.runInAsyncScope(() => {
-      updateChannel.publish(status)
-    })
+    ctx.status = status
+    updateChannel.publish(ctx)
 
     return sendStatus.apply(this, arguments)
   }

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

@@ -1,32 +1,27 @@
 'use strict'
 
 const shimmer = require('../../../datadog-shimmer')
-const { addHook, channel, AsyncResource } = require('../helpers/instrument')
+const { addHook, channel } = require('../helpers/instrument')
 
 const connectChannel = channel('apm:http2:client:connect:start')
 const startChannel = channel('apm:http2:client:request:start')
-const finishChannel = channel('apm:http2:client:request:finish')
+const endChannel = channel('apm:http2:client:request:end')
+const asyncStartChannel = channel('apm:http2:client:request:asyncStart')
+const asyncEndChannel = channel('apm:http2:client:request:asyncEnd')
 const errorChannel = channel('apm:http2:client:request:error')
-const responseChannel = channel('apm:http2:client:response')
 
-function createWrapEmit (requestResource, parentResource) {
+function createWrapEmit (ctx) {
   return function wrapEmit (emit) {
     return function (event, arg1) {
-      requestResource.runInAsyncScope(() => {
-        switch (event) {
-          case 'response':
-            responseChannel.publish(arg1)
-            break
-          case 'error':
-            errorChannel.publish(arg1)
-          case 'close': // eslint-disable-line no-fallthrough
-            finishChannel.publish()
-            break
-        }
-      })
+      ctx.eventName = event
+      ctx.eventData = arg1
 
-      return parentResource.runInAsyncScope(() => {
-        return emit.apply(this, arguments)
+      return asyncStartChannel.runStores(ctx, () => {
+        try {
+          return emit.apply(this, arguments)
+        } finally {
+          asyncEndChannel.publish(ctx)
+        }
       })
     }
   }
@@ -35,17 +30,21 @@ function createWrapEmit (requestResource, parentResource) {
 function createWrapRequest (authority, options) {
   return function wrapRequest (request) {
     return function (headers) {
-      const parentResource = new AsyncResource('bound-anonymous-fn')
-      const requestResource = new AsyncResource('bound-anonymous-fn')
+      const ctx = { headers, authority, options }
 
-      return requestResource.runInAsyncScope(() => {
-        startChannel.publish({ headers, authority, options })
+      return startChannel.runStores(ctx, () => {
+        try {
+          const req = request.apply(this, arguments)
 
-        const req = request.apply(this, arguments)
+          shimmer.wrap(req, 'emit', createWrapEmit(ctx))
 
-        shimmer.wrap(req, 'emit', createWrapEmit(requestResource, parentResource))
-
-        return req
+          return req
+        } catch (e) {
+          ctx.error = e
+          errorChannel.publish(ctx)
+        } finally {
+          endChannel.publish(ctx)
+        }
       })
     }
   }

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

@@ -42,6 +42,7 @@ const jestItrConfigurationCh = channel('ci:jest:itr-configuration')
 let skippableSuites = []
 let isCodeCoverageEnabled = false
 let isSuitesSkippingEnabled = false
+let isSuitesSkipped = false
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -227,7 +228,6 @@ function cliWrapper (cli, jestVersion) {
         log.error(err)
       }
     }
-    const isSuitesSkipped = !!skippableSuites.length
 
     const processArgv = process.argv.slice(2).join(' ')
     sessionAsyncResource.runInAsyncScope(() => {
@@ -430,6 +430,8 @@ addHook({
 
     const filteredTests = getJestSuitesToRun(skippableSuites, tests, rootDir)
 
+    isSuitesSkipped = filteredTests.length !== tests.length
+
     skippableSuites = []
 
     return { ...testPaths, tests: filteredTests }

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

@@ -16,10 +16,19 @@ const consumerFinishCh = channel('apm:kafkajs:consume:finish')
 const consumerErrorCh = channel('apm:kafkajs:consume:error')
 
 addHook({ name: 'kafkajs', versions: ['>=1.4'] }, (obj) => {
-  const Kafka = obj.Kafka
+  class Kafka extends obj.Kafka {
+    constructor (options) {
+      super(options)
+      this._brokers = (options.brokers && typeof options.brokers !== 'function')
+        ? options.brokers.join(',') : undefined
+    }
+  }
+  obj.Kafka = Kafka
+
   shimmer.wrap(Kafka.prototype, 'producer', createProducer => function () {
     const producer = createProducer.apply(this, arguments)
     const send = producer.send
+    const bootstrapServers = this._brokers
 
     producer.send = function () {
       const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
@@ -36,7 +45,7 @@ addHook({ name: 'kafkajs', versions: ['>=1.4'] }, (obj) => {
               message.headers = message.headers || {}
             }
           }
-          producerStartCh.publish({ topic, messages })
+          producerStartCh.publish({ topic, messages, bootstrapServers })
 
           const result = send.apply(this, arguments)
 

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

@@ -46,6 +46,7 @@ const originalCoverageMap = createCoverageMap()
 
 let suitesToSkip = []
 let frameworkVersion
+let isSuitesSkipped = false
 
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
@@ -125,8 +126,6 @@ function mochaHook (Runner) {
       }
       testFileToSuiteAr.clear()
 
-      const isSuitesSkipped = !!suitesToSkip.length
-
       let testCodeCoverageLinesTotal
       if (global.__coverage__) {
         try {
@@ -360,7 +359,10 @@ addHook({
         suitesToSkip = skippableSuites
       }
       // We remove the suites that we skip through ITR
-      runner.suite.suites = getSuitesToRun(runner.suite.suites)
+      const newSuites = getSuitesToRun(runner.suite.suites)
+      isSuitesSkipped = newSuites.length !== runner.suite.suites.length
+      runner.suite.suites = newSuites
+
       global.run()
     }
 

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

@@ -11,6 +11,8 @@ const startCh = channel('apm:redis:command:start')
 const finishCh = channel('apm:redis:command:finish')
 const errorCh = channel('apm:redis:command:error')
 
+let createClientUrl
+
 function wrapAddCommand (addCommand) {
   return function (command) {
     if (!startCh.hasSubscribers) {
@@ -22,7 +24,7 @@ function wrapAddCommand (addCommand) {
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
-      start(this, name, args)
+      start(this, name, args, this._url)
 
       const res = addCommand.apply(this, arguments)
       const onResolve = asyncResource.bind(() => finish(finishCh, errorCh))
@@ -35,12 +37,53 @@ function wrapAddCommand (addCommand) {
   }
 }
 
-addHook({ name: '@redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1.1'] }, redis => {
+function wrapCommandQueueClass (cls) {
+  const ret = class RedisCommandQueue extends cls {
+    constructor () {
+      super(arguments)
+      if (createClientUrl) {
+        try {
+          const parsed = new URL(createClientUrl)
+          if (parsed) {
+            this._url = { host: parsed.hostname, port: +parsed.port || 6379 }
+          }
+        } catch (error) {
+          // ignore
+        }
+      }
+      this._url = this._url || { host: 'localhost', port: 6379 }
+    }
+  }
+  return ret
+}
+
+function wrapCreateClient (request) {
+  return function (opts) {
+    createClientUrl = opts && opts.url
+    const ret = request.apply(this, arguments)
+    createClientUrl = undefined
+    return ret
+  }
+}
+
+addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1'] }, redis => {
+  redis.default = wrapCommandQueueClass(redis.default)
   shimmer.wrap(redis.default.prototype, 'addCommand', wrapAddCommand)
   return redis
 })
 
-addHook({ name: '@node-redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1'] }, redis => {
+addHook({ name: '@node-redis/client', file: 'dist/lib/client/index.js', versions: ['>=1'] }, redis => {
+  shimmer.wrap(redis.default, 'create', wrapCreateClient)
+  return redis
+})
+
+addHook({ name: '@redis/client', file: 'dist/lib/client/index.js', versions: ['>=1.1'] }, redis => {
+  shimmer.wrap(redis.default, 'create', wrapCreateClient)
+  return redis
+})
+
+addHook({ name: '@redis/client', file: 'dist/lib/client/commands-queue.js', versions: ['>=1.1'] }, redis => {
+  redis.default = wrapCommandQueueClass(redis.default)
   shimmer.wrap(redis.default.prototype, 'addCommand', wrapAddCommand)
   return redis
 })
@@ -106,9 +149,9 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
   return redis
 })
 
-function start (client, command, args) {
+function start (client, command, args, url = {}) {
   const db = client.selected_db
-  const connectionOptions = client.connection_options || client.connection_option || client.connectionOption || {}
+  const connectionOptions = client.connection_options || client.connection_option || client.connectionOption || url
   startCh.publish({ db, command, args, connectionOptions })
 }
 

package/packages/datadog-plugin-cypress/src/plugin.js

@@ -37,7 +37,7 @@ const CYPRESS_STATUS_TO_TEST_STATUS = {
 function getTestSpanMetadata (tracer, testName, testSuite, cypressConfig) {
   const childOf = getTestParentSpan(tracer)
 
-  const commonTags = getTestCommonTags(testName, testSuite, cypressConfig.version)
+  const commonTags = getTestCommonTags(testName, testSuite, cypressConfig.version, TEST_FRAMEWORK_NAME)
 
   return {
     childOf,
@@ -119,6 +119,7 @@ function getSkippableTests (isSuitesSkippingEnabled, tracer, testConfiguration)
 }
 
 module.exports = (on, config) => {
+  let isTestsSkipped = false
   const tracer = require('../../dd-trace')
   const testEnvironmentMetadata = getTestEnvironmentMetadata(TEST_FRAMEWORK_NAME)
 
@@ -306,7 +307,7 @@ module.exports = (on, config) => {
         testSessionSpan,
         testModuleSpan,
         {
-          isSuitesSkipped: !!testsToSkip.length,
+          isSuitesSkipped: isTestsSkipped,
           isSuitesSkippingEnabled,
           isCodeCoverageEnabled
         }
@@ -352,6 +353,7 @@ module.exports = (on, config) => {
       if (testsToSkip.find(test => {
         return testName === test.name && testSuite === test.suite
       })) {
+        isTestsSkipped = true
         return { shouldSkip: true }
       }