dd-trace 3.7.1 → 3.9.0

package/LICENSE-3rdparty.csv

@@ -1,6 +1,8 @@
 Component,Origin,License,Copyright
 require,@datadog/native-appsec,Apache license 2.0,Copyright 2018 Datadog Inc.
 require,@datadog/native-metrics,Apache license 2.0,Copyright 2018 Datadog Inc.
+require,@datadog/native-iast-rewriter,Apache license 2.0,Copyright 2018 Datadog Inc.
+require,@datadog/native-iast-taint-tracking,Apache license 2.0,Copyright 2018 Datadog Inc.
 require,@datadog/pprof,Apache license 2.0,Copyright 2019 Google Inc.
 require,@datadog/sketches-js,Apache license 2.0,Copyright 2020 Datadog Inc.
 require,crypto-randomuuid,MIT,Copyright 2021 Node.js Foundation and contributors

package/index.d.ts

@@ -167,6 +167,11 @@ export declare interface SpanContext extends opentracing.SpanContext {
    * Returns the string representation of the internal span ID.
    */
   toSpanId(): string;
+
+  /**
+   * Returns the string representation used for DBM integration.
+   */
+  toTraceparent(): string;
 }
 
 /**
@@ -463,6 +468,12 @@ export declare interface TracerOptions {
    */
   orphanable?: boolean
 
