dd-trace 5.88.0 → 5.90.0

package/packages/datadog-instrumentations/src/helpers/rewriter/orchestrion/index.js

@@ -0,0 +1,43 @@
+'use strict'
+
+/*
+This folder is basically a JavaScript version of Orchestrion-JS. The goal is
+not to replace Orchestrion-JS, but rather to make it easier and faster to write
+new integrations in the short-term, especially as many changes to the rewriter
+will be needed as all the patterns we need have not been identified yet. This
+will avoid the back and forth of having to make Rust changes to an external
+library for every integration change or addition that requires something new.
+
+In the meantime, we'll work concurrently on a change to Orchestrion-JS that
+adds an "arbitrary transform" or "plugin" system that can be used from
+JavaScript, in order to enable quick iteration while still using Orchestrion-JS.
+Once that's done we'll use that, so that we can remove this JS approach and
+return to using Orchestrion-JS.
+
+The long term goal is to backport any additional features we add to the JS
+rewriter (or using the plugin system in Orchestrion-JS once we're using that)
+to Orchestrion-JS  once we're confident that the implementation is fairly
+complete and has all features we need.
+
+Here is a list of the additions and changes in this rewriter compared to
+Orchestrion-JS that will need to be backported:
+
+(NOTE: Please keep this list up-to-date whenever new features are added)
+
+- Supports an `astQuery` field to filter AST nodes with an esquery query. This
+  is mostly meant to be used when experimenting or if what needs to be queried
+  is not a function. We'll see over time if something like this is needed to be
+  backported or if it can be replaced by simpler queries.
+- Supports replacing methods of child class instances in the base constructor.
+- Supports tracing iterator (sync/async) returning functions (sync/async).
+*/
+
+/* eslint-disable camelcase */
+
+const { InstrumentationMatcher } = require('./matcher')
+
+function create (configs, dc_module) {
+  return new InstrumentationMatcher(configs, dc_module)
+}
+
+module.exports = { create }

package/packages/datadog-instrumentations/src/helpers/rewriter/orchestrion/matcher.js

@@ -0,0 +1,49 @@
+'use strict'
+
+/* eslint-disable camelcase */
+
+const semifies = require('../../../../../../vendor/dist/semifies')
+const { Transformer } = require('./transformer')
+
+// TODO: addTransform
+
+class InstrumentationMatcher {
+  #configs = []
+  #dc_module = null
+  #transformers = {}
+
+  constructor (configs, dc_module) {
+    this.#configs = configs
+    this.#dc_module = dc_module || 'diagnostics_channel'
+  }
+
+  free () {
+    this.#transformers = {}
+  }
+
+  getTransformer (module_name, version, file_path) {
+    const id = `${module_name}/${file_path}@${version}`
+
+    if (this.#transformers[id]) return this.#transformers[id]
+
+    const configs = this.#configs.filter(({ module: { name, filePath, versionRange } }) =>
+      name === module_name &&
+      filePath === file_path &&
+      semifies(version, versionRange)
+    )
+
+    if (configs.length === 0) return
+
+    this.#transformers[id] = new Transformer(
+      module_name,
+      version,
+      file_path,
+      configs,
+      this.#dc_module
+    )
+
+    return this.#transformers[id]
+  }
+}
+
+module.exports = { InstrumentationMatcher }

package/packages/datadog-instrumentations/src/helpers/rewriter/orchestrion/transformer.js

