dd-trace 5.97.0 → 5.98.0

package/index.d.ts

@@ -665,7 +665,15 @@ declare namespace tracer {
        * @env DD_RUNTIME_METRICS_EVENT_LOOP_ENABLED
        * Programmatic configuration takes precedence over the environment variables listed above.
        */
-      eventLoop?: boolean
+      eventLoop?: boolean,
+
+       /**
+       * Whether to use native metrics. When set to false, forces the JS implementation
+       * @default true
+       * @env DD_RUNTIME_METRICS_NATIVE
+       * Programmatic configuration takes precedence over the environment variables listed above.
+       */
+      native?: boolean
     }
 
     /**
@@ -795,7 +803,7 @@ declare namespace tracer {
          * Whether to request blocking mode when evaluating prompts via auto-instrumentation.
          * When `true`, AI Guard will block requests that violate security policies.
          * When `false`, AI Guard evaluates but never blocks (monitor-only mode).
-         * @default false
+         * @default true
          * @env DD_AI_GUARD_BLOCK
          * Programmatic configuration takes precedence over the environment variables listed above.
          */
@@ -1847,6 +1855,10 @@ declare namespace tracer {
        * List of tags associated with the evaluation (e.g. indirect-prompt-injection)
        */
       tags: string[];
+      /**
+       * Dictionary of tag probabilities (e.g. { indirect-prompt-injection: 0.2, jailbreak-attempt: 0.8 })
+       */
+      tagProbabilities: { [key: string]: number }
       /**
        * Sensitive Data Scanner findings from the evaluation.
        */
@@ -1866,6 +1878,10 @@ declare namespace tracer {
        * List of tags associated with the evaluation (e.g. indirect-prompt-injection)
        */
       tags: string[];
+      /**
+       * Dictionary of tag probabilities (e.g. { indirect-prompt-injection: 0.2, jailbreak-attempt: 0.8 })
+       */
+      tagProbabilities: { [key: string]: number }
       /**
        * Sensitive Data Scanner findings from the evaluation.
        */
@@ -3048,6 +3064,14 @@ declare namespace tracer {
        * @returns true to instrument the command, false to skip it
        */
       filter?: (command: string) => boolean;
+
+      /**
+       * Whether to use a different service name for each Redis instance based
+       * on the configured connection name of the client.
+       *
+       * @default false
+       */
+      splitByInstance?: boolean;
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.97.0",
+  "version": "5.98.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

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

@@ -235,6 +235,40 @@ function getPickleByFile (runtimeOrCoodinator) {
   }, {})
 }
 
+function getFinalStatus ({
+  status,
+  hasFailedAllRetries,
+  isLastAtrRetry,
+  isLastEfdRetry,
+  isLastAttemptToFix,
+  hasPassedAllRetries,
+  isQuarantined,
+  isDisabled,
+}) {
+  // Note that intermediate executions DO NOT report a final status tag
+
+  // 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 || status === 'skip') {
+    return 'skip'
+  }
+
+  // When no retry feature is active, every execution is final
+  if (!isLastAtrRetry && !isLastEfdRetry && !isLastAttemptToFix) {
+    return status
+  }
+
+  // ATR and EFD: pass unless every attempt failed
+  if (isLastAtrRetry || isLastEfdRetry) {
+    return hasFailedAllRetries ? 'fail' : 'pass'
+  }
+
+  // Branch for ATF (We need to check hasPassedAllRetries)
+  if (isLastAttemptToFix) {
+    return hasPassedAllRetries ? 'pass' : 'fail'
+  }
+}
+
 function wrapRun (pl, isLatestVersion, version) {
   if (patched.has(pl)) return
 
@@ -262,7 +296,7 @@ function wrapRun (pl, isLatestVersion, version) {
     testStartCh.runStores(ctx, () => {})
     const promises = {}
     try {
-      this.eventBroadcaster.on('envelope', async (testCase) => {
+      const onEnvelope = async (testCase) => {
         // Only supported from >=8.0.0
         if (testCase?.testCaseFinished) {
           const { testCaseFinished: { willBeRetried } } = testCase
@@ -280,7 +314,7 @@ function wrapRun (pl, isLatestVersion, version) {
             const isAtrRetry = !isFirstAttempt && isFlakyTestRetriesEnabled
 
             // ATR: record this attempt as failed so when run().finally runs (after retry) we have all statuses
-            if (isFlakyTestRetriesEnabled && isAtrRetry === false) {
+            if (isFlakyTestRetriesEnabled) {
               const nameForKey = this.pickle.name.replace(/\s*\(attempt \d+(?:, retried)?\)\s*$/, '')
               const atrKey = `${this.pickle.uri}:${nameForKey}`
               if (atrStatusesByScenarioKey.has(atrKey)) {
@@ -303,13 +337,15 @@ function wrapRun (pl, isLatestVersion, version) {
             testStartCh.runStores(newCtx, () => {})
           }
         }
-      })
+      }
+      this.eventBroadcaster.on('envelope', onEnvelope)
       let promise
 
       testFnCh.runStores(ctx, () => {
         promise = run.apply(this, arguments)
       })
       promise.finally(async () => {
+        this.eventBroadcaster.removeListener('envelope', onEnvelope)
         const result = this.getWorstStepResult()
         const { status, skipReason } = isLatestVersion
           ? getStatusFromResultLatest(result)
@@ -408,6 +444,31 @@ function wrapRun (pl, isLatestVersion, version) {
         if (promises.hitBreakpointPromise) {
           await promises.hitBreakpointPromise
         }
+
+        // Notice that ATR is handled using cucumber native retries features.
+        // Therefore, if we reach this point, we are certain that it's the last ATR execution
+        const isLastAtrRetry = isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0
+
+        const statuses = lastStatusByPickleId.get(this.pickle.id)
+        const isLastEfdRetry = isEfdRetry && statuses?.length === earlyFlakeDetectionNumRetries + 1
+        const isLastAttemptToFixRetry = isAttemptToFix && statuses?.length === testManagementAttemptToFixRetries + 1
+
+        // Intermediate (non-last EFD or ATF retries) executions do not report a final status
+        const isIntermediateExecution = (isEfdRetry && !isLastEfdRetry) || (isAttemptToFix && !isLastAttemptToFixRetry)
+
+        const finalStatus = isIntermediateExecution
+          ? undefined
+          : getFinalStatus({
+            status,
+            hasFailedAllRetries,
+            isLastAtrRetry,
+            isLastEfdRetry,
+            isLastAttemptToFix: isLastAttemptToFixRetry,
+            hasPassedAllRetries,
+            isQuarantined,
+            isDisabled,
+          })
+
         testFinishCh.publish({
           status,
           skipReason,
@@ -424,6 +485,7 @@ function wrapRun (pl, isLatestVersion, version) {
           isQuarantined,
           isModified,
           ...attemptCtx.currentStore,
+          finalStatus,
         })
       })
       return promise

package/packages/datadog-instrumentations/src/cypress-config.js

@@ -4,9 +4,21 @@ const fs = require('fs')
 const os = require('os')
 const path = require('path')
 const { pathToFileURL } = require('url')
+const { channel } = require('./helpers/instrument')
 
 const DD_CONFIG_WRAPPED = Symbol('dd-trace.cypress.config.wrapped')
 
+const setupNodeEventsCh = channel('ci:cypress:setup-node-events')
+
+// Ensure the cypress plugin is loaded so it can subscribe to our channel.
+// Normally, plugins are loaded when their npm module is required (via addHook),
+// but plain-object configs don't require('cypress'), so the plugin would never
+// be instantiated in the Cypress Config Manager child process.
+const loadCh = channel('dd-trace:instrumentation:load')
+if (loadCh.hasSubscribers) {
+  loadCh.publish({ name: 'cypress' })
+}
+
 const noopTask = {
   'dd:testSuiteStart': () => null,
   'dd:beforeEach': () => ({}),
@@ -93,8 +105,9 @@ function injectSupportFile (config) {
 
 /**
  * Registers dd-trace's Cypress hooks (before:run, after:spec, after:run, tasks)
- * and injects the support file. Handles chaining with user-registered handlers
- * for after:spec/after:run so both the user's code and dd-trace's run in sequence.
+ * and injects the support file. Communicates with the plugin layer via
+ * the `ci:cypress:setup-node-events` diagnostic channel, avoiding direct
+ * tracer references in the instrumentation layer.
  *
  * @param {Function} on Cypress event registration function
  * @param {object} config Cypress resolved config object
@@ -111,8 +124,6 @@ function registerDdTraceHooks (on, config, userAfterSpecHandlers, userAfterRunHa
     }
   }
 
-  const tracer = global._ddtrace
-
   const registerAfterRunWithCleanup = () => {
     on('after:run', (results) => {
       const chain = userAfterRunHandlers.reduce(
@@ -129,49 +140,32 @@ function registerDdTraceHooks (on, config, userAfterSpecHandlers, userAfterRunHa
     on('task', noopTask)
   }
 
-  if (!tracer || !tracer._initialized) {
+  if (!setupNodeEventsCh.hasSubscribers) {
     registerNoopHandlers()
     return config
   }
 
-  const NoopTracer = require('../../../packages/dd-trace/src/noop/tracer')
-
-  if (tracer._tracer instanceof NoopTracer) {
-    registerNoopHandlers()
-    return config
+  // Publish to the plugin layer via diagnostic channel.
+  // The subscriber sets `payload.registered = true` and optionally
+  // `payload.configPromise` when it handles the event.
+  const payload = {
+    on,
+    config,
+    userAfterSpecHandlers,
+    userAfterRunHandlers,
+    cleanupWrapper,
+    registered: false,
+    configPromise: undefined,
   }
 
-  const cypressPlugin = require('../../../packages/datadog-plugin-cypress/src/cypress-plugin')
+  setupNodeEventsCh.publish(payload)
 
-  if (cypressPlugin._isInit) {
-    for (const h of userAfterSpecHandlers) on('after:spec', h)
-    registerAfterRunWithCleanup()
+  if (!payload.registered) {
+    registerNoopHandlers()
     return config
   }
 
-  on('before:run', cypressPlugin.beforeRun.bind(cypressPlugin))
-
-  on('after:spec', (spec, results) => {
-    const chain = userAfterSpecHandlers.reduce(
-      (p, h) => p.then(() => h(spec, results)),
-      Promise.resolve()
-    )
-    return chain.then(() => cypressPlugin.afterSpec(spec, results))
-  })
-
-  on('after:run', (results) => {
-    const chain = userAfterRunHandlers.reduce(
-      (p, h) => p.then(() => h(results)),
-      Promise.resolve()
-    )
-    return chain
-      .then(() => cypressPlugin.afterRun(results))
-      .finally(cleanupWrapper)
-  })
-
-  on('task', cypressPlugin.getTasks())
-
-  return Promise.resolve(cypressPlugin.init(tracer, config)).then(() => config)
+  return payload.configPromise || config
 }
 
 /**

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

@@ -11,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,
@@ -123,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
@@ -756,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)
@@ -813,9 +858,25 @@ 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()
@@ -1255,6 +1316,7 @@ function getCliWrapper (isNewJestVersion) {
 
       let numFailedQuarantinedTests = 0
       let numFailedQuarantinedOrDisabledAttemptedToFixTests = 0
+      let numSuppressedQuarantinedTests = 0
       if (isTestManagementTestsEnabled) {
         const failedTests = result
           .results
@@ -1291,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,
           }
         }
       }
@@ -1865,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/mocha/utils.js

@@ -264,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) {

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-plugin-aws-sdk/src/base.js

@@ -56,7 +56,6 @@ class BaseAwsSdkPlugin extends ClientPlugin {
 
       const meta = {
         'span.kind': 'client',
-        'service.name': this.serviceName(),
         'aws.operation': operation,
         'aws.region': awsRegion,
         region: awsRegion,
@@ -70,6 +69,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
       const span = this.startSpan(this.operationFromRequest(request), {
         childOf,
         meta,
+        service: this.serviceName(),
         integrationName: 'aws-sdk',
       }, ctx)
 

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

@@ -37,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')
@@ -307,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) {