dd-trace 5.92.0 → 5.94.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.92.0",
+  "version": "5.94.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -37,6 +37,8 @@
     "test:trace:guardrails:ci": "nyc -- npm run test:trace:guardrails",
     "test:esbuild": "mocha packages/datadog-esbuild/test/**/*.spec.js",
     "test:esbuild:ci": "nyc -- npm run test:esbuild",
+    "test:webpack": "mocha packages/datadog-webpack/test/**/*.spec.js",
+    "test:webpack:ci": "nyc -- npm run test:webpack",
     "test:instrumentations": "mocha \"packages/datadog-instrumentations/test/@(${PLUGINS}).spec.js\"",
     "test:instrumentations:ci": "yarn services && nyc -- npm run test:instrumentations",
     "test:instrumentations:misc": "mocha packages/datadog-instrumentations/test/*/**/*.spec.js",
@@ -67,6 +69,7 @@
     "test:integration:cypress": "mocha --timeout 60000 \"integration-tests/cypress/*.spec.js\"",
     "test:integration:debugger": "mocha --timeout 60000 \"integration-tests/debugger/*.spec.js\"",
     "test:integration:esbuild": "mocha --timeout 60000 \"integration-tests/esbuild/*.spec.js\"",
+    "test:integration:webpack": "mocha --timeout 60000 \"integration-tests/webpack/*.spec.js\"",
     "test:integration:openfeature": "mocha --timeout 60000 \"integration-tests/openfeature/*.spec.js\"",
     "test:integration:jest": "mocha --timeout 60000 \"integration-tests/jest/*.spec.js\"",
     "test:integration:mocha": "mocha --timeout 60000 \"integration-tests/mocha/*.spec.js\"",
@@ -110,6 +113,7 @@
     "ci/**/*",
     "cypress/**/*",
     "esbuild.js",
+    "webpack.js",
     "ext/**/*",
     "index.d.ts",
     "index.js",
@@ -138,21 +142,21 @@
     "import-in-the-middle": "^3.0.0"
   },
   "optionalDependencies": {
-    "@datadog/libdatadog": "0.8.1",
+    "@datadog/libdatadog": "0.9.2",
     "@datadog/native-appsec": "11.0.1",
     "@datadog/native-iast-taint-tracking": "4.1.0",
     "@datadog/native-metrics": "3.1.1",
-    "@datadog/openfeature-node-server": "^1.1.0",
-    "@datadog/pprof": "5.14.0",
+    "@datadog/openfeature-node-server": "^1.1.1",
+    "@datadog/pprof": "5.14.1",
     "@datadog/wasm-js-rewriter": "5.0.1",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
     "@opentelemetry/api-logs": "<1.0.0",
-    "oxc-parser": "^0.118.0"
+    "oxc-parser": "^0.121.0"
   },
   "devDependencies": {
     "@actions/core": "^3.0.0",
     "@actions/github": "^9.0.0",
-    "@babel/helpers": "^7.28.6",
+    "@babel/helpers": "^7.29.2",
     "@eslint/eslintrc": "^3.3.5",
     "@eslint/js": "^9.39.2",
     "@msgpack/msgpack": "^3.1.3",
@@ -165,12 +169,12 @@
     "axios": "^1.13.4",
     "benchmark": "^2.1.4",
     "body-parser": "^2.2.2",
-    "bun": "1.3.10",
+    "bun": "1.3.11",
     "codeowners-audit": "^2.9.0",
     "eslint": "^9.39.2",
-    "eslint-plugin-cypress": "^6.2.0",
+    "eslint-plugin-cypress": "^6.2.1",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^62.8.0",
+    "eslint-plugin-jsdoc": "^62.8.1",
     "eslint-plugin-mocha": "^11.2.0",
     "eslint-plugin-n": "^17.23.2",
     "eslint-plugin-promise": "^7.2.1",
@@ -194,11 +198,11 @@
     "retry": "^0.13.1",
     "semifies": "^1.0.0",
     "semver": "^7.7.2",
-    "sinon": "^21.0.2",
+    "sinon": "^21.0.3",
     "tiktoken": "^1.0.21",
     "typescript": "^5.9.2",
     "workerpool": "^10.0.0",
-    "yaml": "^2.8.0",
+    "yaml": "^2.8.3",
     "yarn-deduplicate": "^6.0.2"
   }
 }