@@ -0,0 +1,121 @@
+'use strict'
+
+/* eslint-disable camelcase */
+
+const { generate, parse, traverse } = require('./compiler')
+const transforms = require('./transforms')
+
+let SourceMapConsumer
+let SourceMapGenerator
+
+class Transformer {
+  #module_name = null
+  #file_path = null
+  #configs = []
+  #dc_module = null
+
+  // TODO: module_name false for user module
+  constructor (module_name, _version, file_path, configs, dc_module) {
+    this.#module_name = module_name
+    this.#file_path = file_path
+    this.#configs = configs
+    this.#dc_module = dc_module
+  }
+
+  free () {
+    // Freeing is not needed for a JavaScript implementation.
+  }
+
+  transform (code, module_type, sourcemap) {
+    if (!code) return { code }
+
+    const sourceType = module_type === 'esm' ? 'module' : 'script'
+
+    let ast
+
+    for (const config of this.#configs) {
+      const { astQuery, functionQuery = {} } = config
+
+      ast ??= parse(code.toString(), { range: true, sourceType })
+
+      const query = astQuery || this.#fromFunctionQuery(functionQuery)
+      const state = { ...config, dcModule: this.#dc_module, sourceType, functionQuery }
+
+      state.operator = this.#getOperator(state)
+
+      traverse(ast, query, (...args) => this.#visit(state, ...args))
+    }
+
+    if (ast) {
+      SourceMapConsumer ??= require('../../../../../../vendor/dist/@datadog/source-map').SourceMapConsumer
+      SourceMapGenerator ??= require('../../../../../../vendor/dist/@datadog/source-map').SourceMapGenerator
+
+      const file = `${this.#module_name}/${this.#file_path}`
+      const sourceMapInput = sourcemap ? new SourceMapConsumer(sourcemap) : { file }
+      const sourceMap = new SourceMapGenerator(sourceMapInput)
+      const code = generate(ast, { sourceMap })
+      const map = sourceMap.toString()
+
+      return { code, map }
+    }
+
+    return { code }
+  }
+
+  #visit (state, ...args) {
+    const transform = transforms[state.operator]
+    const { index } = state.functionQuery
+
+    if (index !== undefined) {
+      state.functionIndex = ++state.functionIndex || 0
+
+      if (index !== state.functionIndex) return
+    }
+
+    transform(state, ...args)
+  }
+
+  #getOperator ({ functionQuery: { kind } }) {
+    switch (kind) {
+      case 'Async': return 'tracePromise'
+      case 'AsyncIterator': return 'traceAsyncIterator'
+      case 'Callback': return 'traceCallback'
+      case 'Iterator': return 'traceIterator'
+      case 'Sync': return 'traceSync'
+    }
+  }
+
+  #fromFunctionQuery (functionQuery) {
+    const { functionName, expressionName, className } = functionQuery
+    const method = functionQuery.methodName || functionQuery.privateMethodName
+    const type = functionQuery.privateMethodName ? 'PrivateIdentifier' : 'Identifier'
+    const queries = []
+
+    if (className) {
+      queries.push(
+        `[id.name="${className}"]`,
+        `[id.name="${className}"] > ClassExpression`,
+        `[id.name="${className}"] > ClassBody > [key.name="${method}"][key.type=${type}] > [async]`,
+        `[id.name="${className}"] > ClassExpression > ClassBody > [key.name="${method}"][key.type=${type}] > [async]`
+      )
+    } else if (method) {
+      queries.push(
+        `ClassBody > [key.name="${method}"][key.type=${type}] > [async]`,
+        `Property[key.name="${method}"][key.type=${type}] > [async]`
+      )
+    }
+
+    if (functionName) {
+      queries.push(`FunctionDeclaration[id.name="${functionName}"][async]`)
+    } else if (expressionName) {
+      queries.push(
+        `FunctionExpression[id.name="${expressionName}"][async]`,
+        `ArrowFunctionExpression[id.name="${expressionName}"][async]`
+      )
+    }
+
+    return queries.join(', ')
+  }
+}
+
+module.exports = { Transformer }

package/packages/datadog-instrumentations/src/helpers/rewriter/{transforms.js → orchestrion/transforms.js}

