dd-trace 5.52.0 → 5.53.0

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

@@ -26,7 +26,7 @@ const knownTestsCh = channel('ci:vitest:known-tests')
 const isEarlyFlakeDetectionFaultyCh = channel('ci:vitest:is-early-flake-detection-faulty')
 const testManagementTestsCh = channel('ci:vitest:test-management-tests')
 
-const taskToAsync = new WeakMap()
+const taskToCtx = new WeakMap()
 const taskToStatuses = new WeakMap()
 const newTasks = new WeakSet()
 const disabledTasks = new WeakSet()
@@ -455,7 +455,7 @@ addHook({
   // test start (only tests that are not marked as skip or todo)
   // `onBeforeTryTask` is run for every repetition and attempt of the test
   shimmer.wrap(VitestTestRunner.prototype, 'onBeforeTryTask', onBeforeTryTask => async function (task, retryInfo) {
-    if (!testStartCh.hasSubscribers) {
+    if (!testPassCh.hasSubscribers && !testErrorCh.hasSubscribers && !testSkipCh.hasSubscribers) {
       return onBeforeTryTask.apply(this, arguments)
     }
     const testName = getTestName(task)
@@ -500,15 +500,14 @@ addHook({
 
       const promises = {}
       const shouldSetProbe = isDiEnabled && numAttempt === 1
-      const asyncResource = taskToAsync.get(task)
+      const ctx = taskToCtx.get(task)
       const testError = task.result?.errors?.[0]
-      if (asyncResource) {
-        asyncResource.runInAsyncScope(() => {
-          testErrorCh.publish({
-            error: testError,
-            shouldSetProbe,
-            promises
-          })
+      if (ctx) {
+        testErrorCh.publish({
+          error: testError,
+          shouldSetProbe,
+          promises,
+          ...ctx.currentStore
         })
         // We wait for the probe to be set
         if (promises.setProbePromise) {
@@ -528,17 +527,13 @@ addHook({
       // as long as it's not the _last_ iteration (which will be finished normally)
 
       // TODO: check test duration (not to repeat if it's too slow)
-      const asyncResource = taskToAsync.get(task)
-      if (asyncResource) {
+      const ctx = taskToCtx.get(task)
+      if (ctx) {
         if (lastExecutionStatus === 'fail') {
           const testError = task.result?.errors?.[0]
-          asyncResource.runInAsyncScope(() => {
-            testErrorCh.publish({ error: testError })
-          })
+          testErrorCh.publish({ error: testError, ...ctx.currentStore })
         } else {
-          asyncResource.runInAsyncScope(() => {
-            testPassCh.publish({ task })
-          })
+          testPassCh.publish({ task, ...ctx.currentStore })
         }
         if (shouldFlipStatus) {
           statuses.push(lastExecutionStatus)
@@ -555,16 +550,12 @@ addHook({
         statuses.push(lastExecutionStatus)
       }
 
-      const asyncResource = taskToAsync.get(task)
+      const ctx = taskToCtx.get(task)
       if (lastExecutionStatus === 'fail') {
         const testError = task.result?.errors?.[0]
-        asyncResource.runInAsyncScope(() => {
-          testErrorCh.publish({ error: testError })
-        })
+        testErrorCh.publish({ error: testError, ...ctx.currentStore })
       } else {
-        asyncResource.runInAsyncScope(() => {
-          testPassCh.publish({ task })
-        })
+        testPassCh.publish({ task, ...ctx.currentStore })
       }
     }
 
@@ -573,31 +564,29 @@ addHook({
       !isRetryReasonAttemptToFix &&
       !isRetryReasonEfd
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-    taskToAsync.set(task, asyncResource)
+    const ctx = {
+      testName,
+      testSuiteAbsolutePath: task.file.filepath,
+      isRetry: numAttempt > 0 || numRepetition > 0,
+      isRetryReasonEfd,
+      isRetryReasonAttemptToFix: isRetryReasonAttemptToFix && numRepetition > 0,
+      isNew,
+      mightHitProbe: isDiEnabled && numAttempt > 0,
+      isAttemptToFix: attemptToFixTasks.has(task),
+      isDisabled: disabledTasks.has(task),
+      isQuarantined,
+      isRetryReasonAtr
+    }
+    taskToCtx.set(task, ctx)
 
-    asyncResource.runInAsyncScope(() => {
-      testStartCh.publish({
-        testName,
-        testSuiteAbsolutePath: task.file.filepath,
-        isRetry: numAttempt > 0 || numRepetition > 0,
-        isRetryReasonEfd,
-        isRetryReasonAttemptToFix: isRetryReasonAttemptToFix && numRepetition > 0,
-        isNew,
-        mightHitProbe: isDiEnabled && numAttempt > 0,
-        isAttemptToFix: attemptToFixTasks.has(task),
-        isDisabled: disabledTasks.has(task),
-        isQuarantined,
-        isRetryReasonAtr
-      })
-    })
+    testStartCh.runStores(ctx, () => { })
     return onBeforeTryTask.apply(this, arguments)
   })
 
   // test finish (only passed tests)
   shimmer.wrap(VitestTestRunner.prototype, 'onAfterTryTask', onAfterTryTask =>
     async function (task, { retry: retryCount }) {
-      if (!testFinishTimeCh.hasSubscribers) {
+      if (!testPassCh.hasSubscribers && !testErrorCh.hasSubscribers && !testSkipCh.hasSubscribers) {
         return onAfterTryTask.apply(this, arguments)
       }
       const result = await onAfterTryTask.apply(this, arguments)
@@ -605,7 +594,7 @@ addHook({
       const { testManagementAttemptToFixRetries } = getProvidedContext()
 
       const status = getVitestTestStatus(task, retryCount)
-      const asyncResource = taskToAsync.get(task)
+      const ctx = taskToCtx.get(task)
 
       const { isDiEnabled } = getProvidedContext()
 
@@ -626,11 +615,13 @@ addHook({
         }
       }
 
-      if (asyncResource) {
+      if (ctx) {
         // We don't finish here because the test might fail in a later hook (afterEach)
-        asyncResource.runInAsyncScope(() => {
-          testFinishTimeCh.publish({ status, task, attemptToFixPassed, attemptToFixFailed })
-        })
+        ctx.status = status
+        ctx.task = task
+        ctx.attemptToFixPassed = attemptToFixPassed
+        ctx.attemptToFixFailed = attemptToFixFailed
+        testFinishTimeCh.runStores(ctx, () => { })
       }
 
       return result
@@ -728,19 +719,14 @@ addHook({
 }, (vitestPackage, frameworkVersion) => {
   shimmer.wrap(vitestPackage, 'startTests', startTests => async function (testPaths) {
     let testSuiteError = null
-    if (!testSuiteStartCh.hasSubscribers) {
+    if (!testSuiteFinishCh.hasSubscribers) {
       return startTests.apply(this, arguments)
     }
     // From >=3.0.1, the first arguments changes from a string to an object containing the filepath
     const testSuiteAbsolutePath = testPaths[0]?.filepath || testPaths[0]
 
-    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
-    testSuiteAsyncResource.runInAsyncScope(() => {
-      testSuiteStartCh.publish({
-        testSuiteAbsolutePath,
-        frameworkVersion
-      })
-    })
+    const testSuiteCtx = { testSuiteAbsolutePath, frameworkVersion }
+    testSuiteStartCh.runStores(testSuiteCtx, () => { })
     const startTestsResponse = await startTests.apply(this, arguments)
 
     let onFinish = null
@@ -752,7 +738,7 @@ addHook({
 
     // Only one test task per test, even if there are retries
     testTasks.forEach(task => {
-      const testAsyncResource = taskToAsync.get(task)
+      const testCtx = taskToCtx.get(task)
       const { result } = task
       // We have to trick vitest into thinking that the test has passed
       // but we want to report it as failed if it did fail
@@ -768,10 +754,8 @@ addHook({
             isDisabled: disabledTasks.has(task)
           })
         } else if (state === 'pass' && !isSwitchedStatus) {
-          if (testAsyncResource) {
-            testAsyncResource.runInAsyncScope(() => {
-              testPassCh.publish({ task })
-            })
+          if (testCtx) {
+            testPassCh.publish({ task, ...testCtx.currentStore })
           }
         } else if (state === 'fail' || isSwitchedStatus) {
           let testError
@@ -792,16 +776,15 @@ addHook({
             }
           }
 
-          if (testAsyncResource) {
+          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
-            testAsyncResource.runInAsyncScope(() => {
-              testErrorCh.publish({
-                duration: !isRetry ? duration : undefined,
-                error: testError,
-                hasFailedAllRetries,
-                attemptToFixFailed
-              })
+            testErrorCh.publish({
+              duration: !isRetry ? duration : undefined,
+              error: testError,
+              hasFailedAllRetries,
+              attemptToFixFailed,
+              ...testCtx.currentStore
             })
           }
           if (errors?.length) {
@@ -831,14 +814,11 @@ addHook({
     }
 
     if (testSuiteError) {
-      testSuiteAsyncResource.runInAsyncScope(() => {
-        testSuiteErrorCh.publish({ error: testSuiteError })
-      })
+      testSuiteCtx.error = testSuiteError
+      testSuiteErrorCh.runStores(testSuiteCtx, () => { })
     }
 
-    testSuiteAsyncResource.runInAsyncScope(() => {
-      testSuiteFinishCh.publish({ status: testSuiteResult.state, onFinish })
-    })
+    testSuiteFinishCh.publish({ status: testSuiteResult.state, onFinish, ...testSuiteCtx.currentStore })
 
     // TODO: fix too frequent flushes
     await onFinishPromise

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

@@ -221,13 +221,8 @@ class CucumberPlugin extends CiPlugin {
       this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_FINISHED, 'suite', { library: 'istanbul' })
     })
 
-    this.addSub('ci:cucumber:test:start', ({
-      testName,
-      testFileAbsolutePath,
-      testSourceLine,
-      isParallel,
-      promises
-    }) => {
+    this.addBind('ci:cucumber:test:start', (ctx) => {
+      const { testName, testFileAbsolutePath, testSourceLine, isParallel, promises } = ctx
       const store = storage('legacy').getStore()
       const testSuite = getTestSuitePath(testFileAbsolutePath, this.sourceRoot)
       const testSourceFile = getTestSuitePath(testFileAbsolutePath, this.repositoryRoot)
@@ -240,22 +235,23 @@ class CucumberPlugin extends CiPlugin {
         extraTags[CUCUMBER_IS_PARALLEL] = 'true'
       }
 
-      const testSpan = this.startTestSpan(testName, testSuite, extraTags)
+      const span = this.startTestSpan(testName, testSuite, extraTags)
 
-      this.enter(testSpan, store)
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, span }
 
-      this.activeTestSpan = testSpan
+      this.activeTestSpan = span
       // Time we give the breakpoint to be hit
       if (promises && this.runningTestProbe) {
         promises.hitBreakpointPromise = new Promise((resolve) => {
           setTimeout(resolve, BREAKPOINT_HIT_GRACE_PERIOD_MS)
         })
       }
+
+      return ctx.currentStore
     })
 
-    this.addSub('ci:cucumber:test:retry', ({ isFirstAttempt, error, isAtrRetry }) => {
-      const store = storage('legacy').getStore()
-      const span = store.span
+    this.addSub('ci:cucumber:test:retry', ({ span, isFirstAttempt, error, isAtrRetry }) => {
       if (!isFirstAttempt) {
         span.setTag(TEST_IS_RETRY, 'true')
         if (isAtrRetry) {
@@ -284,7 +280,9 @@ class CucumberPlugin extends CiPlugin {
       finishAllTraceSpans(span)
     })
 
-    this.addSub('ci:cucumber:test-step:start', ({ resource }) => {
+    this.addBind('ci:cucumber:test-step:start', (ctx) => {
+      const { resource } = ctx
+
       const store = storage('legacy').getStore()
       const childOf = store ? store.span : store
       const span = this.tracer.startSpan('cucumber.step', {
@@ -295,7 +293,10 @@ class CucumberPlugin extends CiPlugin {
           [RESOURCE_NAME]: resource
         }
       })
-      this.enter(span, store)
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, span }
+
+      return ctx.currentStore
     })
 
     this.addSub('ci:cucumber:worker-report:trace', (traces) => {
@@ -329,6 +330,7 @@ class CucumberPlugin extends CiPlugin {
     })
 
     this.addSub('ci:cucumber:test:finish', ({
+      span,
       isStep,
       status,
       skipReason,
@@ -345,7 +347,6 @@ class CucumberPlugin extends CiPlugin {
       isDisabled,
       isQuarantined
     }) => {
-      const span = storage('legacy').getStore().span
       const statusTag = isStep ? 'step.status' : TEST_STATUS
 
       span.setTag(statusTag, status)
@@ -425,11 +426,21 @@ class CucumberPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:cucumber:error', (err) => {
+    this.addBind('ci:cucumber:error', (ctx) => {
+      const { err } = ctx
       if (err) {
-        const span = storage('legacy').getStore().span
+        const span = ctx.currentStore.span
         span.setTag('error', err)
+
+        ctx.parentStore = ctx.currentStore
+        ctx.currentStore = { ...ctx.currentStore, span }
       }
+
+      return ctx.currentStore
+    })
+
+    this.addBind('ci:cucumber:test:fn', (ctx) => {
+      return ctx.currentStore
     })
   }
 

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

@@ -0,0 +1,18 @@
+'use strict'
+
+const RedisPlugin = require('../../datadog-plugin-redis/src')
+
+class IOValkeyPlugin extends RedisPlugin {
+  static get id () {
+    return 'iovalkey'
+  }
+
+  static get system () { return 'valkey' }
+
+  constructor (...args) {
+    super(...args)
+    this._spanType = 'valkey'
+  }
+}
+
+module.exports = IOValkeyPlugin

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

@@ -333,15 +333,24 @@ class JestPlugin extends CiPlugin {
       this.telemetry.distribution(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, files.length)
     })
 
-    this.addSub('ci:jest:test:start', (test) => {
+    this.addBind('ci:jest:test:start', (ctx) => {
       const store = storage('legacy').getStore()
-      const span = this.startTestSpan(test)
+      const span = this.startTestSpan(ctx)
+
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, span }
 
-      this.enter(span, store)
       this.activeTestSpan = span
+
+      return ctx.currentStore
+    })
+
+    this.addBind('ci:jest:test:fn', (ctx) => {
+      return ctx.currentStore
     })
 
     this.addSub('ci:jest:test:finish', ({
+      span,
       status,
       testStartLine,
       attemptToFixPassed,
@@ -349,7 +358,6 @@ class JestPlugin extends CiPlugin {
       attemptToFixFailed,
       isAtrRetry
     }) => {
-      const span = storage('legacy').getStore().span
       span.setTag(TEST_STATUS, status)
       if (testStartLine) {
         span.setTag(TEST_SOURCE_START, testStartLine)
@@ -384,11 +392,9 @@ class JestPlugin extends CiPlugin {
       this.activeTestSpan = null
     })
 
-    this.addSub('ci:jest:test:err', ({ error, shouldSetProbe, promises }) => {
+    this.addSub('ci:jest:test:err', ({ span, error, shouldSetProbe, promises }) => {
       if (error) {
-        const store = storage('legacy').getStore()
-        if (store && store.span) {
-          const span = store.span
+        if (span) {
           span.setTag(TEST_STATUS, 'fail')
           span.setTag('error', getFormattedError(error, this.repositoryRoot))
           if (shouldSetProbe) {

package/packages/datadog-plugin-kafkajs/src/producer.js

@@ -67,7 +67,7 @@ class KafkajsProducerPlugin extends ProducerPlugin {
     }
   }
 
-  start ({ topic, messages, bootstrapServers, clusterId }) {
+  start ({ topic, messages, bootstrapServers, clusterId, disableHeaderInjection }) {
     const span = this.startSpan({
       resource: topic,
       meta: {
@@ -85,10 +85,11 @@ class KafkajsProducerPlugin extends ProducerPlugin {
     }
     for (const message of messages) {
       if (message !== null && typeof message === 'object') {
-        if (!message.headers) {
-          message.headers = {}
+        // message headers are not supported for kafka broker versions <0.11
+        if (!disableHeaderInjection) {
+          message.headers ??= {}
+          this.tracer.inject(span, 'text_map', message.headers)
         }
-        this.tracer.inject(span, 'text_map', message.headers)
         if (this.config.dsmEnabled) {
           const payloadSize = getMessageSize(message)
           const edgeTags = ['direction:out', `topic:${topic}`, 'type:kafka']
@@ -98,7 +99,9 @@ class KafkajsProducerPlugin extends ProducerPlugin {
           }
 
           const dataStreamsContext = this.tracer.setCheckpoint(edgeTags, span, payloadSize)
-          DsmPathwayCodec.encode(dataStreamsContext, message.headers)
+          if (!disableHeaderInjection) {
+            DsmPathwayCodec.encode(dataStreamsContext, message.headers)
+          }
         }
       }
     }

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

@@ -109,12 +109,9 @@ class MochaPlugin extends CiPlugin {
       this.telemetry.distribution(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, relativeCoverageFiles.length)
     })
 
-    this.addSub('ci:mocha:test-suite:start', ({
-      testSuiteAbsolutePath,
-      isUnskippable,
-      isForcedToRun,
-      itrCorrelationId
-    }) => {
+    this.addBind('ci:mocha:test-suite:start', (ctx) => {
+      const { testSuiteAbsolutePath, isUnskippable, isForcedToRun, itrCorrelationId } = ctx
+
       // If the test module span is undefined, the plugin has not been initialized correctly and we bail out
       if (!this.testModuleSpan) {
         return
@@ -164,38 +161,51 @@ class MochaPlugin extends CiPlugin {
         testSuiteSpan.setTag(ITR_CORRELATION_ID, itrCorrelationId)
       }
       const store = storage('legacy').getStore()
-      this.enter(testSuiteSpan, store)
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, testSuiteSpan }
       this._testSuites.set(testSuite, testSuiteSpan)
     })
 
-    this.addSub('ci:mocha:test-suite:finish', (status) => {
-      const store = storage('legacy').getStore()
-      if (store && store.span) {
-        const span = store.span
+    this.addSub('ci:mocha:test-suite:finish', ({ testSuiteSpan, status }) => {
+      if (testSuiteSpan) {
         // the test status of the suite may have been set in ci:mocha:test-suite:error already
-        if (!span.context()._tags[TEST_STATUS]) {
-          span.setTag(TEST_STATUS, status)
+        if (!testSuiteSpan.context()._tags[TEST_STATUS]) {
+          testSuiteSpan.setTag(TEST_STATUS, status)
         }
-        span.finish()
+        testSuiteSpan.finish()
         this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
       }
     })
 
-    this.addSub('ci:mocha:test-suite:error', (err) => {
-      const store = storage('legacy').getStore()
-      if (store && store.span) {
-        const span = store.span
-        span.setTag('error', err)
-        span.setTag(TEST_STATUS, 'fail')
+    this.addBind('ci:mocha:test-suite:error', (ctx) => {
+      const { error } = ctx
+      const testSuiteSpan = ctx.currentStore?.testSuiteSpan
+
+      if (testSuiteSpan) {
+        testSuiteSpan.setTag('error', error)
+        testSuiteSpan.setTag(TEST_STATUS, 'fail')
+
+        ctx.parentStore = ctx.currentStore
+        ctx.currentStore = { ...ctx.currentStore, testSuiteSpan }
       }
+
+      return ctx.currentStore
     })
 
-    this.addSub('ci:mocha:test:start', (testInfo) => {
+    this.addBind('ci:mocha:test:fn', (ctx) => {
+      return ctx.currentStore
+    })
+
+    this.addBind('ci:mocha:test:start', (ctx) => {
       const store = storage('legacy').getStore()
-      const span = this.startTestSpan(testInfo)
+      const span = this.startTestSpan(ctx)
+
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, span }
 
-      this.enter(span, store)
       this.activeTestSpan = span
+
+      return ctx.currentStore
     })
 
     this.addSub('ci:mocha:worker:finish', () => {
@@ -203,6 +213,7 @@ class MochaPlugin extends CiPlugin {
     })
 
     this.addSub('ci:mocha:test:finish', ({
+      span,
       status,
       hasBeenRetried,
       isLastRetry,
@@ -212,9 +223,6 @@ class MochaPlugin extends CiPlugin {
       isAttemptToFixRetry,
       isAtrRetry
     }) => {
-      const store = storage('legacy').getStore()
-      const span = store?.span
-
       if (span) {
         span.setTag(TEST_STATUS, status)
         if (hasBeenRetried) {
@@ -260,19 +268,26 @@ class MochaPlugin extends CiPlugin {
       }
     })
 
-    this.addSub('ci:mocha:test:skip', (testInfo) => {
+    this.addBind('ci:mocha:test:skip', (ctx) => {
       const store = storage('legacy').getStore()
       // skipped through it.skip, so the span is not created yet
       // for this test
       if (!store) {
-        const testSpan = this.startTestSpan(testInfo)
-        this.enter(testSpan, store)
+        const span = this.startTestSpan(ctx)
+
+        ctx.parentStore = store
+        ctx.currentStore = { ...store, span }
+
+        this.activeTestSpan = span
       }
+
+      return ctx.currentStore
     })
 
-    this.addSub('ci:mocha:test:error', (err) => {
-      const store = storage('legacy').getStore()
-      const span = store?.span
+    this.addBind('ci:mocha:test:error', (ctx) => {
+      const { err } = ctx
+      const span = ctx.currentStore?.span
+
       if (err && span) {
         if (err.constructor.name === 'Pending' && !this.forbidPending) {
           span.setTag(TEST_STATUS, 'skip')
@@ -280,12 +295,17 @@ class MochaPlugin extends CiPlugin {
           span.setTag(TEST_STATUS, 'fail')
           span.setTag('error', err)
         }
+
+        ctx.parentStore = ctx.currentStore
+        ctx.currentStore = { ...ctx.currentStore, span }
+
+        this.activeTestSpan = span
       }
+
+      return ctx.currentStore
     })
 
-    this.addSub('ci:mocha:test:retry', ({ isFirstAttempt, willBeRetried, err, test, isAtrRetry }) => {
-      const store = storage('legacy').getStore()
-      const span = store?.span
+    this.addSub('ci:mocha:test:retry', ({ span, isFirstAttempt, willBeRetried, err, test, isAtrRetry }) => {
       if (span) {
         span.setTag(TEST_STATUS, 'fail')
         if (!isFirstAttempt) {