package/packages/datadog-instrumentations/src/helpers/bundler-register.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const Module = require('module')
 const dc = require('dc-polyfill')
 
 const log = require('../../../dd-trace/src/log')
@@ -11,6 +12,28 @@ const {
 const hooks = require('./hooks')
 const instrumentations = require('./instrumentations')
 
+// register.js has now set up ritm (require-in-the-middle). In bundled
+// environments (webpack, esbuild), Node.js built-in modules required by
+// dd-trace internal modules (e.g. http from request.js) may have been loaded
+// before ritm was active. The bundler's module cache then returns those
+// pre-loaded modules for any subsequent require() calls, bypassing ritm.
+// Re-requiring them via the real Module.prototype.require ensures ritm applies
+// their instrumentation hooks.
+//
+// In regular Node.js, `module` is an instance of Module. In bundlers, the
+// module wrapper object is a plain object (not a Module instance), so we use
+// that to detect a bundled context and avoid unintended side-effects in
+// normal Node.js (e.g. shimmer-wrapping http before ESM modules load).
+if (!(module instanceof Module)) {
+  for (const name of ['http', 'https']) {
+    try {
+      Module.prototype.require.call(module, name)
+    } catch {
+      // Built-in not available in this environment, skip
+    }
+  }
+}
+
 const CHANNEL = 'dd-trace:bundler:load'
 
 if (!dc.subscribe) {

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

@@ -15,6 +15,8 @@ const {
   JEST_WORKER_LOGS_PAYLOAD_CODE,
   getTestEndLine,
   isModifiedTest,
+  DYNAMIC_NAME_RE,
+  collectDynamicNamesFromTraces,
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   SEED_SUFFIX_RE,
@@ -97,7 +99,10 @@ const originalHookFns = new WeakMap()
 const retriedTestsToNumAttempts = new Map()
 const newTestsTestStatuses = new Map()
 const attemptToFixRetriedTestsStatuses = new Map()
-const wrappedWorkers = new WeakSet()
+const wrappedWorkerChannels = new WeakMap()
+// New tests whose names contain likely dynamic data (timestamps, UUIDs, etc.)
+// Populated in-process for runInBand, and via worker-report:trace for parallel mode.
+const newTestsWithDynamicNames = new Set()
 const testSuiteMockedFiles = new Map()
 const testsToBeRetried = new Set()
 // Per-test: how many EFD retries were determined after the first execution.
@@ -154,25 +159,60 @@ function getTestStats (testStatuses) {
  * @param {string[]} quarantineNames
  * @param {number} totalCount
  */
-function logIgnoredFailuresSummary (efdNames, quarantineNames, totalCount) {
-  const names = []
-  for (const n of efdNames) {
-    names.push({ name: n, reason: 'Early Flake Detection' })
+/**
+ * Renders a truncated bullet list from an array of items.
+ *
+ * @param {Array<{ text: string, suffix?: string }>} items
+ * @returns {string}
+ */
+function formatList (items) {
+  const shown = items.slice(0, MAX_IGNORED_TEST_NAMES)
+  const more = items.length - shown.length
+  const moreSuffix = more > 0 ? `\n  ... and ${more} more` : ''
+  return shown.map(({ text, suffix }) => `  • ${text}${suffix ? ` (${suffix})` : ''}`).join('\n') + moreSuffix
+}
+
+/**
+ * Logs a single "Datadog Test Optimization" summary at session end,
+ * combining all relevant sections (ignored failures, dynamic names).
+ *
+ * @param {{ efdNames: string[], quarantineNames: string[], totalCount: number } | undefined} ignoredFailures
+ */
+function logSessionSummary (ignoredFailures) {
+  const sections = []
+
+  if (ignoredFailures) {
+    const items = []
+    for (const n of ignoredFailures.efdNames) {
+      items.push({ text: n, suffix: 'Early Flake Detection' })
+    }
+    for (const n of ignoredFailures.quarantineNames) {
+      items.push({ text: n, suffix: 'Quarantine' })
+    }
+    sections.push(
+      `${ignoredFailures.totalCount} test failure(s) were ignored. Exit code set to 0.\n\n` +
+      formatList(items)
+    )
   }
-  for (const n of quarantineNames) {
-    names.push({ name: n, reason: 'Quarantine' })
+
+  if (newTestsWithDynamicNames.size > 0) {
+    const items = [...newTestsWithDynamicNames].map(name => ({ text: name }))
+    sections.push(
+      `${newTestsWithDynamicNames.size} test(s) detected as new but their names contain ` +
+      'dynamic data (timestamps, UUIDs, etc.).\n' +
+      'Tests with changing names are always treated as new on every run, ' +
+      'causing unnecessary Early Flake Detection retries and preventing correct new test detection.\n' +
+      'Consider using stable, deterministic test names.\n\n' +
+      formatList(items)
+    )
+    newTestsWithDynamicNames.clear()
   }
-  const shown = names.slice(0, MAX_IGNORED_TEST_NAMES)
-  const more = names.length - shown.length
-  const moreSuffix = more > 0 ? `\n  ... and ${more} more` : ''
-  const list = shown.map(({ name, reason }) => `  • ${name} (${reason})`).join('\n')
+
+  if (sections.length === 0) return
+
   const line = '-'.repeat(50)
-  // eslint-disable-next-line no-console -- Intentional user-facing message when exit code is flipped
-  console.warn(
-    `\n${line}\nDatadog Test Optimization\n${line}\n` +
-    `${totalCount} test failure(s) were ignored. Exit code set to 0.\n\n` +
-    `${list}${moreSuffix}\n`
-  )
+  // eslint-disable-next-line no-console -- Intentional user-facing session summary
+  console.warn(`\n${line}\nDatadog Test Optimization\n${line}\n${sections.join('\n\n')}\n`)
 }
 
 function getWrappedEnvironment (BaseEnvironment, jestVersion) {
@@ -457,6 +497,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
 
         const isJestRetry = event.test?.invocations > 1
+        const hasDynamicName = isNewTest && DYNAMIC_NAME_RE.test(testName)
         const ctx = {
           name: testName,
           suite: this.testSuite,
@@ -472,6 +513,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           isDisabled,
           isQuarantined,
           isModified,
+          hasDynamicName,
           testSuiteAbsolutePath: this.testSuiteAbsolutePath,
         }
         testContexts.set(event.test, ctx)
@@ -564,6 +606,11 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         if (!isAttemptToFix && this.isKnownTestsEnabled) {
           const isNew = !this.knownTestsForThisSuite.includes(testFullName)
           if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(testFullName)) {
+            if (DYNAMIC_NAME_RE.test(testFullName)) {
+              // Populated directly for runInBand; for parallel workers the main process
+              // collects these from the TEST_HAS_DYNAMIC_NAME span tag via worker-report:trace.
+              newTestsWithDynamicNames.add(`${this.testSuite} › ${testFullName}`)
+            }
             retriedTestsToNumAttempts.set(testFullName, 0)
             if (this.isEarlyFlakeDetectionEnabled) {
               testsToBeRetried.add(testFullName)
@@ -722,7 +769,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             error: formatJestError(originalError),
             shouldSetProbe,
             promises,
-            finalStatus,
           })
         }
 
@@ -1333,13 +1379,7 @@ function getCliWrapper (isNewJestVersion) {
         })
       }
 
-      if (ignoredFailuresSummary) {
-        logIgnoredFailuresSummary(
-          ignoredFailuresSummary.efdNames,
-          ignoredFailuresSummary.quarantineNames,
-          ignoredFailuresSummary.totalCount
-        )
-      }
+      logSessionSummary(ignoredFailuresSummary)
 
       numSkippedSuites = 0
 
@@ -1793,8 +1833,14 @@ addHook({
 
 function onMessageWrapper (onMessage) {
   return function () {
-    const [code, data] = arguments[0]
+    const response = arguments[0]
+    if (!Array.isArray(response)) {
+      return onMessage.apply(this, arguments)
+    }
+
+    const [code, data] = response
     if (code === JEST_WORKER_TRACE_PAYLOAD_CODE) { // datadog trace payload
+      collectDynamicNamesFromTraces(data, newTestsWithDynamicNames)
       workerReportTraceCh.publish(data)
       return
     }
@@ -1855,15 +1901,40 @@ function sendWrapper (send) {
   }
 }
 
+function wrapWorkerChannel (worker) {
+  const workerChannel = worker._child || worker._worker
+  if (!workerChannel) return
+
+  shimmer.wrap(workerChannel, worker._child ? 'send' : 'postMessage', sendWrapper)
+}
+
+function wrapWorker (worker) {
+  // ChildProcessWorker uses _child (child_process), ExperimentalWorker uses _worker (worker_threads)
+  const workerChannel = worker._child || worker._worker
+  if (!workerChannel) return
+
+  wrapWorkerChannel(worker)
+  shimmer.wrap(worker, '_onMessage', onMessageWrapper)
+  workerChannel.removeAllListeners('message')
+  workerChannel.on('message', worker._onMessage.bind(worker))
+}
+
 function enqueueWrapper (enqueue) {
   return function () {
     shimmer.wrap(arguments[0], 'onStart', onStart => function (worker) {
-      if (worker && !wrappedWorkers.has(worker)) {
-        shimmer.wrap(worker._child, 'send', sendWrapper)
-        shimmer.wrap(worker, '_onMessage', onMessageWrapper)
-        worker._child.removeAllListeners('message')
-        worker._child.on('message', worker._onMessage.bind(worker))
-        wrappedWorkers.add(worker)
+      if (worker) {
+        const currentChannel = worker._child || worker._worker
+        const previousChannel = wrappedWorkerChannels.get(worker)
+        if (currentChannel !== previousChannel) {
+          if (previousChannel) {
+            // Worker restarted — only re-wrap the new child's send/postMessage
+            wrapWorkerChannel(worker)
+          } else {
+            // First time seeing this worker — full setup
+            wrapWorker(worker)
+          }
+          wrappedWorkerChannels.set(worker, currentChannel)
+        }
       }
       return onStart.apply(this, arguments)
     })
@@ -1892,6 +1963,21 @@ addHook({
   return childProcessWorker
 })
 
+addHook({
+  name: 'jest-worker',
+  versions: ['>=24.9.0 <30.0.0'],
+  file: 'build/workers/NodeThreadsWorker.js',
+}, (nodeThreadsWorker) => {
+  const ExperimentalWorker = nodeThreadsWorker.default
+  shimmer.wrap(ExperimentalWorker.prototype, 'send', sendWrapper)
+  if (ExperimentalWorker.prototype._onMessage) {
+    shimmer.wrap(ExperimentalWorker.prototype, '_onMessage', onMessageWrapper)
+  } else if (ExperimentalWorker.prototype.onMessage) {
+    shimmer.wrap(ExperimentalWorker.prototype, 'onMessage', onMessageWrapper)
+  }
+  return nodeThreadsWorker
+})
+
 addHook({
   name: 'jest-worker',
   versions: ['>=30.0.0'],

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

@@ -14,6 +14,8 @@ const {
   mergeCoverage,
   resetCoverage,
   getIsFaultyEarlyFlakeDetection,
+  collectDynamicNamesFromTraces,
+  logDynamicNamesWarning,
 } = require('../../../dd-trace/src/plugins/util/test')
 
 const {
@@ -34,6 +36,7 @@ const {
   getRunTestsWrapper,
   testsAttemptToFix,
   testsStatuses,
+  newTestsWithDynamicNames,
 } = require('./utils')
 
 require('./common')
@@ -207,6 +210,8 @@ function getOnEndHandler (isParallel) {
       isTestManagementEnabled: config.isTestManagementTestsEnabled,
       isParallel,
     })
+
+    logDynamicNamesWarning(newTestsWithDynamicNames)
   }
 }
 
@@ -552,6 +557,7 @@ function onMessage (message) {
   if (Array.isArray(message)) {
     const [messageCode, payload] = message
     if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
+      collectDynamicNamesFromTraces(payload, newTestsWithDynamicNames)
       workerReportTraceCh.publish(payload)
     }
   }

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { getTestSuitePath } = require('../../../dd-trace/src/plugins/util/test')
+const { getTestSuitePath, DYNAMIC_NAME_RE } = require('../../../dd-trace/src/plugins/util/test')
 const { channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
@@ -23,6 +23,7 @@ const testToStartLine = new WeakMap()
 const testFileToSuiteCtx = new Map()
 const wrappedFunctions = new WeakSet()
 const newTests = {}
+const newTestsWithDynamicNames = new Set()
 const testsAttemptToFix = new Set()
 const testsQuarantined = new Set()
 const testsStatuses = new Map()
@@ -221,6 +222,10 @@ function getOnTestHandler (isMain) {
     testInfo.isDisabled = isDisabled
     testInfo.isQuarantined = isQuarantined
     testInfo.isModified = isModified
+    testInfo.hasDynamicName = isNew && DYNAMIC_NAME_RE.test(test.fullTitle())
+    if (testInfo.hasDynamicName) {
+      newTestsWithDynamicNames.add(`${getTestSuitePath(test.file, process.cwd())} › ${test.fullTitle()}`)
+    }
     // We want to store the result of the new tests
     if (isNew) {
       const testFullName = getTestFullName(test)
@@ -241,6 +246,44 @@ function getOnTestHandler (isMain) {
   }
 }
 
+function getFinalStatus ({
+  status,
+  hasFailedAllRetries,
+  isFlakyTestRetriesEnabled,
+  isLastAtrAttempt,
+  isEfdRetry,
+  isLastEfdRetry,
+  isAttemptToFix,
+  isLastAttemptToFix,
+  attemptToFixPassed,
+  isQuarantined,
+  isDisabled,
+}) {
+  // Note that intermediate executions DO NOT report a final status tag
+
+  // If the test is quarantined or disabled, regardless of its actual execution result or active retry features,
+  // the final status of its last execution should be reported as 'skip'.
+  if (isQuarantined || isDisabled) {
+    return 'skip'
+  }
+
+  const isAtrActive = isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry
+
+  // When no retry feature is active, every execution is final
+  if (!isAtrActive && !isEfdRetry && !isAttemptToFix) {
+    return status
+  }
+  if (isAtrActive && isLastAtrAttempt) {
+    return hasFailedAllRetries ? 'fail' : 'pass'
+  }
+  if (isEfdRetry && isLastEfdRetry) {
+    return hasFailedAllRetries ? 'fail' : 'pass'
+  }
+  if (isAttemptToFix && isLastAttemptToFix) {
+    return attemptToFixPassed ? 'pass' : 'fail'
+  }
+}
+
 function getOnTestEndHandler (config) {
   return async function (test) {
     const ctx = getTestContext(test)
@@ -271,6 +314,11 @@ function getOnTestEndHandler (config) {
 
     const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
     const isLastEfdRetry = testStatuses.length === config.earlyFlakeDetectionNumRetries + 1
+    const isLastAtrAttempt = getIsLastRetry(test) || (config.isFlakyTestRetriesEnabled && status === 'pass')
+
+    // Needed for the getFinalStatus call. This is because EFD does NOT tag as
+    // EFD retry the first run of the test. It only tags as retries the clones
+    const isEfdRetry = test._ddIsEfdRetry || (test._ddIsNew && config.isEarlyFlakeDetectionEnabled)
 
     if (test._ddIsAttemptToFix && isLastAttempt) {
       if (testStatuses.includes('fail')) {
@@ -299,8 +347,29 @@ function getOnTestEndHandler (config) {
       !test._ddIsAttemptToFix &&
       !test._ddIsEfdRetry
 
-    // if there are afterEach to be run, we don't finish the test yet
-    if (ctx && !getAfterEachHooks(test).length) {
+    const { isFlakyTestRetriesEnabled } = config
+    const { _ddIsAttemptToFix, _ddIsQuarantined, _ddIsDisabled } = test
+
+    const finalStatus = getFinalStatus({
+      status,
+      hasFailedAllRetries,
+      isFlakyTestRetriesEnabled,
+      isLastAtrAttempt,
+      isEfdRetry,
+      isLastEfdRetry,
+      isAttemptToFix: _ddIsAttemptToFix,
+      isLastAttemptToFix: isLastAttempt,
+      attemptToFixPassed,
+      isQuarantined: _ddIsQuarantined,
+      isDisabled: _ddIsDisabled,
+    })
+
+    // If there are afterEach to be run, we don't finish the test yet.
+    // Disabled tests (marked pending by us) are finished immediately without waiting for afterEach hooks.
+    // In older mocha versions, pending tests don't run afterEach hooks, so we can't rely on
+    // getOnHookEndHandler to finish the test. This mirrors Jest's approach where the skip handler
+    // directly sets finalStatus without waiting for hooks
+    if (ctx && (!getAfterEachHooks(test).length || test._ddIsDisabled)) {
       testFinishCh.publish({
         status,
         hasBeenRetried: isMochaRetry(test),
@@ -311,7 +380,10 @@ function getOnTestEndHandler (config) {
         isAttemptToFixRetry,
         isAtrRetry,
         ...ctx.currentStore,
+        finalStatus,
       })
+    } else if (ctx) { // if there is an afterEach to run, let's store the finalStatus for getOnHookEndHandler
+      ctx.finalStatus = finalStatus
     }
   }
 }
@@ -325,12 +397,15 @@ function getOnHookEndHandler () {
       if (isLastAfterEach) {
         const status = getTestStatus(test)
         const ctx = getTestContext(test)
-        if (ctx) {
+        // Disabled tests are already finished in getOnTestEndHandler,
+        // skip to avoid double-publishing
+        if (ctx && !test._ddIsDisabled) {
           testFinishCh.publish({
             status,
             hasBeenRetried: isMochaRetry(test),
             isLastRetry: getIsLastRetry(test),
             ...ctx.currentStore,
+            finalStatus: ctx.finalStatus,
           })
         }
       }
@@ -356,7 +431,15 @@ function getOnFailHandler (isMain) {
         testContext.err = err
         errorCh.runStores(testContext, () => {})
         // if it's a hook and it has failed, 'test end' will not be called
-        testFinishCh.publish({ status: 'fail', hasBeenRetried: isMochaRetry(test), ...testContext.currentStore })
+        // quarantined and disabled tests always report 'skip'
+        // as final status, even when hooks fail
+        const isSkippedByManagement = test._ddIsQuarantined || test._ddIsDisabled
+        testFinishCh.publish({
+          status: 'fail',
+          hasBeenRetried: isMochaRetry(test),
+          ...testContext.currentStore,
+          finalStatus: isSkippedByManagement ? 'skip' : 'fail',
+        })
       } else {
         testContext.err = err
         errorCh.runStores(testContext, () => {})
@@ -519,6 +602,7 @@ module.exports = {
   testFileToSuiteCtx,
   getRunTestsWrapper,
   newTests,
+  newTestsWithDynamicNames,
   testsQuarantined,
   testsAttemptToFix,
   testsStatuses,

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

@@ -8,6 +8,8 @@ const {
   getTestSuitePath,
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
+  DYNAMIC_NAME_RE,
+  logDynamicNamesWarning,
 } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 const {
@@ -70,6 +72,7 @@ let isImpactedTestsEnabled = false
 let modifiedFiles = {}
 const quarantinedOrDisabledTestsAttemptToFix = []
 let quarantinedButNotAttemptToFixFqns = new Set()
+const newTestsWithDynamicNames = new Set()
 let rootDir = ''
 let sessionProjects = []
 
@@ -381,6 +384,9 @@ function testEndHandler ({
 
   if (testStatuses.length === 0) {
     testsToTestStatuses.set(testFqn, [testStatus])
+    if (test._ddIsNew && DYNAMIC_NAME_RE.test(getTestFullname(test))) {
+      newTestsWithDynamicNames.add(`${getTestSuitePath(test._requireFile, rootDir)} › ${getTestFullname(test)}`)
+    }
   } else {
     testStatuses.push(testStatus)
   }
@@ -432,6 +438,7 @@ function testEndHandler ({
         error,
         extraTags: annotationTags,
         isNew: test._ddIsNew,
+        hasDynamicName: test._ddIsNew && DYNAMIC_NAME_RE.test(getTestFullname(test)),
         isAttemptToFix: test._ddIsAttemptToFix,
         isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
         isQuarantined: test._ddIsQuarantined,
@@ -784,6 +791,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       }
     }
 
+    logDynamicNamesWarning(newTestsWithDynamicNames)
+
     const flushWait = new Promise(resolve => {
       onDone = resolve
     })
@@ -1281,6 +1290,7 @@ addHook({
       error,
       extraTags: annotationTags,
       isNew: test._ddIsNew,
+      hasDynamicName: test._ddIsNew && DYNAMIC_NAME_RE.test(getTestFullname(test)),
       isRetry: retry > 0,
       isEfdRetry: test._ddIsEfdRetry,
       isAttemptToFix: test._ddIsAttemptToFix,