dd-trace 5.96.0 → 5.98.0

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

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const path = require('path')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
@@ -8,6 +11,7 @@ const {
   JEST_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
   JEST_WORKER_TELEMETRY_PAYLOAD_CODE,
+  JEST_WORKER_QUARANTINE_PAYLOAD_CODE,
   getTestLineStart,
   getTestSuitePath,
   getTestParametersString,
@@ -111,6 +115,8 @@ const efdDeterminedRetries = new Map()
 const efdSlowAbortedTests = new Set()
 // Tests added as EFD new-test candidates (not ATF, not impacted).
 const efdNewTestCandidates = new Set()
+// Tests that are genuinely new (not in known tests list).
+const newTests = new Set()
 const testSuiteAbsolutePathsWithFastCheck = new Set()
 const testSuiteJestObjects = new Map()
 
@@ -118,6 +124,38 @@ const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
 const ATR_RETRY_SUPPRESSION_FLAG = '_ddDisableAtrRetry'
 const atrSuppressedErrors = new Map()
 
+// Track quarantined tests whose errors were suppressed, keyed by "suite › testName"
+const quarantinedFailingTests = new Set()
+
+/**
+ * Sends suppressed quarantine test names from a worker process to the main process.
+ * Supports both child_process (process.send) and worker_threads (parentPort.postMessage).
+ * Returns true if the data was sent (worker mode), false if in main process (runInBand).
+ *
+ * @param {string[]} testNames
+ * @returns {boolean}
+ */
+function sendQuarantineInfoToMainProcess (testNames) {
+  const payload = [JEST_WORKER_QUARANTINE_PAYLOAD_CODE, JSON.stringify(testNames)]
+
+  if (process.send) {
+    process.send(payload)
+    return true
+  }
+
+  try {
+    const { isMainThread, parentPort } = require('node:worker_threads')
+    if (!isMainThread && parentPort) {
+      parentPort.postMessage(payload)
+      return true
+    }
+  } catch {
+    // Not in a worker context
+  }
+
+  return false
+}
+
 // based on https://github.com/facebook/jest/blob/main/packages/jest-circus/src/formatNodeAssertErrors.ts#L41
 function formatJestError (errors) {
   let error
@@ -485,7 +523,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
 
         if (this.isKnownTestsEnabled) {
-          isNewTest = retriedTestsToNumAttempts.has(testName)
+          isNewTest = newTests.has(testName)
         }
 
         const willRunEfd = this.isEarlyFlakeDetectionEnabled && (isNewTest || isModified)
@@ -605,6 +643,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
         if (!isAttemptToFix && this.isKnownTestsEnabled) {
           const isNew = !this.knownTestsForThisSuite.includes(testFullName)
+          if (isNew && !isSkipped) {
+            newTests.add(testFullName)
+          }
           if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(testFullName)) {
             if (DYNAMIC_NAME_RE.test(testFullName)) {
               // Populated directly for runInBand; for parallel workers the main process
@@ -715,7 +756,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         let isEfdRetry = false
         // We'll store the test statuses of the retries
         if (this.isKnownTestsEnabled) {
-          const isNewTest = retriedTestsToNumAttempts.has(testName)
+          const isNewTest = newTests.has(testName)
           if (isNewTest) {
             if (newTestsTestStatuses.has(testName)) {
               newTestsTestStatuses.get(testName).push(status)
@@ -748,6 +789,18 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         const willBeRetriedByFailedTestReplay = numRetries > 0 && numTestExecutions - 1 < numRetries
         const mightHitBreakpoint = this.isDiEnabled && numTestExecutions >= 2
 
+        // For quarantined tests, suppress errors so Jest doesn't count them as failures.
+        // This prevents --bail from stopping the test run on quarantined test failures.
+        // The actual status ('fail') is already captured above for dd-trace reporting.
+        // Only suppress on the final execution — not when ATR/EFD/ATF will retry the test.
+        if (!event.test?.[ATR_RETRY_SUPPRESSION_FLAG] && !willBeRetriedByFailedTestReplay) {
+          const quarantineCtx = testContexts.get(event.test)
+          if (quarantineCtx?.isQuarantined && event.test.errors?.length) {
+            quarantinedFailingTests.add(`${quarantineCtx.suite} › ${quarantineCtx.name}`)
+            event.test.errors = []
+          }
+        }
+
         const ctx = testContexts.get(event.test)
         if (!ctx) {
           log.warn('"ci:jest:test_done": no context found for test "%s"', testName)
@@ -776,7 +829,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         // This means that tests retried with DI are BREAKPOINT_HIT_GRACE_PERIOD_MS slower at least.
         if (status === 'fail' && mightHitBreakpoint) {
           await new Promise(resolve => {
-            setTimeout(() => {
+            realSetTimeout(() => {
               resolve()
             }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
           })
@@ -805,12 +858,29 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
       if (event.name === 'run_finish') {
         for (const [test, errors] of atrSuppressedErrors) {
-          test.errors = errors
+          // Do not restore errors for quarantined tests — they should stay suppressed
+          // so Jest doesn't see the failure (prevents --bail from stopping the run).
+          const ctx = testContexts.get(test)
+          if (ctx?.isQuarantined) {
+            const testName = getJestTestName(test, this.getShouldStripSeedFromTestName())
+            quarantinedFailingTests.add(`${ctx.suite} › ${testName}`)
+          } else {
+            test.errors = errors
+          }
         }
         atrSuppressedErrors.clear()
+
+        // In parallel mode, send suppressed quarantine info to the main process
+        // so it can include them in the session summary.
+        // In runInBand mode, keep the set — it will be consumed by the session-level code directly.
+        if (quarantinedFailingTests.size > 0 && sendQuarantineInfoToMainProcess([...quarantinedFailingTests])) {
+          quarantinedFailingTests.clear()
+        }
+
         efdDeterminedRetries.clear()
         efdSlowAbortedTests.clear()
         efdNewTestCandidates.clear()
+        newTests.clear()
         retriedTestsToNumAttempts.clear()
         attemptToFixRetriedTestsStatuses.clear()
         testsToBeRetried.clear()
@@ -1246,6 +1316,7 @@ function getCliWrapper (isNewJestVersion) {
 
       let numFailedQuarantinedTests = 0
       let numFailedQuarantinedOrDisabledAttemptedToFixTests = 0
+      let numSuppressedQuarantinedTests = 0
       if (isTestManagementTestsEnabled) {
         const failedTests = result
           .results
@@ -1282,45 +1353,69 @@ function getCliWrapper (isNewJestVersion) {
           }
         }
 
+        // Include quarantined tests whose errors were suppressed at test_done time.
+        // These tests don't appear as failed in Jest's results because their errors were cleared
+        // to prevent --bail from stopping the run, but they should still be counted for the summary.
+        for (const name of quarantinedFailingTests) {
+          if (!quarantineIgnoredNames.includes(name)) {
+            numSuppressedQuarantinedTests++
+            quarantineIgnoredNames.push(name)
+          }
+        }
+        quarantinedFailingTests.clear()
+
         // If every test that failed was quarantined, we'll consider the suite passed
         // Note that if a test is attempted to fix,
         // it's considered quarantined both if it's disabled and if it's quarantined
         // (it'll run but its status is ignored)
         // Skip if EFD block already flipped (to avoid logging twice)
+        // Only use visible failures (from Jest results) for the flip check.
+        // Suppressed quarantine failures are not in numFailedTests.
+        const visibleQuarantineFailures = numFailedQuarantinedTests + numFailedQuarantinedOrDisabledAttemptedToFixTests
         if (
           !result.results.success &&
           !mustNotFlipSuccess &&
-          (numFailedQuarantinedOrDisabledAttemptedToFixTests !== 0 || numFailedQuarantinedTests !== 0) &&
-          result.results.numFailedTests ===
-            numFailedQuarantinedTests + numFailedQuarantinedOrDisabledAttemptedToFixTests
+          visibleQuarantineFailures !== 0 &&
+          result.results.numFailedTests === visibleQuarantineFailures
         ) {
           result.results.success = true
-          ignoredFailuresSummary = {
-            efdNames: [],
-            quarantineNames: quarantineIgnoredNames,
-            totalCount: numFailedQuarantinedTests + numFailedQuarantinedOrDisabledAttemptedToFixTests,
+        }
+
+        const totalQuarantineFailures = visibleQuarantineFailures + numSuppressedQuarantinedTests
+        if (totalQuarantineFailures > 0) {
+          if (ignoredFailuresSummary) {
+            ignoredFailuresSummary.quarantineNames = quarantineIgnoredNames
+            ignoredFailuresSummary.totalCount += totalQuarantineFailures
+          } else {
+            ignoredFailuresSummary = {
+              efdNames: [],
+              quarantineNames: quarantineIgnoredNames,
+              totalCount: totalQuarantineFailures,
+            }
           }
         }
       }
 
       // Combined check: if all failed tests are accounted for by EFD (flaky retries) and/or quarantine,
       // we should consider the suite passed even when neither check alone covers all failures.
+      // Only visible failures (in Jest results) are compared — suppressed quarantine failures
+      // are already removed from numFailedTests at test_done time.
       if (
         !result.results.success &&
         !mustNotFlipSuccess &&
         (isEarlyFlakeDetectionEnabled || isTestManagementTestsEnabled)
       ) {
-        const totalIgnoredFailures =
+        const visibleIgnoredFailures =
           numEfdFailedTestsToIgnore + numFailedQuarantinedTests + numFailedQuarantinedOrDisabledAttemptedToFixTests
         if (
-          totalIgnoredFailures !== 0 &&
-          result.results.numFailedTests === totalIgnoredFailures
+          visibleIgnoredFailures !== 0 &&
+          result.results.numFailedTests === visibleIgnoredFailures
         ) {
           result.results.success = true
           ignoredFailuresSummary = {
             efdNames: efdIgnoredNames,
             quarantineNames: quarantineIgnoredNames,
-            totalCount: totalIgnoredFailures,
+            totalCount: visibleIgnoredFailures + numSuppressedQuarantinedTests,
           }
         }
       }
@@ -1345,7 +1440,7 @@ function getCliWrapper (isNewJestVersion) {
       })
 
       const timeoutPromise = new Promise((resolve) => {
-        timeoutId = setTimeout(() => {
+        timeoutId = realSetTimeout(() => {
           resolve('timeout')
         }, FLUSH_TIMEOUT).unref()
       })
@@ -1856,6 +1951,12 @@ function onMessageWrapper (onMessage) {
       workerReportTelemetryCh.publish(data)
       return
     }
+    if (code === JEST_WORKER_QUARANTINE_PAYLOAD_CODE) { // quarantined test failures suppressed in worker
+      for (const name of JSON.parse(data)) {
+        quarantinedFailingTests.add(name)
+      }
+      return
+    }
     return onMessage.apply(this, arguments)
   }
 }

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

@@ -14,7 +14,7 @@ function wrapRequest (original) {
 addHook({
   name: 'limitd-client',
   versions: ['>=2.8'],
-  file: ['client.js'],
+  file: 'client.js',
 }, LimitdClient => {
   shimmer.wrap(LimitdClient.prototype, '_directRequest', wrapRequest)
   shimmer.wrap(LimitdClient.prototype, '_retriedRequest', wrapRequest)

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

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const { getTestSuitePath, DYNAMIC_NAME_RE } = require('../../../dd-trace/src/plugins/util/test')
 const { channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
@@ -261,6 +264,14 @@ function getFinalStatus ({
 }) {
   // Note that intermediate executions DO NOT report a final status tag
 
+  // Intermediate EFD and ATF executions must not carry a final status, regardless of quarantine/disabled state
+  const isIntermediateExecution =
+    (isEfdRetry && !isLastEfdRetry) ||
+    (isAttemptToFix && !isLastAttemptToFix)
+  if (isIntermediateExecution) {
+    return
+  }
+
   // If the test is quarantined or disabled, regardless of its actual execution result or active retry features,
   // the final status of its last execution should be reported as 'skip'.
   if (isQuarantined || isDisabled) {
@@ -293,7 +304,7 @@ function getOnTestEndHandler (config) {
     // This means that tests retried with DI are BREAKPOINT_HIT_GRACE_PERIOD_MS slower at least.
     if (test._ddShouldWaitForHitProbe || test._retriedTest?._ddShouldWaitForHitProbe) {
       await new Promise((resolve) => {
-        setTimeout(() => {
+        realSetTimeout(() => {
           resolve()
         }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
       })

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

@@ -16,16 +16,10 @@ const errorTCPCh = channel('apm:net:tcp:error')
 const readyCh = channel('apm:net:tcp:ready')
 const connectionCh = channel('apm:net:tcp:connection')
 
-const names = ['net', 'node:net']
-
-addHook({ name: names }, (net, version, name) => {
+addHook({ name: 'net' }, (net) => {
   // explicitly require dns so that net gets an instrumented instance
   // so that we don't miss the dns calls
-  if (name === 'net') {
-    require('dns')
-  } else {
-    require('node:dns')
-  }
+  require('node:dns')
 
   shimmer.wrap(net.Socket.prototype, 'connect', connect => function () {
     if (!startICPCh.hasSubscribers || !startTCPCh.hasSubscribers) {

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

@@ -97,7 +97,7 @@ addHook({ name: 'pino', versions: ['>=5.14.0 <6.8.0'] }, (pino) => {
   return wrapped
 })
 
-addHook({ name: 'pino', versions: ['>=6.8.0'], patchDefault: false }, (pino, _1, _2, isIitm) => {
+addHook({ name: 'pino', versions: ['>=6.8.0'], patchDefault: false }, (pino) => {
   const mixinSym = pino.symbols.mixinSym
 
   const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino))

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

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const satisfies = require('../../../vendor/dist/semifies')
 
 const shimmer = require('../../datadog-shimmer')
@@ -1216,7 +1219,7 @@ addHook({
 
                 if (isRumActive) {
                   // Give some time RUM to flush data, similar to what we do in selenium
-                  await new Promise(resolve => setTimeout(resolve, RUM_FLUSH_WAIT_TIME))
+                  await new Promise(resolve => realSetTimeout(resolve, RUM_FLUSH_WAIT_TIME))
                   const url = page.url()
                   if (url) {
                     const domain = new URL(url).hostname

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

@@ -136,11 +136,10 @@ function resolveClientDbConfig (clientConfig, datasourceName, runtimeDbConfig) {
 /**
  * @param {unknown} runtime
  * @param {string} versions
- * @param {string} [name]
  * @param {boolean} [isIitm]
  * @returns {object}
  */
-const prismaHook = (runtime, versions, name, isIitm) => {
+const prismaHook = (runtime, versions, isIitm) => {
   /**
    * @typedef {{ getPrismaClient?: (config: PrismaRuntimeConfig, ...args: unknown[]) => Function }} PrismaRuntime
    */

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

@@ -11,6 +11,8 @@ const finishCh = channel('apm:redis:command:finish')
 const errorCh = channel('apm:redis:command:error')
 
 let createClientUrl
+let createClientName
+const instanceInfo = new WeakMap()
 
 function wrapAddCommand (addCommand) {
   return function (command) {
@@ -21,7 +23,7 @@ function wrapAddCommand (addCommand) {
     const name = command[0]
     const args = command.slice(1)
 
-    const ctx = getStartCtx(this, name, args, this._url)
+    const ctx = getStartCtx(this, name, args)
     return startCh.runStores(ctx, () => {
       const res = addCommand.apply(this, arguments)
 
@@ -36,17 +38,16 @@ function wrapCommandQueueClass (cls) {
   const ret = class RedisCommandQueue extends cls {
     constructor (...args) {
       super(...args)
+      let url = { host: 'localhost', port: 6379 }
       if (createClientUrl) {
         try {
           const parsed = new URL(createClientUrl)
-          if (parsed) {
-            this._url = { host: parsed.hostname, port: Number(parsed.port) || 6379 }
-          }
+          url = { host: parsed.hostname, port: Number(parsed.port) || 6379 }
         } catch {
           // ignore
         }
       }
-      this._url = this._url || { host: 'localhost', port: 6379 }
+      instanceInfo.set(this, { connectionName: createClientName, url })
     }
   }
   return ret
@@ -55,8 +56,10 @@ function wrapCommandQueueClass (cls) {
 function wrapCreateClient (request) {
   return function (opts) {
     createClientUrl = opts && opts.url
+    createClientName = opts && opts.name
     const ret = request.apply(this, arguments)
     createClientUrl = undefined
+    createClientName = undefined
     return ret
   }
 }
@@ -134,12 +137,15 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
   return redis
 })
 
-function getStartCtx (client, command, args, url = {}) {
+function getStartCtx (client, command, args) {
+  const { url, connectionName } = instanceInfo.get(client) || {}
+
   return {
     db: client.selected_db,
     command,
     args,
     connectionOptions: client.connection_options || client.connection_option || client.connectionOption || url,
+    connectionName,
   }
 }
 

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

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const shimmer = require('../../datadog-shimmer')
 const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 const { addHook, channel } = require('./helpers/instrument')
@@ -66,7 +69,7 @@ addHook({
     if (isRumActive) {
       // We'll have time for RUM to flush the events (there's no callback to know when it's done)
       await new Promise(resolve => {
-        setTimeout(() => {
+        realSetTimeout(() => {
           resolve()
         }, DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS)
       })

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

@@ -6,7 +6,7 @@ const {
   addHook,
 } = require('./helpers/instrument')
 
-addHook({ name: 'sequelize', versions: ['>=4'], file: ['lib/sequelize.js'] }, Sequelize => {
+addHook({ name: 'sequelize', versions: ['>=4'], file: 'lib/sequelize.js' }, Sequelize => {
   const startCh = channel('datadog:sequelize:query:start')
   const finishCh = channel('datadog:sequelize:query:finish')
 

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

@@ -2,13 +2,11 @@
 
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel } = require('./helpers/instrument')
-const names = ['url', 'node:url']
-
 const parseFinishedChannel = channel('datadog:url:parse:finish')
 const urlGetterChannel = channel('datadog:url:getter:finish')
 const instrumentedGetters = ['host', 'origin', 'hostname']
 
-addHook({ name: names }, function (url) {
+addHook({ name: 'url' }, function (url) {
   shimmer.wrap(url, 'parse', (parse) => {
     return function wrappedParse (input) {
       const parsedValue = parse.apply(this, arguments)

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

@@ -1,4 +1,8 @@
 'use strict'
+
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const path = require('node:path')
 
 const shimmer = require('../../datadog-shimmer')
@@ -83,7 +87,7 @@ function getTestCommand () {
 
 function waitForHitProbe () {
   return new Promise(resolve => {
-    setTimeout(() => {
+    realSetTimeout(() => {
       resolve()
     }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
   })

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

@@ -2,12 +2,10 @@
 
 const shimmer = require('../../datadog-shimmer')
 const { channel, addHook } = require('./helpers/instrument')
-const names = ['vm', 'node:vm']
-
 const runScriptStartChannel = channel('datadog:vm:run-script:start')
 const sourceTextModuleStartChannel = channel('datadog:vm:source-text-module:start')
 
-addHook({ name: names }, function (vm) {
+addHook({ name: 'vm' }, function (vm) {
   vm.Script = class extends vm.Script {
     constructor (code) {
       super(...arguments)

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -23,12 +23,13 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     return id
   }
 
+  /** @type {import('../../dd-trace/src/config/config-types').ConfigProperties['cloudPayloadTagging']} */
   get cloudTaggingConfig () {
     return this._tracerConfig.cloudPayloadTagging
   }
 
   get payloadTaggingRules () {
-    return this.cloudTaggingConfig.rules.aws?.[this.constructor.id]
+    return this.cloudTaggingConfig.rules?.aws?.[this.constructor.id]
   }
 
   constructor (...args) {
@@ -55,7 +56,6 @@ class BaseAwsSdkPlugin extends ClientPlugin {
 
       const meta = {
         'span.kind': 'client',
-        'service.name': this.serviceName(),
         'aws.operation': operation,
         'aws.region': awsRegion,
         region: awsRegion,
@@ -69,6 +69,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
       const span = this.startSpan(this.operationFromRequest(request), {
         childOf,
         meta,
+        service: this.serviceName(),
         integrationName: 'aws-sdk',
       }, ctx)
 
@@ -78,7 +79,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
         this.requestInject(span, request)
       })
 
-      if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.requestsEnabled) {
+      if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.request) {
         const maxDepth = this.cloudTaggingConfig.maxDepth
         const requestTags = tagsFromRequest(this.payloadTaggingRules, request.params, { maxDepth })
         span.addTags(requestTags)
@@ -215,7 +216,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
 
     span.addTags(tags)
 
-    if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.responsesEnabled) {
+    if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.response) {
       const maxDepth = this.cloudTaggingConfig.maxDepth
       const responseBody = this.extractResponseBody(response)
       const responseTags = tagsFromResponse(this.payloadTaggingRules, responseBody, { maxDepth })

package/packages/datadog-plugin-aws-sdk/src/services/dynamodb.js

@@ -40,6 +40,7 @@ class DynamoDb extends BaseAwsSdkPlugin {
 
     // Also add span type to match serverless convention
     tags['span.type'] = 'dynamodb'
+    tags['db.system'] = 'aws.dynamodb'
 
     return tags
   }

package/packages/datadog-plugin-aws-sdk/src/services/eventbridge.js

@@ -12,6 +12,7 @@ class EventBridge extends BaseAwsSdkPlugin {
     return {
       'resource.name': operation ? `${operation} ${params.source}` : params.source,
       'aws.eventbridge.source': `${params.source}`,
+      'messaging.system': 'aws_eventbridge',
       rulename: `${rulename}`,
     }
   }

package/packages/datadog-plugin-aws-sdk/src/services/kinesis.js

@@ -68,6 +68,7 @@ class Kinesis extends BaseAwsSdkPlugin {
     return {
       'resource.name': `${operation} ${params.StreamName}`,
       'aws.kinesis.stream_name': params.StreamName,
+      'messaging.system': 'aws_kinesis',
       streamname: params.StreamName,
     }
   }

package/packages/datadog-plugin-aws-sdk/src/services/redshift.js

@@ -11,6 +11,7 @@ class Redshift extends BaseAwsSdkPlugin {
     return {
       'resource.name': `${operation} ${params.ClusterIdentifier}`,
       'aws.redshift.cluster_identifier': params.ClusterIdentifier,
+      'db.system': 'aws.redshift',
       clusteridentifier: params.ClusterIdentifier,
     }
   }

package/packages/datadog-plugin-aws-sdk/src/services/sns.js

@@ -24,6 +24,7 @@ class Sns extends BaseAwsSdkPlugin {
     return {
       'resource.name': `${operation} ${params.TopicArn || response.data.TopicArn}`,
       'aws.sns.topic_arn': TopicArn,
+      'messaging.system': 'aws.sns',
       topicname: topicName,
     }
 

package/packages/datadog-plugin-aws-sdk/src/services/sqs.js

@@ -100,6 +100,7 @@ class Sqs extends BaseAwsSdkPlugin {
     const tags = {
       'resource.name': `${operation} ${params.QueueName || params.QueueUrl}`,
       'aws.sqs.queue_name': params.QueueName || params.QueueUrl,
+      'messaging.system': 'aws_sqs',
       queuename: queueName,
     }
 

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

@@ -1,5 +1,9 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realDateNow = Date.now.bind(Date)
+const realSetTimeout = setTimeout
+
 const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
@@ -33,6 +37,7 @@ const {
   TEST_SOURCE_FILE,
   TEST_SOURCE_START,
   TEST_STATUS,
+  TEST_FINAL_STATUS,
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
@@ -229,7 +234,7 @@ class CucumberPlugin extends CiPlugin {
       // Time we give the breakpoint to be hit
       if (promises && this.runningTestProbe) {
         promises.hitBreakpointPromise = new Promise((resolve) => {
-          setTimeout(resolve, BREAKPOINT_HIT_GRACE_PERIOD_MS)
+          realSetTimeout(resolve, BREAKPOINT_HIT_GRACE_PERIOD_MS)
         })
       }
 
@@ -252,8 +257,8 @@ class CucumberPlugin extends CiPlugin {
           const { file, line, stackIndex } = probeInformation
           this.runningTestProbe = { file, line }
           this.testErrorStackIndex = stackIndex
-          const waitUntil = Date.now() + BREAKPOINT_SET_GRACE_PERIOD_MS
-          while (Date.now() < waitUntil) {
+          const waitUntil = realDateNow() + BREAKPOINT_SET_GRACE_PERIOD_MS
+          while (realDateNow() < waitUntil) {
             // TODO: To avoid a race condition, we should wait until `probeInformation.setProbePromise` has resolved.
             // However, Cucumber doesn't have a mechanism for waiting asyncrounously here, so for now, we'll have to
             // fall back to a fixed syncronous delay.
@@ -303,11 +308,16 @@ class CucumberPlugin extends CiPlugin {
       isDisabled,
       isQuarantined,
       isModified,
+      finalStatus,
     }) => {
       const statusTag = isStep ? 'step.status' : TEST_STATUS
 
       span.setTag(statusTag, status)
 
+      if (finalStatus) {
+        span.setTag(TEST_FINAL_STATUS, finalStatus)
+      }
+
       if (isNew) {
         span.setTag(TEST_IS_NEW, 'true')
         if (isEfdRetry) {