dd-trace 5.109.0 → 5.111.0

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

@@ -1,504 +1,46 @@
 'use strict'
 
-const { AsyncLocalStorage } = require('node:async_hooks')
+const { addHook, getHooks } = require('./helpers/instrument')
 
-const shimmer = require('../../datadog-shimmer')
-const {
-  addHook,
-  channel,
-} = require('./helpers/instrument')
+// Orchestrion rewriter handles wrapping of:
+// - graphql: execute, parse, validate (CJS + ESM)
+// - @graphql-tools/executor: execute, normalizedExecutor (CJS + ESM)
+// See helpers/rewriter/instrumentations/graphql.js for the full config.
+//
+// The plugin (packages/datadog-plugin-graphql/src/execute.js) handles the
+// `apm:graphql:execute:start` AppSec/WAF contract from inside its bindStart:
+// publishing the channel synchronously runs subscribers, and an
+// `abortController.abort()` from a subscriber is observed by replacing
+// `ctx.arguments[0]` with an object whose getters throw AbortError. The
+// orchestrion-emitted wrapper's `catch { ...; throw err }` block propagates
+// that throw to the caller of graphql.execute. No outer wrap needed.
 
-const ddGlobal = globalThis[Symbol.for('dd-trace')]
-
-/** cached objects */
-
-// `contexts` is the fast resolver-side lookup; `executeCtx` is the fallback
-// when `contextValue` is a primitive and cannot key a WeakMap.
-const contexts = new WeakMap()
-const executeCtx = new AsyncLocalStorage()
-// Tracks normalized args already instrumented in an outer wrap so graphql-yoga
-// (which stacks `execute` + `normalizedExecutor`) only emits one span per call.
-const instrumentedArgs = new WeakSet()
-const documentSources = new WeakMap()
-const patchedResolvers = new WeakSet()
-const patchedTypes = new WeakSet()
-
-/** CHANNELS */
-
-// execute channels
-const startExecuteCh = channel('apm:graphql:execute:start')
-const finishExecuteCh = channel('apm:graphql:execute:finish')
-const executeErrorCh = channel('apm:graphql:execute:error')
-
-// resolve channels
-const startResolveCh = channel('apm:graphql:resolve:start')
-const finishResolveCh = channel('apm:graphql:resolve:finish')
-const updateFieldCh = channel('apm:graphql:resolve:updateField')
-const resolveErrorCh = channel('apm:graphql:resolve:error')
-
-// parse channels
-const parseStartCh = channel('apm:graphql:parser:start')
-const parseFinishCh = channel('apm:graphql:parser:finish')
-const parseErrorCh = channel('apm:graphql:parser:error')
-
-// validate channels
-const validateStartCh = channel('apm:graphql:validate:start')
-const validateFinishCh = channel('apm:graphql:validate:finish')
-const validateErrorCh = channel('apm:graphql:validate:error')
-
-class AbortError extends Error {
-  constructor (message) {
-    super(message)
-    this.name = 'AbortError'
-  }
-}
-
-const types = new Set(['query', 'mutation', 'subscription'])
-
-function getOperation (document, operationName) {
-  if (!document || !Array.isArray(document.definitions)) {
-    return
-  }
-
-  for (const definition of document.definitions) {
-    if (definition && types.has(definition.operation) && (!operationName || definition.name?.value === operationName)) {
-      return definition
-    }
-  }
-}
-
-function normalizeArgs (args, defaultFieldResolver) {
-  if (args.length !== 1) return normalizePositional(args, defaultFieldResolver)
-
-  const original = args[0]
-  const normalized = {
-    ...original,
-    fieldResolver: wrapResolve(original.fieldResolver || defaultFieldResolver),
-  }
-
-  args[0] = normalized
-  return normalized
-}
-
-function normalizePositional (args, defaultFieldResolver) {
-  args[6] = wrapResolve(args[6] || defaultFieldResolver) // fieldResolver
-  args.length = Math.max(args.length, 7)
-
-  return {
-    schema: args[0],
-    document: args[1],
-    rootValue: args[2],
-    contextValue: args[3],
-    variableValues: args[4],
-    operationName: args[5],
-    fieldResolver: args[6],
-  }
-}
-
-// `WeakMap.set` throws `TypeError` on a non-object key; `get`/`has`/`delete`
-// silently miss. Skip the WeakMap entirely for non-keyable `contextValue`.
-function isWeakMapKey (value) {
-  return value !== null && typeof value === 'object'
-}
-
-function wrapParse (parse) {
-  return function (source) {
-    if (!parseStartCh.hasSubscribers) {
-      return parse.apply(this, arguments)
-    }
-
-    const ctx = { source }
-    return parseStartCh.runStores(ctx, () => {
-      try {
-        ctx.document = parse.apply(this, arguments)
-        const operation = getOperation(ctx.document)
-
-        if (!operation) return ctx.document
-
-        if (source) {
-          documentSources.set(ctx.document, source.body || source)
-        }
-        ctx.docSource = documentSources.get(ctx.document)
-
-        return ctx.document
-      } catch (err) {
-        void err.stack
-        ctx.error = err
-        parseErrorCh.publish(ctx)
-
-        throw err
-      } finally {
-        parseFinishCh.publish(ctx)
-      }
-    })
-  }
+for (const hook of getHooks('graphql')) {
+  addHook(hook, exports => exports)
 }
 
-function wrapValidate (validate) {
-  return function (_schema, document, _rules, _typeInfo) {
-    if (!validateStartCh.hasSubscribers) {
-      return validate.apply(this, arguments)
-    }
-
-    const ctx = { docSource: documentSources.get(document), document }
-    return validateStartCh.runStores(ctx, () => {
-      let errors
-      try {
-        errors = validate.apply(this, arguments)
-        if (errors && errors[0]) {
-          ctx.error = errors[0]
-          validateErrorCh.publish(ctx)
-        }
-        return errors
-      } catch (err) {
-        void err.stack
-        ctx.error = err
-        validateErrorCh.publish(ctx)
-
-        throw err
-      } finally {
-        ctx.errors = errors
-        validateFinishCh.publish(ctx)
-      }
-    })
-  }
+for (const hook of getHooks('@graphql-tools/executor')) {
+  addHook(hook, exports => exports)
 }
 
-function wrapExecute (execute) {
-  return function (exe) {
-    const defaultFieldResolver = execute.defaultFieldResolver
-    return function () {
-      if (!startExecuteCh.hasSubscribers) {
-        return exe.apply(this, arguments)
-      }
-
-      // The outer wrap leaves its normalized args object in `arguments[0]`; on
-      // graphql-yoga's inner wrap that reference is already known here.
-      if (instrumentedArgs.has(arguments[0])) {
-        return exe.apply(this, arguments)
-      }
-
-      const args = normalizeArgs(arguments, defaultFieldResolver)
-      const schema = args.schema
-      const document = args.document
-      const source = documentSources.get(document)
-      const contextValue = args.contextValue
-      const keyable = isWeakMapKey(contextValue)
-      const operation = getOperation(document, args.operationName)
-
-      if (keyable && contexts.has(contextValue)) {
-        return exe.apply(this, arguments)
-      }
-
-      const ctx = {
-        operation,
-        args,
-        docSource: source,
-        source,
-        fields: new Map(),
-        abortController: new AbortController(),
-      }
-
-      // Only the object form leaves a stable single-object handle in
-      // `arguments[0]` for the inner wrap to see.
-      if (args === arguments[0]) instrumentedArgs.add(args)
-
-      return startExecuteCh.runStores(ctx, () => {
-        if (schema) {
-          wrapFields(schema._queryType)
-          wrapFields(schema._mutationType)
-        }
-
-        if (keyable) contexts.set(contextValue, ctx)
-
-        const finish = (err, res) => {
-          if (finishResolveCh.hasSubscribers) finishResolvers(ctx)
-
-          const error = err || (res && res.errors && res.errors[0])
-
-          if (error) {
-            ctx.error = error
-            executeErrorCh.publish(ctx)
-          }
-
-          ctx.res = res
-          if (keyable) contexts.delete(contextValue)
-          instrumentedArgs.delete(args)
-          finishExecuteCh.publish(ctx)
-        }
-
-        // Skip the ALS entry on the common object-`contextValue` path; the
-        // resolver reaches `ctx` via the WeakMap there.
-        return keyable
-          ? callInAsyncScope(exe, this, arguments, ctx.abortController, finish)
-          : executeCtx.run(ctx, () => callInAsyncScope(exe, this, arguments, ctx.abortController, finish))
-      })
-    }
-  }
-}
-
-function wrapResolve (resolve) {
-  if (typeof resolve !== 'function' || patchedResolvers.has(resolve)) return resolve
-
-  function resolveAsync (source, args, contextValue, info) {
-    if (!startResolveCh.hasSubscribers) return resolve.apply(this, arguments)
-
-    // `WeakMap.get(primitive)` returns `undefined`, so the fallback covers
-    // executes that ran with a primitive `contextValue`.
-    const ctx = contexts.get(contextValue) ?? executeCtx.getStore()
-
-    /* istanbul ignore if: resolver invoked outside execute(), so no per-execute ctx was registered */
-    if (!ctx) return resolve.apply(this, arguments)
-
-    const field = assertField(ctx, info, args)
-
-    if (ctx.abortController.signal.aborted) {
-      publishResolverFinish(field, null)
-      throw new AbortError('Aborted')
-    }
-
-    try {
-      const result = resolve.call(this, source, args, contextValue, info)
-      if (result !== null && typeof result?.then === 'function') {
-        return result.then(
-          res => {
-            publishResolverFinish(field, null)
-            return res
-          },
-          error => {
-            publishResolverFinish(field, error)
-            throw error
-          }
-        )
-      }
-      publishResolverFinish(field, null)
-      return result
-    } catch (error) {
-      publishResolverFinish(field, error)
-      throw error
-    }
-  }
-
-  patchedResolvers.add(resolveAsync)
-
-  return resolveAsync
-}
-
-/**
- * @param {{ ctx: object, error: unknown }} field
- * @param {unknown} error
- */
-function publishResolverFinish (field, error) {
-  const fieldCtx = field.ctx
-  fieldCtx.error = error
-  fieldCtx.field = field
-  updateFieldCh.publish(fieldCtx)
-}
-
-function callInAsyncScope (fn, thisArg, args, abortController, cb) {
-  if (abortController.signal.aborted) {
-    cb(null, null)
-    throw new AbortError('Aborted')
-  }
-
-  try {
-    const result = fn.apply(thisArg, args)
-    if (result !== null && typeof result?.then === 'function') {
-      return result.then(
-        res => {
-          cb(null, res)
-          return res
-        },
-        /* istanbul ignore next: graphql.execute() rejects only via custom executors (graphql-yoga / graphql-tools) */
-        error => {
-          cb(error)
-          throw error
-        }
-      )
-    }
-    cb(null, result)
-    return result
-  } catch (error) {
-    cb(error)
-    throw error
-  }
-}
-
-/**
- * @typedef {{ prev: PathNode | undefined, key: string | number }} PathNode
- *
- * @typedef {{ error: unknown, ctx: object }} TrackedField
- */
-
-/**
- * @param {{
- *   fields: Map<object, TrackedField>,
- *   collapse: boolean,
- *   collapsedFields?: Map<string, TrackedField>,
- *   pathCache?: Map<PathNode, string>,
- * }} rootCtx
- * @param {import('graphql').GraphQLResolveInfo} info
- * @param {Record<string, unknown>} args
- */
-function assertField (rootCtx, info, args) {
-  const path = info.path
-  const collapse = rootCtx.collapse
-
-  const cache = rootCtx.pathCache ??= new Map()
-  const prev = path.prev
-  const key = path.key
-  const segment = collapse && typeof key !== 'string' ? '*' : key
-
-  const pathString = prev === undefined
-    ? String(segment)
-    : (cache.get(prev) ?? buildCachedPathString(prev, cache, collapse)) + '.' + segment
-  cache.set(path, pathString)
-
-  const fieldCtx = {
-    rootCtx,
-    args,
-    path,
-    pathString,
-    fieldName: info.fieldName,
-    returnType: info.returnType,
-    fieldNode: info.fieldNodes[0],
-    variableValues: info.variableValues,
-  }
-  // Publish per resolver call, before the collapse / depth dedupe below.
-  // IAST mutates each call's own args object; if siblings 2..N skip the
-  // publish, those args objects never get tainted.
-  startResolveCh.publish(fieldCtx)
-
-  let collapsedFields
-  if (collapse) {
-    collapsedFields = rootCtx.collapsedFields ??= new Map()
-    const existing = collapsedFields.get(pathString)
-    // Subsequent siblings of a collapsed list share the first sibling's field
-    // so updateFieldCh fires for every call and the span's finishTime tracks
-    // the last sibling's completion, not the first.
-    if (existing !== undefined) return existing
-  }
-
-  const field = { error: null, ctx: fieldCtx }
-  rootCtx.fields.set(path, field)
-  if (collapsedFields !== undefined) collapsedFields.set(pathString, field)
-  return field
-}
-
-/**
- * Cold path for assertField. graphql-js inserts a synthetic array-index
- * node between a list field and its items, and that node never reaches a
- * resolver — so assertField has no chance to cache it. The first child of
- * the list item that hits the path cache lands here to walk and populate
- * back to a cached ancestor.
- *
- * @param {PathNode} path
- * @param {Map<PathNode, string>} cache
- * @param {boolean} collapse
- */
-function buildCachedPathString (path, cache, collapse) {
-  const key = path.key
-  const segment = collapse && typeof key !== 'string' ? '*' : key
-  const prev = path.prev
-
-  const pathString = prev === undefined
-    ? String(segment)
-    : (cache.get(prev) ?? buildCachedPathString(prev, cache, collapse)) + '.' + segment
-  cache.set(path, pathString)
-  return pathString
-}
-
-function wrapFields (type) {
-  if (!type || !type._fields || patchedTypes.has(type)) {
-    return
-  }
-
-  patchedTypes.add(type)
-
-  for (const field of Object.values(type._fields)) {
-    wrapFieldResolve(field)
-    wrapFieldType(field)
-  }
-}
-
-function wrapFieldResolve (field) {
-  if (!field || !field.resolve) return
-  field.resolve = wrapResolve(field.resolve)
-}
-
-function wrapFieldType (field) {
-  if (!field || !field.type) return
-
-  let unwrappedType = field.type
-
-  while (unwrappedType.ofType) {
-    unwrappedType = unwrappedType.ofType
-  }
-
-  wrapFields(unwrappedType)
-}
-
-function finishResolvers ({ fields }) {
-  for (const field of fields.values()) {
-    const fieldCtx = field.ctx
-    // A depth-gated field publishes startResolveCh for IAST/AppSec but the
-    // resolve plugin's start short-circuits before creating a span, so there
-    // is no span here to finish.
-    if (fieldCtx.currentStore === undefined) continue
-    fieldCtx.finishTime = field.finishTime
-    fieldCtx.field = field
-    if (field.error) {
-      fieldCtx.error = field.error
-      resolveErrorCh.publish(fieldCtx)
-    }
-    finishResolveCh.publish(fieldCtx)
-  }
-}
-
-addHook({ name: '@graphql-tools/executor', versions: ['>=0.0.14'] }, executor => {
-  // graphql-yoga uses the normalizedExecutor function, so we need to wrap both. There is no risk in wrapping both
-  // since the functions are closely related, and our wrappedExecute function prevents double calls with the
-  // contexts.has(contextValue) check.
-  shimmer.wrap(executor, 'execute', wrapExecute(executor))
-  shimmer.wrap(executor, 'normalizedExecutor', wrapExecute(executor))
-  return executor
-})
-
-// TODO(BridgeAR): graphql >=17.0.0-alpha.9 routes execute() through
-// experimentalExecuteIncrementally(), bypassing this hook. The same
-// function returns { initialResult, subsequentResults } for @defer /
-// @stream which callInAsyncScope does not handle — execute finishes
-// before the streamed payloads land.
-addHook({ name: 'graphql', file: 'execution/execute.js', versions: ['>=0.10'] }, execute => {
-  shimmer.wrap(execute, 'execute', wrapExecute(execute))
-  return execute
-})
-
-addHook({ name: 'graphql', file: 'language/parser.js', versions: ['>=0.10'] }, parser => {
-  shimmer.wrap(parser, 'parse', wrapParse)
-  return parser
-})
-
-addHook({ name: 'graphql', file: 'validation/validate.js', versions: ['>=0.10'] }, validate => {
-  shimmer.wrap(validate, 'validate', wrapValidate)
-
-  return validate
-})
+// Module-load hooks: capture references on ddGlobal for cross-plugin access
+// (read lazily inside each callback so agent.load() between mocha suites can
+// rebind globalThis[dd-trace] without us stashing a stale reference).
 
 addHook({ name: 'graphql', file: 'language/printer.js', versions: ['>=0.10'] }, printer => {
-  // HACK: It's possible `graphql` is loaded before `@apollo/gateway` so we
-  //       can't use a channel as the latter plugin would load after the publish
-  //       happened. Not sure how to handle this so for now use a global.
-  ddGlobal.graphql_printer = printer
+  const ddGlobal = globalThis[Symbol.for('dd-trace')]
+  if (ddGlobal) ddGlobal.graphql_printer = printer
   return printer
 })
 
 addHook({ name: 'graphql', file: 'language/visitor.js', versions: ['>=0.10'] }, visitor => {
-  ddGlobal.graphql_visitor = visitor
+  const ddGlobal = globalThis[Symbol.for('dd-trace')]
+  if (ddGlobal) ddGlobal.graphql_visitor = visitor
   return visitor
 })
 
 addHook({ name: 'graphql', file: 'utilities/index.js', versions: ['>=0.10'] }, utilities => {
-  ddGlobal.graphql_utilities = utilities
+  const ddGlobal = globalThis[Symbol.for('dd-trace')]
+  if (ddGlobal) ddGlobal.graphql_utilities = utilities
   return utilities
 })

package/packages/datadog-instrumentations/src/helpers/check-require-cache.js

@@ -1,8 +1,9 @@
 'use strict'
 
-// This code runs before the tracer is configured and before a logger is ready
-// For that reason we queue up the messages now and decide what to do with them later
-const warnings = []
+// Queued before the logger is ready; flushed once the tracer knows its config.
+const warnings = [] // conflicts; flushed under DD_TRACE_DEBUG
+const loadOrderWarnings = [] // "loaded before dd-trace"; flushed under startupLogs
+const frameworkWarnings = [] // curated (e.g. Next.js); flushed unconditionally
 
 /**
  * Here we maintain a list of packages that an application
@@ -28,6 +29,24 @@ const potentialConflicts = new Set([
 
 const extractPackageAndModulePath = require('./extract-package-and-module-path')
 
+/**
+ * Frameworks that load their own server code before any user code (and thus
+ * before a late `tracer.init()`) can run. When their server module is already
+ * in `require.cache` at init time, dd-trace was loaded too late to instrument
+ * them and the integration silently no-ops. Unlike the broad scan below, this
+ * set is high-signal enough to warn on by default. `file` is the module whose
+ * presence proves the server is already loaded; `guidance` is the bundler note
+ * appended to the warning.
+ */
+const earlyLoadFrameworks = new Map([
+  ['next', {
+    // dist/server/next-server.js (>=11.1), dist/next-server/server/next-server.js (older)
+    file: 'next-server.js',
+    guidance: "add 'dd-trace' to `serverExternalPackages` (Next.js >=15) or " +
+      '`experimental.serverComponentsExternalPackages` (13-14) so it is not bundled',
+  }],
+])
+
 /**
  * The lowest hanging fruit to debug an app that isn't tracing
  * properly is to check that it is loaded before any modules
@@ -43,25 +62,53 @@ const extractPackageAndModulePath = require('./extract-package-and-module-path')
  * app loads a package we instrument but outside of an
  * unsupported version then a warning would still be displayed.
  * This is OK as the tracer should be loaded earlier anyway.
+ *
+ * Curated frameworks (see `earlyLoadFrameworks`) surface unconditionally; the
+ * broad list of packages loaded before dd-trace is queued for the startupLogs-
+ * gated flush (`flushLoadOrderWarnings`).
  */
 module.exports.checkForRequiredModules = function () {
   const packages = require('./hooks')
   const naughties = new Set()
+  const frameworksSeen = new Set()
   let didWarn = false
 
   for (const pathToModule of Object.keys(require.cache)) {
-    const { pkg } = extractPackageAndModulePath(pathToModule)
+    // require.cache keys use the platform separator; normalize so the
+    // `node_modules/<pkg>` parsing works on Windows (backslash paths).
+    const { pkg, path } = extractPackageAndModulePath(pathToModule.replaceAll('\\', '/'))
 
-    if (naughties.has(pkg)) continue
-    if (!(pkg in packages)) continue
+    if (pkg === null) continue
+
+    // A curated framework loads its own server before user code, so its server
+    // module being cached means dd-trace was too late to instrument it. These
+    // surface unconditionally (see flushFrameworkWarnings) with an actionable
+    // message, so they never fall through to the broad load-order list below.
+    const framework = earlyLoadFrameworks.get(pkg)
+    if (framework !== undefined) {
+      if (!frameworksSeen.has(pkg) && path?.endsWith(framework.file)) {
+        frameworksSeen.add(pkg)
+        frameworkWarnings.push(
+          `'${pkg}' was loaded before dd-trace, so the ${pkg} integration will not be applied. ` +
+          'Initialize dd-trace before your application starts — ' +
+          "NODE_OPTIONS='--require dd-trace/init' (CommonJS) or '--import dd-trace/initialize.mjs' (ESM) — " +
+          `and ${framework.guidance}.`
+        )
+      }
+      continue
+    }
 
-    warnings.push(() => `Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`)
+    if (naughties.has(pkg) || !(pkg in packages)) continue
+
+    loadOrderWarnings.push(
+      () => `Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`
+    )
 
     naughties.add(pkg)
     didWarn = true
   }
 
-  if (didWarn) warnings.push('Warning: Please ensure dd-trace is loaded before other modules.')
+  if (didWarn) loadOrderWarnings.push('Warning: Please ensure dd-trace is loaded before other modules.')
 }
 
 /**
@@ -104,3 +151,29 @@ module.exports.flushStartupLogs = function (log) {
     log.warn(typeof entry === 'function' ? entry() : entry)
   }
 }
+
+/**
+ * Drains the broad "loaded before dd-trace" warnings collected by
+ * `checkForRequiredModules`. The tracer gates this on startupLogs (these are
+ * startup diagnostics), unlike the unconditional `flushFrameworkWarnings`.
+ * @param {(message: string) => void} warn
+ */
+module.exports.flushLoadOrderWarnings = function (warn) {
+  while (loadOrderWarnings.length) {
+    const entry = loadOrderWarnings.shift()
+    warn(typeof entry === 'function' ? entry() : entry)
+  }
+}
+
+/**
+ * Drains the framework warnings collected by `checkForRequiredModules`. The
+ * tracer surfaces these unconditionally (not gated on startupLogs or
+ * DD_TRACE_DEBUG), unlike the DD_TRACE_DEBUG-only `flushStartupLogs` queue,
+ * because the affected users run with neither enabled (#5430 / #5432).
+ * @param {(message: string) => void} warn
+ */
+module.exports.flushFrameworkWarnings = function (warn) {
+  while (frameworkWarnings.length) {
+    warn(frameworkWarnings.shift())
+  }
+}

package/packages/datadog-instrumentations/src/helpers/instrument.js

@@ -42,6 +42,31 @@ exports.tracingChannel = function (name) {
   return tc
 }
 
+/**
+ * Build a guarded publisher for a public error channel. A subscriber that
+ * re-enters the same wrapped dispatch while handling the error would otherwise
+ * republish here and recurse until the stack overflows. Each framework binds
+ * its own publisher, so the in-flight flag stays private to one channel: a
+ * genuinely nested error on a different framework's channel (a Koa app mounted
+ * inside Express) still reaches its subscribers instead of being dropped, and
+ * the guard costs a closure read rather than a per-publish channel lookup.
+ *
+ * @param {Channel} errorChannel
+ */
+exports.createErrorPublisher = function createErrorPublisher (errorChannel) {
+  let publishing = false
+  /** @param {object} message */
+  return function publishError (message) {
+    if (publishing) return
+    publishing = true
+    try {
+      errorChannel.publish(message)
+    } finally {
+      publishing = false
+    }
+  }
+}
+
 exports.getHooks = function getHooks (names) {
   names = [names].flat()
 
@@ -55,9 +80,9 @@ exports.getHooks = function getHooks (names) {
  * @param {object} args
  * @param {string} args.name module name
  * @param {string[]} [args.versions] array of semver range strings
- * @param {string} [args.file] path to file within package to instrument. Defaults to 'index.js'.
+ * @param {string} [args.file] path to file within package to instrument. Defaults to 'index.js'.
  * @param {string} [args.filePattern] pattern to match files within package to instrument
- * @param {boolean} [args.patchDefault] whether to patch the default export. Defaults to true.
+ * @param {boolean} [args.patchDefault] whether to patch the default export. Defaults to true.
  * @param {(moduleExports: unknown, version: string, isIitm?: boolean, hookMeta?: object) => unknown} [hook]
  * Patches module exports
  */