dd-trace 5.110.0 → 5.111.0

package/README.md

@@ -1,6 +1,6 @@
 # `dd-trace`: Node.js APM Tracer Library
 
-[![npm v5](https://img.shields.io/npm/v/dd-trace/latest?color=blue&label=dd-trace%40v5&logo=npm)](https://www.npmjs.com/package/dd-trace)
+[![npm v6](https://img.shields.io/npm/v/dd-trace/latest?color=blue&label=dd-trace%40v6&logo=npm)](https://www.npmjs.com/package/dd-trace)
 [![codecov](https://codecov.io/gh/DataDog/dd-trace-js/branch/master/graph/badge.svg)](https://codecov.io/gh/DataDog/dd-trace-js)
 
 <img align="right" src="https://user-images.githubusercontent.com/551402/208212084-1d0c07e2-4135-4c61-b2da-8f2fddbc66ed.png" alt="Bits the dog  JavaScript" width="200px"/>
@@ -28,30 +28,35 @@ Most of the documentation for `dd-trace` is available on these webpages:
 | [`v2`](https://github.com/DataDog/dd-trace-js/tree/v2.x) | ![npm v2](https://img.shields.io/npm/v/dd-trace/latest-node12?color=white&label=%20&style=flat-square) | `>= v12` | NO | NO | **EOL** | 2022-01-28     | 2023-08-15  |
 | [`v3`](https://github.com/DataDog/dd-trace-js/tree/v3.x) | ![npm v3](https://img.shields.io/npm/v/dd-trace/latest-node14?color=white&label=%20&style=flat-square) | `>= v14` | NO | YES | **EOL** | 2022-08-15     | 2024-05-15  |
 | [`v4`](https://github.com/DataDog/dd-trace-js/tree/v4.x) | ![npm v4](https://img.shields.io/npm/v/dd-trace/latest-node16?color=white&label=%20&style=flat-square) | `>= v16` | YES | YES | **EOL**     | 2023-05-12     | 2025-01-11     |
-| [`v5`](https://github.com/DataDog/dd-trace-js/tree/v5.x) | ![npm v5](https://img.shields.io/npm/v/dd-trace/latest?color=white&label=%20&style=flat-square)        | `>= v18` | YES | YES | **Current**     | 2024-01-11     | Unknown     |
+| [`v5`](https://github.com/DataDog/dd-trace-js/tree/v5.x) | ![npm v5](https://img.shields.io/npm/v/dd-trace/latest-node18?color=white&label=%20&style=flat-square)  | `>= v18` | YES | YES | **Maintenance** | 2024-01-11     | Unknown     |
+| [`v6`](https://github.com/DataDog/dd-trace-js/tree/v6.x) | ![npm v6](https://img.shields.io/npm/v/dd-trace/latest?color=white&label=%20&style=flat-square)         | `>= v22` | YES | YES | **Current**     | 2026-07-02     | Unknown     |
 
 * EOL = End-of-life
 * SSI = Single-Step Install
 
-We currently maintain one release line, namely `v5`.
+We currently maintain two release lines: `v6` (current) and `v5` (maintenance).
 
-For any new projects it is recommended to use the `v5` release line:
+For any new projects it is recommended to use the `v6` release line:
 
 ```sh
 $ npm install dd-trace
 $ yarn add dd-trace
 ```
 
-Existing projects that need to use EOL versions of Node.js may continue to use these older release lines.
-This is done by specifying the version when installing the package.
+Existing projects on `v5` may continue to use it during its maintenance window by pinning the major version:
+
+```sh
+$ npm install dd-trace@5
+$ yarn add dd-trace@5
+```
+
+Older EOL release lines are no longer maintained, but can still be pinned if needed:
 
 ```sh
 $ npm install dd-trace@4 # or whatever version you need
 $ yarn add dd-trace@4 # or whatever version you need
 ```
 
-Note, however, that the end-of-life release lines are no longer maintained and will not receive updates.
-
 Any backwards-breaking functionality that is introduced into the library will result in an increase of the major version of the library and therefore a new release line.
 Such releases are kept to a minimum to reduce the pain of upgrading the library.
 

package/ci/init.js

@@ -1,13 +1,14 @@
 'use strict'
 
 /* eslint-disable no-console */
-const tracer = require('../packages/dd-trace')
 const log = require('../packages/dd-trace/src/log')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../packages/dd-trace/src/config/helper')
+const { isTrue } = require('../packages/dd-trace/src/util')
 
 const PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm']
 const DEFAULT_FLUSH_INTERVAL = 5000
 const JEST_FLUSH_INTERVAL = 0
+const VITEST_NO_WORKER_INIT_ACTIVE_ENV = 'DD_TEST_OPT_VITEST_NO_WORKER_INIT_ACTIVE'
 const EXPORTER_MAP = {
   jest: 'jest_worker',
   cucumber: 'cucumber_worker',
@@ -78,10 +79,28 @@ if (isTestWorker) {
   }
 }
 
-if (shouldInit) {
+const skipVitestWorkerInit = shouldSkipVitestWorkerInit()
+const tracer = skipVitestWorkerInit
+  ? {
+      init () {},
+      use () {},
+    }
+  : require('../packages/dd-trace')
+
+if (shouldInit && !skipVitestWorkerInit) {
   tracer.init(baseOptions)
   tracer.use('fs', false)
   tracer.use('child_process', false)
 }
 
 module.exports = tracer
+
+function shouldSkipVitestWorkerInit () {
+  return getValueFromEnvSources('DD_VITEST_WORKER') &&
+    isVitestNoWorkerInitActive()
+}
+
+function isVitestNoWorkerInitActive () {
+  // eslint-disable-next-line eslint-rules/eslint-process-env
+  return isTrue(process.env[VITEST_NO_WORKER_INIT_ACTIVE_ENV])
+}

package/ci/vitest-no-worker-init-setup.mjs

@@ -0,0 +1,430 @@
+import { realpathSync } from 'node:fs'
+import { relative } from 'node:path'
+import { performance } from 'node:perf_hooks'
+
+import { afterEach, beforeAll, beforeEach } from 'vitest'
+
+// Instrumentation-less worker setup for DD_EXPERIMENTAL_TEST_OPT_VITEST_NO_WORKER_INIT.
+// It applies Test Optimization execution changes without initializing dd-trace in Vitest workers.
+const VITEST_NO_WORKER_INIT_ACTIVE_ENV = 'DD_TEST_OPT_VITEST_NO_WORKER_INIT_ACTIVE'
+const isNoWorkerInitActive = getIsNoWorkerInitActive()
+const providedContext = isNoWorkerInitActive ? getProvidedContext() : {}
+const attemptToFixTests = providedContext.attemptToFixTests || {}
+const attemptToFixRetries = providedContext.attemptToFixRetries || 0
+const disabledTests = providedContext.disabledTests || {}
+const earlyFlakeDetectionRetries = providedContext.earlyFlakeDetectionRetries || 0
+const earlyFlakeDetectionRetryThresholds = Array.isArray(providedContext.earlyFlakeDetectionRetryThresholds)
+  ? providedContext.earlyFlakeDetectionRetryThresholds
+  : []
+const earlyFlakeDetectionSlowRetries = providedContext.earlyFlakeDetectionSlowRetries || {}
+const hasEarlyFlakeDetectionSlowRetries = Object.keys(earlyFlakeDetectionSlowRetries).length > 0
+const isEarlyFlakeDetectionEnabled = providedContext.isEarlyFlakeDetectionEnabled === true
+const knownTests = providedContext.knownTests || {}
+const modifiedFiles = providedContext.modifiedFiles || {}
+const quarantinedTests = providedContext.quarantinedTests || {}
+const repositoryRoot = realpath(providedContext.repositoryRoot || process.cwd())
+let setVitestTaskFn
+if (isNoWorkerInitActive) {
+  try {
+    // Vitest does not expose setFn from the public setup API; keep this optional for strict installers.
+    const vitestRunner = await import('@vitest/runner')
+    setVitestTaskFn = vitestRunner.setFn
+  } catch {}
+}
+const earlyFlakeDetectionRetriesByTask = new WeakMap()
+const earlyFlakeDetectionSkippedResults = new WeakMap()
+const earlyFlakeDetectionStartByTask = new WeakMap()
+const nextAttemptIndexByTask = new WeakMap()
+const realpaths = new Map()
+
+if (isNoWorkerInitActive) {
+  // eslint-disable-next-line no-empty-pattern
+  beforeAll(function ({}, suite) {
+    suite ||= arguments[0]
+    applyExecutionChanges(suite)
+  })
+
+  beforeEach(function ({ onTestFinished, task, skip }) {
+    const testSuite = getTestSuite(task)
+    const testName = getTestName(task)
+    const isAttemptToFixTest = attemptToFixTests[testSuite]?.[testName]
+    const isEarlyFlakeDetectionTestAttempt = isEarlyFlakeDetectionTest(testSuite, testName)
+    const isQuarantinedTest = quarantinedTests[testSuite]?.[testName] && !isAttemptToFixTest
+    const attemptIndex = getNextAttemptIndex(task)
+    if (attemptIndex > 0) {
+      recordTestOptimizationStatus(task, attemptIndex - 1)
+    }
+
+    if (disabledTests[testSuite]?.[testName] && !isAttemptToFixTest) {
+      skip('Skipped by Datadog Test Optimization')
+    } else if (isAttemptToFixTest && attemptIndex > 0) {
+      task.result.state = 'run'
+    } else if (isEarlyFlakeDetectionTestAttempt) {
+      const isSkippedRepeat = prepareEarlyFlakeDetectionAttempt(task, attemptIndex)
+      if (!isSkippedRepeat && attemptIndex > 0) {
+        task.result.state = 'run'
+      }
+    }
+
+    if (isAttemptToFixTest || isEarlyFlakeDetectionTestAttempt || isQuarantinedTest) {
+      onTestFinished(() => {
+        if (attemptIndex === getFinalAttemptIndex(task)) {
+          if (isAttemptToFixTest || isEarlyFlakeDetectionTestAttempt) {
+            recordTestOptimizationStatus(task, attemptIndex, true)
+          }
+          switchQuarantinedFinalFailure(task, attemptIndex)
+        }
+      })
+    }
+  })
+
+  afterEach(function ({ task }) {
+    const attemptIndex = task.meta.__ddTestOptCurrentAttemptIndex
+    if (restoreEarlyFlakeDetectionSkippedResult(task)) {
+      return
+    }
+    if (attemptIndex === getFinalAttemptIndex(task)) {
+      recordTestOptimizationStatus(task, attemptIndex)
+    }
+    switchQuarantinedFinalFailure(task, attemptIndex)
+  })
+}
+
+function applyExecutionChanges (suite) {
+  for (const task of suite?.tasks || []) {
+    if (task.type === 'suite') {
+      applyExecutionChanges(task)
+      continue
+    }
+
+    const testSuite = getTestSuite(task)
+    const testName = getTestName(task)
+    if (attemptToFixTests[testSuite]?.[testName]) {
+      task.retry = 0
+      task.repeats = attemptToFixRetries
+      task.meta.__ddTestOptAtfRetries = attemptToFixRetries
+    } else if (disabledTests[testSuite]?.[testName]) {
+      task.mode = 'skip'
+    } else if (isEarlyFlakeDetectionTest(testSuite, testName)) {
+      task.retry = 0
+      task.repeats = earlyFlakeDetectionRetries
+      task.meta.__ddTestOptEfdRetries = earlyFlakeDetectionRetries
+    }
+  }
+}
+
+function getNextAttemptIndex (task) {
+  const attemptIndex = nextAttemptIndexByTask.get(task) || 0
+  nextAttemptIndexByTask.set(task, attemptIndex + 1)
+  task.meta.__ddTestOptCurrentAttemptIndex = attemptIndex
+  return attemptIndex
+}
+
+function recordTestOptimizationStatus (task, attemptIndex = task.result?.repeatCount || 0, onlyIfNewErrors = false) {
+  const testSuite = getTestSuite(task)
+  const testName = getTestName(task)
+
+  if (attemptToFixTests[testSuite]?.[testName]) {
+    recordAttemptToFixStatus(task, attemptIndex, onlyIfNewErrors)
+  } else if (isEarlyFlakeDetectionTest(testSuite, testName)) {
+    recordEarlyFlakeDetectionStatus(task, attemptIndex, onlyIfNewErrors)
+  } else if (task.repeats > 0) {
+    recordManualRepeatStatus(task, attemptIndex)
+  }
+}
+
+function recordAttemptToFixStatus (task, attemptIndex, onlyIfNewErrors) {
+  if (onlyIfNewErrors && !hasNewErrors(task.meta.__ddTestOptAtfErrorCounts, attemptIndex, task)) {
+    return
+  }
+
+  task.meta.__ddTestOptAtfStatuses ||= []
+  task.meta.__ddTestOptAtfErrorCounts ||= []
+  task.meta.__ddTestOptAtfStatuses[attemptIndex] = getAttemptStatus(
+    task,
+    task.meta.__ddTestOptAtfErrorCounts,
+    attemptIndex
+  )
+  task.meta.__ddTestOptAtfErrorCounts[attemptIndex] = task.result?.errors?.length || 0
+
+  if (
+    attemptIndex === getAttemptToFixRetryCount(task) &&
+    task.meta.__ddTestOptAtfStatuses.includes('fail') &&
+    task.result?.state === 'pass'
+  ) {
+    task.result.state = 'fail'
+  }
+}
+
+function recordEarlyFlakeDetectionStatus (task, attemptIndex, onlyIfNewErrors) {
+  if (restoreEarlyFlakeDetectionSkippedResult(task)) {
+    return
+  }
+
+  const retryCount = earlyFlakeDetectionRetriesByTask.get(task)
+  if (retryCount !== undefined && attemptIndex > retryCount) {
+    return
+  }
+
+  if (onlyIfNewErrors && !hasNewErrors(task.meta.__ddTestOptEfdErrorCounts, attemptIndex, task)) {
+    return
+  }
+
+  if (!earlyFlakeDetectionRetriesByTask.has(task)) {
+    const retryCount = getEarlyFlakeDetectionRetryCount(task)
+    earlyFlakeDetectionRetriesByTask.set(task, retryCount)
+    task.repeats = retryCount
+    task.meta.__ddTestOptEfdRetries = retryCount
+    if (retryCount === 0 && hasEarlyFlakeDetectionSlowRetries) {
+      task.meta.__ddTestOptEfdAbortReason = 'slow'
+    }
+  }
+
+  task.meta.__ddTestOptEfdStatuses ||= []
+  task.meta.__ddTestOptEfdErrorCounts ||= []
+  task.meta.__ddTestOptEfdStatuses[attemptIndex] = getAttemptStatus(
+    task,
+    task.meta.__ddTestOptEfdErrorCounts,
+    attemptIndex
+  )
+  task.meta.__ddTestOptEfdErrorCounts[attemptIndex] = task.result?.errors?.length || 0
+
+  if (attemptIndex === getEarlyFlakeDetectionRetryCountForTask(task) &&
+    task.meta.__ddTestOptEfdStatuses.includes('pass')) {
+    task.result.state = 'pass'
+  }
+}
+
+function recordManualRepeatStatus (task, attemptIndex) {
+  task.meta.__ddTestOptRepeatStatuses ||= []
+  task.meta.__ddTestOptRepeatErrorCounts ||= []
+  task.meta.__ddTestOptRepeatStatuses[attemptIndex] = getManualRepeatStatus(
+    task,
+    task.meta.__ddTestOptRepeatErrorCounts,
+    attemptIndex
+  )
+  task.meta.__ddTestOptRepeatErrorCounts[attemptIndex] = task.result?.errors?.length || 0
+}
+
+function restoreEarlyFlakeDetectionSkippedResult (task) {
+  if (!task.meta.__ddTestOptEfdSkipCurrentAttempt) {
+    return false
+  }
+
+  delete task.meta.__ddTestOptEfdSkipCurrentAttempt
+  const skippedResult = earlyFlakeDetectionSkippedResults.get(task)
+  if (skippedResult) {
+    task.result = skippedResult
+    earlyFlakeDetectionSkippedResults.delete(task)
+  }
+  return true
+}
+
+function hasNewErrors (errorCounts, attemptIndex, task) {
+  const recordedErrorCount = errorCounts?.[attemptIndex]
+  const previousErrorCount = recordedErrorCount ?? getPreviousErrorCount(errorCounts, attemptIndex)
+  return (task.result?.errors?.length || 0) > previousErrorCount
+}
+
+function getFinalAttemptIndex (task) {
+  const testSuite = getTestSuite(task)
+  const testName = getTestName(task)
+
+  if (attemptToFixTests[testSuite]?.[testName]) {
+    return getAttemptToFixRetryCount(task)
+  }
+  if (isEarlyFlakeDetectionTest(testSuite, testName)) {
+    return getEarlyFlakeDetectionRetryCountForTask(task)
+  }
+  return task.repeats
+}
+
+function switchQuarantinedFinalFailure (task, attemptIndex) {
+  const testSuite = getTestSuite(task)
+  const testName = getTestName(task)
+  if (
+    !quarantinedTests[testSuite]?.[testName] ||
+    attemptToFixTests[testSuite]?.[testName] ||
+    task.result?.state !== 'fail'
+  ) {
+    return
+  }
+
+  const retryCount = task.result?.retryCount || 0
+  const retryLimit = task.retry || 0
+  if (retryCount < retryLimit || attemptIndex < getFinalAttemptIndex(task)) {
+    return
+  }
+
+  task.meta.__ddTestOptQuarantinedFailed = true
+  task.result.state = 'pass'
+}
+
+function getAttemptToFixRetryCount (task) {
+  return task.meta.__ddTestOptAtfRetries ?? task.repeats
+}
+
+function getEarlyFlakeDetectionRetryCountForTask (task) {
+  return earlyFlakeDetectionRetriesByTask.get(task) ?? task.meta.__ddTestOptEfdRetries ?? task.repeats
+}
+
+function getAttemptStatus (task, errorCounts, repeatCount) {
+  const errorCount = task.result?.errors?.length || 0
+  if (errorCount > getPreviousErrorCount(errorCounts, repeatCount)) {
+    return 'fail'
+  }
+  return task.result?.state === 'fail' ? 'fail' : 'pass'
+}
+
+function getManualRepeatStatus (task, errorCounts, repeatCount) {
+  const errorCount = task.result?.errors?.length || 0
+  return errorCount > getPreviousErrorCount(errorCounts, repeatCount) ? 'fail' : 'pass'
+}
+
+function getPreviousErrorCount (errorCounts, repeatCount) {
+  for (let index = repeatCount - 1; index >= 0; index--) {
+    if (errorCounts[index] !== undefined) {
+      return errorCounts[index]
+    }
+  }
+  return 0
+}
+
+function prepareEarlyFlakeDetectionAttempt (task, attemptIndex) {
+  if (attemptIndex === 0) {
+    earlyFlakeDetectionStartByTask.set(task, performance.now())
+    return false
+  }
+
+  let retryCount = earlyFlakeDetectionRetriesByTask.get(task)
+  if (retryCount === undefined) {
+    retryCount = getEarlyFlakeDetectionRetryCount(task)
+    earlyFlakeDetectionRetriesByTask.set(task, retryCount)
+    task.repeats = retryCount
+    task.meta.__ddTestOptEfdRetries = retryCount
+    if (retryCount === 0 && hasEarlyFlakeDetectionSlowRetries) {
+      task.meta.__ddTestOptEfdAbortReason = 'slow'
+    }
+  }
+
+  if (attemptIndex <= retryCount) {
+    earlyFlakeDetectionStartByTask.set(task, performance.now())
+    return false
+  }
+
+  if (!canReplaceVitestTaskFn()) {
+    earlyFlakeDetectionStartByTask.set(task, performance.now())
+    return false
+  }
+
+  if (task.result) {
+    earlyFlakeDetectionSkippedResults.set(task, {
+      ...task.result,
+      errors: task.result.errors?.slice(),
+    })
+  }
+  task.meta.__ddTestOptEfdSkipCurrentAttempt = true
+  replaceVitestTaskFn(task, noopTest)
+  return true
+}
+
+function getEarlyFlakeDetectionRetryCount (task) {
+  if (!hasEarlyFlakeDetectionSlowRetries) {
+    return earlyFlakeDetectionRetries
+  }
+
+  const executionStart = earlyFlakeDetectionStartByTask.get(task)
+  const duration = executionStart === undefined ? task.result?.duration ?? 0 : performance.now() - executionStart
+  for (const { key, limitMs } of earlyFlakeDetectionRetryThresholds) {
+    if (duration < limitMs) {
+      return earlyFlakeDetectionSlowRetries[key] ?? 0
+    }
+  }
+  return 0
+}
+
+function noopTest () {}
+
+/**
+ * Returns whether Vitest's private task function setter is available.
+ *
+ * @returns {boolean}
+ */
+function canReplaceVitestTaskFn () {
+  return typeof setVitestTaskFn === 'function'
+}
+
+/**
+ * Replaces the function Vitest runs for a task.
+ *
+ * @param {object} task
+ * @param {(...args: unknown[]) => unknown} testFn
+ */
+function replaceVitestTaskFn (task, testFn) {
+  setVitestTaskFn(task, testFn)
+}
+
+function isEarlyFlakeDetectionTest (testSuite, testName) {
+  if (!isEarlyFlakeDetectionEnabled || earlyFlakeDetectionRetries <= 0) return false
+  if (isModifiedTest(testSuite)) return true
+  const testsForSuite = knownTests[testSuite] || []
+  return !testsForSuite.includes(testName)
+}
+
+function isModifiedTest (testSuite) {
+  return modifiedFiles[testSuite]?.length > 0
+}
+
+function getTestSuite (task) {
+  let filepath = realpaths.get(task.file.filepath)
+  if (filepath === undefined) {
+    filepath = realpath(task.file.filepath)
+    realpaths.set(task.file.filepath, filepath)
+  }
+
+  return normalizePath(relative(repositoryRoot, filepath))
+}
+
+function realpath (filepath) {
+  try {
+    return realpathSync(filepath)
+  } catch {
+    return filepath
+  }
+}
+
+function getTestName (task) {
+  let testName = task.name
+  let currentTask = task.suite
+
+  while (currentTask) {
+    if (currentTask.name) {
+      testName = `${currentTask.name} ${testName}`
+    }
+    currentTask = currentTask.suite
+  }
+
+  return testName
+}
+
+function normalizePath (filepath) {
+  return filepath.replaceAll('\\', '/')
+}
+
+function getIsNoWorkerInitActive () {
+  try {
+    // eslint-disable-next-line eslint-rules/eslint-process-env
+    const value = process.env[VITEST_NO_WORKER_INIT_ACTIVE_ENV]
+    return value === '1' || value === 'true'
+  } catch {
+    return false
+  }
+}
+
+function getProvidedContext () {
+  try {
+    return globalThis.__vitest_worker__.providedContext._ddVitestWorkerSetup || {}
+  } catch {
+    return {}
+  }
+}

package/ext/tags.js

@@ -27,6 +27,8 @@ const tags = {
   HTTP_CLIENT_IP: 'http.client_ip',
   NETWORK_CLIENT_IP: 'network.client.ip',
 
+  GRPC_STATUS_CODE: 'grpc.status.code',
+
   // Messaging
 
   // DSM Specific

package/index.d.ts

@@ -2625,6 +2625,18 @@ declare namespace tracer {
     typeResolver?: any,
     }
 
+    /** Context object passed to the `hooks.resolve` callback for each instrumented field. */
+    interface FieldContext {
+      /** The field name being resolved */
+      fieldName: string;
+      /** The dot-separated field path (e.g. `'user.address.city'`) */
+      path: string;
+      /** The error from the resolver, or `null` if it succeeded */
+      error: Error | null;
+      /** The value returned by the resolver (sync resolvers only; `undefined` for async) */
+      result: unknown;
+    }
+
     /**
      * This plugin automatically instruments the
      * [graphql](https://github.com/graphql/graphql-js) module.
@@ -2703,6 +2715,7 @@ declare namespace tracer {
         execute?: (span?: Span, args?: ExecutionArgs, res?: any) => void;
         validate?: (span?: Span, document?: any, errors?: any) => void;
         parse?: (span?: Span, source?: any, document?: any) => void;
+        resolve?: (span?: Span, field?: FieldContext) => void;
       }
     }
 

package/initialize.mjs

@@ -19,7 +19,7 @@ import { isMainThread } from 'worker_threads'
 // This file must support Node.js 12.0.0 syntax
 
 import {
-  iitmExclusions,
+  iitmExclusionRegExp,
   load as hookLoad,
   resolve as hookResolve,
 } from './loader-hook.mjs'
@@ -67,8 +67,7 @@ const [NODE_MAJOR, NODE_MINOR] = process.versions.node.split('.').map(Number)
 const brokenLoaders = NODE_MAJOR === 18 && NODE_MINOR === 0
 
 export async function load (url, context, nextLoad) {
-  const iitmExclusionsMatch = iitmExclusions.some((exclusion) => exclusion.test(url))
-  const loadHook = (brokenLoaders || iitmExclusionsMatch) ? nextLoad : hookLoad
+  const loadHook = (brokenLoaders || iitmExclusionRegExp.test(url)) ? nextLoad : hookLoad
   return insertInit(await loadHook(url, context, nextLoad), url, context)
 }
 
@@ -78,8 +77,8 @@ if (isMainThread) {
   const require = Module.createRequire(import.meta.url)
   require('./init.js')
   if (Module.register) {
-    Module.register('./loader-hook.mjs', import.meta.url, {
-      data: { exclude: iitmExclusions },
-    })
+    // The loader builds its own include/exclude matcher in `initialize`, so no
+    // options need to cross the registration boundary.
+    Module.register('./loader-hook.mjs', import.meta.url)
   }
 }