dd-trace 6.14.0 → 6.16.0

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

@@ -6,90 +6,30 @@ const { addHook } = require('./helpers/instrument')
 
 const anthropicTracingChannel = tracingChannel('apm:anthropic:request')
 const onStreamedChunkCh = channel('apm:anthropic:request:chunk')
-const messagesBeforeChannel = channel('dd-trace:anthropic:messages:before')
-const messagesAfterChannel = channel('dd-trace:anthropic:messages:after')
 
-/**
- * Publishes a provider-native lifecycle payload to a cancelable lifecycle channel.
- *
- * Subscribers push async work into `pending` synchronously during publication and
- * abort `abortController` with an error before the pushed promise resolves to block.
- *
- * @param {object} channel
- * @param {object} payload
- * @returns {Promise<void>}
- */
-function publishLifecycle (channel, payload) {
-  const abortController = new AbortController()
-  const ctx = { ...payload, abortController, pending: [] }
-
-  channel.publish(ctx)
-
-  return Promise.all(ctx.pending).then(() => {
-    if (abortController.signal.aborted) {
-      throw abortController.signal.reason
-    }
-  })
-}
+// `prepare` is published before the SDK is invoked, so subscribers may replace `arguments[0]`.
+// `intercept` follows with the native call data; a subscriber may set either callback and this
+// instrumentation applies it, so the wrapping stays here and only the policy lives outside:
+//   beforeResult () => Promise<void>|undefined   holds the result back until it settles
+//   onResult (body) => unknown|Promise<unknown>  inspects or replaces the delivered body
+const messagesPrepareChannel = channel('dd-trace:anthropic:messages:prepare')
+const messagesInterceptChannel = channel('dd-trace:anthropic:messages:intercept')
 
 /**
+ * Returns `promise`, but not before `settled` settles, so a rejection from an interceptor
+ * reaches the caller instead of the SDK's value.
+ *
  * @template T
  * @param {Promise<T>} promise
- * @param {Promise<void>|undefined} verdict
+ * @param {Promise<void>|undefined} settled
  * @returns {Promise<T>}
  */
