dd-trace 6.20.1 → 6.22.0

package/packages/datadog-instrumentations/src/helpers/rewriter/transforms/postgres.js

@@ -12,11 +12,37 @@ const POSTGRES_SIMPLE_DBM_QUERIES = '__ddTracePostgresSimpleDbmQueries'
 const POSTGRES_STATEMENT = 'this.string ?? (this.tagged && this.strings?.length !== 1 ? undefined : this.strings?.[0])'
 
 module.exports = {
+  postgresQueryAcquire,
   postgresQueryHandlers,
   postgresQueryLifecycle,
   postgresQueryPreparation,
 }
 
+/**
+ * @param {object} state
+ * @param {import('estree').Program} program
+ */
+function postgresQueryAcquire (state, program) {
+  const channelVariable = injectPostgresTracingChannel(state, program)
+  const executeFunctions = query(program, 'FunctionDeclaration[id.name="execute"]')
+  assert(executeFunctions.length === 1, 'postgresQueryAcquire: unexpected execute function count')
+
+  const execute = executeFunctions[0]
+  const queryParameter = execute.params[0]
+  assert(queryParameter?.type === 'Identifier', 'postgresQueryAcquire: execute query parameter changed')
+  assert(execute.body.type === 'BlockStatement', 'postgresQueryAcquire: execute body changed')
+
+  const body = execute.body.body
+  const executeIndex = body.findIndex(statement => statement.type === 'TryStatement')
+  assert(executeIndex !== -1, 'postgresQueryAcquire: execute try block changed')
+
+  body.splice(executeIndex, 0, ...parse(`
+    if (${channelVariable}.start.hasSubscribers) {
+      ${channelVariable}.start.publish({ query: ${queryParameter.name} });
+    }
+  `).body)
+}
+
 /**
  * Starts a Postgres.js query at the pool handler that owns its connection options.
  *
@@ -154,6 +180,7 @@ function wrapPostgresHandler (handler, queryParameter, channelVariable) {
   assert(handler.body.type === 'BlockStatement', 'postgresQueryHandlers: handler body changed')
   assert(!handler.async && !handler.generator, 'postgresQueryHandlers: unsupported handler kind')
 
+  // Direct handoffs publish before the handler returns, so they record zero pool wait.
   const originalBody = handler.body.body
   const wrapperBody = parse(`
     function wrapper () {
@@ -167,12 +194,18 @@ function wrapPostgresHandler (handler, queryParameter, channelVariable) {
           __ddTraceContext.host = ${POSTGRES_OPTIONS}.host[0];
           __ddTraceContext.port = ${POSTGRES_OPTIONS}.port[0];
         }
-        return ${channelVariable}.start.runStores(__ddTraceContext, () => {});
+        const __ddTraceResult = ${channelVariable}.start.runStores(__ddTraceContext, () => {});
+        if (!__ddTraceContext.poolWaitFinished) {
+          __ddTraceContext.poolWaitStartMs = performance.now();
+        }
+        return __ddTraceResult;
       }
     }
   `).body[0].body.body
 
-  wrapperBody[0].consequent.body.at(-1).argument.arguments[1].body.body = originalBody
+  const tracingCalls = query(wrapperBody[0], 'CallExpression[callee.property.name="runStores"]')
+  assert(tracingCalls.length === 1, 'postgresQueryHandlers: runStores call changed')
+  tracingCalls[0].arguments[1].body.body = originalBody
   handler.body.body = [...wrapperBody, ...originalBody]
 }
 
@@ -272,8 +305,13 @@ function findPostgresQueryIdentifier (program) {
 
   const declarations = query(program, 'VariableDeclarator[id.type="ObjectPattern"]')
   for (const declaration of declarations) {
-    if (declaration.init?.type !== 'CallExpression' || declaration.init.callee.name !== 'require') continue
-    if (declaration.init.arguments[0]?.value !== './query.js') continue
+    if (
+      declaration.init?.type !== 'CallExpression' ||
+      declaration.init.callee.name !== 'require' ||
+      declaration.init.arguments[0]?.value !== './query.js'
+    ) {
+      continue
+    }
 
     for (const property of declaration.id.properties) {
       if (property.type === 'Property' && property.key.name === 'Query' && property.value.type === 'Identifier') {

package/packages/datadog-instrumentations/src/helpers/rewriter/transforms.js

@@ -140,8 +140,7 @@ function awaitContextCallback (state, node, _parent, ancestry) {
     const generatedCallback = createAwaitedContextCallback(
       state,
       insertionTarget,
-      callbackAncestry,
-      'awaitContextCallback'
+      callbackAncestry
     )
     if (!generatedCallback) return
 
@@ -158,8 +157,7 @@ function awaitContextCallback (state, node, _parent, ancestry) {
   const generatedCallback = createAwaitedContextCallback(
     state,
     node.consequent,
-    ancestry,
-    'awaitContextCallback'
+    ancestry
   )
   if (!generatedCallback) return
 
@@ -181,18 +179,17 @@ function awaitContextCallback (state, node, _parent, ancestry) {
  * @param {Parameters<typeof awaitContextCallback>[0]} state
  * @param {import('estree').BlockStatement} insertionTarget
  * @param {import('estree').Node[]} ancestry
- * @param {string} transformName
  * @returns {{
  *   callbackStatements: import('estree').Statement[],
  *   callbackVariable: string
  * }|undefined}
  */