+  /**
+   * Enables DBM to APM link using tag injection.
+   * @default 'disabled'
+   */
+  dbmPropagationMode?: 'disabled' | 'service' | 'full'
+
   /**
    * Configuration of the AppSec protection. Can be a boolean as an alias to `appsec.enabled`.
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "3.7.1",
+  "version": "3.9.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -58,7 +58,9 @@
     "node": ">=14"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^1.2.1",
+    "@datadog/native-appsec": "2.0.0",
+    "@datadog/native-iast-rewriter": "1.0.0",
+    "@datadog/native-iast-taint-tracking": "1.0.0",
     "@datadog/native-metrics": "^1.5.0",
     "@datadog/pprof": "^1.1.1",
     "@datadog/sketches-js": "^2.1.0",

package/packages/datadog-instrumentations/src/body-parser.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
+
+const bodyParserReadCh = channel('datadog:body-parser:read:finish')
+
+function publishRequestBodyAndNext (request, next) {
+  return function () {
+    if (bodyParserReadCh.hasSubscribers && request) {
+      bodyParserReadCh.publish({ request })
+    }
+    next.apply(this, arguments)
+  }
+}
+
+addHook({
+  name: 'body-parser',
+  file: 'lib/read.js',
+  versions: ['>=1']
+}, read => {
+  return function (req, res, next) {
+    const nextResource = new AsyncResource('bound-anonymous-fn')
+    arguments[2] = nextResource.bind(publishRequestBodyAndNext(req, next))
+    read.apply(this, arguments)
+  }
+})

package/packages/datadog-instrumentations/src/child-process.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const childProcessChannel = channel('datadog:child_process:execution:start')
+const execMethods = ['exec', 'execFile', 'fork', 'spawn', 'execFileSync', 'execSync', 'spawnSync']
+const names = ['child_process', 'node:child_process']
+names.forEach(name => {
+  addHook({ name }, childProcess => {
+    shimmer.massWrap(childProcess, execMethods, wrapChildProcessMethod())
+    return childProcess
+  })
+})
+
+function wrapChildProcessMethod () {
+  function wrapMethod (childProcessMethod) {
+    return function () {
+      if (childProcessChannel.hasSubscribers && arguments.length > 0) {
+        const command = arguments[0]
+        childProcessChannel.publish({ command })
+      }
+      return childProcessMethod.apply(this, arguments)
+    }
+  }
+  return wrapMethod
+}

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

@@ -50,7 +50,7 @@ function wrapRun (pl, isLatestVersion) {
 
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
-      runStartCh.publish({ pickleName: this.pickle.name, pickleUri: this.pickle.uri })
+      runStartCh.publish({ testName: this.pickle.name, fullTestSuite: this.pickle.uri })
       try {
         const promise = run.apply(this, arguments)
         promise.finally(() => {

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -8,6 +8,7 @@ module.exports = {
   '@grpc/grpc-js': () => require('../grpc'),
   '@hapi/hapi': () => require('../hapi'),
   '@jest/core': () => require('../jest'),
+  '@jest/reporters': () => require('../jest'),
   '@koa/router': () => require('../koa'),
   '@node-redis/client': () => require('../redis'),
   '@opensearch-project/opensearch': () => require('../opensearch'),
@@ -16,8 +17,11 @@ module.exports = {
   'amqplib': () => require('../amqplib'),
   'aws-sdk': () => require('../aws-sdk'),
   'bluebird': () => require('../bluebird'),
+  'body-parser': () => require('../body-parser'),
   'bunyan': () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
+  'child_process': () => require('../child-process'),
+  'node:child_process': () => require('../child-process'),
   'connect': () => require('../connect'),
   'couchbase': () => require('../couchbase'),
   'crypto': () => require('../crypto'),
@@ -64,6 +68,7 @@ module.exports = {
   'promise-js': () => require('../promise-js'),
   'promise': () => require('../promise'),
   'q': () => require('../q'),
+  'qs': () => require('../qs'),
   'redis': () => require('../redis'),
   'restify': () => require('../restify'),
   'rhea': () => require('../rhea'),

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

@@ -1,8 +1,8 @@
 'use strict'
-const istanbul = require('istanbul-lib-coverage')
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
+const { getCoveredFilenamesFromCoverage } = require('../../dd-trace/src/plugins/util/test')
 
 const testSessionStartCh = channel('ci:jest:session:start')
 const testSessionFinishCh = channel('ci:jest:session:finish')
@@ -23,6 +23,7 @@ const jestConfigurationCh = channel('ci:jest:configuration')
 
 let skippableSuites = []
 let isCodeCoverageEnabled = false
+let isSuitesSkippingEnabled = false
 
 const {
   getTestSuitePath,
@@ -33,21 +34,6 @@ const { getFormattedJestTestParameters, getJestTestName } = require('../../datad
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
-function extractCoverageInformation (coverage, rootDir) {
-  const coverageMap = istanbul.createCoverageMap(coverage)
-
-  return coverageMap
-    .files()
-    .filter(filename => {
-      const fileCoverage = coverageMap.fileCoverageFor(filename)
-      const lineCoverage = fileCoverage.getLineCoverage()
-      const isAnyLineExecuted = Object.entries(lineCoverage).some(([, numExecutions]) => !!numExecutions)
-
-      return isAnyLineExecuted
-    })
-    .map(filename => filename.replace(`${rootDir}/`, ''))
-}
-
 const specStatusToTestStatus = {
   'pending': 'skip',
   'disabled': 'skip',
@@ -186,38 +172,42 @@ addHook({
 
 function cliWrapper (cli) {
   const wrapped = shimmer.wrap(cli, 'runCLI', runCLI => async function () {
-    let onResponse, onError
-    const configurationPromise = new Promise((resolve, reject) => {
-      onResponse = resolve
-      onError = reject
+    let onDone
+    const configurationPromise = new Promise((resolve) => {
+      onDone = resolve
     })
 
     sessionAsyncResource.runInAsyncScope(() => {
-      jestConfigurationCh.publish({ onResponse, onError })
+      jestConfigurationCh.publish({ onDone })
     })
 
-    let isSuitesSkippingEnabled = false
-
     try {
-      const config = await configurationPromise
+      const { err, config } = await configurationPromise
+      if (err) {
+        log.error(err)
+      }
       isCodeCoverageEnabled = config.isCodeCoverageEnabled
       isSuitesSkippingEnabled = config.isSuitesSkippingEnabled
     } catch (e) {
-      // ignore error
+      log.error(e)
     }
 
     if (isSuitesSkippingEnabled) {
-      const skippableSuitesPromise = new Promise((resolve, reject) => {
-        onResponse = resolve
-        onError = reject
+      const skippableSuitesPromise = new Promise((resolve) => {
+        onDone = resolve
       })
 
       sessionAsyncResource.runInAsyncScope(() => {
-        skippableSuitesCh.publish({ onResponse, onError })
+        skippableSuitesCh.publish({ onDone })
       })
 
       try {
-        skippableSuites = await skippableSuitesPromise
+        const { err, skippableSuites: receivedSkippableSuites } = await skippableSuitesPromise
+        if (err) {
+          log.error(err)
+        } else {
+          skippableSuites = receivedSkippableSuites
+        }
       } catch (e) {
         log.error(e)
       }
@@ -253,6 +243,35 @@ function cliWrapper (cli) {
   return cli
 }
 
+function coverageReporterWrapper (coverageReporter) {
+  const CoverageReporter = coverageReporter.default ? coverageReporter.default : coverageReporter
+
+  /**
+   * If ITR is active, we're running fewer tests, so of course the total code coverage is reduced.
+   * This calculation adds no value, so we'll skip it.
+   */
+  shimmer.wrap(CoverageReporter.prototype, '_addUntestedFiles', addUntestedFiles => async function () {
+    if (isSuitesSkippingEnabled) {
+      return Promise.resolve()
+    }
+    return addUntestedFiles.apply(this, arguments)
+  })
+
+  return coverageReporter
+}
+
+addHook({
+  name: '@jest/reporters',
+  file: 'build/coverage_reporter.js',
+  versions: ['>=24.8.0 <26.6.2']
+}, coverageReporterWrapper)
+
+addHook({
+  name: '@jest/reporters',
+  file: 'build/CoverageReporter.js',
+  versions: ['>=26.6.2']
+}, coverageReporterWrapper)
+
 addHook({
   name: '@jest/core',
   file: 'build/cli/index.js',
@@ -263,6 +282,9 @@ function jestAdapterWrapper (jestAdapter) {
   const adapter = jestAdapter.default ? jestAdapter.default : jestAdapter
   const newAdapter = shimmer.wrap(adapter, function () {
     const environment = arguments[2]
+    if (!environment) {
+      return adapter.apply(this, arguments)
+    }
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     return asyncResource.runInAsyncScope(() => {
       testSuiteStartCh.publish({
@@ -278,11 +300,16 @@ function jestAdapterWrapper (jestAdapter) {
           status = 'fail'
         }
         testSuiteFinishCh.publish({ status, errorMessage })
-        if (environment.global.__coverage__) {
-          const coverageFiles = extractCoverageInformation(environment.global.__coverage__, environment.rootDir)
-          if (coverageFiles.length) {
+
+        const coverageFiles = getCoveredFilenamesFromCoverage(environment.global.__coverage__)
+          .map(filename => getTestSuitePath(filename, environment.rootDir))
+
+        if (coverageFiles &&
+          environment.testEnvironmentOptions &&
+          environment.testEnvironmentOptions._ddTestCodeCoverageEnabled) {
+          asyncResource.runInAsyncScope(() => {
             testSuiteCodeCoverageCh.publish([...coverageFiles, environment.testSuite])
-          }
+          })
         }
         return suiteResults
       })
@@ -305,15 +332,15 @@ addHook({
 
 function configureTestEnvironment (readConfigsResult) {
   const { configs } = readConfigsResult
-  configs.forEach(config => {
-    skippableSuites.forEach((suite) => {
-      config.testMatch.push(`!**/${suite}`)
-    })
-    skippableSuites = []
-  })
   sessionAsyncResource.runInAsyncScope(() => {
     testSessionConfigurationCh.publish(configs.map(config => config.testEnvironmentOptions))
   })
+  // We can't directly use isCodeCoverageEnabled when reporting coverage in `jestAdapterWrapper`
+  // because `jestAdapterWrapper` runs in a different process. We have to go through `testEnvironmentOptions`
+  configs.forEach(config => {
+    config.testEnvironmentOptions._ddTestCodeCoverageEnabled = isCodeCoverageEnabled
+  })
+
   if (isCodeCoverageEnabled) {
     const globalConfig = {
       ...readConfigsResult.globalConfig,
@@ -321,6 +348,16 @@ function configureTestEnvironment (readConfigsResult) {
     }
     readConfigsResult.globalConfig = globalConfig
   }
+  if (isSuitesSkippingEnabled) {
+    // If suite skipping is enabled, the code coverage results are not going to be relevant,
+    // so we do not show them.
+    const globalConfig = {
+      ...readConfigsResult.globalConfig,
+      coverageReporters: ['none']
+    }
+    readConfigsResult.globalConfig = globalConfig
+  }
+
   return readConfigsResult
 }
 
@@ -342,6 +379,39 @@ function jestConfigSyncWrapper (jestConfig) {
   return jestConfig
 }
 
+/**
+ * Hook to remove the test paths (test suite) that are part of `skippableSuites`
+ */
+addHook({
+  name: '@jest/core',
+  versions: ['>=24.8.0'],
+  file: 'build/SearchSource.js'
+}, searchSourcePackage => {
+  const SearchSource = searchSourcePackage.default ? searchSourcePackage.default : searchSourcePackage
+
+  shimmer.wrap(SearchSource.prototype, 'getTestPaths', getTestPaths => async function () {
+    if (!skippableSuites.length) {
+      return getTestPaths.apply(this, arguments)
+    }
+
+    const [{ rootDir }] = arguments
+
+    const testPaths = await getTestPaths.apply(this, arguments)
+    const { tests } = testPaths
+
+    const filteredTests = tests.filter(({ path: testPath }) => {
+      const relativePath = testPath.replace(`${rootDir}/`, '')
+      return !skippableSuites.includes(relativePath)
+    })
+
+    skippableSuites = []
+
+    return { ...testPaths, tests: filteredTests }
+  })
+
+  return searchSourcePackage
+})
+
 // from 25.1.0 on, readConfigs becomes async
 addHook({
   name: 'jest-config',

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

@@ -1,5 +1,15 @@
+const { createCoverageMap } = require('istanbul-lib-coverage')
+
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
+const log = require('../../dd-trace/src/log')
+const {
+  getCoveredFilenamesFromCoverage,
+  resetCoverage,
+  mergeCoverage,
+  getTestSuitePath,
+  fromCoverageMapToCoverage
+} = require('../../dd-trace/src/plugins/util/test')
 
 const testStartCh = channel('ci:mocha:test:start')
 const errorCh = channel('ci:mocha:test:error')
@@ -7,12 +17,16 @@ const skipCh = channel('ci:mocha:test:skip')
 const testFinishCh = channel('ci:mocha:test:finish')
 const parameterizedTestCh = channel('ci:mocha:test:parameterize')
 
+const configurationCh = channel('ci:mocha:configuration')
+const skippableSuitesCh = channel('ci:mocha:test-suite:skippable')
+
 const testSessionStartCh = channel('ci:mocha:session:start')
 const testSessionFinishCh = channel('ci:mocha:session: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')
+const testSuiteCodeCoverageCh = channel('ci:mocha:test-suite:code-coverage')
 
 // TODO: remove when root hooks and fixtures are implemented
 const patched = new WeakSet()
@@ -21,6 +35,11 @@ const testToAr = new WeakMap()
 const originalFns = new WeakMap()
 const testFileToSuiteAr = new Map()
 
+// We'll preserve the original coverage here
+const originalCoverageMap = createCoverageMap()
+
+let suitesToSkip = []
+
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
   function getSuites (suite) {
@@ -46,13 +65,13 @@ function getSuitesByTestFile (root) {
 }
 
 function getTestStatus (test) {
-  if (test.pending) {
+  if (test.isPending()) {
     return 'skip'
   }
-  if (test.state !== 'failed' && !test.timedOut) {
-    return 'pass'
+  if (test.isFailed() || test.timedOut) {
+    return 'fail'
   }
-  return 'fail'
+  return 'pass'
 }
 
 function isRetry (test) {
@@ -93,6 +112,8 @@ function mochaHook (Runner) {
       }
       testFileToSuiteAr.clear()
       testSessionFinishCh.publish(status)
+      // restore the original coverage
+      global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
     }))
 
     this.once('start', testRunAsyncResource.bind(function () {
@@ -140,9 +161,21 @@ function mochaHook (Runner) {
         })
       }
 
+      if (global.__coverage__) {
+        const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
+
+        testSuiteCodeCoverageCh.publish({
+          coverageFiles,
+          suiteFile: suite.file
+        })
+        // We need to reset coverage to get a code coverage per suite
+        // Before that, we preserve the original coverage
+        mergeCoverage(global.__coverage__, originalCoverageMap)
+        resetCoverage(global.__coverage__)
+      }
+
       const asyncResource = testFileToSuiteAr.get(suite.file)
       asyncResource.runInAsyncScope(() => {
-        // get suite status
         testSuiteFinishCh.publish(status)
       })
     })
@@ -229,7 +262,8 @@ function mochaHook (Runner) {
           skipCh.publish(test)
         })
       } else {
-        // if there is no async resource, the test has been skipped through `test.skip``
+        // if there is no async resource, the test has been skipped through `test.skip`
+        // or the parent suite is skipped
         const skippedTestAsyncResource = new AsyncResource('bound-anonymous-fn')
         if (test.fn) {
           testToAr.set(test.fn, skippedTestAsyncResource)
@@ -242,6 +276,11 @@ function mochaHook (Runner) {
       }
     })
 
+    // We remove the suites that we skip through ITR
+    this.suite.suites = this.suite.suites.filter(suite =>
+      !suitesToSkip.includes(getTestSuitePath(suite.file, process.cwd()))
+    )
+
     return run.apply(this, arguments)
   })
 
@@ -266,6 +305,48 @@ function mochaEachHook (mochaEach) {
   })
 }
 
+addHook({
+  name: 'mocha',
+  versions: ['>=5.2.0'],
+  file: 'lib/mocha.js'
+}, (Mocha) => {
+  const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
+
+  /**
+   * Get ITR configuration and skippable suites
+   * If ITR is disabled, `onDone` is called immediately on the subscriber
+   */
+  shimmer.wrap(Mocha.prototype, 'run', run => function () {
+    const onReceivedSkippableSuites = ({ err, skippableSuites }) => {
+      if (err) {
+        log.error(err)
+        suitesToSkip = []
+      } else {
+        suitesToSkip = skippableSuites
+      }
+      run.apply(this, arguments)
+    }
+
+    const onReceivedConfiguration = ({ err }) => {
+      if (err) {
+        log.error(err)
+        return run.apply(this, arguments)
+      }
+
+      skippableSuitesCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
+      })
+    }
+
+    mochaRunAsyncResource.runInAsyncScope(() => {
+      configurationCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedConfiguration)
+      })
+    })
+  })
+  return Mocha
+})
+
 addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],

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

@@ -37,13 +37,12 @@ function wrapQuery (query) {
       return retval
     }
 
-    const statement = pgQuery.text
     const callbackResource = new AsyncResource('bound-anonymous-fn')
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     const processId = this.processID
 
     return asyncResource.runInAsyncScope(() => {
-      startCh.publish({ params: this.connectionParameters, statement, processId })
+      startCh.publish({ params: this.connectionParameters, query: pgQuery, processId })
 
       const finish = asyncResource.bind(function (error) {
         if (error) {

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

@@ -0,0 +1,24 @@
+'use strict'
+
+const { addHook, channel } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const qsParseCh = channel('datadog:qs:parse:finish')
+
+function wrapParse (originalParse) {
+  return function () {
+    const qsParsedObj = originalParse.apply(this, arguments)
+    if (qsParseCh.hasSubscribers && qsParsedObj) {
+      qsParseCh.publish({ qs: qsParsedObj })
+    }
+    return qsParsedObj
+  }
+}
+
+addHook({
+  name: 'qs',
+  versions: ['>=1']
+}, qs => {
+  shimmer.wrap(qs, 'parse', wrapParse)
+  return qs
+})

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

@@ -1,24 +1,18 @@
 'use strict'
 
-const Plugin = require('../../dd-trace/src/plugins/plugin')
+const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
 
 const {
-  CI_APP_ORIGIN,
   TEST_SKIP_REASON,
-  ERROR_MESSAGE,
   TEST_STATUS,
-  TEST_CODE_OWNERS,
   finishAllTraceSpans,
-  getTestEnvironmentMetadata,
-  getTestSuitePath,
-  getCodeOwnersFileEntries,
-  getCodeOwnersForFilename,
-  getTestCommonTags
+  getTestSuitePath
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
+const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
 
-class CucumberPlugin extends Plugin {
+class CucumberPlugin extends CiPlugin {
   static get name () {
     return 'cucumber'
   }
@@ -26,36 +20,18 @@ class CucumberPlugin extends Plugin {
   constructor (...args) {
     super(...args)
 
-    const testEnvironmentMetadata = getTestEnvironmentMetadata('cucumber', this.config)
-    const sourceRoot = process.cwd()
-    const codeOwnersEntries = getCodeOwnersFileEntries(sourceRoot)
-
     this.addSub('ci:cucumber:session:finish', () => {
       this.tracer._exporter._writer.flush()
     })
 
-    this.addSub('ci:cucumber:run:start', ({ pickleName, pickleUri }) => {
+    this.addSub('ci:cucumber:run:start', ({ testName, fullTestSuite }) => {
       const store = storage.getStore()
       const childOf = store ? store.span : store
-      const testSuite = getTestSuitePath(pickleUri, sourceRoot)
-
-      const commonTags = getTestCommonTags(pickleName, testSuite, this.tracer._version)
+      const testSuite = getTestSuitePath(fullTestSuite, process.cwd())
 
-      const codeOwners = getCodeOwnersForFilename(testSuite, codeOwnersEntries)
-      if (codeOwners) {
-        commonTags[TEST_CODE_OWNERS] = codeOwners
-      }
+      const testSpan = this.startTestSpan(testName, testSuite, childOf)
 
-      const span = this.tracer.startSpan('cucumber.test', {
-        childOf,
-        tags: {
-          ...commonTags,
-          ...testEnvironmentMetadata
-        }
-      })
-
-      span.context()._trace.origin = CI_APP_ORIGIN
-      this.enter(span, store)
+      this.enter(testSpan, store)
     })
 
     this.addSub('ci:cucumber:run-step:start', ({ resource }) => {
@@ -64,6 +40,7 @@ class CucumberPlugin extends Plugin {
       const span = this.tracer.startSpan('cucumber.step', {
         childOf,
         tags: {
+          [COMPONENT]: this.constructor.name,
           'cucumber.step': resource,
           [RESOURCE_NAME]: resource
         }
@@ -98,6 +75,10 @@ class CucumberPlugin extends Plugin {
       }
     })
   }
+
+  startTestSpan (testName, testSuite, childOf) {
+    return super.startTestSpan(testName, testSuite, {}, childOf)
+  }
 }
 
 module.exports = CucumberPlugin