-function waitForVerdict (promise, verdict) {
-  if (!verdict) return promise
+function heldUntil (promise, settled) {
+  if (!settled) return promise
 
-  // The lifecycle verdict takes precedence over an earlier SDK rejection.
+  // The interceptor's rejection wins over an earlier SDK rejection, so keep that one handled.
   promise.catch(() => {})
-  return verdict.then(() => promise)
-}
-
-/**
- * @param {Array<unknown>} args
- * @returns {Array<unknown>|undefined}
- */
-function snapshotLifecycleArgs (args) {
-  const options = args[0]
-  if (!options || typeof options !== 'object') return
-
-  const input = { messages: options.messages }
-  if (options.system !== undefined) input.system = options.system
-
-  // Snapshot via JSON so AI Guard evaluates exactly what the SDK serializes and sends, immune to
-  // later caller mutation. If it can't serialize (e.g. circular), the SDK's own serialization would
-  // fail too, so skipping evaluation is safe — nothing reaches the model.
-  try {
-    const snapshot = [...args]
-    // eslint-disable-next-line unicorn/prefer-structured-clone
-    snapshot[0] = { ...options, ...JSON.parse(JSON.stringify(input)) }
-    return snapshot
-  } catch {
-    // Unserializable input — leave AI Guard inactive for this call (the SDK send would fail too).
-  }
-}
-
-/**
- * Finishes after output evaluation so a block propagates to the caller and span.
- *
- * @param {object} ctx
- * @param {object} result
- * @param {(body: object) => Promise<void>|undefined} getVerdict
- * @param {object|string} [returnedResult]
- * @returns {object|string|Promise<object|string>}
- */
-function finishResult (ctx, result, getVerdict, returnedResult = result) {
-  const verdict = getVerdict(result)
-  if (!verdict) {
-    finish(ctx, result)
-    return returnedResult
-  }
-
-  return verdict.then(() => {
-    finish(ctx, result)
-    return returnedResult
-  })
+  return settled.then(() => promise)
 }
 
 /**
@@ -106,22 +46,36 @@ function finishAndThrow (ctx, error) {
  * @param {object} response
  * @param {'json'|'text'} method
  * @param {object} ctx
- * @param {(body: object) => Promise<void>|undefined} getVerdict
+ * @param {object} [interceptCtx]
  */
-function wrapResponseReader (response, method, ctx, getVerdict) {
+function wrapResponseReader (response, method, ctx, interceptCtx) {
   if (typeof response[method] !== 'function') return
 
   shimmer.wrap(response, method, original => function (...args) {
     return original.apply(this, args)
       .then(body => {
-        if (method === 'json') return finishResult(ctx, body, getVerdict)
+        // `text()` callers keep their string; only the callback and the span see the parsed body.
+        let parsed = body
+        if (method === 'text') {
+          try {
+            parsed = JSON.parse(body)
+          } catch {
+            finish(ctx)
+            return body
+          }
+        }
 
-        try {
-          return finishResult(ctx, JSON.parse(body), getVerdict, body)
-        } catch {
-          finish(ctx)
+        if (!interceptCtx?.onResult) {
+          finish(ctx, parsed)
           return body
         }
+
+        return Promise.resolve(interceptCtx.onResult(parsed)).then(deliveredBody => {
+          finish(ctx, parsed)
+          // `json()` callers get any replacement; `text()` callers keep their original string,
+          // because the callback was handed the parsed object rather than the text.
+          return method === 'json' ? deliveredBody : body
+        })
       })
       .catch(error => finishAndThrow(ctx, error))
   })
@@ -130,17 +84,17 @@ function wrapResponseReader (response, method, ctx, getVerdict) {
 /**
  * @param {object} response
  * @param {object} ctx
- * @param {(body: object) => Promise<void>|undefined} getVerdict
+ * @param {object} [interceptCtx]
  */
-function wrapRawResponse (response, ctx, getVerdict) {
-  wrapResponseReader(response, 'json', ctx, getVerdict)
-  wrapResponseReader(response, 'text', ctx, getVerdict)
+function wrapRawResponse (response, ctx, interceptCtx) {
+  wrapResponseReader(response, 'json', ctx, interceptCtx)
+  wrapResponseReader(response, 'text', ctx, interceptCtx)
 
   if (typeof response.clone !== 'function') return
 
   shimmer.wrap(response, 'clone', clone => function (...args) {
     const clonedResponse = clone.apply(this, args)
-    wrapRawResponse(clonedResponse, ctx, getVerdict)
+    wrapRawResponse(clonedResponse, ctx, interceptCtx)
     return clonedResponse
   })
 }
@@ -172,68 +126,60 @@ function wrapStreamIterator (iterator, ctx) {
 
 function wrapCreate (create) {
   return function (...args) {
-    const options = args[0]
-    const stream = options?.stream
-
-    // Streaming is out of scope for lifecycle evaluation.
-    const lifecycleArgs = !stream &&
-      (messagesBeforeChannel.hasSubscribers || messagesAfterChannel.hasSubscribers)
-      ? snapshotLifecycleArgs(args)
-      : undefined
+    const stream = args[0]?.stream
+    const preparing = !stream && messagesPrepareChannel.hasSubscribers
+    const intercepting = !stream && messagesInterceptChannel.hasSubscribers
 
-    if (!anthropicTracingChannel.start.hasSubscribers && !lifecycleArgs) {
+    if (!anthropicTracingChannel.start.hasSubscribers && !preparing && !intercepting) {
       return create.apply(this, args)
     }
 
-    const ctx = { options: lifecycleArgs?.[0] ?? options, resource: 'create', baseUrl: this._client?.baseURL }
+    // `args` is this wrapper's own rest array, so replacing `arguments[0]` changes what reaches
+    // the SDK without touching anything the caller still holds.
+    if (preparing) {
+      messagesPrepareChannel.publish({ arguments: args })
+    }
 
-    return anthropicTracingChannel.start.runStores(ctx, () => {
-      const parentSpan = lifecycleArgs ? ctx.currentStore?.span : undefined
+    const ctx = { options: args[0], resource: 'create', baseUrl: this._client?.baseURL }
 
+    return anthropicTracingChannel.start.runStores(ctx, () => {
       let apiPromise
       try {
-        // Anthropic starts the request eagerly; the input verdict only gates result delivery.
-        apiPromise = create.apply(this, lifecycleArgs ?? args)
+        // Anthropic starts the request eagerly, so subscribers can only hold back delivery.
+        apiPromise = create.apply(this, args)
       } catch (error) {
         finish(ctx, null, error)
         throw error
       }
 
-      let beforeVerdict
-      let afterVerdict
-      let parseResult
-      let wrappedResponse
-
-      function getBeforeVerdict () {
-        if (!lifecycleArgs || beforeVerdict) return beforeVerdict
-        if (!messagesBeforeChannel.hasSubscribers) return
-
-        beforeVerdict = publishLifecycle(messagesBeforeChannel, { args: lifecycleArgs, parentSpan })
-        return beforeVerdict
+      let interceptCtx
+      if (intercepting) {
+        interceptCtx = { arguments: args, tracingContext: ctx }
+        messagesInterceptChannel.publish(interceptCtx)
       }
 
-      /**
-       * @param {object|string} body
-       */
-      function getAfterVerdict (body) {
-        if (!lifecycleArgs || afterVerdict) return afterVerdict
-        if (!messagesAfterChannel.hasSubscribers) return
-
-        afterVerdict = publishLifecycle(messagesAfterChannel, { args: lifecycleArgs, body, parentSpan })
-        return afterVerdict
-      }
+      let parseResult
+      let wrappedResponse
 
       shimmer.wrap(apiPromise, 'parse', parse => function (...parseArgs) {
         if (parseResult) return parseResult
 
-        const parsed = parse.apply(this, parseArgs)
-        parseResult = waitForVerdict(parsed, getBeforeVerdict())
+        parseResult = heldUntil(parse.apply(this, parseArgs), interceptCtx?.beforeResult?.())
           .then(response => {
             if (stream) {
               shimmer.wrap(response, Symbol.asyncIterator, iterator => wrapStreamIterator(iterator, ctx))
               return response
             }
-            return finishResult(ctx, response, getAfterVerdict)
+
+            if (!interceptCtx?.onResult) {
+              finish(ctx, response)
+              return response
+            }
+
+            return Promise.resolve(interceptCtx.onResult(response)).then(deliveredResponse => {
+              finish(ctx, response)
+              return deliveredResponse
+            })
           })
           .catch(error => finishAndThrow(ctx, error))
 
@@ -242,18 +188,14 @@ function wrapCreate (create) {
 
       if (typeof apiPromise.asResponse === 'function') {
         shimmer.wrap(apiPromise, 'asResponse', origAsResponse => function (...asResponseArgs) {
-          return waitForVerdict(origAsResponse.apply(this, asResponseArgs), getBeforeVerdict())
+          return heldUntil(origAsResponse.apply(this, asResponseArgs), interceptCtx?.beforeResult?.())
             .then(response => {
-              // Wrap the raw response's json()/text()/clone() readers to evaluate output on read,
-              // but only while someone still consumes the result and not twice for the same response.
-              const outputObserved = anthropicTracingChannel.start.hasSubscribers ||
-                afterVerdict || messagesAfterChannel.hasSubscribers
-              if (!stream && outputObserved && wrappedResponse !== response) {
+              // Wrap json()/text()/clone() so the span still closes on the raw-response path,
+              // and not twice for the same response.
+              if (!stream && wrappedResponse !== response) {
                 wrappedResponse = response
-                wrapRawResponse(response, ctx, getAfterVerdict)
+                wrapRawResponse(response, ctx, interceptCtx)
               }
-
-              if (afterVerdict) return afterVerdict.then(() => response)
               return response
             })
             .catch(error => finishAndThrow(ctx, error))

package/packages/datadog-instrumentations/src/aws-durable-execution-sdk-js.js

@@ -105,7 +105,7 @@ function observeDurablePromise (dp, onSettle) {
   dp[ON_SETTLE] = onSettle
 }
 
-for (const hook of getHooks('@aws/durable-execution-sdk-js')) {
+for (const hook of getHooks('@aws/durable-execution-sdk-js').values()) {
   hook.file = null
   addHook(hook, exports => exports)
 }

package/packages/datadog-instrumentations/src/azure-cosmos.js

@@ -2,6 +2,6 @@
 
 const { addHook, getHooks } = require('./helpers/instrument')
 
-for (const hook of getHooks('@azure/cosmos')) {
+for (const hook of getHooks('@azure/cosmos').values()) {
   addHook(hook, exports => exports)
 }

package/packages/datadog-instrumentations/src/azure-durable-functions.js

@@ -5,6 +5,7 @@ const shimmer = require('../../datadog-shimmer')
 
 const {
   addHook,
+  getHooks,
 } = require('./helpers/instrument')
 
 /**
@@ -12,6 +13,10 @@ const {
  */
 const azureDurableFunctionsChannel = dc.tracingChannel('datadog:azure:durable-functions:invoke')
 
+for (const hook of getHooks('durable-functions').values()) {
+  addHook(hook, exports => exports)
+}
+
 addHook({ name: 'durable-functions', versions: ['>=3'], patchDefault: false }, (df) => {
   const { app } = df
 
@@ -42,9 +47,16 @@ function entityHandler (handler, entityName) {
     if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, args)
 
     const entityContext = args[0]
+    const traceContext = entityContext?.traceContext
     return azureDurableFunctionsChannel.traceSync(
       handler,
-      { trigger: 'Entity', functionName: entityName, operationName: entityContext?.df?.operationName },
+      {
+        trigger: 'Entity',
+        functionName: entityName,
+        operationName: entityContext?.df?.operationName,
+        traceparent: traceContext?.traceParent,
+        tracestate: traceContext?.traceState,
+      },
       this, ...args)
   }
 }
@@ -58,16 +70,18 @@ function activityHandler (method) {
       return function (...args) {
         if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, args)
 
+        const traceContext = args[1]?.traceContext
+        const channelCtx = {
+          trigger: 'Activity',
+          functionName: activityName,
+          traceparent: traceContext?.traceParent,
+          tracestate: traceContext?.traceState,
+        }
+
         // use tracePromise if this is an async handler. otherwise, use traceSync
         return isAsync
-          ? azureDurableFunctionsChannel.tracePromise(
-            handler,
-            { trigger: 'Activity', functionName: activityName },
-            this, ...args)
-          : azureDurableFunctionsChannel.traceSync(
-            handler,
-            { trigger: 'Activity', functionName: activityName },
-            this, ...args)
+          ? azureDurableFunctionsChannel.tracePromise(handler, channelCtx, this, ...args)
+          : azureDurableFunctionsChannel.traceSync(handler, channelCtx, this, ...args)
       }
     })
     return method.apply(this, arguments)

package/packages/datadog-instrumentations/src/azure-functions.js

@@ -8,6 +8,12 @@ const {
 
 const azureFunctionsChannel = dc.tracingChannel('datadog:azure:functions:invoke')
 
+// Orchestrators register via app.generic; activities/entities use the durable-functions hook.
+const azureDurableFunctionsChannel = dc.tracingChannel('datadog:azure:durable-functions:invoke')
+
+const ORCHESTRATION_TRIGGER_TYPE = 'orchestrationTrigger'
+const ORCHESTRATOR_COMPLETED_EVENT_TYPE = 13
+
 addHook({ name: '@azure/functions', versions: ['>=4'], patchDefault: false }, (azureFunction) => {
   const { app } = azureFunction
 
@@ -29,9 +35,51 @@ addHook({ name: '@azure/functions', versions: ['>=4'], patchDefault: false }, (a
   // CosmosDB triggers
   shimmer.wrap(app, 'cosmosDB', wrapHandler)
 
+  // Durable Functions orchestration triggers
+  shimmer.wrap(app, 'generic', wrapGeneric)
+
   return azureFunction
 })
 
+function wrapGeneric (method) {
+  return function (name, options) {
+    if (options?.trigger?.type === ORCHESTRATION_TRIGGER_TYPE && typeof options.handler === 'function') {
+      options.handler = traceOrchestrationHandler(options.handler, name)
+    }
+    return method.apply(this, arguments)
+  }
+}
+
+function traceOrchestrationHandler (handler, functionName) {
+  return function (...args) {
+    if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, args)
+
+    const orchestrationBinding = args[0]
+    // we do not want to trace if the orchestrator has already completed and is being reactivated
+    const history = orchestrationBinding?.history
+    const hasPreviousActivation = history?.some(
+      event => event.EventType === ORCHESTRATOR_COMPLETED_EVENT_TYPE
+    )
+
+    if (hasPreviousActivation) {
+      return handler.apply(this, args)
+    }
+
+    const traceContext = args[1]?.traceContext
+    const channelCtx = {
+      trigger: 'Orchestration',
+      functionName,
+      traceparent: traceContext?.traceParent,
+      tracestate: traceContext?.traceState,
+    }
+
+    return azureDurableFunctionsChannel.tracePromise(
+      handler,
+      channelCtx,
+      this, ...args)
+  }
+}
+
 // The http methods are overloaded so we need to check which type of argument was passed in order to wrap the handler
 // The arguments are either an object with a handler property or the handler function itself
 function wrapHandler (method) {

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

@@ -6,6 +6,6 @@
 
 const { addHook, getHooks } = require('./helpers/instrument')
 
-for (const hook of getHooks('bullmq')) {
+for (const hook of getHooks('bullmq').values()) {
   addHook(hook, exports => exports)
 }

package/packages/datadog-instrumentations/src/claude-agent-sdk.js

@@ -638,7 +638,7 @@ function wrapQueryAsyncIterator (asyncIterator, ctx) {
 
 let querySubscribed = false
 
-for (const hook of getHooks('@anthropic-ai/claude-agent-sdk')) {
+for (const hook of getHooks('@anthropic-ai/claude-agent-sdk').values()) {
   hook.file = null
 
   addHook(hook, exports => {

package/packages/datadog-instrumentations/src/dd-trace-api.js

@@ -3,5 +3,5 @@
 const { addHook } = require('./helpers/instrument')
 
 // Empty hook just to make the plugin load.
-// TODO: Add version range when the module is released on npm.
-addHook({ name: 'dd-trace-api' }, api => api)
+// Version 1.0.1 re-publishes tracer initialization after the plugin subscribes.
+addHook({ name: 'dd-trace-api', versions: ['>=1.0.1'] }, api => api)

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

@@ -12,7 +12,7 @@ const { addHook, getHooks } = require('./helpers/instrument')
  */
 function addRewriterHooks (name) {
   const files = new Set()
-  for (const hook of getHooks(name)) {
+  for (const hook of getHooks(name).values()) {
     if (files.has(hook.file)) continue
     files.add(hook.file)
     addHook(hook, exports => exports)

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

@@ -4,13 +4,16 @@ const Module = require('module')
 const dc = require('dc-polyfill')
 
 const log = require('../../../dd-trace/src/log')
+const { loadChannel } = require('./register.js')
 const {
   filename,
-  loadChannel,
+  getDisabledInstrumentations,
   matchVersion,
-} = require('./register.js')
+  matchesInstrumentation,
+} = require('./instrumentation-utils')
 const hooks = require('./hooks')
 const instrumentations = require('./instrumentations')
+const disabledInstrumentations = getDisabledInstrumentations()
 
 // register.js has now set up ritm (require-in-the-middle). In bundled
 // environments (webpack, esbuild), Node.js built-in modules required by
@@ -69,21 +72,29 @@ function doHook (name) {
 
   try {
     hookFn()
-  } catch {
-    log.error('esbuild-wrapped %s hook failed', name)
+  } catch (error) {
+    log.error('esbuild-wrapped %s hook failed: %s', name, String(error?.message ?? error), error)
   }
 }
 
+/**
+ * @typedef {object} Payload
+ * @property {boolean} [activate]
+ * @property {string} package
+ * @property {unknown} [module]
+ * @property {string} [version]
+ * @property {string} [path]
+ */
+
 /** @type {Set<string>} */
 const instrumentedNodeModules = new Set()
 
-/** @typedef {{ package: string, module: unknown, version: string, path: string }} Payload */
 dc.subscribe(CHANNEL, (message) => {
   const payload = /** @type {Payload} */ (message)
   const name = payload.package
+  if (disabledInstrumentations.has(name)) return
 
   const isPrefixedWithNode = name.startsWith('node:')
-
   const isNodeModule = isPrefixedWithNode || !hooks[name]
 
   if (isNodeModule) {
@@ -100,20 +111,34 @@ dc.subscribe(CHANNEL, (message) => {
   const instrumentation = instrumentations[name] ?? instrumentations[`node:${name}`]
 
   if (!instrumentation) {
-    log.error('esbuild-wrapped %s missing in list of instrumentations', name)
+    if (!payload.activate) log.error('esbuild-wrapped %s missing in list of instrumentations', name)
     return
   }
 
-  for (const { file, versions, hook } of instrumentation) {
-    if (payload.path !== filename(name, file) || !matchVersion(payload.version, versions)) {
-      continue
+  if (payload.activate) {
+    for (const { sourceRewrite, versions, hook } of instrumentation) {
+      if (!sourceRewrite || payload.path !== filename(name, sourceRewrite) ||
+        !matchVersion(payload.version, versions)) continue
+
+      try {
+        loadChannel.publish({ name })
+        hook(undefined, payload.version)
+      } catch (error) {
+        log.error('Error executing bundler hook: %s', String(error?.message ?? error), error)
+      }
+      return
     }
+    return
+  }
+
+  for (const entry of instrumentation) {
+    if (!matchesInstrumentation(name, payload.version, payload.path, entry)) continue
 
     try {
-      loadChannel.publish({ name, version: payload.version, file })
-      payload.module = hook(payload.module, payload.version) ?? payload.module
-    } catch (e) {
-      log.error('Error executing bundler hook', e)
+      loadChannel.publish({ name })
+      payload.module = entry.hook(payload.module, payload.version) ?? payload.module
+    } catch (error) {
+      log.error('Error executing bundler hook: %s', String(error?.message ?? error), error)
     }
   }
 })

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

@@ -5,6 +5,8 @@ const dc = /** @type {typeof import('node:diagnostics_channel')} */ (require('dc
 const instrumentations = require('./instrumentations')
 const rewriterInstrumentations = require('./rewriter/instrumentations')
 
+const sourceRewritePaths = new WeakMap()
+
 /**
  * @typedef {import('node:diagnostics_channel').Channel} Channel
  * @typedef {import('node:diagnostics_channel').TracingChannel} TracingChannel
@@ -74,13 +76,26 @@ exports.createErrorPublisher = function createErrorPublisher (errorChannel) {
   }
 }
 
+// The rewriter instrumentation list holds one entry per *transform*, so a
+// module with several transforms repeats its module definition several times
+// (mercurius defines 3, graphql 26). A hook only cares about the module, not
+// the transform, so duplicates would push the same (versionRange, filePath)
+// registration through `addHook` once per transform and have shimmer patch the
+// same file several times.
 exports.getHooks = function getHooks (names) {
-  names = [names].flat()
-
-  return rewriterInstrumentations
-    .map(inst => inst.module)
-    .filter(({ name }) => names.includes(name))
-    .map(({ name, versionRange, filePath }) => ({ name, versions: [versionRange], file: filePath }))
+  const requested = new Set([names].flat())
+  const hooks = new Map()
+  for (const { module } of rewriterInstrumentations) {
+    if (!requested.has(module.name)) continue
+    // Fresh objects, including the versions array: callers may adjust a hook
+    // for their own registration (the ai, claude-agent-sdk and
+    // aws-durable-execution-sdk-js plugins set `hook.file = null`), which must
+    // not leak into any other call.
+    const hook = { name: module.name, versions: [module.versionRange], file: module.filePath }
+    sourceRewritePaths.set(hook, module.filePath)
+    hooks.set(`${module.name}|${module.versionRange}|${module.filePath}`, hook)
+  }
+  return hooks
 }
 
 /**
@@ -93,12 +108,14 @@ exports.getHooks = function getHooks (names) {
  * @param {(moduleExports: unknown, version: string, isIitm?: boolean, hookMeta?: object) => unknown} [hook]
  * Patches module exports
  */
-exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {
+exports.addHook = function addHook (args, hook) {
+  const { name, versions, file, filePattern, patchDefault } = args
   if (!instrumentations[name]) {
     instrumentations[name] = []
   }
 
-  instrumentations[name].push({ versions, file, filePattern, hook, patchDefault })
+  const sourceRewrite = sourceRewritePaths.get(args)
+  instrumentations[name].push({ versions, file, filePattern, hook, patchDefault, sourceRewrite })
 }
 
 exports.AsyncResource = AsyncResource