-function createAwaitedContextCallback (state, insertionTarget, ancestry, transformName) {
+function createAwaitedContextCallback (state, insertionTarget, ancestry) {
   const { callbackArgumentNames = [], callbackName, callbackThis = false } = state.transformOptions ?? {}
 
-  assert(identifierPattern.test(callbackName), `${transformName}: callbackName must be an identifier`)
+  assert(identifierPattern.test(callbackName), 'awaitContextCallback: callbackName must be an identifier')
   assert(Array.isArray(callbackArgumentNames) && callbackArgumentNames.every(name => identifierPattern.test(name)),
-    `${transformName}: callbackArgumentNames must be identifiers`)
+    'awaitContextCallback: callbackArgumentNames must be identifiers')
 
   let enclosingFunction
   let hasTraceWrapper = false
@@ -215,8 +212,8 @@ function createAwaitedContextCallback (state, insertionTarget, ancestry, transfo
     hasTraceWrapper ||= hasContextBinding && hasTracedBinding
   }
 
-  assert(enclosingFunction?.async, `${transformName}: expected an enclosing async function`)
-  assert(hasTraceWrapper, `${transformName}: expected an enclosing trace wrapper`)
+  assert(enclosingFunction?.async, 'awaitContextCallback: expected an enclosing async function')
+  assert(hasTraceWrapper, 'awaitContextCallback: expected an enclosing trace wrapper')
 
   const callbackVariable = `__apm$${callbackName}`
   if (query(insertionTarget, `[id.name="${callbackVariable}"]`).length > 0) return

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

@@ -14,9 +14,7 @@ const connectionOptionsCache = new WeakMap()
 
 function wrapRedis (Redis) {
   shimmer.wrap(Redis.prototype, 'sendCommand', sendCommand => function (command, stream) {
-    if (!startCh.hasSubscribers) return sendCommand.call(this, command, stream)
-
-    if (!command?.promise) return sendCommand.call(this, command, stream)
+    if (!startCh.hasSubscribers || !command?.promise) return sendCommand.call(this, command, stream)
 
     const options = this.options || {}
     let connectionOptions = connectionOptionsCache.get(this)
@@ -32,7 +30,7 @@ function wrapRedis (Redis) {
       connectionName: options.connectionName,
     }
     return startCh.runStores(ctx, () => {
-      command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
+      command.promise.then(() => finish(ctx), err => finish(ctx, err))
 
       return sendCommand.call(this, command, stream)
     })
@@ -51,7 +49,11 @@ addHook({ name: 'ioredis', versions: ['>=4.11.0 <5'], file: 'built/redis/index.j
 
 addHook({ name: 'ioredis', versions: ['>=5'] }, wrapRedis)
 
-function finish (finishCh, errorCh, ctx, error) {
+/**
+ * @param {Record<string, unknown> & { error?: Error }} ctx
+ * @param {Error} [error]
+ */
+function finish (ctx, error) {
   if (error) {
     ctx.error = error
     errorCh.publish(ctx)

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

@@ -12,9 +12,7 @@ const errorCh = channel('apm:iovalkey:command:error')
 
 addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
   shimmer.wrap(Valkey.prototype, 'sendCommand', sendCommand => function (command, stream) {
-    if (!startCh.hasSubscribers) return sendCommand.apply(this, arguments)
-
-    if (!command?.promise) return sendCommand.apply(this, arguments)
+    if (!startCh.hasSubscribers || !command?.promise) return sendCommand.apply(this, arguments)
 
     const options = this.options || {}
     const connectionName = options.connectionName
@@ -22,7 +20,7 @@ addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
 
     const ctx = { command: command.name, args: command.args, connectionOptions, connectionName }
     return startCh.runStores(ctx, () => {
-      command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
+      command.promise.then(() => finish(ctx), err => finish(ctx, err))
 
       try {
         return sendCommand.apply(this, arguments)
@@ -37,7 +35,11 @@ addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
   return Valkey
 })
 
-function finish (finishCh, errorCh, ctx, error) {
+/**
+ * @param {Record<string, unknown> & { error?: Error }} ctx
+ * @param {Error} [error]
+ */
+function finish (ctx, error) {
   if (error) {
     ctx.error = error
     errorCh.publish(ctx)

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

@@ -10,6 +10,7 @@ const { performance } = require('node:perf_hooks')
 const path = require('path')
 const satisfies = require('../../../vendor/dist/semifies')
 const { DD_MAJOR } = require('../../../version')
+const { storage } = require('../../datadog-core')
 const shimmer = require('../../datadog-shimmer')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 const log = require('../../dd-trace/src/log')
@@ -88,6 +89,8 @@ 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 snapshotStorage = storage('ci:jest:snapshots')
+let activeSnapshotTrackers = 0
 const testSuiteHookFnCh = channel('ci:jest:test-suite:hook:fn')
 const consoleLogSubmissionCh = channel('ci:log-submission:console')
 const logSubmissionFlushCh = channel('ci:log-submission:flush')
@@ -666,7 +669,12 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     #discardedEfdRetryTests
     #earlyFlakeDetectionRetryPolicy
     #efdRetryGatesByName
+    #expect
     #pendingPre30ConcurrentTests
+    /** @type {(() => void)|undefined} */
+    #restoreSnapshotState
+    /** @type {Set<string>|undefined} */
+    #snapshotTestNames
 
     constructor (config, context) {
       super(config, context)
@@ -883,8 +891,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      */
     wrapConcurrentTestFunction (target, methodName, state) {
       let concurrentTest = target?.[methodName]
-      if (typeof concurrentTest !== 'function') return
-      if (this.wrappedConcurrentTestFunctions.has(concurrentTest)) return
+      if (typeof concurrentTest !== 'function' || this.wrappedConcurrentTestFunctions.has(concurrentTest)) return
 
       const originalConcurrentTest = getOriginalConcurrentTest(concurrentTest)
       if (originalConcurrentTest !== concurrentTest) {
@@ -1445,6 +1452,98 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
+    getSnapshotState () {
+      return this.#expect?.getState?.()?.snapshotState
+    }
+
+    /**
+     * Attributes snapshot increments to the executing test when serial and concurrent bodies can overlap.
+     * Both Jest and image snapshot matchers write this shared counter directly.
+     */
+    #trackQuarantinedSnapshots () {
+      if (!this.hasConcurrentTests || !this.testManagementTestsForThisSuite?.quarantined?.length) return
+
+      const snapshotState = this.getSnapshotState()
+      const descriptor = snapshotState && Object.getOwnPropertyDescriptor(snapshotState, 'unmatched')
+      if (!descriptor?.configurable || typeof descriptor.value !== 'number') return
+
+      let unmatched = descriptor.value
+      try {
+        Object.defineProperty(snapshotState, 'unmatched', {
+          configurable: true,
+          enumerable: descriptor.enumerable,
+          get () { return unmatched },
+          /** @param {number} value */
+          set (value) {
+            const ctx = /** @type {{ unmatchedSnapshots?: number }|undefined} */ (snapshotStorage.getStore())
+            if (ctx?.unmatchedSnapshots !== undefined && value > unmatched) {
+              ctx.unmatchedSnapshots += value - unmatched
+            }
+            unmatched = value
+          },
+        })
+      } catch (error) {
+        log.error('Could not track quarantined Jest snapshots: %s', error)
+        return
+      }
+
+      if (activeSnapshotTrackers++ === 0) testFnCh.bindStore(snapshotStorage)
+      this.#restoreSnapshotState = () => {
+        try {
+          Object.defineProperty(snapshotState, 'unmatched', { ...descriptor, value: unmatched })
+        } catch (error) {
+          log.error('Could not restore Jest snapshot state: %s', error)
+        } finally {
+          if (--activeSnapshotTrackers === 0) testFnCh.unbindStore(snapshotStorage)
+        }
+      }
+    }
+
+    /**
+     * Keeps the snapshot results of a quarantined test from failing the run.
+     *
+     * Jest fails the run on unmatched or obsolete snapshots even when no test failed.
+     *
+     * @param {object} test
+     */
+    ignoreQuarantinedSnapshotResults (test) {
+      const ctx = testContexts.get(test)
+      const unmatchedBeforeTest = ctx?.unmatchedSnapshotsBeforeTest
+      const unmatchedSnapshots = ctx?.unmatchedSnapshots
+      // Jest retries the attempts that still have errors and resets their snapshot results itself.
+      if ((unmatchedBeforeTest === undefined && unmatchedSnapshots === undefined) || test.errors?.length) return
+
+      const snapshotState = this.getSnapshotState()
+      if (!snapshotState) return
+
+      if (unmatchedSnapshots !== undefined) {
+        snapshotState.unmatched -= unmatchedSnapshots
+        ctx.unmatchedSnapshots = 0
+      } else if (snapshotState.unmatched > unmatchedBeforeTest) {
+        snapshotState.unmatched = unmatchedBeforeTest
+      }
+      // Jest's name-based marker can consume other tests' keys, so delete only keys owned by this test.
+      const keys = snapshotState._uncheckedKeys
+      const testNames = this.#snapshotTestNames
+      if (!keys?.delete || !testNames) return
+      const testName = getRawJestTestName(test)
+      const hintPrefix = `${testName}: `
+      for (const key of keys) {
+        const snapshotName = key.slice(0, key.lastIndexOf(' '))
+        if (snapshotName !== testName && !snapshotName.startsWith(hintPrefix)) continue
+        let belongsToAnotherTest = false
+        // Snapshot names do not identify their owner when another registered name matches the same key.
+        for (const name of testNames) {
+          if (name !== testName &&
+            (snapshotName === name || snapshotName.startsWith(`${name}: `))) {
+            belongsToAnotherTest = true
+            break
+          }
+        }
+        if (!belongsToAnotherTest) keys.delete(key)
+      }
+    }
+
     // This function returns an array if the known tests are valid and null otherwise.
     getKnownTestsForSuite (suiteKnownTests) {
       // `suiteKnownTests` is `this.testEnvironmentOptions._ddKnownTests`,
@@ -1819,6 +1918,11 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (event.concurrent) {
         this.hasConcurrentTests = true
       }
+      const registeredTest = getTestEntries(state.currentDescribeBlock)?.at(-1)
+      if (registeredTest && this.testManagementTestsForThisSuite?.quarantined?.length) {
+        this.#snapshotTestNames ??= new Set()
+        this.#snapshotTestNames.add(getRawJestTestName(registeredTest))
+      }
       if (event.failing) {
         return
       }
@@ -1827,7 +1931,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       const concurrentTestContexts = this.concurrentTestContexts.get(testFullName)
       const concurrentTestState = this.concurrentTestStates.get(event.fn) ||
         concurrentTestContexts?.at(-1)?.concurrentTestState
-      const registeredTest = getTestEntries(state.currentDescribeBlock)?.at(-1)
       if (concurrentTestState && registeredTest?.fn === event.fn) {
         testContexts.set(registeredTest, concurrentTestState.ctx)
       }
@@ -1925,10 +2028,12 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
 
       if (event.name === 'run_start') {
+        this.#trackQuarantinedSnapshots()
         const registerResultHandler = dynamicAtrResultHandlerRegistrations.get(this)
         dynamicAtrResultHandlerRegistrations.delete(this)
         registerResultHandler?.()
       } else if (event.name === 'setup') {
+        this.#expect = event.runtimeGlobals?.expect ?? this.global.expect
         this.wrapConcurrentTest(state)
         this.bindTestEach(this.global.test)
       }
@@ -2044,6 +2149,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           ctx.concurrentTestState = concurrentTestState
           concurrentTestState.ctx = ctx
         }
+        if (isQuarantined && !isAttemptToFix && !event.test.concurrent && !ctx.concurrentTestState) {
+          if (this.#restoreSnapshotState) {
+            ctx.unmatchedSnapshots = 0
+          } else if (!this.hasConcurrentTests) {
+            ctx.unmatchedSnapshotsBeforeTest = this.getSnapshotState()?.unmatched
+          }
+        }
         testContexts.set(event.test, ctx)
 
         if (isAttemptToFix) {
@@ -2282,6 +2394,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             event.test.errors = []
           }
         }
+        this.ignoreQuarantinedSnapshotResults(event.test)
 
         // Quarantine must consume terminal failures before we save errors for Jest's final result.
         if (dynamicAtrCount !== undefined && failedAllTests && event.test.errors?.length) {
@@ -2359,6 +2472,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           ctx.currentStore = undefined
         }
       } else if (event.name === 'run_finish') {
+        this.#restoreSnapshotState?.()
+        this.#restoreSnapshotState = undefined
         this.removeDiscardedEfdRetries()
         for (const [test, errors] of atrSuppressedErrors) {
           // Do not restore errors for non-ATF quarantined tests — they should stay suppressed
@@ -2528,6 +2643,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     }
 
     teardown () {
+      this.#restoreSnapshotState?.()
+      this.#restoreSnapshotState = undefined
       if (this._globalProxy?.propertyToValue) {
         for (const [key] of this._globalProxy.propertyToValue) {
           if (typeof key === 'string' && key.startsWith('_dd')) {
@@ -2557,10 +2674,7 @@ function getTestEnvironment (pkg, jestVersion) {
     const wrappedTestEnvironment = getWrappedEnvironment(pkg.default, jestVersion)
     return new Proxy(pkg, {
       get (target, prop) {
-        if (prop === 'default') {
-          return wrappedTestEnvironment
-        }
-        if (prop === 'TestEnvironment') {
+        if (prop === 'default' || prop === 'TestEnvironment') {
           return wrappedTestEnvironment
         }
         return target[prop]
@@ -4377,10 +4491,7 @@ function sendWrapper (send) {
       // In here we modify the `config.testEnvironmentOptions` to include the known tests for the suite.
       // This way the suite only knows about the tests that are part of it.
       const args = request.at(-1)
-      if (args.length > 1) {
-        return send.apply(this, arguments)
-      }
-      if (!args[0]?.config) {
+      if (args.length > 1 || !args[0]?.config) {
         return send.apply(this, arguments)
       }
       const [{ globalConfig, config, path: testSuiteAbsolutePath }] = args

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

@@ -62,13 +62,13 @@ addHook({
       const rawResult = raw.apply(this, args)
       shimmer.wrap(rawResult, 'then', originalThen => function (...args) {
         return rawQuerySubscribes.runStores(context, () => {
-          args[0] = wrapCallbackWithFinish(args[0], finish, context)
-          if (args[1]) args[1] = wrapCallbackWithFinish(args[1], finish, context)
+          args[0] = wrapCallbackWithFinish(args[0], context)
+          if (args[1]) args[1] = wrapCallbackWithFinish(args[1], context)
 
           const originalThenResult = originalThen.apply(this, args)
 
           shimmer.wrap(originalThenResult, 'catch', originalCatch => function (...args) {
-            args[0] = wrapCallbackWithFinish(args[0], finish, context)
+            args[0] = wrapCallbackWithFinish(args[0], context)
             return originalCatch.apply(this, args)
           })
 
@@ -78,7 +78,7 @@ addHook({
 
       shimmer.wrap(rawResult, 'asCallback', originalAsCallback => function (...args) {
         return rawQuerySubscribes.runStores(context, () => {
-          args[0] = wrapCallbackWithFinish(args[0], finish, context)
+          args[0] = wrapCallbackWithFinish(args[0], context)
           return originalAsCallback.apply(this, args)
         })
       })
@@ -118,7 +118,11 @@ addHook({
   return Transaction
 })
 
-function wrapCallbackWithFinish (callback, finish, context) {
+/**
+ * @param {unknown} callback
+ * @param {object} context
+ */
+function wrapCallbackWithFinish (callback, context) {
   if (typeof callback !== 'function') return callback
 
   return shimmer.wrapFunction(callback, callback => function (...args) {

package/packages/datadog-instrumentations/src/mariadb-bundle.js

@@ -1055,9 +1055,9 @@ function createWrapCallbackGetConnection (options) {
   return function wrapGetConnection (getConnection) {
     return function () {
       const callback = arguments[arguments.length - 1]
-      if (typeof callback !== 'function') return getConnection.apply(this, arguments)
-
-      if (!connectionStartCh.hasSubscribers) return getConnection.apply(this, arguments)
+      if (typeof callback !== 'function' || !connectionStartCh.hasSubscribers) {
+        return getConnection.apply(this, arguments)
+      }
 
       if (!acquireStartCh.hasSubscribers) {
         const ctx = {}

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

@@ -11,33 +11,45 @@ const MINIMUM_MOCHA_VERSION = DD_MAJOR >= 6 ? '>=8.0.0' : '>=5.2.0'
 const parameterizedTestCh = channel('ci:mocha:test:parameterize')
 const patched = new WeakSet()
 
+/** @typedef {{ moduleBaseDir?: string }} MochaHookMeta */
+
 /**
  * Registers every Mocha package view that can expose the constructor.
  *
  * @param {string[]} versions
- * @param {(Mocha: Function, frameworkVersion: string) => Function} wrapMochaRun
+ * @param {(Mocha: Function, frameworkVersion: string, hookMeta: MochaHookMeta) => Function} wrapMochaRun
  */
 function addMochaRunHooks (versions, wrapMochaRun) {
-  const patchedMochaConstructors = new WeakSet()
+  const patchedMochaConstructors = new WeakMap()
 
   /**
    * @param {Function} Mocha
    * @param {string} frameworkVersion
+   * @param {boolean | undefined} isIitm
+   * @param {{ moduleBaseDir: string } | undefined} hookMeta
    * @returns {Function}
    */
-  function wrapMochaOnce (Mocha, frameworkVersion) {
-    if (patchedMochaConstructors.has(Mocha)) return Mocha
-    patchedMochaConstructors.add(Mocha)
-    return wrapMochaRun(Mocha, frameworkVersion)
+  function wrapMochaOnce (Mocha, frameworkVersion, isIitm, hookMeta) {
+    let metadata = patchedMochaConstructors.get(Mocha)
+    if (metadata) {
+      // A bundler can expose the constructor before an ordinary loader supplies its package directory.
+      metadata.moduleBaseDir ??= hookMeta?.moduleBaseDir
+      return Mocha
+    }
+    metadata = { moduleBaseDir: hookMeta?.moduleBaseDir }
+    patchedMochaConstructors.set(Mocha, metadata)
+    return wrapMochaRun(Mocha, frameworkVersion, metadata)
   }
 
   /**
    * @param {object|Function} MochaPackage
    * @param {string} frameworkVersion
+   * @param {boolean | undefined} isIitm
+   * @param {{ moduleBaseDir: string } | undefined} hookMeta
    * @returns {object|Function}
    */
-  function wrapMochaPackage (MochaPackage, frameworkVersion) {
-    wrapMochaOnce(MochaPackage.default ?? MochaPackage, frameworkVersion)
+  function wrapMochaPackage (MochaPackage, frameworkVersion, isIitm, hookMeta) {
+    wrapMochaOnce(MochaPackage.default ?? MochaPackage, frameworkVersion, isIitm, hookMeta)
     return MochaPackage
   }