dd-trace 5.97.0 → 5.99.0

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/modelcontextprotocol-sdk.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { addHook, getHooks } = require('./helpers/instrument')
+
+for (const hook of getHooks('@modelcontextprotocol/sdk')) {
+  addHook(hook, exports => exports)
+}

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

@@ -34,22 +34,6 @@ function wrapAsJson (asJson) {
   }
 }
 
-function wrapMixin (mixin) {
-  const ch = channel('apm:pino:log')
-  return function mixinWithTrace () {
-    let obj = {}
-
-    if (mixin) {
-      obj = mixin.apply(this, arguments)
-    }
-
-    const payload = { message: obj }
-    ch.publish(payload)
-
-    return payload.message
-  }
-}
-
 function wrapPrettifyObject (prettifyObject) {
   const ch = channel('apm:pino:log')
   return function prettifyObjectWithTrace (input) {
@@ -81,26 +65,18 @@ addHook({ name: 'pino', versions: ['2 - 3', '4'], patchDefault: true }, (pino) =
   return wrapped
 })
 
-addHook({ name: 'pino', versions: ['>=5 <5.14.0'], patchDefault: true }, (pino) => {
+addHook({ name: 'pino', versions: ['>=5 <6.8.0'], patchDefault: true }, (pino) => {
   const asJsonSym = ((pino.default || pino)?.symbols.asJsonSym) || 'asJson'
 
-  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
-
-  return wrapped
-})
-
-addHook({ name: 'pino', versions: ['>=5.14.0 <6.8.0'] }, (pino) => {
-  const mixinSym = (pino.default || pino).symbols.mixinSym
-
-  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino.default || pino))
+  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino.default || pino))
 
   return wrapped
 })
 
 addHook({ name: 'pino', versions: ['>=6.8.0'], patchDefault: false }, (pino) => {
-  const mixinSym = pino.symbols.mixinSym
+  const asJsonSym = pino.symbols.asJsonSym
 
-  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino))
+  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
   wrapped.pino = wrapped
   wrapped.default = wrapped
 

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

@@ -0,0 +1,27 @@
+'use strict'
+
+// Serialized into chromium via Playwright's `page.evaluate`. Excluded from coverage by filename.
+// Rename only if you update that glob too.
+
+/** @returns {{ isRumInstrumented: boolean, isRumActive: boolean, rumSamplingRate: number | null }} */
+function detectRum () {
+  const isRumInstrumented = !!window.DD_RUM
+  const isRumActive = window.DD_RUM && window.DD_RUM.getInternalContext
+    ? !!window.DD_RUM.getInternalContext()
+    : false
+  const rumSamplingRate = window.DD_RUM && window.DD_RUM.getInitConfiguration
+    ? window.DD_RUM.getInitConfiguration().sessionSampleRate
+    : null
+  return { isRumInstrumented, isRumActive, rumSamplingRate }
+}
+
+/** @returns {boolean} */
+function stopRumSession () {
+  if (window.DD_RUM && window.DD_RUM.stopSession) {
+    window.DD_RUM.stopSession()
+    return true
+  }
+  return false
+}
+
+module.exports = { detectRum, stopRumSession }

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

@@ -52,6 +52,9 @@ let applyRepeatEachIndex = null
 
 let startedSuites = []
 
