dd-trace 2.40.0 → 2.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "2.40.0",
+  "version": "2.41.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": "^1.6.0",
-    "@datadog/pprof": "2.2.3",
+    "@datadog/pprof": "3.0.0",
     "@datadog/sketches-js": "^2.1.0",
     "@types/node": "<18.13",
     "@opentelemetry/api": "^1.0.0",
@@ -95,7 +95,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,15 +1,17 @@
 '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 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) {
@@ -99,45 +101,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) {
@@ -145,25 +141,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,13 +1,15 @@
 '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 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
@@ -31,28 +33,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
     })
   }
 }
@@ -67,69 +79,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/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-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 }
       }
 

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const { storage } = require('../../datadog-core')
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
 const { TEXT_MAP } = require('../../../ext/formats')
 const { addMetadataTags, getFilter, getMethodMetadata } = require('./util')
@@ -7,9 +8,20 @@ const { addMetadataTags, getFilter, getMethodMetadata } = require('./util')
 class GrpcClientPlugin extends ClientPlugin {
   static get id () { return 'grpc' }
   static get operation () { return 'client:request' }
+  static get prefix () { return `apm:grpc:client:request` }
   static get peerServicePrecursors () { return ['rpc.service'] }
 
-  start ({ metadata, path, type }) {
+  constructor (...args) {
+    super(...args)
+
+    this.addTraceBind('emit', ({ parentStore }) => {
+      return parentStore
+    })
+  }
+
+  bindStart (message) {
+    const store = storage.getStore()
+    const { metadata, path, type } = message
     const metadataFilter = this.config.metadataFilter
     const method = getMethodMetadata(path, type)
     const span = this.startSpan(this.operationName(), {
@@ -28,7 +40,7 @@ class GrpcClientPlugin extends ClientPlugin {
       metrics: {
         'grpc.status.code': 0
       }
-    })
+    }, false)
 
     // needed as precursor for peer.service
     if (method.service && method.package) {
@@ -39,22 +51,27 @@ class GrpcClientPlugin extends ClientPlugin {
       addMetadataTags(span, metadata, metadataFilter, 'request')
       inject(this.tracer, span, metadata)
     }
-  }
 
-  error (error) {
-    const span = this.activeSpan
+    message.span = span
+    message.parentStore = store
+    message.currentStore = { ...store, span }
 
-    if (!span) return
+    return message.currentStore
+  }
 
-    this.addCode(span, error.code)
-    this.addError(error)
+  bindAsyncStart ({ parentStore }) {
+    return parentStore
   }
 
-  finish ({ code, metadata }) {
-    const span = this.activeSpan
+  error ({ span, error }) {
+    this.addCode(span, error.code)
+    this.addError(error, span)
+  }
 
+  finish ({ span, result }) {
     if (!span) return
 
+    const { code, metadata } = result || {}
     const metadataFilter = this.config.metadataFilter
 
     this.addCode(span, code)
@@ -63,7 +80,8 @@ class GrpcClientPlugin extends ClientPlugin {
       addMetadataTags(span, metadata, metadataFilter, 'response')
     }
 
-    super.finish()
+    this.tagPeerService(span)
+    span.finish()
   }
 
   configure (config) {