dd-trace 5.83.0 → 5.84.0

package/LICENSE-3rdparty.csv

@@ -11,7 +11,6 @@
 "@isaacs/ttlcache","https://github.com/isaacs/ttlcache","['BlueOak-1.0.0']","['Isaac Z. Schlueter']"
 "@jsep-plugin/assignment","https://github.com/EricSmekens/jsep","['MIT']","['Shelly']"
 "@jsep-plugin/regex","https://github.com/EricSmekens/jsep","['MIT']","['Shelly']"
-"@openfeature/server-sdk","https://github.com/open-feature/js-sdk","['Apache-2.0']","['open-feature']"
 "@opentelemetry/api","https://github.com/open-telemetry/opentelemetry-js","['Apache-2.0']","['OpenTelemetry Authors']"
 "@opentelemetry/api-logs","https://github.com/open-telemetry/opentelemetry-js","['Apache-2.0']","['OpenTelemetry Authors']"
 "@opentelemetry/core","https://github.com/open-telemetry/opentelemetry-js","['Apache-2.0']","['OpenTelemetry Authors']"

package/index.d.ts

@@ -148,7 +148,7 @@ interface Tracer extends opentracing.Tracer {
    * OpenFeature Provider with Remote Config integration.
    *
    * Extends DatadogNodeServerProvider with Remote Config integration for dynamic flag configuration.
-   * Enable with DD_FLAGGING_PROVIDER_ENABLED=true.
+   * Enable with DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true.
    *
    * @beta This feature is in preview and not ready for production use
    */
@@ -241,6 +241,8 @@ interface Plugins {
   "express": tracer.plugins.express;
   "fastify": tracer.plugins.fastify;
   "fetch": tracer.plugins.fetch;
+  "find-my-way": tracer.plugins.find_my_way;
+  "fs": tracer.plugins.fs;
   "generic-pool": tracer.plugins.generic_pool;
   "google-cloud-pubsub": tracer.plugins.google_cloud_pubsub;
   "google-cloud-vertexai": tracer.plugins.google_cloud_vertexai;
@@ -269,6 +271,7 @@ interface Plugins {
   "mysql2": tracer.plugins.mysql2;
   "net": tracer.plugins.net;
   "next": tracer.plugins.next;
+  "nyc": tracer.plugins.nyc;
   "openai": tracer.plugins.openai;
   "opensearch": tracer.plugins.opensearch;
   "oracledb": tracer.plugins.oracledb;
@@ -286,7 +289,9 @@ interface Plugins {
   "tedious": tracer.plugins.tedious;
   "undici": tracer.plugins.undici;
   "vitest": tracer.plugins.vitest;
+  "web": tracer.plugins.web;
   "winston": tracer.plugins.winston;
+  "ws": tracer.plugins.ws;
 }
 
 declare namespace tracer {
@@ -687,6 +692,7 @@ declare namespace tracer {
         /**
          * Whether to enable the feature flagging provider.
          * Requires Remote Config to be properly configured.
+         * Can be configured via DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED environment variable.
          *
          * @default false
          */
@@ -694,6 +700,7 @@ declare namespace tracer {
         /**
          * Timeout in milliseconds for OpenFeature provider initialization.
          * If configuration is not received within this time, initialization fails.
+         * Can be configured via DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS environment variable.
          *
          * @default 30000
          */
@@ -1924,6 +1931,16 @@ declare namespace tracer {
      */
     interface fetch extends HttpClient {}
 
+    /**
+     * This plugin patches the [find-my-way](https://github.com/delvedor/find-my-way) router.
+     */
+    interface find_my_way extends Integration {}
+
+    /**
+     * This plugin automatically instruments Node.js core fs operations.
+     */
+    interface fs extends Instrumentation {}
+
     /**
      * This plugin patches the [generic-pool](https://github.com/coopernurse/node-pool)
      * module to bind the callbacks the the caller context.
@@ -2355,6 +2372,11 @@ declare namespace tracer {
       };
     }
 
+    /**
+     * This plugin integrates with [nyc](https://github.com/istanbuljs/nyc) for CI visibility.
+     */
+    interface nyc extends Integration {}
+
     /**
      * This plugin automatically instruments the
      * [openai](https://platform.openai.com/docs/api-reference?lang=node.js) module.
@@ -2541,6 +2563,32 @@ declare namespace tracer {
      */
     interface vitest extends Integration {}
 
+    /**
+     * This plugin implements shared web request instrumentation helpers.
+     */
+    interface web extends HttpServer {
+      /**
+       * Custom filter function used to decide whether a URL/path should be instrumented.
+       * Takes precedence over allowlist/blocklist.
+       */
+      filter?: (urlOrPath: string) => boolean;
+
+      /**
+       * Whether (or how) to obfuscate querystring values in `http.url`.
+       *
+       * - `true`: obfuscate all values
+       * - `false`: disable obfuscation
+       * - `string`: regex string used to obfuscate matching values (empty string disables)
+       * - `RegExp`: regex used to obfuscate matching values
+       */
+      queryStringObfuscation?: boolean | string | RegExp;
+
+      /**
+       * Whether to enable resource renaming when the framework route is unavailable.
+       */
+      resourceRenamingEnabled?: boolean;
+    }
+
     /**
      * This plugin patches the [winston](https://github.com/winstonjs/winston)
      * to automatically inject trace identifiers in log records when the
@@ -2548,6 +2596,18 @@ declare namespace tracer {
      * on the tracer.
      */
     interface winston extends Integration {}
+
+    /**
+     * This plugin automatically instruments the
+     * [ws](https://github.com/websockets/ws) module.
+     */
+    interface ws extends Instrumentation {
+      /**
+       * Controls whether websocket messages should be traced.
+       * This is also configurable via `DD_TRACE_WEBSOCKET_MESSAGES_ENABLED`.
+       */
+      traceWebsocketMessagesEnabled?: boolean;
+    }
   }
 
   export namespace opentelemetry {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.83.0",
+  "version": "5.84.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -28,7 +28,7 @@
     "test:debugger": "mocha packages/dd-trace/test/debugger/**/*.spec.js",
     "test:debugger:ci": "nyc --no-clean --include \"packages/dd-trace/src/debugger/**/*.js\" -- npm run test:debugger",
     "test:eslint-rules": "node eslint-rules/*.test.mjs",
-    "test:trace:core": "node scripts/mocha-parallel-files.js --expose-gc --timeout 30000 -- \"packages/dd-trace/test/*.spec.js\" \"packages/dd-trace/test/{ci-visibility,config,crashtracking,datastreams,encode,exporters,msgpack,opentelemetry,opentracing,payload-tagging,plugins,remote_config,service-naming,standalone,telemetry,external-logger}/**/*.spec.js\"",
+    "test:trace:core": "node scripts/mocha-parallel-files.js --expose-gc --timeout 30000 -- \"packages/dd-trace/test/*.spec.js\" \"packages/dd-trace/test/{agent,ci-visibility,config,crashtracking,datastreams,encode,exporters,msgpack,opentelemetry,opentracing,payload-tagging,plugins,remote_config,service-naming,standalone,telemetry,external-logger}/**/*.spec.js\"",
     "test:trace:core:ci": "nyc --no-clean --include \"packages/dd-trace/src/**/*.js\" -- npm run test:trace:core",
     "test:trace:guardrails": "mocha packages/dd-trace/test/guardrails/**/*.spec.js",
     "test:trace:guardrails:ci": "nyc --no-clean --include \"packages/dd-trace/src/guardrails/**/*.js\" -- npm run test:trace:guardrails",
@@ -137,7 +137,7 @@
     "@datadog/native-appsec": "10.3.0",
     "@datadog/native-iast-taint-tracking": "4.1.0",
     "@datadog/native-metrics": "3.1.1",
-    "@datadog/openfeature-node-server": "^0.2.0",
+    "@datadog/openfeature-node-server": "^0.3.3",
     "@datadog/pprof": "5.13.2",
     "@datadog/wasm-js-rewriter": "5.0.1",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",

package/packages/datadog-instrumentations/src/helpers/rewriter/compiler.js

@@ -24,4 +24,10 @@ module.exports = {
 
     return esquery.traverse(ast, selector, visitor)
   },
+
+  query: (ast, query) => {
+    esquery ??= require('../../../../../vendor/dist/esquery').default
+
+    return esquery.query(ast, query)
+  },
 }

package/packages/datadog-instrumentations/src/helpers/rewriter/index.js

@@ -127,6 +127,7 @@ function fromFunctionQuery (functionQuery) {
   if (className) {
     queries.push(
       `[id.name="${className}"]`,
+      `[id.name="${className}"] > ClassExpression`,
       `[id.name="${className}"] > ClassBody > [key.name="${methodName}"] > [async]`,
       `[id.name="${className}"] > ClassExpression > ClassBody > [key.name="${methodName}"] > [async]`
     )

package/packages/datadog-instrumentations/src/helpers/rewriter/transforms.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { parse } = require('./compiler')
+const { parse, query } = require('./compiler')
 
 const tracingChannelPredicate = (node) => (
   node.specifiers?.[0]?.local?.name === 'tr_ch_apm_tracingChannel' ||
@@ -106,34 +106,91 @@ function traceInstanceMethod (state, node, program) {
 }
 
 function wrap (state, node) {
-  const { channelName, operator, functionQuery: { index = -1 } } = state
+  const { channelName, operator } = state
+
+  if (operator === 'traceCallback') return wrapCallback(state, node)
+
   const async = operator === 'tracePromise' ? 'async' : ''
   const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
-  const tracedArgs = operator === 'traceCallback'
-    ? `__apm$original_args.splice(${index}, 1, arguments[${index >= 0 ? index : `arguments.length + ${index}`}])`
-    : '__apm$original_args'
-  const traceParams = operator === 'traceCallback'
-    ? `__apm$traced, ${index}`
-    : '__apm$traced'
   const wrapper = parse(`
     function wrapper () {
-      const __apm$original_args = arguments;
-      const __apm$traced = ${async} function () {
+      const __apm$traced = ${async} () => {
         const __apm$wrapped = () => {};
-        const __apm$traced_args = ${tracedArgs};
-        return __apm$wrapped.apply(this, __apm$traced_args);
+        return __apm$wrapped.apply(this, arguments);
       };
-      if (!${channelVariable}.hasSubscribers) return __apm$traced.apply(this, arguments);
-      return ${channelVariable}.${operator}(${traceParams}, {
+      if (!${channelVariable}.hasSubscribers) return __apm$traced();
+      return ${channelVariable}.${operator}(__apm$traced, {
+        arguments,
+        self: this,
+        moduleVersion: "1.0.0"
+      });
+    }
+  `).body[0].body // Extract only block statement of function body.
+
+  // Replace the right-hand side assignment of `const __apm$wrapped = () => {}`.
+  query(wrapper, '[id.name=__apm$wrapped]')[0].init = node
+
+  return wrapper
+}
+
+function wrapCallback (state, node) {
+  const { channelName, functionQuery: { index = -1 } } = state
+  const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
+  const wrapper = parse(`
+    function wrapper () {
+      const __apm$cb = Array.prototype.at.call(arguments, ${index});
+      const __apm$ctx = {
         arguments,
         self: this,
         moduleVersion: "1.0.0"
-      }, this, ...arguments);
+      };
+      const __apm$traced = () => {
+        const __apm$wrapped = () => {};
+        return __apm$wrapped.apply(this, arguments);
+      };
+
+      if (!${channelVariable}.start.hasSubscribers) return __apm$traced();
+
+      function __apm$wrappedCb(err, res) {
+        if (err) {
+          __apm$ctx.error = err;
+          ${channelVariable}.error.publish(__apm$ctx);
+        } else {
+          __apm$ctx.result = res;
+        }
+
+        ${channelVariable}.asyncStart.runStores(__apm$ctx, () => {
+          try {
+            if (__apm$cb) {
+              return __apm$cb.apply(this, arguments);
+            }
+          } finally {
+            ${channelVariable}.asyncEnd.publish(__apm$ctx);
+          }
+        });
+      }
+
+      if (typeof __apm$cb !== 'function') {
+        return __apm$traced();
+      }
+      Array.prototype.splice.call(arguments, ${index}, 1, __apm$wrappedCb);
+
+      return ${channelVariable}.start.runStores(__apm$ctx, () => {
+        try {
+          return __apm$traced();
+        } catch (err) {
+          __apm$ctx.error = err;
+          ${channelVariable}.error.publish(__apm$ctx);
+          throw err;
+        } finally {
+          ${channelVariable}.end.publish(__apm$ctx);
+        }
+      });
     }
   `).body[0].body // Extract only block statement of function body.
 
   // Replace the right-hand side assignment of `const __apm$wrapped = () => {}`.
-  wrapper.body[1].declarations[0].init.body.body[0].declarations[0].init = node
+  query(wrapper, '[id.name=__apm$wrapped]')[0].init = node
 
   return wrapper
 }

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

@@ -91,6 +91,7 @@ const wrappedWorkers = new WeakSet()
 const testSuiteMockedFiles = new Map()
 const testsToBeRetried = new Set()
 const testSuiteAbsolutePathsWithFastCheck = new Set()
+const testSuiteJestObjects = new Map()
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
 const ATR_RETRY_SUPPRESSION_FLAG = '_ddDisableAtrRetry'
@@ -237,6 +238,28 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
+    /**
+     * Jest mock state issue during test retries
+     *
+     * Problem:
+     * - Jest tracks mock function calls using internal state (call count, call arguments, etc.)
+     * - When a test is retried, the mock state is not automatically reset
+     * - This causes assertions like `toHaveBeenCalledTimes(1)` to fail because the call count
+     *   accumulates across retries
+     *
+     * The solution is to clear all mocks before each retry attempt.
+     */
+    resetMockState () {
+      try {
+        const jestObject = testSuiteJestObjects.get(this.testSuiteAbsolutePath)
+        if (jestObject?.clearAllMocks) {
+          jestObject.clearAllMocks()
+        }
+      } catch (e) {
+        log.warn('Error resetting mock state', e)
+      }
+    }
+
     // This function returns an array if the known tests are valid and null otherwise.
     getKnownTestsForSuite (suiteKnownTests) {
       // `suiteKnownTests` is `this.testEnvironmentOptions._ddKnownTests`,
@@ -339,8 +362,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (event.name === 'test_start') {
         const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
         if (testsToBeRetried.has(testName)) {
-          // This is needed because we're trying tests with the same name
+          // This is needed because we're retrying tests with the same name
           this.resetSnapshotState()
+          this.resetMockState()
         }
 
         let isNewTest = false
@@ -864,7 +888,6 @@ function getCliWrapper (isNewJestVersion) {
 
       const {
         results: {
-          success,
           coverageMap,
           numFailedTestSuites,
           numFailedTests,
@@ -883,53 +906,6 @@ function getCliWrapper (isNewJestVersion) {
           // ignore errors
         }
       }
-      let status, error
-
-      if (success) {
-        status = numTotalTests === 0 && numTotalTestSuites === 0 ? 'skip' : 'pass'
-      } else {
-        status = 'fail'
-        error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
-      }
-      let timeoutId
-
-      // Pass the resolve callback to defer it to DC listener
-      const flushPromise = new Promise((resolve) => {
-        onDone = () => {
-          clearTimeout(timeoutId)
-          resolve()
-        }
-      })
-
-      const timeoutPromise = new Promise((resolve) => {
-        timeoutId = setTimeout(() => {
-          resolve('timeout')
-        }, FLUSH_TIMEOUT).unref()
-      })
-
-      testSessionFinishCh.publish({
-        status,
-        isSuitesSkipped,
-        isSuitesSkippingEnabled,
-        isCodeCoverageEnabled,
-        testCodeCoverageLinesTotal,
-        numSkippedSuites,
-        hasUnskippableSuites,
-        hasForcedToRunSuites,
-        error,
-        isEarlyFlakeDetectionEnabled,
-        isEarlyFlakeDetectionFaulty,
-        isTestManagementTestsEnabled,
-        onDone
-      })
-
-      const waitingResult = await Promise.race([flushPromise, timeoutPromise])
-
-      if (waitingResult === 'timeout') {
-        log.error('Timeout waiting for the tracer to flush')
-      }
-
-      numSkippedSuites = 0
 
       /**
        * If Early Flake Detection (EFD) is enabled the logic is as follows:
@@ -938,7 +914,6 @@ function getCliWrapper (isNewJestVersion) {
        * The rationale behind is the following: you may still be able to block your CI pipeline by gating
        * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
        */
-
       if (isEarlyFlakeDetectionEnabled) {
         let numFailedTestsToIgnore = 0
         for (const testStatuses of newTestsTestStatuses.values()) {
@@ -996,6 +971,55 @@ function getCliWrapper (isNewJestVersion) {
         }
       }
 
+      // Determine session status after EFD and quarantine checks have potentially modified success
+      let status, error
+      if (result.results.success) {
+        status = numTotalTests === 0 && numTotalTestSuites === 0 ? 'skip' : 'pass'
+      } else {
+        status = 'fail'
+        error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
+      }
+
+      let timeoutId
+
+      // Pass the resolve callback to defer it to DC listener
+      const flushPromise = new Promise((resolve) => {
+        onDone = () => {
+          clearTimeout(timeoutId)
+          resolve()
+        }
+      })
+
+      const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => {
+          resolve('timeout')
+        }, FLUSH_TIMEOUT).unref()
+      })
+
+      testSessionFinishCh.publish({
+        status,
+        isSuitesSkipped,
+        isSuitesSkippingEnabled,
+        isCodeCoverageEnabled,
+        testCodeCoverageLinesTotal,
+        numSkippedSuites,
+        hasUnskippableSuites,
+        hasForcedToRunSuites,
+        error,
+        isEarlyFlakeDetectionEnabled,
+        isEarlyFlakeDetectionFaulty,
+        isTestManagementTestsEnabled,
+        onDone
+      })
+
+      const waitingResult = await Promise.race([flushPromise, timeoutPromise])
+
+      if (waitingResult === 'timeout') {
+        log.error('Timeout waiting for the tracer to flush')
+      }
+
+      numSkippedSuites = 0
+
       return result
     }, {
       replaceGetter: true
@@ -1148,9 +1172,19 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
         })
       }
       testSuiteFinishCh.publish({ status, errorMessage, testSuiteAbsolutePath: environment.testSuiteAbsolutePath })
+
+      // Cleanup per-suite state to avoid memory leaks
+      testSuiteMockedFiles.delete(environment.testSuiteAbsolutePath)
+      testSuiteJestObjects.delete(environment.testSuiteAbsolutePath)
+
       return suiteResults
     }).catch(error => {
       testSuiteFinishCh.publish({ status: 'fail', error, testSuiteAbsolutePath: environment.testSuiteAbsolutePath })
+
+      // Cleanup per-suite state to avoid memory leaks
+      testSuiteMockedFiles.delete(environment.testSuiteAbsolutePath)
+      testSuiteJestObjects.delete(environment.testSuiteAbsolutePath)
+
       throw error
     })
   })
@@ -1312,6 +1346,11 @@ addHook({
     const result = _createJestObjectFor.apply(this, arguments)
     const suiteFilePath = this._testPath || from
 
+    // Store the jest object so we can access it later for resetting mock state
+    if (suiteFilePath) {
+      testSuiteJestObjects.set(suiteFilePath, result)
+    }
+
     shimmer.wrap(result, 'mock', mock => function (moduleName) {
       // If the library is mocked with `jest.mock`, we don't want to bypass jest's own require engine
       if (LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {

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

@@ -484,10 +484,11 @@ function dispatcherRunWrapper (run) {
 
 function dispatcherRunWrapperNew (run) {
   return function (testGroups) {
-    // Filter out disabled tests from testGroups before they get scheduled
+    // Filter out disabled tests from testGroups before they get scheduled,
+    // unless they have attemptToFix (in which case they should still run and be retried)
     if (isTestManagementTestsEnabled) {
       testGroups.forEach(group => {
-        group.tests = group.tests.filter(test => !test._ddIsDisabled)
+        group.tests = group.tests.filter(test => !test._ddIsDisabled || test._ddIsAttemptToFix)
       })
       // Remove empty groups
       testGroups = testGroups.filter(group => group.tests.length > 0)
@@ -911,14 +912,16 @@ addHook({
       const fileSuitesWithManagedTestsToProjects = new Map()
       for (const test of allTests) {
         const testProperties = getTestProperties(test)
-        // Disabled tests are skipped and not retried
+        // Disabled tests are skipped unless they have attemptToFix
         if (testProperties.disabled) {
           test._ddIsDisabled = true
-          test.expectedStatus = 'skipped'
-          // setting test.expectedStatus to 'skipped' does not work for every case,
-          // so we need to filter out disabled tests in dispatcherRunWrapperNew,
-          // so they don't get to the workers
-          continue
+          if (!testProperties.attemptToFix) {
+            test.expectedStatus = 'skipped'
+            // setting test.expectedStatus to 'skipped' does not work for every case,
+            // so we need to filter out disabled tests in dispatcherRunWrapperNew,
+            // so they don't get to the workers
+            continue
+          }
         }
         if (testProperties.quarantined) {
           test._ddIsQuarantined = true
@@ -947,6 +950,7 @@ addHook({
         (test) => test._ddIsAttemptToFix,
         [
           (test) => test._ddIsQuarantined && '_ddIsQuarantined',
+          (test) => test._ddIsDisabled && '_ddIsDisabled',
           '_ddIsAttemptToFix',
           '_ddIsAttemptToFixRetry'
         ],

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

@@ -5,48 +5,48 @@ const { storage } = require('../../datadog-core')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 
 const {
-  TEST_SKIP_REASON,
-  TEST_STATUS,
-  TEST_SOURCE_START,
+  addIntelligentTestRunnerSpanTags,
   finishAllTraceSpans,
-  getTestSuitePath,
+  getTestEndLine,
   getTestSuiteCommonTags,
-  addIntelligentTestRunnerSpanTags,
-  TEST_ITR_UNSKIPPABLE,
-  TEST_ITR_FORCED_RUN,
-  TEST_CODE_OWNERS,
+  getTestSuitePath,
+  isModifiedTest,
+  CUCUMBER_IS_PARALLEL,
   ITR_CORRELATION_ID,
-  TEST_SOURCE_FILE,
-  TEST_EARLY_FLAKE_ENABLED,
+  TEST_BROWSER_DRIVER,
+  TEST_CODE_OWNERS,
   TEST_EARLY_FLAKE_ABORT_REASON,
+  TEST_EARLY_FLAKE_ENABLED,
+  TEST_HAS_FAILED_ALL_RETRIES,
+  TEST_IS_MODIFIED,
   TEST_IS_NEW,
   TEST_IS_RETRY,
-  CUCUMBER_IS_PARALLEL,
-  TEST_RETRY_REASON,
+  TEST_IS_RUM_ACTIVE,
+  TEST_ITR_FORCED_RUN,
+  TEST_ITR_UNSKIPPABLE,
+  TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED,
   TEST_MANAGEMENT_ENABLED,
-  TEST_MANAGEMENT_IS_QUARANTINED,
-  TEST_MANAGEMENT_IS_DISABLED,
   TEST_MANAGEMENT_IS_ATTEMPT_TO_FIX,
-  TEST_HAS_FAILED_ALL_RETRIES,
-  TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED,
+  TEST_MANAGEMENT_IS_DISABLED,
+  TEST_MANAGEMENT_IS_QUARANTINED,
   TEST_RETRY_REASON_TYPES,
-  TEST_IS_MODIFIED,
-  isModifiedTest,
-  getTestEndLine
+  TEST_RETRY_REASON,
+  TEST_SKIP_REASON,
+  TEST_SOURCE_FILE,
+  TEST_SOURCE_START,
+  TEST_STATUS,
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
 const {
+  TELEMETRY_CODE_COVERAGE_EMPTY,
+  TELEMETRY_CODE_COVERAGE_FINISHED,
+  TELEMETRY_CODE_COVERAGE_NUM_FILES,
+  TELEMETRY_CODE_COVERAGE_STARTED,
   TELEMETRY_EVENT_CREATED,
   TELEMETRY_EVENT_FINISHED,
-  TELEMETRY_CODE_COVERAGE_STARTED,
-  TELEMETRY_CODE_COVERAGE_FINISHED,
   TELEMETRY_ITR_FORCED_TO_RUN,
-  TELEMETRY_CODE_COVERAGE_EMPTY,
   TELEMETRY_ITR_UNSKIPPABLE,
-  TELEMETRY_CODE_COVERAGE_NUM_FILES,
-  TEST_IS_RUM_ACTIVE,
-  TEST_BROWSER_DRIVER,
   TELEMETRY_TEST_SESSION
 } = require('../../dd-trace/src/ci-visibility/telemetry')
 
@@ -362,18 +362,19 @@ class CucumberPlugin extends CiPlugin {
         }
       }
 
+      const spanTags = span.context()._tags
+      const telemetryTags = {
+        hasCodeOwners: !!spanTags[TEST_CODE_OWNERS],
+        isNew,
+        isRum: spanTags[TEST_IS_RUM_ACTIVE] === 'true',
+        browserDriver: spanTags[TEST_BROWSER_DRIVER]
+      }
       span.finish()
       if (!isStep) {
-        const spanTags = span.context()._tags
         this.telemetry.ciVisEvent(
           TELEMETRY_EVENT_FINISHED,
           'test',
-          {
-            hasCodeOwners: !!spanTags[TEST_CODE_OWNERS],
-            isNew,
-            isRum: spanTags[TEST_IS_RUM_ACTIVE] === 'true',
-            browserDriver: spanTags[TEST_BROWSER_DRIVER]
-          }
+          telemetryTags
         )
         finishAllTraceSpans(span)
         // If it's a worker, flushing is cheap, as it's just sending data to the main process