dd-trace 5.73.0 → 5.75.0

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

@@ -7,13 +7,15 @@ const shimmer = require('../../datadog-shimmer')
 const {
   parseAnnotations,
   getTestSuitePath,
-  PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE
+  PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
+  getIsFaultyEarlyFlakeDetection
 } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 const { DD_MAJOR } = require('../../../version')
 
 const testStartCh = channel('ci:playwright:test:start')
 const testFinishCh = channel('ci:playwright:test:finish')
+const testSkipCh = channel('ci:playwright:test:skip')
 
 const testSessionStartCh = channel('ci:playwright:session:start')
 const testSessionFinishCh = channel('ci:playwright:session:finish')
@@ -36,6 +38,8 @@ const testSuiteToTestStatuses = new Map()
 const testSuiteToErrors = new Map()
 const testsToTestStatuses = new Map()
 
+const RUM_FLUSH_WAIT_TIME = 1000
+
 let applyRepeatEachIndex = null
 
 let startedSuites = []
@@ -52,6 +56,7 @@ let isKnownTestsEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
 let isEarlyFlakeDetectionFaulty = false
+let earlyFlakeDetectionFaultyThreshold = 0
 let isFlakyTestRetriesEnabled = false
 let flakyTestRetriesCount = 0
 let knownTests = {}
