dd-trace 5.41.1 → 5.42.0

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

@@ -43,7 +43,7 @@ const testErrCh = channel('ci:jest:test:err')
 const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const libraryConfigurationCh = channel('ci:jest:library-configuration')
 const knownTestsCh = channel('ci:jest:known-tests')
-const quarantinedTestsCh = channel('ci:jest:quarantined-tests')
+const testManagementTestsCh = channel('ci:jest:test-management-tests')
 
 const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 
@@ -71,8 +71,8 @@ let earlyFlakeDetectionFaultyThreshold = 30
 let isEarlyFlakeDetectionFaulty = false
 let hasFilteredSkippableSuites = false
 let isKnownTestsEnabled = false
-let isQuarantinedTestsEnabled = false
-let quarantinedTests = {}
+let isTestManagementTestsEnabled = false
+let testManagementTests = {}
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -143,7 +143,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.flakyTestRetriesCount = this.testEnvironmentOptions._ddFlakyTestRetriesCount
       this.isDiEnabled = this.testEnvironmentOptions._ddIsDiEnabled
       this.isKnownTestsEnabled = this.testEnvironmentOptions._ddIsKnownTestsEnabled
-      this.isQuarantinedTestsEnabled = this.testEnvironmentOptions._ddIsQuarantinedTestsEnabled
+      this.isTestManagementTestsEnabled = this.testEnvironmentOptions._ddIsTestManagementTestsEnabled
 
       if (this.isKnownTestsEnabled) {
         try {
@@ -166,15 +166,15 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
       }
 
-      if (this.isQuarantinedTestsEnabled) {
+      if (this.isTestManagementTestsEnabled) {
         try {
-          const hasQuarantinedTests = !!quarantinedTests.jest
-          this.quarantinedTestsForThisSuite = hasQuarantinedTests
-            ? this.getQuarantinedTestsForSuite(quarantinedTests.jest.suites?.[this.testSuite]?.tests)
-            : this.getQuarantinedTestsForSuite(this.testEnvironmentOptions._ddQuarantinedTests)
+          const hasTestManagementTests = !!testManagementTests.jest
+          this.testManagementTestsForThisSuite = hasTestManagementTests
+            ? this.getTestManagementTestsForSuite(testManagementTests.jest.suites?.[this.testSuite]?.tests)
+            : this.getTestManagementTestsForSuite(this.testEnvironmentOptions._ddTestManagementTests)
         } catch (e) {
-          log.error('Error parsing quarantined tests', e)
-          this.isQuarantinedTestsEnabled = false
+          log.error('Error parsing test management tests', e)
+          this.isTestManagementTestsEnabled = false
         }
       }
     }
@@ -209,25 +209,38 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       return knownTestsForSuite
     }
 
