dd-trace 5.51.0 → 5.53.0

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

@@ -70,7 +70,7 @@ function wrapRenderToHTML (renderToHTML) {
 
 function wrapRenderErrorToHTML (renderErrorToHTML) {
   return function (err, req, res, pathname, query) {
-    return instrument(req, res, err, () => renderErrorToHTML.apply(this, arguments))
+    return instrument(req, res, () => renderErrorToHTML.apply(this, arguments), err)
   }
 }
 
@@ -82,7 +82,7 @@ function wrapRenderToResponse (renderToResponse) {
 
 function wrapRenderErrorToResponse (renderErrorToResponse) {
   return function (ctx, err) {
-    return instrument(ctx.req, ctx.res, err, () => renderErrorToResponse.apply(this, arguments))
+    return instrument(ctx.req, ctx.res, () => renderErrorToResponse.apply(this, arguments), err)
   }
 }
 
@@ -121,12 +121,7 @@ function getRequestMeta (req, key) {
   return typeof key === 'string' ? meta[key] : meta
 }
 
-function instrument (req, res, error, handler) {
-  if (typeof error === 'function') {
-    handler = error
-    error = null
-  }
-
+function instrument (req, res, handler, error) {
   req = req.originalRequest || req
   res = res.originalResponse || res
 
@@ -216,13 +211,13 @@ addHook({
   name: 'next',
   versions: ['>=11.1'],
   file: 'dist/server/serve-static.js'
-}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
+}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic, { replaceGetter: true }))
 
 addHook({
   name: 'next',
   versions: ['>=10.2 <11.1'],
   file: 'dist/next-server/server/serve-static.js'
-}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic))
+}, serveStatic => shimmer.wrap(serveStatic, 'serveStatic', wrapServeStatic, { replaceGetter: true }))
 
 addHook({ name: 'next', versions: ['>=11.1'], file: 'dist/server/next-server.js' }, nextServer => {
   const Server = nextServer.default
@@ -282,8 +277,7 @@ addHook({
   versions: ['>=13'],
   file: 'dist/server/web/spec-extension/request.js'
 }, request => {
-  const nextUrlDescriptor = Object.getOwnPropertyDescriptor(request.NextRequest.prototype, 'nextUrl')
-  shimmer.wrap(nextUrlDescriptor, 'get', function (originalGet) {
+  shimmer.wrap(request.NextRequest.prototype, 'nextUrl', function (originalGet) {
     return function wrappedGet () {
       const nextUrl = originalGet.apply(this, arguments)
       if (queryParsedChannel.hasSubscribers) {
@@ -300,8 +294,6 @@ addHook({
     }
   })
 
-  Object.defineProperty(request.NextRequest.prototype, 'nextUrl', nextUrlDescriptor)
-
   shimmer.massWrap(request.NextRequest.prototype, ['text', 'json'], function (originalMethod) {
     return async function wrappedJson () {
       const body = await originalMethod.apply(this, arguments)

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

@@ -14,6 +14,8 @@ const errorCh = channel('apm:pg:query:error')
 const startPoolQueryCh = channel('datadog:pg:pool:query:start')
 const finishPoolQueryCh = channel('datadog:pg:pool:query:finish')
 
+const { errorMonitor } = require('node:events')
+
 addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
   shimmer.wrap(pg.Client.prototype, 'query', query => wrapQuery(query))
   shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
@@ -39,13 +41,15 @@ function wrapQuery (query) {
       ? arguments[0]
       : { text: arguments[0] }
 
-    const textProp = Object.getOwnPropertyDescriptor(pgQuery, 'text')
+    const textPropObj = pgQuery.cursor ?? pgQuery
+    const textProp = Object.getOwnPropertyDescriptor(textPropObj, 'text')
+    const stream = typeof textPropObj.read === 'function'
 
-    // Only alter `text` property if safe to do so.
+    // Only alter `text` property if safe to do so. Initially, it's a property, not a getter.
     if (!textProp || textProp.configurable) {
-      const originalText = pgQuery.text
+      const originalText = textPropObj.text
 
-      Object.defineProperty(pgQuery, 'text', {
+      Object.defineProperty(textPropObj, 'text', {
         get () {
           return this?.__ddInjectableQuery || originalText
         }
@@ -57,9 +61,10 @@ function wrapQuery (query) {
 
       startCh.publish({
         params: this.connectionParameters,
-        query: pgQuery,
+        query: textPropObj,
         processId,
-        abortController
+        abortController,
+        stream
       })
 
       const finish = asyncResource.bind(function (error, res) {
@@ -124,9 +129,12 @@ function wrapQuery (query) {
         }
       } else if (newQuery.once) {
         newQuery
-          .once('error', finish)
+          .once(errorMonitor, finish)
           .once('end', (res) => finish(null, res))
       } else {
+        // TODO: This code is never reached in our tests.
+        // Internally, pg always uses callbacks or streams, even for promise based queries.
+        // Investigate if this code should just be removed.
         newQuery.then((res) => finish(null, res), finish)
       }
 

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

@@ -25,8 +25,8 @@ const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
 const workerReportCh = channel('ci:playwright:worker:report')
 const testPageGotoCh = channel('ci:playwright:test:page-goto')
 
-const testToAr = new WeakMap()
-const testSuiteToAr = new Map()
+const testToCtx = new WeakMap()
+const testSuiteToCtx = new Map()
 const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 const testsToTestStatuses = new Map()
@@ -279,11 +279,9 @@ function testBeginHandler (test, browserName, isMainProcess) {
 
   if (isNewTestSuite) {
     startedSuites.push(testSuiteAbsolutePath)
-    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
-    testSuiteToAr.set(testSuiteAbsolutePath, testSuiteAsyncResource)
-    testSuiteAsyncResource.runInAsyncScope(() => {
-      testSuiteStartCh.publish(testSuiteAbsolutePath)
-    })
+    const testSuiteCtx = { testSuiteAbsolutePath }
+    testSuiteToCtx.set(testSuiteAbsolutePath, testSuiteCtx)
+    testSuiteStartCh.runStores(testSuiteCtx, () => { })
   }
 
   // We disable retries by default if attemptToFix is true
@@ -293,19 +291,17 @@ function testBeginHandler (test, browserName, isMainProcess) {
 
   // this handles tests that do not go through the worker process (because they're skipped)
   if (isMainProcess) {
-    const testAsyncResource = new AsyncResource('bound-anonymous-fn')
-    testToAr.set(test, testAsyncResource)
     const testName = getTestFullname(test)
+    const testCtx = {
+      testName,
+      testSuiteAbsolutePath,
+      testSourceLine,
+      browserName,
+      isDisabled: test._ddIsDisabled
+    }
+    testToCtx.set(test, testCtx)
 
-    testAsyncResource.runInAsyncScope(() => {
-      testStartCh.publish({
-        testName,
-        testSuiteAbsolutePath,
-        testSourceLine,
-        browserName,
-        isDisabled: test._ddIsDisabled
-      })
-    })
+    testStartCh.runStores(testCtx, () => { })
   }
 }
 
@@ -337,6 +333,9 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout, isMain
   }
 
   if (testStatuses.length === testManagementAttemptToFixRetries + 1) {
+    if (testStatuses.some(status => status === 'fail')) {
+      test._ddHasFailedAttemptToFixRetries = true
+    }
     if (testStatuses.every(status => status === 'fail')) {
       test._ddHasFailedAllRetries = true
     } else if (testStatuses.every(status => status === 'pass')) {
@@ -347,27 +346,27 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout, isMain
   // this handles tests that do not go through the worker process (because they're skipped)
   if (isMainProcess) {
     const testResult = results[results.length - 1]
-    const testAsyncResource = testToAr.get(test)
+    const testCtx = testToCtx.get(test)
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
       !test._ddIsAttemptToFix &&
       !test._ddIsEfdRetry
-    testAsyncResource.runInAsyncScope(() => {
-      testFinishCh.publish({
-        testStatus,
-        steps: testResult?.steps || [],
-        isRetry: testResult?.retry > 0,
-        error,
-        extraTags: annotationTags,
-        isNew: test._ddIsNew,
-        isAttemptToFix: test._ddIsAttemptToFix,
-        isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
-        isQuarantined: test._ddIsQuarantined,
-        isEfdRetry: test._ddIsEfdRetry,
-        hasFailedAllRetries: test._ddHasFailedAllRetries,
-        hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
-        isAtrRetry
-      })
+    testFinishCh.publish({
+      testStatus,
+      steps: testResult?.steps || [],
+      isRetry: testResult?.retry > 0,
+      error,
+      extraTags: annotationTags,
+      isNew: test._ddIsNew,
+      isAttemptToFix: test._ddIsAttemptToFix,
+      isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+      isQuarantined: test._ddIsQuarantined,
+      isEfdRetry: test._ddIsEfdRetry,
+      hasFailedAllRetries: test._ddHasFailedAllRetries,
+      hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+      hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
+      isAtrRetry,
+      ...testCtx.currentStore
     })
   }
 
@@ -397,10 +396,8 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout, isMain
     }
 
     const suiteError = getTestSuiteError(testSuiteAbsolutePath)
-    const testSuiteAsyncResource = testSuiteToAr.get(testSuiteAbsolutePath)
-    testSuiteAsyncResource.runInAsyncScope(() => {
-      testSuiteFinishCh.publish({ status: testSuiteStatus, error: suiteError })
-    })
+    const testSuiteCtx = testSuiteToCtx.get(testSuiteAbsolutePath)
+    testSuiteFinishCh.publish({ status: testSuiteStatus, error: suiteError, ...testSuiteCtx.currentStore })
   }
 }
 
@@ -492,6 +489,7 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
           _ddIsEfdRetry: test._ddIsEfdRetry,
           _ddHasFailedAllRetries: test._ddHasFailedAllRetries,
           _ddHasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+          _ddHasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
           _ddIsAtrRetry: isAtrRetry
         }
       })
@@ -605,7 +603,7 @@ function runnerHook (runnerExport, playwrightVersion) {
         totalAttemptToFixFailedTestCount += testStatuses.filter(status => status === 'fail').length
       }
 
-      if (totalFailedTestCount === totalAttemptToFixFailedTestCount) {
+      if (totalFailedTestCount > 0 && totalFailedTestCount === totalAttemptToFixFailedTestCount) {
         runAllTestsReturn = 'passed'
       }
     }
@@ -868,17 +866,16 @@ addHook({
     // If test events are created in the worker process I need to stop creating it in the main process
     // Probably yet another test worker exporter is needed in addition to the ones for mocha, jest and cucumber
     // it's probably hard to tell that's a playwright worker though, as I don't think there is a specific env variable
-    const testAsyncResource = new AsyncResource('bound-anonymous-fn')
+    const testCtx = {
+      testName,
+      testSuiteAbsolutePath,
+      testSourceLine,
+      browserName
+    }
+    testToCtx.set(test, testCtx)
     // TODO - In the future we may need to implement a mechanism to send test properties
     // to the worker process before _runTest is called
-    testAsyncResource.runInAsyncScope(() => {
-      testStartCh.publish({
-        testName,
-        testSuiteAbsolutePath,
-        testSourceLine,
-        browserName
-      })
-
+    testStartCh.runStores(testCtx, () => {
       let existAfterEachHook = false
 
       // We try to find an existing afterEach hook with _ddHook to avoid adding a new one
@@ -971,24 +968,24 @@ addHook({
     // Wait for the properties to be received
     await ddPropertiesPromise
 
-    testAsyncResource.runInAsyncScope(() => {
-      testFinishCh.publish({
-        testStatus: STATUS_TO_TEST_STATUS[status],
-        steps: steps.filter(step => step.testId === testId),
-        error,
-        extraTags: annotationTags,
-        isNew: test._ddIsNew,
-        isRetry: retry > 0,
-        isEfdRetry: test._ddIsEfdRetry,
-        isAttemptToFix: test._ddIsAttemptToFix,
-        isDisabled: test._ddIsDisabled,
-        isQuarantined: test._ddIsQuarantined,
-        isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
-        hasFailedAllRetries: test._ddHasFailedAllRetries,
-        hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
-        isAtrRetry: test._ddIsAtrRetry,
-        onDone
-      })
+    testFinishCh.publish({
+      testStatus: STATUS_TO_TEST_STATUS[status],
+      steps: steps.filter(step => step.testId === testId),
+      error,
+      extraTags: annotationTags,
+      isNew: test._ddIsNew,
+      isRetry: retry > 0,
+      isEfdRetry: test._ddIsEfdRetry,
+      isAttemptToFix: test._ddIsAttemptToFix,
+      isDisabled: test._ddIsDisabled,
+      isQuarantined: test._ddIsQuarantined,
+      isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+      hasFailedAllRetries: test._ddHasFailedAllRetries,
+      hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+      hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
+      isAtrRetry: test._ddIsAtrRetry,
+      onDone,
+      ...testCtx.currentStore
     })
 
     await flushPromise

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

@@ -26,23 +26,17 @@ addHook({ name: names }, function (url) {
 
   const URLPrototype = url.URL.prototype.constructor.prototype
   instrumentedGetters.forEach(property => {
-    const originalDescriptor = Object.getOwnPropertyDescriptor(URLPrototype, property)
+    shimmer.wrap(URLPrototype, property, function (originalGet) {
+      return function get () {
+        const result = originalGet.call(this)
+        if (!urlGetterChannel.hasSubscribers) return result
 
-    if (originalDescriptor?.get) {
-      const newDescriptor = shimmer.wrap(originalDescriptor, 'get', function (originalGet) {
-        return function get () {
-          const result = originalGet.apply(this, arguments)
-          if (!urlGetterChannel.hasSubscribers) return result
+        const context = { urlObject: this, result, property }
+        urlGetterChannel.publish(context)
 
-          const context = { urlObject: this, result, property }
-          urlGetterChannel.publish(context)
-
-          return context.result
-        }
-      })
-
-      Object.defineProperty(URLPrototype, property, newDescriptor)
-    }
+        return context.result
+      }
+    })
   })
 
   shimmer.wrap(url, 'URL', (URL) => {
@@ -83,6 +77,4 @@ addHook({ name: names }, function (url) {
       }
     })
   }
-
-  return url
 })

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()
 
@@ -614,18 +603,25 @@ addHook({
       }
 
       let attemptToFixPassed = false
+      let attemptToFixFailed = false
       if (attemptToFixTasks.has(task)) {
         const statuses = taskToStatuses.get(task)
-        if (statuses.length === testManagementAttemptToFixRetries && statuses.every(status => status === 'pass')) {
-          attemptToFixPassed = true
+        if (statuses.length === testManagementAttemptToFixRetries) {
+          if (statuses.every(status => status === 'pass')) {
+            attemptToFixPassed = true
+          } else if (statuses.some(status => status === 'fail')) {
+            attemptToFixFailed = true
+          }
         }
       }
 
-      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 })
-        })
+        ctx.status = status
+        ctx.task = task
+        ctx.attemptToFixPassed = attemptToFixPassed
+        ctx.attemptToFixFailed = attemptToFixFailed
+        testFinishTimeCh.runStores(ctx, () => { })
       }
 
       return result
@@ -723,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
@@ -747,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
@@ -763,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
@@ -776,18 +765,26 @@ addHook({
           }
 
           let hasFailedAllRetries = false
+          let attemptToFixFailed = false
           if (attemptToFixTasks.has(task)) {
             const statuses = taskToStatuses.get(task)
+            if (statuses.some(status => status === 'fail')) {
+              attemptToFixFailed = true
+            }
             if (statuses.every(status => status === 'fail')) {
               hasFailedAllRetries = true
             }
           }
 
-          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 })
+            testErrorCh.publish({
+              duration: !isRetry ? duration : undefined,
+              error: testError,
+              hasFailedAllRetries,
+              attemptToFixFailed,
+              ...testCtx.currentStore
             })
           }
           if (errors?.length) {
@@ -817,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-confluentinc-kafka-javascript/src/batch-consumer.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const KafkajsBatchConsumerPlugin = require('../../datadog-plugin-kafkajs/src/batch-consumer')
+
+class ConfluentKafkaJsBatchConsumerPlugin extends KafkajsBatchConsumerPlugin {
+  static get id () {
+    return '@confluentinc/kafka-javascript'
+  }
+}
+
+module.exports = ConfluentKafkaJsBatchConsumerPlugin

package/packages/datadog-plugin-confluentinc-kafka-javascript/src/consumer.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const KafkajsConsumerPlugin = require('../../datadog-plugin-kafkajs/src/consumer')
+
+class ConfluentKafkaJsConsumerPlugin extends KafkajsConsumerPlugin {
+  static get id () {
+    return '@confluentinc/kafka-javascript'
+  }
+}
+
+module.exports = ConfluentKafkaJsConsumerPlugin