@@ -111,8 +116,10 @@ function deepCloneSuite (suite, filterTest, tags = []) {
       if (filterTest(entry)) {
         const copiedTest = entry._clone()
         tags.forEach(tag => {
-          if (tag) {
-            copiedTest[tag] = true
+          const resolvedTag = typeof tag === 'function' ? tag(entry) : tag
+
+          if (resolvedTag) {
+            copiedTest[resolvedTag] = true
           }
         })
         copy._addTest(copiedTest)
@@ -281,7 +288,12 @@ function getTestFullname (test) {
   return names.join(' ')
 }
 
-function testBeginHandler (test, browserName, isMainProcess) {
+function shouldFinishTestSuite (testSuiteAbsolutePath) {
+  const remainingTests = remainingTestsByFile[testSuiteAbsolutePath]
+  return !remainingTests.length || remainingTests.every(test => test.expectedStatus === 'skipped')
+}
+
+function testBeginHandler (test, browserName, shouldCreateTestSpan) {
   const {
     _requireFile: testSuiteAbsolutePath,
     location: {
@@ -293,6 +305,10 @@ function testBeginHandler (test, browserName, isMainProcess) {
   if (_type === 'beforeAll' || _type === 'afterAll') {
     return
   }
+  // this means that a skipped test is being handled
+  if (!remainingTestsByFile[testSuiteAbsolutePath].length) {
+    return
+  }
 
   const isNewTestSuite = !startedSuites.includes(testSuiteAbsolutePath)
 
@@ -309,7 +325,7 @@ function testBeginHandler (test, browserName, isMainProcess) {
   }
 
   // this handles tests that do not go through the worker process (because they're skipped)
-  if (isMainProcess) {
+  if (shouldCreateTestSpan) {
     const testName = getTestFullname(test)
     const testCtx = {
       testName,
@@ -324,8 +340,20 @@ function testBeginHandler (test, browserName, isMainProcess) {
   }
 }
 
-function testEndHandler (test, annotations, testStatus, error, isTimeout, isMainProcess) {
-  const { _requireFile: testSuiteAbsolutePath, results, _type } = test
+function testEndHandler ({
+  test,
+  annotations,
+  testStatus,
+  error,
+  isTimeout,
+  shouldCreateTestSpan,
+  projects
+}) {
+  const {
+    _requireFile: testSuiteAbsolutePath,
+    results,
+    _type,
+  } = test
 
   let annotationTags
   if (annotations.length) {
@@ -364,31 +392,34 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout, isMain
   }
 
   // this handles tests that do not go through the worker process (because they're skipped)
-  if (isMainProcess) {
+  if (shouldCreateTestSpan) {
     const testResult = results.at(-1)
     const testCtx = testToCtx.get(test)
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
       !test._ddIsAttemptToFix &&
       !test._ddIsEfdRetry
-    testFinishCh.publish({
-      testStatus,
-      steps: testResult?.steps || [],
-      isRetry: testResult?.retry > 0,
-      error,
-      extraTags: annotationTags,
-      isNew: test._ddIsNew,
-      isAttemptToFix: test._ddIsAttemptToFix,
-      isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
-      isQuarantined: test._ddIsQuarantined,
-      isEfdRetry: test._ddIsEfdRetry,
-      hasFailedAllRetries: test._ddHasFailedAllRetries,
-      hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
-      hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
-      isAtrRetry,
-      isModified: test._ddIsModified,
-      ...testCtx.currentStore
-    })
+    // if there is no testCtx, the skipped test will be created later
+    if (testCtx) {
+      testFinishCh.publish({
+        testStatus,
+        steps: testResult?.steps || [],
+        isRetry: testResult?.retry > 0,
+        error,
+        extraTags: annotationTags,
+        isNew: test._ddIsNew,
+        isAttemptToFix: test._ddIsAttemptToFix,
+        isAttemptToFixRetry: test._ddIsAttemptToFixRetry,
+        isQuarantined: test._ddIsQuarantined,
+        isEfdRetry: test._ddIsEfdRetry,
+        hasFailedAllRetries: test._ddHasFailedAllRetries,
+        hasPassedAttemptToFixRetries: test._ddHasPassedAttemptToFixRetries,
+        hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
+        isAtrRetry,
+        isModified: test._ddIsModified,
+        ...testCtx.currentStore
+      })
+    }
   }
 
   if (testSuiteToTestStatuses.has(testSuiteAbsolutePath)) {
@@ -406,8 +437,25 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout, isMain
       .filter(currentTest => currentTest !== test)
   }
 
-  // Last test, we finish the suite
-  if (!remainingTestsByFile[testSuiteAbsolutePath].length) {
+  if (shouldFinishTestSuite(testSuiteAbsolutePath)) {
+    const skippedTests = remainingTestsByFile[testSuiteAbsolutePath]
+      .filter(test => test.expectedStatus === 'skipped')
+
+    for (const test of skippedTests) {
+      const browserName = getBrowserNameFromProjects(projects, test)
+      testSkipCh.publish({
+        testName: getTestFullname(test),
+        testSuiteAbsolutePath,
+        testSourceLine: test.location.line,
+        browserName,
+        isNew: test._ddIsNew,
+        isDisabled: test._ddIsDisabled,
+        isModified: test._ddIsModified,
+        isQuarantined: test._ddIsQuarantined
+      })
+    }
+    remainingTestsByFile[testSuiteAbsolutePath] = []
+
     const testStatuses = testSuiteToTestStatuses.get(testSuiteAbsolutePath)
     let testSuiteStatus = 'pass'
     if (testStatuses.includes('fail')) {
@@ -446,10 +494,13 @@ function dispatcherHook (dispatcherExport) {
   shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
     const dispatcher = this
     const worker = createWorker.apply(this, arguments)
+    const projects = getProjectsFromDispatcher(dispatcher)
+
+    // for older versions of playwright, `shouldCreateTestSpan` should always be true,
+    // since the `_runTest` function wrapper is not available for older versions
     worker.process.on('message', ({ method, params }) => {
       if (method === 'testBegin') {
         const { test } = dispatcher._testById.get(params.testId)
-        const projects = getProjectsFromDispatcher(dispatcher)
         const browser = getBrowserNameFromProjects(projects, test)
         testBeginHandler(test, browser, true)
       } else if (method === 'testEnd') {
@@ -460,12 +511,15 @@ function dispatcherHook (dispatcherExport) {
 
         const isTimeout = testResult.status === 'timedOut'
         testEndHandler(
-          test,
-          params.annotations,
-          STATUS_TO_TEST_STATUS[testResult.status],
-          testResult.error,
-          isTimeout,
-          true
+          {
+            test,
+            annotations: params.annotations,
+            testStatus: STATUS_TO_TEST_STATUS[testResult.status],
+            error: testResult.error,
+            isTimeout,
+            shouldCreateTestSpan: true,
+            projects
+          }
         )
       }
     })
@@ -480,18 +534,30 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
   shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
     const dispatcher = this
     const worker = createWorker.apply(this, arguments)
+    const projects = getProjectsFromDispatcher(dispatcher)
 
     worker.on('testBegin', ({ testId }) => {
       const test = getTestByTestId(dispatcher, testId)
-      const projects = getProjectsFromDispatcher(dispatcher)
       const browser = getBrowserNameFromProjects(projects, test)
-      testBeginHandler(test, browser, false)
+      const shouldCreateTestSpan = test.expectedStatus === 'skipped'
+      testBeginHandler(test, browser, shouldCreateTestSpan)
     })
     worker.on('testEnd', ({ testId, status, errors, annotations }) => {
       const test = getTestByTestId(dispatcher, testId)
 
       const isTimeout = status === 'timedOut'
-      testEndHandler(test, annotations, STATUS_TO_TEST_STATUS[status], errors && errors[0], isTimeout, false)
+      const shouldCreateTestSpan = test.expectedStatus === 'skipped'
+      testEndHandler(
+        {
+          test,
+          annotations,
+          testStatus: STATUS_TO_TEST_STATUS[status],
+          error: errors && errors[0],
+          isTimeout,
+          shouldCreateTestSpan,
+          projects
+        }
+      )
       const testResult = test.results.at(-1)
       const isAtrRetry = testResult?.retry > 0 &&
         isFlakyTestRetriesEnabled &&
@@ -542,6 +608,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+        earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
         isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
         isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -620,6 +687,9 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
 
     let runAllTestsReturn = await runAllTests.apply(this, arguments)
 
+    // Tests that have only skipped tests may reach this point
+    // Skipped tests may or may not go through `testBegin` or `testEnd`
+    // depending on the playwright configuration
     Object.values(remainingTestsByFile).forEach(tests => {
       // `tests` should normally be empty, but if it isn't,
       // there were tests that did not go through `testBegin` or `testEnd`,
@@ -627,7 +697,15 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       tests.forEach(test => {
         const browser = getBrowserNameFromProjects(projects, test)
         testBeginHandler(test, browser, true)
-        testEndHandler(test, [], 'skip', null, false, true)
+        testEndHandler({
+          test,
+          annotations: [],
+          testStatus: 'skip',
+          error: null,
+          isTimeout: false,
+          shouldCreateTestSpan: true,
+          projects
+        })
       })
     })
 
@@ -761,6 +839,30 @@ addHook({
   return suiteUtilsPackage
 })
 
+/**
+ * We could repeat the logic of `applyRepeatEachIndex` here, but it'd be more risky
+ * as playwright could change it at any time.
+ *
+ * `applyRepeatEachIndex` goes through all the tests in a suite and applies the "repeat" logic
+ * for a single repeat index.
+ *
+ * This means that the clone logic is cumbersome:
+ * - we grab the unique file suites that have new tests
+ * - we store its project suite
+ * - we clone each of these file suites for each repeat index
+ * - we execute `applyRepeatEachIndex` for each of these cloned file suites
+ * - we add the cloned file suites to the project suite
+ */
+function applyRetriesToTests (fileSuitesWithTestsToRetry, filterTest, tagsToApply, numRetries) {
+  for (const [fileSuite, projectSuite] of fileSuitesWithTestsToRetry.entries()) {
+    for (let repeatEachIndex = 1; repeatEachIndex <= numRetries; repeatEachIndex++) {
+      const copyFileSuite = deepCloneSuite(fileSuite, filterTest, tagsToApply)
+      applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
+      projectSuite._addSuite(copyFileSuite)
+    }
+  }
+}
+
 addHook({
   name: 'playwright',
   file: 'lib/runner/loadUtils.js',
@@ -780,87 +882,112 @@ addHook({
     const allTests = rootSuite.allTests()
 
     if (isTestManagementTestsEnabled) {
+      const fileSuitesWithManagedTestsToProjects = new Map()
       for (const test of allTests) {
         const testProperties = getTestProperties(test)
+        // Disabled tests are skipped and not retried
         if (testProperties.disabled) {
           test._ddIsDisabled = true
-        } else if (testProperties.quarantined) {
+          test.expectedStatus = 'skipped'
+          continue
+        }
+        if (testProperties.quarantined) {
           test._ddIsQuarantined = true
+          if (!testProperties.attemptToFix) {
+            // Do not skip quarantined tests, let them run and overwrite results post-run if they fail
+            const testFqn = getTestFullyQualifiedName(test)
+            quarantinedButNotAttemptToFixFqns.add(testFqn)
+          }
         }
         if (testProperties.attemptToFix) {
           test._ddIsAttemptToFix = true
           const fileSuite = getSuiteType(test, 'file')
-          const projectSuite = getSuiteType(test, 'project')
-          const isAttemptToFix = test => getTestProperties(test).attemptToFix
-          for (let repeatEachIndex = 1; repeatEachIndex <= testManagementAttemptToFixRetries; repeatEachIndex++) {
-            const copyFileSuite = deepCloneSuite(fileSuite, isAttemptToFix, [
-              testProperties.disabled && '_ddIsDisabled',
-              testProperties.quarantined && '_ddIsQuarantined',
-              '_ddIsAttemptToFix',
-              '_ddIsAttemptToFixRetry'
-            ])
-            applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
-            projectSuite._addSuite(copyFileSuite)
+
+          if (!fileSuitesWithManagedTestsToProjects.has(fileSuite)) {
+            fileSuitesWithManagedTestsToProjects.set(fileSuite, getSuiteType(test, 'project'))
           }
           if (testProperties.disabled || testProperties.quarantined) {
             quarantinedOrDisabledTestsAttemptToFix.push(test)
           }
-        } else if (testProperties.disabled) {
-          test.expectedStatus = 'skipped'
-        } else if (testProperties.quarantined) {
-          // Do not skip quarantined tests, let them run and overwrite results post-run if they fail
-          const testFqn = getTestFullyQualifiedName(test)
-          quarantinedButNotAttemptToFixFqns.add(testFqn)
         }
       }
+      applyRetriesToTests(
+        fileSuitesWithManagedTestsToProjects,
+        (test) => test._ddIsAttemptToFix,
+        [
+          (test) => test._ddIsQuarantined && '_ddIsQuarantined',
+          '_ddIsAttemptToFix',
+          '_ddIsAttemptToFixRetry'
+        ],
+        testManagementAttemptToFixRetries
+      )
     }
 
     if (isImpactedTestsEnabled) {
-      await Promise.all(allTests.map(async (test) => {
-        const { isModified } = await getChannelPromise(isModifiedCh, {
+      const impactedTests = allTests.filter(test => {
+        let isImpacted = false
+        isModifiedCh.publish({
           filePath: test._requireFile,
-          modifiedFiles
+          modifiedFiles,
+          onDone: (isModified) => { isImpacted = isModified }
         })
-        if (isModified) {
-          test._ddIsModified = true
-        }
-        if (isEarlyFlakeDetectionEnabled && test.expectedStatus !== 'skipped') {
-          const isNew = isKnownTestsEnabled && isNewTest(test)
-          const fileSuite = getSuiteType(test, 'file')
-          const projectSuite = getSuiteType(test, 'project')
-          // If something change in the file, all tests in the file are impacted
-          const isModifiedTest = () => isModified
-          for (let repeatEachIndex = 1; repeatEachIndex <= earlyFlakeDetectionNumRetries; repeatEachIndex++) {
-            const copyFileSuite = deepCloneSuite(fileSuite, isModifiedTest, [
-              isNew && '_ddIsNew',
-              '_ddIsModified',
-              '_ddIsEfdRetry'
-            ])
-            applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
-            projectSuite._addSuite(copyFileSuite)
+        return isImpacted
+      })
+
+      const fileSuitesWithImpactedTestsToProjects = new Map()
+      impactedTests.forEach(impactedTest => {
+        impactedTest._ddIsModified = true
+        if (isEarlyFlakeDetectionEnabled && impactedTest.expectedStatus !== 'skipped') {
+          const fileSuite = getSuiteType(impactedTest, 'file')
+          if (!fileSuitesWithImpactedTestsToProjects.has(fileSuite)) {
+            fileSuitesWithImpactedTestsToProjects.set(fileSuite, getSuiteType(impactedTest, 'project'))
           }
         }
-      }))
+      })
+      // If something change in the file, all tests in the file are impacted, hence the () => true filter
+      applyRetriesToTests(
+        fileSuitesWithImpactedTestsToProjects,
+        () => true,
+        [
+          '_ddIsModified',
+          '_ddIsEfdRetry',
+          (test) => (isKnownTestsEnabled && isNewTest(test) ? '_ddIsNew' : null)
+        ],
+        earlyFlakeDetectionNumRetries
+      )
     }
 
     if (isKnownTestsEnabled) {
       const newTests = allTests.filter(isNewTest)
 
-      for (const newTest of newTests) {
-        // No need to filter out attempt to fix tests here because attempt to fix tests are never new
-        newTest._ddIsNew = true
-        if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped' && !newTest._ddIsModified) {
-          const fileSuite = getSuiteType(newTest, 'file')
-          const projectSuite = getSuiteType(newTest, 'project')
-          for (let repeatEachIndex = 1; repeatEachIndex <= earlyFlakeDetectionNumRetries; repeatEachIndex++) {
-            const copyFileSuite = deepCloneSuite(fileSuite, isNewTest, [
-              '_ddIsNew',
-              '_ddIsEfdRetry'
-            ])
-            applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
-            projectSuite._addSuite(copyFileSuite)
+      const isFaulty = getIsFaultyEarlyFlakeDetection(
+        allTests.map(test => getTestSuitePath(test._requireFile, rootDir)),
+        knownTests.playwright,
+        earlyFlakeDetectionFaultyThreshold
+      )
+
+      if (isFaulty) {
+        isEarlyFlakeDetectionEnabled = false
+        isKnownTestsEnabled = false
+        isEarlyFlakeDetectionFaulty = true
+      } else {
+        const fileSuitesWithNewTestsToProjects = new Map()
+        newTests.forEach(newTest => {
+          newTest._ddIsNew = true
+          if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped' && !newTest._ddIsModified) {
+            const fileSuite = getSuiteType(newTest, 'file')
+            if (!fileSuitesWithNewTestsToProjects.has(fileSuite)) {
+              fileSuitesWithNewTestsToProjects.set(fileSuite, getSuiteType(newTest, 'project'))
+            }
           }
-        }
+        })
+
+        applyRetriesToTests(
+          fileSuitesWithNewTestsToProjects,
+          isNewTest,
+          ['_ddIsNew', '_ddIsEfdRetry'],
+          earlyFlakeDetectionNumRetries
+        )
       }
     }
 
@@ -953,6 +1080,9 @@ addHook({
   const stepInfoByStepId = {}
 
   shimmer.wrap(workerPackage.WorkerMain.prototype, '_runTest', _runTest => async function (test) {
+    if (test.expectedStatus === 'skipped') {
+      return _runTest.apply(this, arguments)
+    }
     steps = []
 
     const {
@@ -1006,6 +1136,8 @@ addHook({
                 })
 
                 if (isRumActive) {
+                  // Give some time RUM to flush data, similar to what we do in selenium
+                  await new Promise(resolve => setTimeout(resolve, RUM_FLUSH_WAIT_TIME))
                   const url = page.url()
                   if (url) {
                     const domain = new URL(url).hostname
@@ -1013,9 +1145,10 @@ addHook({
                       name: 'datadog-ci-visibility-test-execution-id',
                       value: '',
                       domain,
-                      expires: 0,
                       path: '/'
                     }])
+                  } else {
+                    log.error('RUM is active but page.url() is not available')
                   }
                 }
               }

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

@@ -5,6 +5,19 @@ const pathToRegExp = require('path-to-regexp')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel } = require('./helpers/instrument')
 
+const {
+  getRouterMountPaths,
+  joinPath,
+  getLayerMatchers,
+  setLayerMatchers,
+  isAppMounted,
+  setRouterMountPath,
+  extractMountPaths,
+  getRouteFullPaths,
+  wrapRouteMethodsAndPublish,
+  collectRoutesFromRouter
+} = require('./helpers/router-helper')
+
 function isFastStar (layer, matchers) {
   return layer.regexp?.fast_star ?? matchers.some(matcher => matcher.path === '*')
 }
@@ -22,7 +35,6 @@ function createWrapRouterMethod (name) {
   const nextChannel = channel(`apm:${name}:middleware:next`)
   const routeAddedChannel = channel(`apm:${name}:route:added`)
 
-  const layerMatchers = new WeakMap()
   const regexpCache = Object.create(null)
 
   function wrapLayerHandle (layer, original) {
@@ -31,7 +43,7 @@ function createWrapRouterMethod (name) {
     return shimmer.wrapFunction(original, original => function () {
       if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
 
-      const matchers = layerMatchers.get(layer)
+      const matchers = getLayerMatchers(layer)
       const lastIndex = arguments.length - 1
       const name = original._name || original.name
       const req = arguments[arguments.length > 3 ? 1 : 0]
@@ -78,7 +90,7 @@ function createWrapRouterMethod (name) {
         layer.handle = wrapLayerHandle(layer, layer.handle)
       }
 
-      layerMatchers.set(layer, matchers)
+      setLayerMatchers(layer, matchers)
 
       if (layer.route) {
         METHODS.forEach(method => {
@@ -115,7 +127,7 @@ function createWrapRouterMethod (name) {
     return arg.map(pattern => ({
       path: pattern instanceof RegExp ? `(${pattern})` : pattern,
       test: layer => {
-        const matchers = layerMatchers.get(layer)
+        const matchers = getLayerMatchers(layer)
         return !isFastStar(layer, matchers) &&
           !isFastSlash(layer, matchers) &&
           cachedPathToRegExp(pattern).test(layer.path)
@@ -134,12 +146,12 @@ function createWrapRouterMethod (name) {
   }
 
   function wrapMethod (original) {
-    return shimmer.wrapFunction(original, original => function methodWithTrace (fn) {
+    return shimmer.wrapFunction(original, original => function methodWithTrace (fn, ...otherArgs) {
       let offset = 0
       if (this.stack) {
         offset = Array.isArray(this.stack) ? this.stack.length : 1
       }
-      const router = original.apply(this, arguments)
+      const router = original.call(this, fn, ...otherArgs)
 
       if (typeof this.stack === 'function') {
         this.stack = [{ handle: this.stack }]
@@ -149,6 +161,51 @@ function createWrapRouterMethod (name) {
         routeAddedChannel.publish({ topOfStackFunc: methodWithTrace, layer: this.stack.at(-1) })
       }
 
+      // Publish only if this router was mounted by app.use() (prevents early '/sub/...')
+      if (routeAddedChannel.hasSubscribers && isAppMounted(this) && this.stack?.length > offset) {
+        // Handle nested router mounting for 'use' method
+        if (original.name === 'use' && otherArgs.length >= 1) {
+          const { mountPaths, startIdx } = extractMountPaths(fn)
+
+          if (mountPaths.length) {
+            const parentPaths = getRouterMountPaths(this)
+            const callArgs = [fn, ...otherArgs]
+
+            for (let i = startIdx; i < callArgs.length; i++) {
+              const nestedRouter = callArgs[i]
+
+              if (!nestedRouter || typeof nestedRouter !== 'function') continue
+
+              for (const parentPath of parentPaths) {
+                for (const normalizedMountPath of mountPaths) {
+                  const fullMountPath = joinPath(parentPath, normalizedMountPath)
+                  if (fullMountPath === null) continue
+
+                  setRouterMountPath(nestedRouter, fullMountPath)
+                  collectRoutesFromRouter(nestedRouter, fullMountPath)
+                }
+              }
+            }
+          }
+        }
+
+        const mountPaths = getRouterMountPaths(this)
+
+        if (mountPaths.length) {
+          const layer = this.stack.at(-1)
+
+          if (layer?.route) {
+            const route = layer.route
+
+            const fullPaths = mountPaths.flatMap(mountPath => getRouteFullPaths(route, mountPath))
+
+            wrapRouteMethodsAndPublish(route, fullPaths, (payload) => {
+              routeAddedChannel.publish(payload)
+            })
+          }
+        }
+      }
+
       if (this.stack.length > offset) {
         wrapStack(this.stack.slice(offset), extractMatchers(fn))
       }