dd-trace 5.108.0 → 5.110.0

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

@@ -2,29 +2,33 @@
 
 const { channel, tracingChannel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
-const { convertVercelPromptToMessages, buildOutputMessages } = require('./helpers/ai-messages')
 const { addHook, getHooks } = require('./helpers/instrument')
 
 const vercelAiTracingChannel = tracingChannel('dd-trace:vercel-ai')
 const vercelAiSpanSetAttributesChannel = channel('dd-trace:vercel-ai:span:setAttributes')
-const aiguardChannel = channel('dd-trace:ai:aiguard')
+const doGenerateBeforeChannel = channel('dd-trace:vercel-ai:doGenerate:before')
+const doGenerateAfterChannel = channel('dd-trace:vercel-ai:doGenerate:after')
+const doStreamBeforeChannel = channel('dd-trace:vercel-ai:doStream:before')
+const doStreamAfterChannel = channel('dd-trace:vercel-ai:doStream:after')
 
 const tracers = new WeakSet()
 const wrappedModels = new WeakSet()
 
 /**
- * Publishes already-converted AI-style messages to the AI Guard evaluation channel.
+ * Publishes a provider-native lifecycle payload to a cancelable lifecycle channel.
  *
- * Subscribers push async work into `pending` and abort `abortController` to block.
+ * Subscribers push async work into `pending` synchronously during publication and
+ * abort `abortController` with an error before the pushed promise resolves to block.
  *
- * @param {Array<object>} messages - AI-style messages to evaluate.
+ * @param {object} lifecycleChannel
+ * @param {object} payload
  * @returns {Promise<void>}
  */
-function publishEvaluation (messages) {
+function publishLifecycle (lifecycleChannel, payload) {
   const abortController = new AbortController()
-  const ctx = { messages, integration: 'ai', abortController, pending: [] }
+  const ctx = { ...payload, abortController, pending: [] }
 
-  aiguardChannel.publish(ctx)
+  lifecycleChannel.publish(ctx)
 
   return Promise.all(ctx.pending).then(() => {
     if (abortController.signal.aborted) {
@@ -34,12 +38,11 @@ function publishEvaluation (messages) {
 }
 
 /**
- * Wraps a Vercel AI language model's doGenerate and doStream methods to evaluate
- * messages with AIGuard.
+ * Wraps a Vercel AI language model's doGenerate and doStream lifecycle methods.
  *
  * @param {object} model - A Vercel AI language model instance
  */
-function wrapModelWithAIGuard (model) {
+function wrapModelWithLifecycle (model) {
   if (!model || wrappedModels.has(model)) return
   wrappedModels.add(model)
 
@@ -48,20 +51,18 @@ function wrapModelWithAIGuard (model) {
       return function (options) {
         const originalResult = original.call(this, options)
 
-        if (!aiguardChannel.hasSubscribers) return originalResult
+        if (!doGenerateBeforeChannel.hasSubscribers && !doGenerateAfterChannel.hasSubscribers) return originalResult
         if (!options.prompt?.length) return originalResult
 
-        const inputMessages = convertVercelPromptToMessages(options.prompt)
-        if (!inputMessages.length) return originalResult
+        const beforeEvaluation = doGenerateBeforeChannel.hasSubscribers
+          ? publishLifecycle(doGenerateBeforeChannel, { prompt: options.prompt, options })
+          : Promise.resolve()
 
-        // Run AI Guard input evaluation and LLM call in parallel.
-        // The LLM has no side effects so it is safe to discard its result if AI Guard blocks.
-        return Promise.all([publishEvaluation(inputMessages), originalResult])
+        return Promise.all([beforeEvaluation, originalResult])
           .then(([, result]) => {
-            if (!result.content?.length) return result
-            const outputMessages = buildOutputMessages(inputMessages, result.content)
-            return publishEvaluation(outputMessages)
-              .then(() => result)
+            if (!doGenerateAfterChannel.hasSubscribers || !result.content?.length) return result
+            const payload = { prompt: options.prompt, options, result }
+            return publishLifecycle(doGenerateAfterChannel, payload).then(() => result)
           })
       }
     })
@@ -72,16 +73,17 @@ function wrapModelWithAIGuard (model) {
       return function (options) {
         const originalResult = original.call(this, options)
 
-        if (!aiguardChannel.hasSubscribers) return originalResult
+        if (!doStreamBeforeChannel.hasSubscribers && !doStreamAfterChannel.hasSubscribers) return originalResult
         if (!options.prompt?.length) return originalResult
 
-        const inputMessages = convertVercelPromptToMessages(options.prompt)
-        if (!inputMessages.length) return originalResult
+        const beforeEvaluation = doStreamBeforeChannel.hasSubscribers
+          ? publishLifecycle(doStreamBeforeChannel, { prompt: options.prompt, options })
+          : Promise.resolve()
 
-        // Run AI Guard input evaluation and LLM call in parallel.
-        // The LLM has no side effects so it is safe to discard its result if AI Guard blocks.
-        return Promise.all([publishEvaluation(inputMessages), originalResult])
+        return Promise.all([beforeEvaluation, originalResult])
           .then(([, result]) => {
+            if (!doStreamAfterChannel.hasSubscribers) return result
+
             const chunks = []
             const reader = result.stream.getReader()
 
@@ -94,26 +96,19 @@ function wrapModelWithAIGuard (model) {
             }
 
             return readAll().then(() => {
-              const toolCalls = chunks.filter(c => c?.type === 'tool-call')
-              const text = chunks.filter(c => c?.type === 'text-delta').map(c => c.textDelta).join('')
-              const content = toolCalls.length ? toolCalls : text ? [{ type: 'text', text }] : []
-
-              const evaluate = content.length
-                ? publishEvaluation(buildOutputMessages(inputMessages, content))
-                : Promise.resolve()
-
-              return evaluate.then(() => {
-                // eslint-disable-next-line n/no-unsupported-features/node-builtins
-                const stream = new ReadableStream({
-                  start (controller) {
-                    for (const chunk of chunks) {
-                      controller.enqueue(chunk)
-                    }
-                    controller.close()
-                  },
+              return publishLifecycle(doStreamAfterChannel, { prompt: options.prompt, options, chunks })
+                .then(() => {
+                  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+                  const stream = new ReadableStream({
+                    start (controller) {
+                      for (const chunk of chunks) {
+                        controller.enqueue(chunk)
+                      }
+                      controller.close()
+                    },
+                  })
+                  return { ...result, stream }
                 })
-                return { ...result, stream }
-              })
             })
           })
       }
@@ -230,7 +225,7 @@ for (const hook of getHooks('ai')) {
     // generateObject, streamObject)
     tracingChannel('orchestrion:ai:resolveLanguageModel').subscribe({
       end (ctx) {
-        wrapModelWithAIGuard(ctx.result)
+        wrapModelWithLifecycle(ctx.result)
       },
     })
 
@@ -238,4 +233,4 @@ for (const hook of getHooks('ai')) {
   })
 }
 
-module.exports = { wrapModelWithAIGuard }
+module.exports = { wrapModelWithLifecycle }

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

@@ -0,0 +1,18 @@
+'use strict'
+
+// Methods on `DurableContextImpl` that return a lazy DurablePromise. The rewriter
+// instrumentation generates a `kind: 'Sync'` Orchestrion hook for each so Orchestrion
+// does not eagerly side-chain `.then()`; the runtime instrumentation side-chains the
+// returned DurablePromise itself and publishes a `:settle` channel once it settles,
+// preserving the SDK's lazy semantics. Shared between both so the lists cannot drift.
+module.exports = [
+  'step',
+  'invoke',
+  'runInChildContext',
+  'wait',
+  'waitForCondition',
+  'waitForCallback',
+  'createCallback',
+  'map',
+  'parallel',
+]

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

@@ -0,0 +1,111 @@
+'use strict'
+
+const { channel, tracingChannel } = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, getHooks } = require('./helpers/instrument')
+const LAZY_DURABLE_PROMISE_METHODS = require('./aws-durable-execution-sdk-js-context-methods')
+
+for (const method of LAZY_DURABLE_PROMISE_METHODS) {
+  const orchestrionCh = tracingChannel(`orchestrion:@aws/durable-execution-sdk-js:DurableContextImpl_${method}`)
+  const settleCh = channel(`apm:aws-durable-execution-sdk-js:${method}:settle`)
+
+  orchestrionCh.end.subscribe(ctx => {
+    if (!settleCh.hasSubscribers) return
+    observeDurablePromise(ctx.result, error => {
+      if (error !== undefined) ctx.error = error
+      settleCh.publish(ctx)
+    })
+  })
+}
+
+// runHandler(event, context, executionContext, mode, checkpointToken, handler) creates the
+// DurableContext internally and passes it to the user handler, and drives suspension through
+// executionContext.terminationManager.terminate(). The cross-invocation checkpoint plugin needs
+// both: the DurableContext (to reach the checkpoint manager) and a signal that the execution is
+// suspending. Capture the former off the handler call and surface the latter on a channel.
+const HANDLER_ARG_INDEX = 5
+const EXECUTION_CONTEXT_ARG_INDEX = 2
+
+const withDurableExecutionCh = tracingChannel('orchestrion:@aws/durable-execution-sdk-js:withDurableExecution')
+const terminateCh = channel('apm:aws-durable-execution-sdk-js:terminate')
+
+withDurableExecutionCh.start.subscribe(ctx => {
+  // Only wrap while the plugin is listening (cross-invocation tracing enabled).
+  if (!terminateCh.hasSubscribers) return
+
+  // ctx.arguments is an array-like `arguments` object, not a true Array.
+  const args = ctx.arguments
+  if (!args) return
+
+  if (typeof args[HANDLER_ARG_INDEX] === 'function') {
+    shimmer.wrap(args, HANDLER_ARG_INDEX, handler => function (event, durableContext) {
+      ctx.durableContext = durableContext
+      return handler.apply(this, arguments)
+    })
+  }
+
+  const terminationManager = args[EXECUTION_CONTEXT_ARG_INDEX]?.terminationManager
+  if (typeof terminationManager?.terminate === 'function') {
+    shimmer.wrap(terminationManager, 'terminate', terminate => function (options) {
+      // Publish before the original runs so the plugin can enqueue the checkpoint while the
+      // checkpoint manager is still accepting writes (it flips to "terminating" inside terminate()).
+      ctx.terminationReason = options?.reason
+      terminateCh.publish(ctx)
+      return terminate.apply(this, arguments)
+    })
+  }
+})
+
+// Per-instance settle callback read by the shared prototype wrappers installed by
+// `instrumentDurablePromiseProto`. Stored on the DurablePromise instance so the prototype
+// wrappers stay allocation-free and the promise carries its own observer.
+const ON_SETTLE = Symbol('_dd.durableExecution.onSettle')
+
+const instrumentedProtos = new WeakSet()
+
+/**
+ * Wraps `then`/`catch`/`finally` on a DurablePromise prototype once so every instance shares
+ * the same wrappers instead of being re-wrapped individually. The wrappers side-chain a settle
+ * observer the first time user code chains off the promise, then clear `ON_SETTLE` so the
+ * observer attaches at most once (a promise settles only once). Instances we don't observe
+ * never set `ON_SETTLE`, so for them the wrappers are a single property read and a passthrough.
+ * @param {object} proto - The DurablePromise prototype (`Object.getPrototypeOf(dp)`).
+ * @returns {void}
+ */
+function instrumentDurablePromiseProto (proto) {
+  if (instrumentedProtos.has(proto)) return
+  instrumentedProtos.add(proto)
+
+  // Capture the genuine `.then` before wrapping so the settle observer side-chains without
+  // recursing back into the wrapper below.
+  const originalThen = proto.then
+
+  shimmer.massWrap(proto, ['then', 'catch', 'finally'], original => function (...args) {
+    const onSettle = this[ON_SETTLE]
+    if (onSettle !== undefined) {
+      this[ON_SETTLE] = undefined
+      originalThen.call(this, () => onSettle(), err => onSettle(err))
+    }
+    return original.apply(this, args)
+  })
+}
+
+/**
+ * Registers a settle observer on a returned DurablePromise. Callers pair `kind: 'Sync'` with this
+ * helper so `onSettle` only fires after user code first awaits / chains, preserving the SDK's
+ * lazy semantics.
+ * @param {object} dp - The returned DurablePromise instance.
+ * @param {(err: unknown) => void} onSettle - Called once with `undefined` on success or the
+ *   rejection reason on failure.
+ * @returns {void}
+ */
+function observeDurablePromise (dp, onSettle) {
+  if (!dp || typeof dp.then !== 'function') return
+  instrumentDurablePromiseProto(Object.getPrototypeOf(dp))
+  dp[ON_SETTLE] = onSettle
+}
+
+for (const hook of getHooks('@aws/durable-execution-sdk-js')) {
+  hook.file = null
+  addHook(hook, exports => exports)
+}

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

@@ -150,6 +150,7 @@ function wrapDeserialize (deserialize, headersCh, responseIndex = 0) {
 function wrapSmithySend (send) {
   return function (command, ...args) {
     const cb = args.at(-1)
+    const cbExists = typeof cb === 'function'
     const serviceIdentifier = this.config.serviceId.toLowerCase()
     const channelSuffix = getChannelSuffix(serviceIdentifier)
     const channels = getChannelBag(channelSuffix)
@@ -188,6 +189,7 @@ function wrapSmithySend (send) {
       operation,
       awsService: clientName,
       request,
+      cbExists,
     }
 
     return channels.start.runStores(ctx, () => {
@@ -197,7 +199,7 @@ function wrapSmithySend (send) {
         channels.region.publish(ctx)
       })
 
-      if (typeof cb === 'function') {
+      if (cbExists) {
         args[args.length - 1] = shimmer.wrapCallback(cb, cb => function (err, result) {
           addResponse(ctx, err, result)
 

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, createErrorPublisher } = require('./helpers/instrument')
 
 const enterChannel = channel('apm:connect:middleware:enter')
 const exitChannel = channel('apm:connect:middleware:exit')
@@ -9,6 +9,7 @@ const errorChannel = channel('apm:connect:middleware:error')
 const nextChannel = channel('apm:connect:middleware:next')
 const finishChannel = channel('apm:connect:middleware:finish')
 const handleChannel = channel('apm:connect:request:handle')
+const publishError = createErrorPublisher(errorChannel)
 
 function wrapConnect (connect) {
   if (typeof connect !== 'function') return connect
@@ -78,7 +79,7 @@ function wrapLayerHandle (layer) {
     try {
       return original.apply(this, args)
     } catch (error) {
-      errorChannel.publish({ req, error })
+      publishError({ req, error })
       nextChannel.publish({ req })
       finishChannel.publish({ req })
 
@@ -93,7 +94,7 @@ function wrapNext (req, next) {
   // Mirror next's name/arity so wrapCallback skips its per-call identity rewrite.
   return shimmer.wrapCallback(next, original => function next (error) {
     if (error) {
-      errorChannel.publish({ req, error })
+      publishError({ req, error })
     }
 
     nextChannel.publish({ req })

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

@@ -218,7 +218,7 @@ addHook({ name: 'electron', versions: ['>=37.0.0'] }, electron => {
     wrap(ipcRenderer, 'removeAllListeners', createWrapRemoveAllListeners(listeners))
 
     ipcRenderer.send('datadog:apm:renderer:patched')
-  } else {
+  } else if (ipcMain) {
     wrap(ipcMain, 'addListener', createWrapAddListener(mainReceiveCh, listeners))
     wrap(ipcMain, 'handle', createWrapAddListener(mainHandleCh, handlers))
     wrap(ipcMain, 'handleOnce', createWrapAddListener(mainHandleCh, handlers))

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

@@ -1,9 +1,10 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, createErrorPublisher } = require('./helpers/instrument')
 
 const errorChannel = channel('apm:fastify:middleware:error')
+const publishErrorChannel = createErrorPublisher(errorChannel)
 const handleChannel = channel('apm:fastify:request:handle')
 const routeAddedChannel = channel('apm:fastify:route:added')
 const bodyParserReadCh = channel('datadog:fastify:body-parser:finish')
@@ -303,18 +304,9 @@ function getRouteConfig (request) {
   return request?.routeOptions?.config
 }
 
-let publishingError = false
-
 function publishError (ctx) {
-  // `errorChannel` is public: a subscriber that re-enters the hook pipeline while
-  // handling the error republishes here and recurses until the stack overflows.
-  if (ctx.error && !publishingError) {
-    publishingError = true
-    try {
-      errorChannel.publish(ctx)
-    } finally {
-      publishingError = false
-    }
+  if (ctx.error) {
+    publishErrorChannel(ctx)
   }
 
   return ctx.error

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

@@ -455,15 +455,26 @@ function finishResolvers ({ fields }) {
   }
 }
 
-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))
+// The CJS package root re-exports `execute` and `normalizedExecutor` as
+// non-configurable tslib `__exportStar` getters that shimmer cannot rewrite in
+// place, so the inner execute.js hook below carries CJS instead: graphql-yoga
+// (`normalizedExecutor`) and direct callers both funnel through that `execute`.
+// Under iitm (ESM) the namespace is settable and the inner-file hook never
+// matches the `esm/` path, so the root wrap is the only option there.
+addHook({ name: '@graphql-tools/executor', versions: ['>=0.0.14'] }, (executor, _version, isIitm) => {
+  /* istanbul ignore if: covered only by the graphql-yoga ESM integration test (subprocess) */
+  if (isIitm) {
+    shimmer.wrap(executor, 'execute', wrapExecute(executor))
+    shimmer.wrap(executor, 'normalizedExecutor', wrapExecute(executor))
+  }
   return executor
 })
 
+addHook({ name: '@graphql-tools/executor', file: 'cjs/execution/execute.js', versions: ['>=0.0.14'] }, execute => {
+  shimmer.wrap(execute, 'execute', wrapExecute(execute))
+  return execute
+})
+
 // TODO(BridgeAR): graphql >=17.0.0-alpha.9 routes execute() through
 // experimentalExecuteIncrementally(), bypassing this hook. The same
 // function returns { initialResult, subsequentResults } for @defer /

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/hooks.js

@@ -22,6 +22,7 @@ module.exports = {
   '@modelcontextprotocol/sdk': () => require('../modelcontextprotocol-sdk'),
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
+  '@aws/durable-execution-sdk-js': () => require('../aws-durable-execution-sdk-js'),
   '@azure/cosmos': { esmFirst: true, fn: () => require('../azure-cosmos') },
   '@azure/event-hubs': () => require('../azure-event-hubs'),
   '@azure/functions': () => require('../azure-functions'),

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
  */