@@ -8,13 +8,13 @@ const tracingChannelPredicate = (node) => (
 )
 
 const transforms = module.exports = {
-  tracingChannelImport ({ sourceType }, node) {
+  tracingChannelImport ({ dcModule, sourceType }, node) {
     if (node.body.some(tracingChannelPredicate)) return
 
     const index = node.body.findIndex(child => child.directive === 'use strict')
     const code = sourceType === 'module'
-      ? 'import { tracingChannel as tr_ch_apm_tracingChannel } from "diagnostics_channel"'
-      : 'const {tracingChannel: tr_ch_apm_tracingChannel} = require("diagnostics_channel")'
+      ? `import { tracingChannel as tr_ch_apm_tracingChannel } from "${dcModule}"`
+      : `const {tracingChannel: tr_ch_apm_tracingChannel} = require("${dcModule}")`
 
     node.body.splice(index + 1, 0, parse(code, { sourceType }).body[0])
   },
@@ -196,11 +196,11 @@ function wrapSuper (_state, node) {
 }
 
 function wrapCallback (state, node) {
-  const { channelName, functionQuery: { index = -1 } } = state
+  const { channelName, functionQuery: { callbackIndex = -1 } } = state
   const channelVariable = 'tr_ch_apm$' + channelName.replaceAll(':', '_')
   const wrapper = parse(`
     function wrapper () {
-      const __apm$cb = Array.prototype.at.call(arguments, ${index});
+      const __apm$cb = Array.prototype.at.call(arguments, ${callbackIndex});
       const __apm$ctx = {
         arguments,
         self: this,
@@ -235,7 +235,7 @@ function wrapCallback (state, node) {
       if (typeof __apm$cb !== 'function') {
         return __apm$traced();
       }
-      Array.prototype.splice.call(arguments, ${index}, 1, __apm$wrappedCb);
+      Array.prototype.splice.call(arguments, ${callbackIndex}, 1, __apm$wrappedCb);
 
       return ${channelVariable}.start.runStores(__apm$ctx, () => {
         try {

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

@@ -47,6 +47,7 @@ const testSkippedCh = channel('ci:jest:test:skip')
 const testFinishCh = channel('ci:jest:test:finish')
 const testErrCh = channel('ci:jest:test:err')
 const testFnCh = channel('ci:jest:test:fn')
+const testSuiteHookFnCh = channel('ci:jest:test-suite:hook:fn')
 
 const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const libraryConfigurationCh = channel('ci:jest:library-configuration')
@@ -69,7 +70,9 @@ const RETRY_TIMES = Symbol.for('RETRY_TIMES')
 let skippableSuites = []
 let knownTests = {}
 let isCodeCoverageEnabled = false
+let isCodeCoverageEnabledBecauseOfUs = false
 let isSuitesSkippingEnabled = false
+let isKeepingCoverageConfiguration = false
 let isUserCodeCoverageEnabled = false
 let isSuitesSkipped = false
 let numSkippedSuites = 0
@@ -503,6 +506,19 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         })
       }
 
+      if (event.name === 'hook_start' && (event.hook.type === 'beforeAll' || event.hook.type === 'afterAll')) {
+        const ctx = { testSuiteAbsolutePath: this.testSuiteAbsolutePath }
+        let hookFn = event.hook.fn
+        if (originalHookFns.has(event.hook)) {
+          hookFn = originalHookFns.get(event.hook)
+        } else {
+          originalHookFns.set(event.hook, hookFn)
+        }
+        event.hook.fn = shimmer.wrapFunction(hookFn, hookFn => function () {
+          return testSuiteHookFnCh.runStores(ctx, () => hookFn.apply(this, arguments))
+        })
+      }
+
       if (event.name === 'add_test') {
         if (event.failing) {
           return
@@ -671,6 +687,14 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
 
+        // ATR: set failedAllTests when all auto test retries were exhausted and every attempt failed
+        if (this.isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry) {
+          const maxRetries = Number(this.global[RETRY_TIMES]) || 0
+          if (event.test?.invocations === maxRetries + 1 && status === 'fail') {
+            failedAllTests = true
+          }
+        }
+
         const promises = {}
         const numRetries = this.global[RETRY_TIMES]
         const numTestExecutions = event.test?.invocations
@@ -994,6 +1018,8 @@ function getCliWrapper (isNewJestVersion) {
         if (!err) {
           isCodeCoverageEnabled = libraryConfig.isCodeCoverageEnabled
           isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
+          isKeepingCoverageConfiguration =
+            libraryConfig.isKeepingCoverageConfiguration ?? isKeepingCoverageConfiguration
           isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
           earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
           earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
@@ -1327,9 +1353,10 @@ function coverageReporterWrapper (coverageReporter) {
    */
   // `_addUntestedFiles` is an async function
   shimmer.wrap(CoverageReporter.prototype, '_addUntestedFiles', addUntestedFiles => function () {
-    // If the user has added coverage manually, they're willing to pay the price of this execution, so
-    // we will not skip it.
-    if (isSuitesSkippingEnabled && !isUserCodeCoverageEnabled) {
+    if (isKeepingCoverageConfiguration) {
+      return addUntestedFiles.apply(this, arguments)
+    }
+    if (isCodeCoverageEnabledBecauseOfUs) {
       return Promise.resolve()
     }
     return addUntestedFiles.apply(this, arguments)
@@ -1509,12 +1536,13 @@ function configureTestEnvironment (readConfigsResult) {
   }
 
   isUserCodeCoverageEnabled = !!readConfigsResult.globalConfig.collectCoverage
+  isCodeCoverageEnabledBecauseOfUs = isCodeCoverageEnabled && !isUserCodeCoverageEnabled
 
   if (readConfigsResult.globalConfig.forceExit) {
     log.warn("Jest's '--forceExit' flag has been passed. This may cause loss of data.")
   }
 
-  if (isCodeCoverageEnabled) {
+  if (isCodeCoverageEnabledBecauseOfUs) {
     const globalConfig = {
       ...readConfigsResult.globalConfig,
       collectCoverage: true,
@@ -1522,14 +1550,18 @@ function configureTestEnvironment (readConfigsResult) {
     readConfigsResult.globalConfig = globalConfig
   }
   if (isSuitesSkippingEnabled) {
-    // If suite skipping is enabled, the code coverage results are not going to be relevant,
-    // so we do not show them.
-    // Also, we might skip every test, so we need to pass `passWithNoTests`
+    // If suite skipping is enabled, we pass `passWithNoTests` in case every test gets skipped.
     const globalConfig = {
       ...readConfigsResult.globalConfig,
-      coverageReporters: ['none'],
       passWithNoTests: true,
     }
+    if (isCodeCoverageEnabledBecauseOfUs && !isKeepingCoverageConfiguration) {
+      globalConfig.coverageReporters = ['none']
+      readConfigsResult.configs = configs.map(config => ({
+        ...config,
+        coverageReporters: ['none'],
+      }))
+    }
     readConfigsResult.globalConfig = globalConfig
   }
 
@@ -1552,49 +1584,97 @@ function jestConfigSyncWrapper (jestConfig) {
   })
 }
 
+const DD_TEST_ENVIRONMENT_OPTION_KEYS = [
+  '_ddTestModuleId',
+  '_ddTestSessionId',
+  '_ddTestCommand',
+  '_ddTestSessionName',
+  '_ddForcedToRun',
+  '_ddUnskippable',
+  '_ddItrCorrelationId',
+  '_ddKnownTests',
+  '_ddIsEarlyFlakeDetectionEnabled',
+  '_ddEarlyFlakeDetectionSlowTestRetries',
+  '_ddRepositoryRoot',
+  '_ddIsFlakyTestRetriesEnabled',
+  '_ddFlakyTestRetriesCount',
+  '_ddIsDiEnabled',
+  '_ddIsKnownTestsEnabled',
+  '_ddIsTestManagementTestsEnabled',
+  '_ddTestManagementTests',
+  '_ddTestManagementAttemptToFixRetries',
+  '_ddModifiedFiles',
+]
+
+function removeDatadogTestEnvironmentOptions (testEnvironmentOptions) {
+  const removedEntries = []
+
+  for (const key of DD_TEST_ENVIRONMENT_OPTION_KEYS) {
+    if (!Object.hasOwn(testEnvironmentOptions, key)) {
+      continue
+    }
+
+    removedEntries.push([key, testEnvironmentOptions[key]])
+    delete testEnvironmentOptions[key]
+  }
+
+  return function restoreDatadogTestEnvironmentOptions () {
+    for (const [key, value] of removedEntries) {
+      testEnvironmentOptions[key] = value
+    }
+  }
+}
+
+/**
+ * Wrap `createScriptTransformer` to temporarily hide Datadog-specific
+ * `testEnvironmentOptions` keys while Jest builds its transform config.
+ *
+ * @param {Function} createScriptTransformer
+ * @returns {Function}
+ */
+function wrapCreateScriptTransformer (createScriptTransformer) {
+  return function (config) {
+    const testEnvironmentOptions = config?.testEnvironmentOptions
+
+    if (!testEnvironmentOptions) {
+      return createScriptTransformer.apply(this, arguments)
+    }
+
+    const restoreTestEnvironmentOptions = removeDatadogTestEnvironmentOptions(testEnvironmentOptions)
+
+    try {
+      const result = createScriptTransformer.apply(this, arguments)
+
+      if (result?.then) {
+        return result.finally(restoreTestEnvironmentOptions)
+      }
+
+      restoreTestEnvironmentOptions()
+      return result
+    } catch (e) {
+      restoreTestEnvironmentOptions()
+      throw e
+    }
+  }
+}
+
 addHook({
   name: '@jest/transform',
-  versions: ['>=24.8.0'],
+  versions: ['>=24.8.0 <30.0.0'],
   file: 'build/ScriptTransformer.js',
 }, transformPackage => {
-  const originalCreateScriptTransformer = transformPackage.createScriptTransformer
-
-  // `createScriptTransformer` is an async function
-  transformPackage.createScriptTransformer = function (config) {
-    const { testEnvironmentOptions, ...restOfConfig } = config
-    const {
-      _ddTestModuleId,
-      _ddTestSessionId,
-      _ddTestCommand,
-      _ddTestSessionName,
-      _ddForcedToRun,
-      _ddUnskippable,
-      _ddItrCorrelationId,
-      _ddKnownTests,
-      _ddIsEarlyFlakeDetectionEnabled,
-      _ddEarlyFlakeDetectionSlowTestRetries,
-      _ddRepositoryRoot,
-      _ddIsFlakyTestRetriesEnabled,
-      _ddFlakyTestRetriesCount,
-      _ddIsDiEnabled,
-      _ddIsKnownTestsEnabled,
-      _ddIsTestManagementTestsEnabled,
-      _ddTestManagementTests,
-      _ddTestManagementAttemptToFixRetries,
-      _ddModifiedFiles,
-      ...restOfTestEnvironmentOptions
-    } = testEnvironmentOptions
-
-    restOfConfig.testEnvironmentOptions = restOfTestEnvironmentOptions
-
-    arguments[0] = restOfConfig
-
-    return originalCreateScriptTransformer.apply(this, arguments)
-  }
+  transformPackage.createScriptTransformer = wrapCreateScriptTransformer(transformPackage.createScriptTransformer)
 
   return transformPackage
 })
 
+addHook({
+  name: '@jest/transform',
+  versions: ['>=30.0.0'],
+}, transformPackage => {
+  return shimmer.wrap(transformPackage, 'createScriptTransformer', wrapCreateScriptTransformer, { replaceGetter: true })
+})
+
 /**
  * Hook to remove the test paths (test suite) that are part of `skippableSuites`
  */

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

@@ -315,10 +315,10 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
     config.testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
     config.isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
-    // ITR and auto test retries are not supported in parallel mode yet
+    // ITR is not supported in parallel mode yet
     config.isSuitesSkippingEnabled = !isParallel && libraryConfig.isSuitesSkippingEnabled
-    config.isFlakyTestRetriesEnabled = !isParallel && libraryConfig.isFlakyTestRetriesEnabled
-    config.flakyTestRetriesCount = !isParallel && libraryConfig.flakyTestRetriesCount
+    config.isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
+    config.flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
 
     if (config.isKnownTestsEnabled) {
       ctx.onDone = onReceivedKnownTests
@@ -663,7 +663,8 @@ addHook({
     if (!testFinishCh.hasSubscribers ||
         (!config.isKnownTestsEnabled &&
          !config.isTestManagementTestsEnabled &&
-         !config.isImpactedTestsEnabled)) {
+         !config.isImpactedTestsEnabled &&
+         !config.isFlakyTestRetriesEnabled)) {
       return run.apply(this, arguments)
     }
 
@@ -709,6 +710,11 @@ addHook({
       newWorkerArgs._ddModifiedFiles = config.modifiedFiles || {}
     }
 
+    if (config.isFlakyTestRetriesEnabled) {
+      newWorkerArgs._ddIsFlakyTestRetriesEnabled = true
+      newWorkerArgs._ddFlakyTestRetriesCount = config.flakyTestRetriesCount
+    }
+
     // We pass the known tests for the test file to the worker
     const testFileResult = await run.apply(
       this,

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

@@ -289,6 +289,12 @@ function getOnTestEndHandler (config) {
       hasFailedAllRetries = true
     }
 
+    // ATR: set hasFailedAllRetries when all auto test retries were exhausted and every attempt failed
+    if (config.isFlakyTestRetriesEnabled && !test._ddIsAttemptToFix && !test._ddIsEfdRetry &&
+      getIsLastRetry(test) && testStatuses.every(status => status === 'fail')) {
+      hasFailedAllRetries = true
+    }
+
     const isAttemptToFixRetry = test._ddIsAttemptToFix && testStatuses.length > 1
     const isAtrRetry = config.isFlakyTestRetriesEnabled &&
       !test._ddIsAttemptToFix &&

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

@@ -10,6 +10,7 @@ const {
   getOnHookEndHandler,
   getOnFailHandler,
   getOnPendingHandler,
+  getOnTestRetryHandler,
   getRunTestsWrapper,
 } = require('./utils')
 require('./common')
@@ -48,6 +49,12 @@ addHook({
       delete this.options._ddIsTestManagementTestsEnabled
       delete this.options._ddTestManagementTests
     }
+    if (this.options._ddIsFlakyTestRetriesEnabled) {
+      config.isFlakyTestRetriesEnabled = true
+      config.flakyTestRetriesCount = this.options._ddFlakyTestRetriesCount
+      delete this.options._ddIsFlakyTestRetriesEnabled
+      delete this.options._ddFlakyTestRetriesCount
+    }
     return run.apply(this, arguments)
   })
 
@@ -74,6 +81,8 @@ addHook({
 
     this.on('test end', getOnTestEndHandler(config))
 
+    this.on('retry', getOnTestRetryHandler(config))
+
     // If the hook passes, 'hook end' will be emitted. Otherwise, 'fail' will be emitted
     this.on('hook end', getOnHookEndHandler())
 
@@ -92,5 +101,4 @@ addHook({
   name: 'mocha',
   versions: ['>=5.2.0'],
   file: 'lib/runnable.js',
-}, runnableWrapper)
-// TODO: parallel mode does not support flaky test retries, so no library config is passed.
+}, (runnablePackage) => runnableWrapper(runnablePackage, config))

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

@@ -302,6 +302,7 @@ function testBeginHandler (test, browserName, shouldCreateTestSpan) {
   const {
     _requireFile: testSuiteAbsolutePath,
     location: {
+      file: testSourceFileAbsolutePath,
       line: testSourceLine,
     },
     _type,
@@ -319,7 +320,7 @@ function testBeginHandler (test, browserName, shouldCreateTestSpan) {
 
   if (isNewTestSuite) {
     startedSuites.push(testSuiteAbsolutePath)
-    const testSuiteCtx = { testSuiteAbsolutePath }
+    const testSuiteCtx = { testSuiteAbsolutePath, testSourceFileAbsolutePath }
     testSuiteToCtx.set(testSuiteAbsolutePath, testSuiteCtx)
     testSuiteStartCh.runStores(testSuiteCtx, () => {})
   }
@@ -335,6 +336,7 @@ function testBeginHandler (test, browserName, shouldCreateTestSpan) {
     const testCtx = {
       testName,
       testSuiteAbsolutePath,
+      testSourceFileAbsolutePath,
       testSourceLine,
       browserName,
       isDisabled: test._ddIsDisabled,
@@ -404,6 +406,15 @@ function testEndHandler ({
     test._ddHasFailedAllRetries = true
   }
 
+  // ATR: set _ddHasFailedAllRetries when all auto test retries were exhausted and every attempt failed
+  if (isFlakyTestRetriesEnabled && !testProperties.attemptToFix && !test._ddIsEfdRetry &&
+    !(test._ddIsNew || test._ddIsModified) &&
+    flakyTestRetriesCount != null && flakyTestRetriesCount > 0 &&
+    testStatuses.length === flakyTestRetriesCount + 1 &&
+    testStatuses.every(status => status === 'fail')) {
+    test._ddHasFailedAllRetries = true
+  }
+
   // this handles tests that do not go through the worker process (because they're skipped)
   if (shouldCreateTestSpan) {
     const testResult = results.at(-1)
@@ -459,6 +470,7 @@ function testEndHandler ({
       testSkipCh.publish({
         testName: getTestFullname(test),
         testSuiteAbsolutePath,
+        testSourceFileAbsolutePath: test.location.file,
         testSourceLine: test.location.line,
         browserName,
         isNew: test._ddIsNew,
@@ -1144,6 +1156,7 @@ addHook({
     const {
       _requireFile: testSuiteAbsolutePath,
       location: {
+        file: testSourceFileAbsolutePath,
         line: testSourceLine,
       },
     } = test
@@ -1159,6 +1172,7 @@ addHook({
     const testCtx = {
       testName,
       testSuiteAbsolutePath,
+      testSourceFileAbsolutePath,
       testSourceLine,
       browserName,
     }
@@ -1322,7 +1336,10 @@ function generateSummaryWrapper (generateSummary) {
       if (didNotRun) {
         const {
           _requireFile: testSuiteAbsolutePath,
-          location: { line: testSourceLine },
+          location: {
+            file: testSourceFileAbsolutePath,
+            line: testSourceLine,
+          },
           _ddIsNew: isNew,
           _ddIsDisabled: isDisabled,
           _ddIsModified: isModified,
@@ -1333,6 +1350,7 @@ function generateSummaryWrapper (generateSummary) {
         testSkipCh.publish({
           testName: getTestFullname(test),
           testSuiteAbsolutePath,
+          testSourceFileAbsolutePath,
           testSourceLine,
           browserName,
           isNew,

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

@@ -172,8 +172,10 @@ const prismaHook = (runtime, versions, name, isIitm) => {
         prismaHelperInit.publish(prismaHelperCtx)
 
         const helper = prismaHelperCtx.helper
-        this._tracingHelper = helper
-        this._engine.tracingHelper = helper
+        if (helper) {
+          this._tracingHelper = helper
+          this._engine.tracingHelper = helper
+        }
       }
     }
   }