dd-trace 5.31.0 → 5.33.0

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

@@ -201,6 +201,7 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     if (err) {
       config.knownTests = []
       config.isEarlyFlakeDetectionEnabled = false
+      config.isKnownTestsEnabled = false
     } else {
       config.knownTests = knownTests
     }
@@ -222,12 +223,13 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     config.isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
     config.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
     config.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
+    config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
     // ITR and auto test retries are not supported in parallel mode yet
     config.isSuitesSkippingEnabled = !isParallel && libraryConfig.isSuitesSkippingEnabled
     config.isFlakyTestRetriesEnabled = !isParallel && libraryConfig.isFlakyTestRetriesEnabled
     config.flakyTestRetriesCount = !isParallel && libraryConfig.flakyTestRetriesCount
 
-    if (config.isEarlyFlakeDetectionEnabled) {
+    if (config.isKnownTestsEnabled) {
       knownTestsCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedKnownTests)
       })
@@ -273,7 +275,7 @@ addHook({
     })
 
     getExecutionConfiguration(runner, false, () => {
-      if (config.isEarlyFlakeDetectionEnabled) {
+      if (config.isKnownTestsEnabled) {
         const testSuites = this.files.map(file => getTestSuitePath(file, process.cwd()))
         const isFaulty = getIsFaultyEarlyFlakeDetection(
           testSuites,
@@ -283,6 +285,7 @@ addHook({
         if (isFaulty) {
           config.isEarlyFlakeDetectionEnabled = false
           config.isEarlyFlakeDetectionFaulty = true
+          config.isKnownTestsEnabled = false
         }
       }
       if (getCodeCoverageCh.hasSubscribers) {
@@ -537,7 +540,7 @@ addHook({
     this.once('end', getOnEndHandler(true))
 
     getExecutionConfiguration(this, true, () => {
-      if (config.isEarlyFlakeDetectionEnabled) {
+      if (config.isKnownTestsEnabled) {
         const testSuites = files.map(file => getTestSuitePath(file, process.cwd()))
         const isFaulty = getIsFaultyEarlyFlakeDetection(
           testSuites,
@@ -545,6 +548,7 @@ addHook({
           config.earlyFlakeDetectionFaultyThreshold
         )
         if (isFaulty) {
+          config.isKnownTestsEnabled = false
           config.isEarlyFlakeDetectionEnabled = false
           config.isEarlyFlakeDetectionFaulty = true
         }
@@ -569,7 +573,7 @@ addHook({
   const { BufferedWorkerPool } = BufferedWorkerPoolPackage
 
   shimmer.wrap(BufferedWorkerPool.prototype, 'run', run => async function (testSuiteAbsolutePath, workerArgs) {
-    if (!testStartCh.hasSubscribers || !config.isEarlyFlakeDetectionEnabled) {
+    if (!testStartCh.hasSubscribers || !config.isKnownTestsEnabled) {
       return run.apply(this, arguments)
     }
 
@@ -584,6 +588,7 @@ addHook({
         {
           ...workerArgs,
           _ddEfdNumRetries: config.earlyFlakeDetectionNumRetries,
+          _ddIsEfdEnabled: config.isEarlyFlakeDetectionEnabled,
           _ddKnownTests: {
             mocha: {
               [testPath]: testSuiteKnownTests

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

@@ -19,6 +19,7 @@ const skipCh = channel('ci:mocha:test:skip')
 // suite channels
 const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
 
+const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
 const testToAr = new WeakMap()
 const originalFns = new WeakMap()
 const testToStartLine = new WeakMap()
@@ -73,7 +74,7 @@ function isMochaRetry (test) {
   return test._currentRetry !== undefined && test._currentRetry !== 0
 }
 
-function isLastRetry (test) {
+function getIsLastRetry (test) {
   return test._currentRetry === test._retries
 }
 
@@ -203,14 +204,28 @@ function getOnTestHandler (isMain) {
 }
 
 function getOnTestEndHandler () {
-  return function (test) {
+  return async function (test) {
     const asyncResource = getTestAsyncResource(test)
     const status = getTestStatus(test)
 
+    // After finishing it might take a bit for the snapshot to be handled.
+    // This means that tests retried with DI are BREAKPOINT_HIT_GRACE_PERIOD_MS slower at least.
+    if (test._ddShouldWaitForHitProbe || test._retriedTest?._ddShouldWaitForHitProbe) {
+      await new Promise((resolve) => {
+        setTimeout(() => {
+          resolve()
+        }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
+      })
+    }
+
     // if there are afterEach to be run, we don't finish the test yet
     if (asyncResource && !test.parent._afterEach.length) {
       asyncResource.runInAsyncScope(() => {
-        testFinishCh.publish({ status, hasBeenRetried: isMochaRetry(test) })
+        testFinishCh.publish({
+          status,
+          hasBeenRetried: isMochaRetry(test),
+          isLastRetry: getIsLastRetry(test)
+        })
       })
     }
   }
@@ -220,16 +235,17 @@ function getOnHookEndHandler () {
   return function (hook) {
     const test = hook.ctx.currentTest
     if (test && hook.parent._afterEach.includes(hook)) { // only if it's an afterEach
-      const isLastAfterEach = hook.parent._afterEach.indexOf(hook) === hook.parent._afterEach.length - 1
-      if (test._retries > 0 && !isLastRetry(test)) {
+      const isLastRetry = getIsLastRetry(test)
+      if (test._retries > 0 && !isLastRetry) {
         return
       }
+      const isLastAfterEach = hook.parent._afterEach.indexOf(hook) === hook.parent._afterEach.length - 1
       if (isLastAfterEach) {
         const status = getTestStatus(test)
         const asyncResource = getTestAsyncResource(test)
         if (asyncResource) {
           asyncResource.runInAsyncScope(() => {
-            testFinishCh.publish({ status, hasBeenRetried: isMochaRetry(test) })
+            testFinishCh.publish({ status, hasBeenRetried: isMochaRetry(test), isLastRetry })
           })
         }
       }
@@ -286,7 +302,7 @@ function getOnTestRetryHandler () {
       const isFirstAttempt = test._currentRetry === 0
       const willBeRetried = test._currentRetry < test._retries
       asyncResource.runInAsyncScope(() => {
-        testRetryCh.publish({ isFirstAttempt, err, willBeRetried })
+        testRetryCh.publish({ isFirstAttempt, err, willBeRetried, test })
       })
     }
     const key = getTestToArKey(test)
@@ -333,12 +349,14 @@ function getOnPendingHandler () {
 // Hook to add retries to tests if EFD is enabled
 function getRunTestsWrapper (runTests, config) {
   return function (suite, fn) {
-    if (config.isEarlyFlakeDetectionEnabled) {
+    if (config.isKnownTestsEnabled) {
       // by the time we reach `this.on('test')`, it is too late. We need to add retries here
       suite.tests.forEach(test => {
         if (!test.isPending() && isNewTest(test, config.knownTests)) {
           test._ddIsNew = true
-          retryTest(test, config.earlyFlakeDetectionNumRetries)
+          if (config.isEarlyFlakeDetectionEnabled) {
+            retryTest(test, config.earlyFlakeDetectionNumRetries)
+          }
         }
       })
     }

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

@@ -25,10 +25,12 @@ addHook({
 }, (Mocha) => {
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
     if (this.options._ddKnownTests) {
-      // EFD is enabled if there's a list of known tests
-      config.isEarlyFlakeDetectionEnabled = true
+      // If there are known tests, it means isKnownTestsEnabled should be true
+      config.isKnownTestsEnabled = true
+      config.isEarlyFlakeDetectionEnabled = this.options._ddIsEfdEnabled
       config.knownTests = this.options._ddKnownTests
       config.earlyFlakeDetectionNumRetries = this.options._ddEfdNumRetries
+      delete this.options._ddIsEfdEnabled
       delete this.options._ddKnownTests
       delete this.options._ddEfdNumRetries
     }

package/packages/datadog-instrumentations/src/node-serialize.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const nodeUnserializeCh = channel('datadog:node-serialize:unserialize:start')
+
+function wrapUnserialize (serialize) {
+  return function wrappedUnserialize (obj) {
+    if (nodeUnserializeCh.hasSubscribers) {
+      nodeUnserializeCh.publish({ obj })
+    }
+
+    return serialize.apply(this, arguments)
+  }
+}
+
+addHook({ name: 'node-serialize', versions: ['0.0.4'] }, serialize => {
+  shimmer.wrap(serialize, 'unserialize', wrapUnserialize)
+
+  return serialize
+})

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

@@ -338,6 +338,8 @@ for (const shim of V4_PACKAGE_SHIMS) {
               })
           })
 
+          ch.end.publish(ctx)
+
           return apiProm
         })
       })

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

@@ -35,6 +35,7 @@ const STATUS_TO_TEST_STATUS = {
 }
 
 let remainingTestsByFile = {}
+let isKnownTestsEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
 let isFlakyTestRetriesEnabled = false
@@ -418,6 +419,7 @@ function runnerHook (runnerExport, playwrightVersion) {
     try {
       const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh)
       if (!err) {
+        isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
         isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
@@ -425,19 +427,22 @@ function runnerHook (runnerExport, playwrightVersion) {
       }
     } catch (e) {
       isEarlyFlakeDetectionEnabled = false
+      isKnownTestsEnabled = false
       log.error('Playwright session start error', e)
     }
 
-    if (isEarlyFlakeDetectionEnabled && semver.gte(playwrightVersion, MINIMUM_SUPPORTED_VERSION_EFD)) {
+    if (isKnownTestsEnabled && semver.gte(playwrightVersion, MINIMUM_SUPPORTED_VERSION_EFD)) {
       try {
         const { err, knownTests: receivedKnownTests } = await getChannelPromise(knownTestsCh)
         if (!err) {
           knownTests = receivedKnownTests
         } else {
           isEarlyFlakeDetectionEnabled = false
+          isKnownTestsEnabled = false
         }
       } catch (err) {
         isEarlyFlakeDetectionEnabled = false
+        isKnownTestsEnabled = false
         log.error('Playwright known tests error', err)
       }
     }
@@ -553,7 +558,7 @@ addHook({
 
   async function newCreateRootSuite () {
     const rootSuite = await oldCreateRootSuite.apply(this, arguments)
-    if (!isEarlyFlakeDetectionEnabled) {
+    if (!isKnownTestsEnabled) {
       return rootSuite
     }
     const newTests = rootSuite
@@ -562,7 +567,7 @@ addHook({
 
     newTests.forEach(newTest => {
       newTest._ddIsNew = true
-      if (newTest.expectedStatus !== 'skipped') {
+      if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped') {
         const fileSuite = getSuiteType(newTest, 'file')
         const projectSuite = getSuiteType(newTest, 'project')
         for (let repeatEachIndex = 0; repeatEachIndex < earlyFlakeDetectionNumRetries; repeatEachIndex++) {

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

@@ -25,9 +25,49 @@ const isEarlyFlakeDetectionFaultyCh = channel('ci:vitest:is-early-flake-detectio
 const taskToAsync = new WeakMap()
 const taskToStatuses = new WeakMap()
 const newTasks = new WeakSet()
+let isRetryReasonEfd = false
 const switchedStatuses = new WeakSet()
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
+const BREAKPOINT_HIT_GRACE_PERIOD_MS = 400
+
+function waitForHitProbe () {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve()
+    }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
+  })
+}
+
+function getProvidedContext () {
+  try {
+    const {
+      _ddIsEarlyFlakeDetectionEnabled,
+      _ddIsDiEnabled,
+      _ddKnownTests: knownTests,
+      _ddEarlyFlakeDetectionNumRetries: numRepeats,
+      _ddIsKnownTestsEnabled: isKnownTestsEnabled
+    } = globalThis.__vitest_worker__.providedContext
+
+    return {
+      isDiEnabled: _ddIsDiEnabled,
+      isEarlyFlakeDetectionEnabled: _ddIsEarlyFlakeDetectionEnabled,
+      knownTests,
+      numRepeats,
+      isKnownTestsEnabled
+    }
+  } catch (e) {
+    log.error('Vitest workers could not parse provided context, so some features will not work.')
+    return {
+      isDiEnabled: false,
+      isEarlyFlakeDetectionEnabled: false,
+      knownTests: {},
+      numRepeats: 0,
+      isKnownTestsEnabled: false
+    }
+  }
+}
+
 function isReporterPackage (vitestPackage) {
   return vitestPackage.B?.name === 'BaseSequencer'
 }
@@ -117,6 +157,7 @@ function getSortWrapper (sort) {
     let isEarlyFlakeDetectionEnabled = false
     let earlyFlakeDetectionNumRetries = 0
     let isEarlyFlakeDetectionFaulty = false
+    let isKnownTestsEnabled = false
     let isDiEnabled = false
     let knownTests = {}
 
@@ -128,22 +169,26 @@ function getSortWrapper (sort) {
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
         isDiEnabled = libraryConfig.isDiEnabled
+        isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
       }
     } catch (e) {
       isFlakyTestRetriesEnabled = false
       isEarlyFlakeDetectionEnabled = false
       isDiEnabled = false
+      isKnownTestsEnabled = false
     }
 
     if (isFlakyTestRetriesEnabled && !this.ctx.config.retry && flakyTestRetriesCount > 0) {
       this.ctx.config.retry = flakyTestRetriesCount
     }
 
-    if (isEarlyFlakeDetectionEnabled) {
+    if (isKnownTestsEnabled) {
       const knownTestsResponse = await getChannelPromise(knownTestsCh)
       if (!knownTestsResponse.err) {
         knownTests = knownTestsResponse.knownTests
-        const testFilepaths = await this.ctx.getTestFilepaths()
+        const getFilePaths = this.ctx.getTestFilepaths || this.ctx._globTestFilepaths
+
+        const testFilepaths = await getFilePaths.call(this.ctx)
 
         isEarlyFlakeDetectionFaultyCh.publish({
           knownTests: knownTests.vitest || {},
@@ -154,13 +199,15 @@ function getSortWrapper (sort) {
         })
         if (isEarlyFlakeDetectionFaulty) {
           isEarlyFlakeDetectionEnabled = false
-          log.warn('Early flake detection is disabled because the number of new tests is too high.')
+          isKnownTestsEnabled = false
+          log.warn('New test detection is disabled because the number of new tests is too high.')
         } else {
           // TODO: use this to pass session and module IDs to the worker, instead of polluting process.env
           // Note: setting this.ctx.config.provide directly does not work because it's cached
           try {
             const workspaceProject = this.ctx.getCoreWorkspaceProject()
-            workspaceProject._provided._ddKnownTests = knownTests.vitest
+            workspaceProject._provided._ddIsKnownTestsEnabled = isKnownTestsEnabled
+            workspaceProject._provided._ddKnownTests = knownTests.vitest || {}
             workspaceProject._provided._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
             workspaceProject._provided._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
           } catch (e) {
@@ -169,6 +216,7 @@ function getSortWrapper (sort) {
         }
       } else {
         isEarlyFlakeDetectionEnabled = false
+        isKnownTestsEnabled = false
       }
     }
 
@@ -253,29 +301,30 @@ addHook({
   // `onBeforeRunTask` is run before any repetition or attempt is run
   shimmer.wrap(VitestTestRunner.prototype, 'onBeforeRunTask', onBeforeRunTask => async function (task) {
     const testName = getTestName(task)
-    try {
-      const {
-        _ddKnownTests: knownTests,
-        _ddIsEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionEnabled,
-        _ddEarlyFlakeDetectionNumRetries: numRepeats
-      } = globalThis.__vitest_worker__.providedContext
-
-      if (isEarlyFlakeDetectionEnabled) {
-        isNewTestCh.publish({
-          knownTests,
-          testSuiteAbsolutePath: task.file.filepath,
-          testName,
-          onDone: (isNew) => {
-            if (isNew) {
+
+    const {
+      knownTests,
+      isEarlyFlakeDetectionEnabled,
+      isKnownTestsEnabled,
+      numRepeats
+    } = getProvidedContext()
+
+    if (isKnownTestsEnabled) {
+      isNewTestCh.publish({
+        knownTests,
+        testSuiteAbsolutePath: task.file.filepath,
+        testName,
+        onDone: (isNew) => {
+          if (isNew) {
+            if (isEarlyFlakeDetectionEnabled) {
+              isRetryReasonEfd = task.repeats !== numRepeats
               task.repeats = numRepeats
-              newTasks.add(task)
-              taskToStatuses.set(task, [])
             }
+            newTasks.add(task)
+            taskToStatuses.set(task, [])
           }
-        })
-      }
-    } catch (e) {
-      log.error('Vitest workers could not parse known tests, so Early Flake Detection will not work.')
+        }
+      })
     }
 
     return onBeforeRunTask.apply(this, arguments)
@@ -283,9 +332,7 @@ addHook({
 
   // `onAfterRunTask` is run after all repetitions or attempts are run
   shimmer.wrap(VitestTestRunner.prototype, 'onAfterRunTask', onAfterRunTask => async function (task) {
-    const {
-      _ddIsEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionEnabled
-    } = globalThis.__vitest_worker__.providedContext
+    const { isEarlyFlakeDetectionEnabled } = getProvidedContext()
 
     if (isEarlyFlakeDetectionEnabled && taskToStatuses.has(task)) {
       const statuses = taskToStatuses.get(task)
@@ -309,43 +356,41 @@ addHook({
     }
     const testName = getTestName(task)
     let isNew = false
-    let isEarlyFlakeDetectionEnabled = false
-    let isDiEnabled = false
 
-    try {
-      const {
-        _ddIsEarlyFlakeDetectionEnabled,
-        _ddIsDiEnabled
-      } = globalThis.__vitest_worker__.providedContext
-
-      isEarlyFlakeDetectionEnabled = _ddIsEarlyFlakeDetectionEnabled
-      isDiEnabled = _ddIsDiEnabled
+    const {
+      isKnownTestsEnabled,
+      isEarlyFlakeDetectionEnabled,
+      isDiEnabled
+    } = getProvidedContext()
 
-      if (isEarlyFlakeDetectionEnabled) {
-        isNew = newTasks.has(task)
-      }
-    } catch (e) {
-      log.error('Vitest workers could not parse known tests, so Early Flake Detection will not work.')
+    if (isKnownTestsEnabled) {
+      isNew = newTasks.has(task)
     }
+
     const { retry: numAttempt, repeats: numRepetition } = retryInfo
 
     // We finish the previous test here because we know it has failed already
     if (numAttempt > 0) {
-      const probe = {}
+      const shouldWaitForHitProbe = isDiEnabled && numAttempt > 1
+      if (shouldWaitForHitProbe) {
+        await waitForHitProbe()
+      }
+
+      const promises = {}
+      const shouldSetProbe = isDiEnabled && numAttempt === 1
       const asyncResource = taskToAsync.get(task)
       const testError = task.result?.errors?.[0]
       if (asyncResource) {
         asyncResource.runInAsyncScope(() => {
           testErrorCh.publish({
             error: testError,
-            willBeRetried: true,
-            probe,
-            isDiEnabled
+            shouldSetProbe,
+            promises
           })
         })
         // We wait for the probe to be set
-        if (probe.setProbePromise) {
-          await probe.setProbePromise
+        if (promises.setProbePromise) {
+          await promises.setProbePromise
         }
       }
     }
@@ -401,7 +446,9 @@ addHook({
         testName,
         testSuiteAbsolutePath: task.file.filepath,
         isRetry: numAttempt > 0 || numRepetition > 0,
-        isNew
+        isRetryReasonEfd,
+        isNew,
+        mightHitProbe: isDiEnabled && numAttempt > 0
       })
     })
     return onBeforeTryTask.apply(this, arguments)
@@ -418,6 +465,12 @@ addHook({
       const status = getVitestTestStatus(task, retryCount)
       const asyncResource = taskToAsync.get(task)
 
+      const { isDiEnabled } = getProvidedContext()
+
+      if (isDiEnabled && retryCount > 1) {
+        await waitForHitProbe()
+      }
+
       if (asyncResource) {
         // We don't finish here because the test might fail in a later hook (afterEach)
         asyncResource.runInAsyncScope(() => {
@@ -457,15 +510,6 @@ addHook({
   return vitestPackage
 })
 
-addHook({
-  name: 'vitest',
-  versions: ['>=2.1.0'],
-  filePattern: 'dist/chunks/RandomSequencer.*'
-}, (randomSequencerPackage) => {
-  shimmer.wrap(randomSequencerPackage.B.prototype, 'sort', getSortWrapper)
-  return randomSequencerPackage
-})
-
 addHook({
   name: 'vitest',
   versions: ['>=2.0.5 <2.1.0'],
@@ -478,6 +522,24 @@ addHook({
   return vitestPackage
 })
 
+addHook({
+  name: 'vitest',
+  versions: ['>=2.1.0 <3.0.0'],
+  filePattern: 'dist/chunks/RandomSequencer.*'
+}, (randomSequencerPackage) => {
+  shimmer.wrap(randomSequencerPackage.B.prototype, 'sort', getSortWrapper)
+  return randomSequencerPackage
+})
+
+addHook({
+  name: 'vitest',
+  versions: ['>=3.0.0'],
+  filePattern: 'dist/chunks/resolveConfig.*'
+}, (randomSequencerPackage) => {
+  shimmer.wrap(randomSequencerPackage.B.prototype, 'sort', getSortWrapper)
+  return randomSequencerPackage
+})
+
 // Can't specify file because compiled vitest includes hashes in their files
 addHook({
   name: 'vitest',
@@ -498,15 +560,17 @@ addHook({
   versions: ['>=1.6.0'],
   file: 'dist/index.js'
 }, (vitestPackage, frameworkVersion) => {
-  shimmer.wrap(vitestPackage, 'startTests', startTests => async function (testPath) {
+  shimmer.wrap(vitestPackage, 'startTests', startTests => async function (testPaths) {
     let testSuiteError = null
     if (!testSuiteStartCh.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: testPath[0], frameworkVersion })
+      testSuiteStartCh.publish({ testSuiteAbsolutePath, frameworkVersion })
     })
     const startTestsResponse = await startTests.apply(this, arguments)
 
@@ -528,7 +592,11 @@ addHook({
       if (result) {
         const { state, duration, errors } = result
         if (state === 'skip') { // programmatic skip
-          testSkipCh.publish({ testName: getTestName(task), testSuiteAbsolutePath: task.file.filepath })
+          testSkipCh.publish({
+            testName: getTestName(task),
+            testSuiteAbsolutePath: task.file.filepath,
+            isNew: newTasks.has(task)
+          })
         } else if (state === 'pass' && !isSwitchedStatus) {
           if (testAsyncResource) {
             testAsyncResource.runInAsyncScope(() => {
@@ -554,7 +622,11 @@ addHook({
           }
         }
       } else { // test.skip or test.todo
-        testSkipCh.publish({ testName: getTestName(task), testSuiteAbsolutePath: task.file.filepath })
+        testSkipCh.publish({
+          testName: getTestName(task),
+          testSuiteAbsolutePath: task.file.filepath,
+          isNew: newTasks.has(task)
+        })
       }
     })
 

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

@@ -0,0 +1,49 @@
+'use strict'
+
+const { channel, addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const names = ['vm', 'node:vm']
+
+const runScriptStartChannel = channel('datadog:vm:run-script:start')
+const sourceTextModuleStartChannel = channel('datadog:vm:source-text-module:start')
+
+addHook({ name: names }, function (vm) {
+  vm.Script = class extends vm.Script {
+    constructor (code) {
+      super(...arguments)
+
+      if (runScriptStartChannel.hasSubscribers && code) {
+        runScriptStartChannel.publish({ code })
+      }
+    }
+  }
+
+  if (vm.SourceTextModule && typeof vm.SourceTextModule === 'function') {
+    vm.SourceTextModule = class extends vm.SourceTextModule {
+      constructor (code) {
+        super(...arguments)
+
+        if (sourceTextModuleStartChannel.hasSubscribers && code) {
+          sourceTextModuleStartChannel.publish({ code })
+        }
+      }
+    }
+  }
+
+  shimmer.wrap(vm, 'runInContext', wrapVMMethod)
+  shimmer.wrap(vm, 'runInNewContext', wrapVMMethod)
+  shimmer.wrap(vm, 'runInThisContext', wrapVMMethod)
+  shimmer.wrap(vm, 'compileFunction', wrapVMMethod)
+
+  return vm
+})
+
+function wrapVMMethod (original) {
+  return function wrappedVMMethod (code) {
+    if (runScriptStartChannel.hasSubscribers && code) {
+      runScriptStartChannel.publish({ code })
+    }
+
+    return original.apply(this, arguments)
+  }
+}

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

@@ -0,0 +1,16 @@
+const CompositePlugin = require('../../../../dd-trace/src/plugins/composite')
+const BedrockRuntimeTracing = require('./tracing')
+const BedrockRuntimeLLMObsPlugin = require('../../../../dd-trace/src/llmobs/plugins/bedrockruntime')
+class BedrockRuntimePlugin extends CompositePlugin {
+  static get id () {
+    return 'bedrockruntime'
+  }
+
+  static get plugins () {
+    return {
+      llmobs: BedrockRuntimeLLMObsPlugin,
+      tracing: BedrockRuntimeTracing
+    }
+  }
+}
+module.exports = BedrockRuntimePlugin