+// Browser-side callbacks live in a coverage-excluded file so coverage counters can't reach chromium.
+const { detectRum, stopRumSession } = require('./playwright-browser-scripts')
+
 const STATUS_TO_TEST_STATUS = {
   passed: 'pass',
   failed: 'fail',
@@ -1117,16 +1120,7 @@ addHook({
 
     try {
       if (page) {
-        const { isRumInstrumented, isRumActive, rumSamplingRate } = await page.evaluate(() => {
-          const isRumInstrumented = !!window.DD_RUM
-          const isRumActive = window.DD_RUM && window.DD_RUM.getInternalContext
-            ? !!window.DD_RUM.getInternalContext()
-            : false
-          const rumSamplingRate = window.DD_RUM && window.DD_RUM.getInitConfiguration
-            ? window.DD_RUM.getInitConfiguration().sessionSampleRate
-            : null
-          return { isRumInstrumented, isRumActive, rumSamplingRate }
-        })
+        const { isRumInstrumented, isRumActive, rumSamplingRate } = await page.evaluate(detectRum)
         if (isRumInstrumented && rumSamplingRate < 100 && !isRumActive) {
           log.debug("RUM was detected on the page, but it isn't active because the sampling rate is below 100%")
         }
@@ -1209,13 +1203,7 @@ addHook({
           fn: async function ({ page }) {
             try {
               if (page) {
-                const isRumActive = await page.evaluate(() => {
-                  if (window.DD_RUM && window.DD_RUM.stopSession) {
-                    window.DD_RUM.stopSession()
-                    return true
-                  }
-                  return false
-                })
+                const isRumActive = await page.evaluate(stopRumSession)
 
                 if (isRumActive) {
                   // Give some time RUM to flush data, similar to what we do in selenium

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/stripe.js

@@ -58,35 +58,49 @@ function wrapConstructEventAsync (constructEventAsync) {
   }
 }
 
-function wrapStripe (Stripe) {
+function instrumentStripeInstance (stripe) {
+  if (typeof stripe.checkout?.sessions?.create === 'function') {
+    shimmer.wrap(stripe.checkout.sessions, 'create', wrapSessionCreate)
+  }
+  if (typeof stripe.paymentIntents?.create === 'function') {
+    shimmer.wrap(stripe.paymentIntents, 'create', wrapPaymentIntentCreate)
+  }
+  if (typeof stripe.webhooks?.constructEvent === 'function') {
+    shimmer.wrap(stripe.webhooks, 'constructEvent', wrapConstructEvent)
+  }
+  if (typeof stripe.webhooks?.constructEventAsync === 'function') {
+    shimmer.wrap(stripe.webhooks, 'constructEventAsync', wrapConstructEventAsync)
+  }
+}
+
+// stripe <22: the constructor mutates this (when invoked with 'new') and
+// returns nothing; without 'new' it delegates to 'new Stripe(...)' and returns
+// that result. We need to instrument whichever object actually got populated
+function wrapLegacyStripe (Stripe) {
   return function wrappedStripe () {
-    let stripe = Stripe.apply(this, arguments)
-
-    // to support both with and without "new" operator syntax
-    if (this instanceof Stripe) {
-      stripe = this
-    }
-
-    if (typeof stripe.checkout?.sessions?.create === 'function') {
-      shimmer.wrap(stripe.checkout.sessions, 'create', wrapSessionCreate)
-    }
-    if (typeof stripe.paymentIntents?.create === 'function') {
-      shimmer.wrap(stripe.paymentIntents, 'create', wrapPaymentIntentCreate)
-    }
-    if (typeof stripe.webhooks?.constructEvent === 'function') {
-      shimmer.wrap(stripe.webhooks, 'constructEvent', wrapConstructEvent)
-    }
-    if (typeof stripe.webhooks?.constructEventAsync === 'function') {
-      shimmer.wrap(stripe.webhooks, 'constructEventAsync', wrapConstructEventAsync)
-    }
+    const result = Stripe.apply(this, arguments)
+    const stripe = this instanceof Stripe ? this : result
+    instrumentStripeInstance(stripe)
+    return stripe
+  }
+}
 
+// stripe >=22: the constructor is a factory that always returns a fresh Stripe
+// instance regardless of 'new', so we just instrument and forward the result
+function wrapStripe (Stripe) {
+  return function wrappedStripe () {
+    const stripe = Stripe.apply(this, arguments)
+    instrumentStripeInstance(stripe)
     return stripe
   }
 }
 
 addHook({
   name: 'stripe',
-  versions: ['9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '>=20.0.0'],
-}, Stripe => {
-  return shimmer.wrapFunction(Stripe, wrapStripe)
-})
+  versions: ['9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '>=20.0.0 <22'],
+}, Stripe => shimmer.wrapFunction(Stripe, wrapLegacyStripe))
+
+addHook({
+  name: 'stripe',
+  versions: ['>=22'],
+}, Stripe => shimmer.wrapFunction(Stripe, wrapStripe))

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

@@ -866,6 +866,9 @@ function wrapVitestTestRunner (VitestTestRunner) {
       } else {
         testPassCh.publish({ task, ...ctx.currentStore })
       }
+      if (shouldFlipStatus) {
+        task.result.state = 'pass'
+      }
     }
 
     const isRetryReasonAtr = numAttempt > 0 &&
@@ -1174,7 +1177,12 @@ addHook({
           })
         } else if (state === 'pass' && !isSwitchedStatus) {
           if (testCtx) {
-            testPassCh.publish({ task, ...testCtx.currentStore })
+            testPassCh.publish({
+              task,
+              finalStatus:
+                disabledTasks.has(task) || quarantinedTasks.has(task) ? 'skip' : 'pass',
+              ...testCtx.currentStore,
+            })
           }
         } else if (state === 'fail' || isSwitchedStatus) {
           let testError
@@ -1197,7 +1205,9 @@ addHook({
 
           // Check if all EFD retries failed
           const providedContext = getProvidedContext()
-          if (providedContext.isEarlyFlakeDetectionEnabled && (newTasks.has(task) || modifiedTasks.has(task))) {
+          const isEfdRetry =
+            providedContext.isEarlyFlakeDetectionEnabled && (newTasks.has(task) || modifiedTasks.has(task))
+          if (isEfdRetry) {
             const statuses = taskToStatuses.get(task)
             // statuses only includes repetitions (not the initial run), so we check against numRepeats (not +1)
             if (statuses && statuses.length === providedContext.numRepeats &&
@@ -1207,8 +1217,9 @@ addHook({
           }
 
           // ATR: set hasFailedAllRetries when all auto test retries were exhausted and every attempt failed
-          if (providedContext.isFlakyTestRetriesEnabled && !attemptToFixTasks.has(task) &&
-            !newTasks.has(task) && !modifiedTasks.has(task)) {
+          const isAtrRetry = providedContext.isFlakyTestRetriesEnabled && !attemptToFixTasks.has(task) &&
+            !newTasks.has(task) && !modifiedTasks.has(task)
+          if (isAtrRetry) {
             const maxRetries = providedContext.flakyTestRetriesCount ?? 0
             if (maxRetries > 0 && task.result?.retryCount === maxRetries) {
               hasFailedAllRetries = true
@@ -1218,11 +1229,28 @@ addHook({
           if (testCtx) {
             const isRetry = task.result?.retryCount > 0
             // `duration` is the duration of all the retries, so it can't be used if there are retries
+
+            let finalStatus
+            if (isSwitchedStatus) {
+              if (disabledTasks.has(task) || quarantinedTasks.has(task)) {
+                finalStatus = 'skip'
+              } else if (isAtrRetry || isEfdRetry) {
+                finalStatus = hasFailedAllRetries ? 'fail' : 'pass'
+              } else if (attemptToFixTasks.has(task)) {
+                finalStatus = attemptToFixFailed ? 'fail' : 'pass'
+              } else {
+                finalStatus = undefined
+              }
+            } else {
+              finalStatus = 'fail'
+            }
+
             testErrorCh.publish({
               duration: isRetry ? undefined : duration,
               error: testError,
               hasFailedAllRetries,
               attemptToFixFailed,
+              finalStatus,
               ...testCtx.currentStore,
             })
           }

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

@@ -0,0 +1,29 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook } = require('./helpers/instrument')
+const { createCallbackInstrumentor } = require('./helpers/callback-instrumentor')
+
+const asyncMethods = [
+  'brotliCompress',
+  'brotliDecompress',
+  'deflate',
+  'deflateRaw',
+  'gunzip',
+  'gzip',
+  'inflate',
+  'inflateRaw',
+  'unzip',
+  'zstdCompress', // Node 22.15+ / 23.8+ / 24+
+  'zstdDecompress', // Node 22.15+ / 23.8+ / 24+
+]
+
+addHook({ name: 'zlib' }, zlib => {
+  const instrument = createCallbackInstrumentor('apm:zlib:operation')
+  for (const method of asyncMethods) {
+    if (typeof zlib[method] === 'function') {
+      shimmer.wrap(zlib, method, instrument(() => ({ operation: method })))
+    }
+  }
+  return zlib
+})

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)
 
@@ -197,8 +197,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
 
   isEnabled (request) {
     const serviceId = this.serviceIdentifier.toUpperCase()
-    const envVarValue = getValueFromEnvSources(`DD_TRACE_AWS_SDK_${serviceId}_ENABLED`)
-    return envVarValue ? isTrue(envVarValue) : true
+    return this._tracerConfig[`DD_TRACE_AWS_SDK_${serviceId}_ENABLED`] ?? true
   }
 
   addResponseTags (span, response) {

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,
     }