-    getQuarantinedTestsForSuite (quarantined) {
-      if (this.quarantinedTestsForThisSuite) {
-        return this.quarantinedTestsForThisSuite
+    getTestManagementTestsForSuite (testManagementTests) {
+      if (this.testManagementTestsForThisSuite) {
+        return this.testManagementTestsForThisSuite
       }
-      if (!quarantined) {
-        return []
+      // TODO - ADD ATTEMPT_TO_FIX tests
+      if (!testManagementTests) {
+        return {
+          disabled: [],
+          quarantined: []
+        }
       }
-      let quarantinedTestsForSuite = quarantined
-      // If jest is using workers, quarantined tests are serialized to json.
+      let testManagementTestsForSuite = testManagementTests
+      // If jest is using workers, test management tests are serialized to json.
       // If jest runs in band, they are not.
-      if (typeof quarantinedTestsForSuite === 'string') {
-        quarantinedTestsForSuite = JSON.parse(quarantinedTestsForSuite)
+      if (typeof testManagementTestsForSuite === 'string') {
+        testManagementTestsForSuite = JSON.parse(testManagementTestsForSuite)
+      }
+
+      const result = {
+        disabled: [],
+        quarantined: []
       }
-      return Object.entries(quarantinedTestsForSuite).reduce((acc, [testName, { properties }]) => {
-        if (properties?.quarantined) {
-          acc.push(testName)
+
+      Object.entries(testManagementTestsForSuite).forEach(([testName, { properties }]) => {
+        if (properties?.disabled) {
+          result.disabled.push(testName)
+        } else if (properties?.quarantined) {
+          result.quarantined.push(testName)
         }
-        return acc
-      }, [])
+      })
+
+      return result
     }
 
     // Add the `add_test` event we don't have the test object yet, so
@@ -275,6 +288,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             retriedTestsToNumAttempts.set(originalTestName, numEfdRetry + 1)
           }
         }
+
+        if (this.isTestManagementTestsEnabled) {
+          const isDisabled = this.testManagementTestsForThisSuite?.disabled?.includes(testName)
+          if (isDisabled) {
+            event.test.mode = 'skip'
+          }
+        }
         const isJestRetry = event.test?.invocations > 1
         asyncResource.runInAsyncScope(() => {
           testStartCh.publish({
@@ -341,9 +361,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
         let isQuarantined = false
 
-        if (this.isQuarantinedTestsEnabled) {
+        if (this.isTestManagementTestsEnabled) {
           const testName = getJestTestName(event.test)
-          isQuarantined = this.quarantinedTestsForThisSuite?.includes(testName)
+          isQuarantined = this.testManagementTestsForThisSuite?.quarantined?.includes(testName)
         }
 
         const promises = {}
@@ -391,12 +411,15 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         const asyncResource = new AsyncResource('bound-anonymous-fn')
         asyncResource.runInAsyncScope(() => {
           testSkippedCh.publish({
-            name: getJestTestName(event.test),
-            suite: this.testSuite,
-            testSourceFile: this.testSourceFile,
-            displayName: this.displayName,
-            frameworkVersion: jestVersion,
-            testStartLine: getTestLineStart(event.test.asyncError, this.testSuite)
+            test: {
+              name: getJestTestName(event.test),
+              suite: this.testSuite,
+              testSourceFile: this.testSourceFile,
+              displayName: this.displayName,
+              frameworkVersion: jestVersion,
+              testStartLine: getTestLineStart(event.test.asyncError, this.testSuite)
+            },
+            isDisabled: this.testManagementTestsForThisSuite?.disabled?.includes(getJestTestName(event.test))
           })
         })
       }
@@ -528,7 +551,7 @@ function cliWrapper (cli, jestVersion) {
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
         earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
-        isQuarantinedTestsEnabled = libraryConfig.isQuarantinedTestsEnabled
+        isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
       }
     } catch (err) {
       log.error('Jest library configuration error', err)
@@ -576,22 +599,22 @@ function cliWrapper (cli, jestVersion) {
       }
     }
 
-    if (isQuarantinedTestsEnabled) {
-      const quarantinedTestsPromise = new Promise((resolve) => {
+    if (isTestManagementTestsEnabled) {
+      const testManagementTestsPromise = new Promise((resolve) => {
         onDone = resolve
       })
 
       sessionAsyncResource.runInAsyncScope(() => {
-        quarantinedTestsCh.publish({ onDone })
+        testManagementTestsCh.publish({ onDone })
       })
 
       try {
-        const { err, quarantinedTests: receivedQuarantinedTests } = await quarantinedTestsPromise
+        const { err, testManagementTests: receivedTestManagementTests } = await testManagementTestsPromise
         if (!err) {
-          quarantinedTests = receivedQuarantinedTests
+          testManagementTests = receivedTestManagementTests
         }
       } catch (err) {
-        log.error('Jest quarantined tests error', err)
+        log.error('Jest test management tests error', err)
       }
     }
 
@@ -664,7 +687,7 @@ function cliWrapper (cli, jestVersion) {
         error,
         isEarlyFlakeDetectionEnabled,
         isEarlyFlakeDetectionFaulty,
-        isQuarantinedTestsEnabled,
+        isTestManagementTestsEnabled,
         onDone
       })
     })
@@ -698,7 +721,7 @@ function cliWrapper (cli, jestVersion) {
       }
     }
 
-    if (isQuarantinedTestsEnabled) {
+    if (isTestManagementTestsEnabled) {
       const failedTests = result
         .results
         .testResults.flatMap(({ testResults, testFilePath: testSuiteAbsolutePath }) => (
@@ -710,7 +733,7 @@ function cliWrapper (cli, jestVersion) {
 
       for (const { testName, testSuiteAbsolutePath } of failedTests) {
         const testSuite = getTestSuitePath(testSuiteAbsolutePath, result.globalConfig.rootDir)
-        const isQuarantined = quarantinedTests
+        const isQuarantined = testManagementTests
           ?.jest
           ?.suites
           ?.[testSuite]
@@ -922,8 +945,8 @@ addHook({
       _ddFlakyTestRetriesCount,
       _ddIsDiEnabled,
       _ddIsKnownTestsEnabled,
-      _ddIsQuarantinedTestsEnabled,
-      _ddQuarantinedTests,
+      _ddIsTestManagementTestsEnabled,
+      _ddTestManagementTests,
       ...restOfTestEnvironmentOptions
     } = testEnvironmentOptions
 
@@ -1037,7 +1060,7 @@ addHook({
 /*
 * This hook does three things:
 * - Pass known tests to the workers.
-* - Pass quarantined tests to the workers.
+* - Pass test management tests to the workers.
 * - Receive trace, coverage and logs payloads from the workers.
 */
 addHook({
@@ -1047,7 +1070,7 @@ addHook({
 }, (childProcessWorker) => {
   const ChildProcessWorker = childProcessWorker.default
   shimmer.wrap(ChildProcessWorker.prototype, 'send', send => function (request) {
-    if (!isKnownTestsEnabled && !isQuarantinedTestsEnabled) {
+    if (!isKnownTestsEnabled && !isTestManagementTestsEnabled) {
       return send.apply(this, arguments)
     }
     const [type] = request
@@ -1068,14 +1091,14 @@ addHook({
       const testSuite = getTestSuitePath(testSuiteAbsolutePath, globalConfig.rootDir || process.cwd())
       const suiteKnownTests = knownTests?.jest?.[testSuite] || []
 
-      const suiteQuarantinedTests = quarantinedTests.jest?.suites?.[testSuite]?.tests || {}
+      const suiteTestManagementTests = testManagementTests.jest?.suites?.[testSuite]?.tests || {}
 
       args[0].config = {
         ...config,
         testEnvironmentOptions: {
           ...config.testEnvironmentOptions,
           _ddKnownTests: suiteKnownTests,
-          _ddQuarantinedTests: suiteQuarantinedTests
+          _ddTestManagementTests: suiteTestManagementTests
         }
       }
     }

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

@@ -61,17 +61,36 @@ for (const extension of extensions) {
     return exports
   })
 
-  addHook({ name: '@langchain/openai', file: `dist/embeddings.${extension}`, versions: ['>=0.1'] }, exports => {
-    const OpenAIEmbeddings = exports.OpenAIEmbeddings
+  addHook({ name: '@langchain/core', file: `dist/embeddings.${extension}`, versions: ['>=0.1'] }, exports => {
+    // we cannot patch the prototype of the Embeddings class directly
+    // this is because the "abstract class Embeddings" is transpiled from TypeScript to not include abstract functions
+    // thus, we patch the exported class directly instead instead.
+
+    shimmer.wrap(exports, 'Embeddings', Embeddings => {
+      return class extends Embeddings {
+        constructor (...args) {
+          super(...args)
+
+          const namespace = ['langchain', 'embeddings']
+
+          // when originally implemented, we only wrapped OpenAI embeddings
+          // these embeddings had the resource name of `langchain.embeddings.openai.OpenAIEmbeddings`
+          // we need to make sure `openai` is appended to the resource name until a new tracer major version
+          if (this.constructor.name === 'OpenAIEmbeddings') {
+            namespace.push('openai')
+          }
+
+          shimmer.wrap(this, 'embedQuery', embedQuery => wrapLangChainPromise(embedQuery, 'embedding', namespace))
+          shimmer.wrap(this, 'embedDocuments',
+            embedDocuments => wrapLangChainPromise(embedDocuments, 'embedding', namespace))
+        }
+
+        static [Symbol.hasInstance] (instance) {
+          return instance instanceof Embeddings
+        }
+      }
+    })
 
-    // OpenAI (and Embeddings in general) do not define an lc_namespace
-    const namespace = ['langchain', 'embeddings', 'openai']
-    shimmer.wrap(OpenAIEmbeddings.prototype, 'embedDocuments', embedDocuments =>
-      wrapLangChainPromise(embedDocuments, 'embedding', namespace)
-    )
-    shimmer.wrap(OpenAIEmbeddings.prototype, 'embedQuery', embedQuery =>
-      wrapLangChainPromise(embedQuery, 'embedding', namespace)
-    )
     return exports
   })
 }

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

@@ -17,6 +17,7 @@ const {
 
 const {
   isNewTest,
+  getTestProperties,
   getSuitesByTestFile,
   runnableWrapper,
   getOnTestHandler,
@@ -62,7 +63,7 @@ const testSuiteCodeCoverageCh = channel('ci:mocha:test-suite:code-coverage')
 const libraryConfigurationCh = channel('ci:mocha:library-configuration')
 const knownTestsCh = channel('ci:mocha:known-tests')
 const skippableSuitesCh = channel('ci:mocha:test-suite:skippable')
-const quarantinedTestsCh = channel('ci:mocha:quarantined-tests')
+const testManagementTestsCh = channel('ci:mocha:test-management-tests')
 const workerReportTraceCh = channel('ci:mocha:worker-report:trace')
 const testSessionStartCh = channel('ci:mocha:session:start')
 const testSessionFinishCh = channel('ci:mocha:session:finish')
@@ -76,7 +77,7 @@ function isTestFailed (test) {
     return test.isFailed()
   }
   if (test.isPending) {
-    return !test.isPending() && test.state !== 'failed'
+    return !test.isPending() && test.state === 'failed'
   }
   return false
 }
@@ -138,7 +139,7 @@ function getOnEndHandler (isParallel) {
     }
 
     // We subtract the errors from quarantined tests from the total number of failures
-    if (config.isQuarantinedTestsEnabled) {
+    if (config.isTestManagementTestsEnabled) {
       let numFailedQuarantinedTests = 0
       for (const test of testsQuarantined) {
         if (isTestFailed(test)) {
@@ -179,7 +180,7 @@ function getOnEndHandler (isParallel) {
       error,
       isEarlyFlakeDetectionEnabled: config.isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty: config.isEarlyFlakeDetectionFaulty,
-      isQuarantinedTestsEnabled: config.isQuarantinedTestsEnabled,
+      isTestManagementEnabled: config.isTestManagementTestsEnabled,
       isParallel
     })
   })
@@ -188,12 +189,12 @@ function getOnEndHandler (isParallel) {
 function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
   const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
 
-  const onReceivedQuarantinedTests = ({ err, quarantinedTests: receivedQuarantinedTests }) => {
+  const onReceivedTestManagementTests = ({ err, testManagementTests: receivedTestManagementTests }) => {
     if (err) {
-      config.quarantinedTests = {}
-      config.isQuarantinedTestsEnabled = false
+      config.testManagementTests = {}
+      config.isTestManagementTestsEnabled = false
     } else {
-      config.quarantinedTests = receivedQuarantinedTests
+      config.testManagementTests = receivedTestManagementTests
     }
     if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
@@ -236,9 +237,9 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     } else {
       config.knownTests = knownTests
     }
-    if (config.isQuarantinedTestsEnabled) {
-      quarantinedTestsCh.publish({
-        onDone: mochaRunAsyncResource.bind(onReceivedQuarantinedTests)
+    if (config.isTestManagementTestsEnabled) {
+      testManagementTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedTestManagementTests)
       })
     } else if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
@@ -258,19 +259,19 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     config.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
     config.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
     config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
-    // ITR, auto test retries and quarantine are not supported in parallel mode yet
+    config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
+    // 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
-    config.isQuarantinedTestsEnabled = !isParallel && libraryConfig.isQuarantinedTestsEnabled
 
     if (config.isKnownTestsEnabled) {
       knownTestsCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedKnownTests)
       })
-    } else if (config.isQuarantinedTestsEnabled) {
-      quarantinedTestsCh.publish({
-        onDone: mochaRunAsyncResource.bind(onReceivedQuarantinedTests)
+    } else if (config.isTestManagementTestsEnabled) {
+      testManagementTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedTestManagementTests)
       })
     } else if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
@@ -282,7 +283,8 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
   }
 
   libraryConfigurationCh.publish({
-    onDone: mochaRunAsyncResource.bind(onReceivedConfiguration)
+    onDone: mochaRunAsyncResource.bind(onReceivedConfiguration),
+    isParallel
   })
 }
 
@@ -613,41 +615,54 @@ addHook({
   const { BufferedWorkerPool } = BufferedWorkerPoolPackage
 
   shimmer.wrap(BufferedWorkerPool.prototype, 'run', run => async function (testSuiteAbsolutePath, workerArgs) {
-    if (!testStartCh.hasSubscribers || !config.isKnownTestsEnabled) {
+    if (!testStartCh.hasSubscribers || (!config.isKnownTestsEnabled && !config.isTestManagementTestsEnabled)) {
       return run.apply(this, arguments)
     }
 
     const testPath = getTestSuitePath(testSuiteAbsolutePath, process.cwd())
-    const testSuiteKnownTests = config.knownTests.mocha?.[testPath] || []
-    const testSuiteQuarantinedTests = config.quarantinedTests?.modules?.mocha?.suites?.[testPath] || []
+
+    const newWorkerArgs = { ...workerArgs }
+
+    if (config.isKnownTestsEnabled) {
+      const testSuiteKnownTests = config.knownTests.mocha?.[testPath] || []
+      newWorkerArgs._ddEfdNumRetries = config.earlyFlakeDetectionNumRetries
+      newWorkerArgs._ddIsEfdEnabled = config.isEarlyFlakeDetectionEnabled
+      newWorkerArgs._ddIsKnownTestsEnabled = true
+      newWorkerArgs._ddKnownTests = {
+        mocha: {
+          [testPath]: testSuiteKnownTests
+        }
+      }
+    }
+    if (config.isTestManagementTestsEnabled) {
+      const testSuiteTestManagementTests = config.testManagementTests?.mocha?.suites?.[testPath] || {}
+      newWorkerArgs._ddIsTestManagementTestsEnabled = true
+      newWorkerArgs._ddTestManagementTests = {
+        mocha: {
+          suites: {
+            [testPath]: testSuiteTestManagementTests
+          }
+        }
+      }
+    }
 
     // We pass the known tests for the test file to the worker
     const testFileResult = await run.apply(
       this,
       [
         testSuiteAbsolutePath,
-        {
-          ...workerArgs,
-          _ddEfdNumRetries: config.earlyFlakeDetectionNumRetries,
-          _ddIsEfdEnabled: config.isEarlyFlakeDetectionEnabled,
-          _ddIsQuarantinedEnabled: config.isQuarantinedTestsEnabled,
-          _ddQuarantinedTests: testSuiteQuarantinedTests,
-          _ddKnownTests: {
-            mocha: {
-              [testPath]: testSuiteKnownTests
-            }
-          }
-        }
+        newWorkerArgs
       ]
     )
+
     const tests = testFileResult
       .events
       .filter(event => event.eventName === 'test end')
       .map(event => event.data)
 
-    // `newTests` is filled in the worker process, so we need to use the test results to fill it here too.
     for (const test of tests) {
-      if (isNewTest(test, config.knownTests)) {
+      // `newTests` is filled in the worker process, so we need to use the test results to fill it here too.
+      if (config.isKnownTestsEnabled && isNewTest(test, config.knownTests)) {
         const testFullName = getTestFullName(test)
         const tests = newTests[testFullName]
 
@@ -657,6 +672,10 @@ addHook({
           tests.push(test)
         }
       }
+      // `testsQuarantined` is filled in the worker process, so we need to use the test results to fill it here too.
+      if (config.isTestManagementTestsEnabled && getTestProperties(test, config.testManagementTests).isQuarantined) {
+        testsQuarantined.add(test)
+      }
     }
     return testFileResult
   })

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

@@ -28,24 +28,26 @@ const wrappedFunctions = new WeakSet()
 const newTests = {}
 const testsQuarantined = new Set()
 
-function isQuarantinedTest (test, testsToQuarantine) {
+function getAfterEachHooks (testOrHook) {
+  const hooks = []
+
+  while (testOrHook.parent) {
+    if (testOrHook.parent._afterEach) {
+      hooks.push(...testOrHook.parent._afterEach)
+    }
+    testOrHook = testOrHook.parent
+  }
+  return hooks
+}
+
+function getTestProperties (test, testManagementTests) {
   const testSuite = getTestSuitePath(test.file, process.cwd())
   const testName = test.fullTitle()
 
-  const isQuarantined = (testsToQuarantine
-    .mocha
-    ?.suites
-    ?.[testSuite]
-    ?.tests
-    ?.[testName]
-    ?.properties
-    ?.quarantined) ?? false
-
-  if (isQuarantined) {
-    testsQuarantined.add(test)
-  }
+  const { disabled: isDisabled, quarantined: isQuarantined } =
+    testManagementTests?.mocha?.suites?.[testSuite]?.tests?.[testName]?.properties || {}
 
-  return isQuarantined
+  return { isDisabled, isQuarantined }
 }
 
 function isNewTest (test, knownTests) {
@@ -193,6 +195,7 @@ function getOnTestHandler (isMain) {
       title,
       _ddIsNew: isNew,
       _ddIsEfdRetry: isEfdRetry,
+      _ddIsDisabled: isDisabled,
       _ddIsQuarantined: isQuarantined
     } = test
 
@@ -209,6 +212,7 @@ function getOnTestHandler (isMain) {
 
     testInfo.isNew = isNew
     testInfo.isEfdRetry = isEfdRetry
+    testInfo.isDisabled = isDisabled
     testInfo.isQuarantined = isQuarantined
     // We want to store the result of the new tests
     if (isNew) {
@@ -220,6 +224,10 @@ function getOnTestHandler (isMain) {
       }
     }
 
+    if (isDisabled) {
+      test.pending = true
+    }
+
     asyncResource.runInAsyncScope(() => {
       testStartCh.publish(testInfo)
     })
@@ -242,7 +250,7 @@ function getOnTestEndHandler () {
     }
 
     // if there are afterEach to be run, we don't finish the test yet
-    if (asyncResource && !test.parent._afterEach.length) {
+    if (asyncResource && !getAfterEachHooks(test).length) {
       asyncResource.runInAsyncScope(() => {
         testFinishCh.publish({
           status,
@@ -257,18 +265,15 @@ function getOnTestEndHandler () {
 function getOnHookEndHandler () {
   return function (hook) {
     const test = hook.ctx.currentTest
-    if (test && hook.parent._afterEach.includes(hook)) { // only if it's an afterEach
-      const isLastRetry = getIsLastRetry(test)
-      if (test._retries > 0 && !isLastRetry) {
-        return
-      }
-      const isLastAfterEach = hook.parent._afterEach.indexOf(hook) === hook.parent._afterEach.length - 1
+    const afterEachHooks = getAfterEachHooks(hook)
+    if (test && afterEachHooks.includes(hook)) { // only if it's an afterEach
+      const isLastAfterEach = afterEachHooks.indexOf(hook) === afterEachHooks.length - 1
       if (isLastAfterEach) {
         const status = getTestStatus(test)
         const asyncResource = getTestAsyncResource(test)
         if (asyncResource) {
           asyncResource.runInAsyncScope(() => {
-            testFinishCh.publish({ status, hasBeenRetried: isMochaRetry(test), isLastRetry })
+            testFinishCh.publish({ status, hasBeenRetried: isMochaRetry(test), isLastRetry: getIsLastRetry(test) })
           })
         }
       }
@@ -384,9 +389,13 @@ function getRunTestsWrapper (runTests, config) {
       })
     }
 
-    if (config.isQuarantinedTestsEnabled) {
+    if (config.isTestManagementTestsEnabled) {
       suite.tests.forEach(test => {
-        if (isQuarantinedTest(test, config.quarantinedTests)) {
+        const { isDisabled, isQuarantined } = getTestProperties(test, config.testManagementTests)
+        if (isDisabled) {
+          test._ddIsDisabled = true
+        } else if (isQuarantined) {
+          testsQuarantined.add(test)
           test._ddIsQuarantined = true
         }
       })
@@ -398,6 +407,7 @@ function getRunTestsWrapper (runTests, config) {
 
 module.exports = {
   isNewTest,
+  getTestProperties,
   retryTest,
   getSuitesByTestFile,
   isMochaRetry,

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

@@ -24,8 +24,7 @@ addHook({
   file: 'lib/mocha.js'
 }, (Mocha) => {
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
-    if (this.options._ddKnownTests) {
-      // If there are known tests, it means isKnownTestsEnabled should be true
+    if (this.options._ddIsKnownTestsEnabled) {
       config.isKnownTestsEnabled = true
       config.isEarlyFlakeDetectionEnabled = this.options._ddIsEfdEnabled
       config.knownTests = this.options._ddKnownTests
@@ -33,13 +32,13 @@ addHook({
       delete this.options._ddIsEfdEnabled
       delete this.options._ddKnownTests
       delete this.options._ddEfdNumRetries
-      delete this.options._ddQuarantinedTests
+      delete this.options._ddIsKnownTestsEnabled
     }
-    if (this.options._ddIsQuarantinedEnabled) {
-      config.isQuarantinedEnabled = true
-      config.quarantinedTests = this.options._ddQuarantinedTests
-      delete this.options._ddIsQuarantinedEnabled
-      delete this.options._ddQuarantinedTests
+    if (this.options._ddIsTestManagementTestsEnabled) {
+      config.isTestManagementTestsEnabled = true
+      config.testManagementTests = this.options._ddTestManagementTests
+      delete this.options._ddIsTestManagementTestsEnabled
+      delete this.options._ddTestManagementTests
     }
     return run.apply(this, arguments)
   })

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

@@ -391,5 +391,5 @@ function finish (ctx, response, error) {
 }
 
 function getOption (args, option, defaultValue) {
-  return args[args.length - 1]?.[option] || defaultValue
+  return args[0]?.[option] || defaultValue
 }