dd-trace 5.108.0 → 5.109.0

package/index.d.ts

@@ -235,6 +235,7 @@ interface Plugins {
   "anthropic": tracer.plugins.anthropic;
   "apollo": tracer.plugins.apollo;
   "avsc": tracer.plugins.avsc;
+  "aws-durable-execution-sdk-js": tracer.plugins.aws_durable_execution_sdk_js;
   "aws-sdk": tracer.plugins.aws_sdk;
   "azure-cosmos": tracer.plugins.azure_cosmos;
   "azure-event-hubs": tracer.plugins.azure_event_hubs;
@@ -2351,6 +2352,12 @@ declare namespace tracer {
      */
     interface avsc extends Integration {}
 
+    /**
+     * This plugin automatically instruments the
+     * [aws-durable-execution-sdk-js](https://github.com/aws/aws-durable-execution-sdk-js) module.
+     */
+    interface aws_durable_execution_sdk_js extends Integration {}
+
     /**
      * This plugin automatically instruments the
      * [aws-sdk](https://github.com/aws/aws-sdk-js) module.
@@ -2428,7 +2435,21 @@ declare namespace tracer {
      * This plugin automatically instruments the
      * [bullmq](https://github.com/npmjs/package/bullmq) message queue library.
      */
-    interface bullmq extends Instrumentation {}
+    interface bullmq extends Instrumentation {
+      /**
+       * Filter applied to BullMQ producer operations (`Queue.add`, `Queue.addBulk`,
+       * `FlowProducer.add`). Return `false` to skip span creation, trace context
+       * injection, and DSM checkpoint handling for the matching job. Consumer-side
+       * (`Worker`) instrumentation is unaffected.
+       *
+       * @param job.name - The BullMQ job name.
+       * @param job.data - The BullMQ job data.
+       * @param job.opts - The BullMQ job options.
+       * @param job.queueName - The name of the queue the job is being added to.
+       * @returns true to instrument the producer operation, false to skip it.
+       */
+      producerFilter?: (job: { name?: string; data?: unknown; opts?: unknown; queueName?: string }) => boolean;
+    }
 
     interface bunyan extends Integration {}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.108.0",
+  "version": "5.109.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -102,6 +102,7 @@
     "test:integration:plugins": "yarn services && mocha \"packages/datadog-plugin-@(${PLUGINS})/test/integration-test/**/${SPEC:-*}*.spec.js\"",
     "test:integration:plugins:coverage": "yarn services && node ./integration-tests/coverage/run-suite.js \"packages/datadog-plugin-@(${PLUGINS})/test/integration-test/**/${SPEC:-*}*.spec.js\"",
     "test:unit:plugins": "mocha \"packages/datadog-instrumentations/test/@(${PLUGINS}).spec.js\" \"packages/datadog-plugin-@(${PLUGINS})/test/**/*.spec.js\" --exclude \"packages/datadog-plugin-@(${PLUGINS})/test/integration-test/**/*.spec.js\"",
+    "test:release": "mocha \"scripts/release/**/*.spec.js\"",
     "test:shimmer": "mocha \"packages/datadog-shimmer/test/**/*.spec.js\"",
     "test:shimmer:ci": "nyc --silent node init && nyc -- npm run test:shimmer",
     "verify:workflow-job-names": "node scripts/verify-workflow-job-names.js",

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/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/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/rewriter/instrumentations/aws-durable-execution-sdk-js.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const contextMethods = require('../../../aws-durable-execution-sdk-js-context-methods')
+
+const baseModule = { name: '@aws/durable-execution-sdk-js', versionRange: '>=1.1.0' }
+
+const buildEntries = filePath => {
+  const module = { ...baseModule, filePath }
+  return [
+    {
+      module,
+      functionQuery: { functionName: 'runHandler', kind: 'Async' },
+      channelName: 'withDurableExecution',
+    },
+    ...contextMethods.map(methodName => ({
+      module,
+      functionQuery: { className: 'DurableContextImpl', methodName, kind: 'Sync' },
+      channelName: `DurableContextImpl_${methodName}`,
+    })),
+    {
+      module,
+      functionQuery: { className: 'CheckpointManager', methodName: 'checkpoint', kind: 'Async' },
+      channelName: 'CheckpointManager_checkpoint',
+    },
+  ]
+}
+
+module.exports = [
+  ...buildEntries('dist/index.mjs'),
+  ...buildEntries('dist-cjs/index.js'),
+]

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

@@ -8,4 +8,5 @@ module.exports = [
   ...require('./langgraph'),
   ...require('./modelcontextprotocol-sdk'),
   ...require('./playwright'),
+  ...require('./aws-durable-execution-sdk-js'),
 ]

package/packages/datadog-instrumentations/src/http/client.js

@@ -14,6 +14,7 @@ const finishChannel = channel('apm:http:client:request:finish')
 const endChannel = channel('apm:http:client:request:end')
 const asyncStartChannel = channel('apm:http:client:request:asyncStart')
 const errorChannel = channel('apm:http:client:request:error')
+const responseStartChannel = channel('apm:http:client:response:start')
 const responseFinishChannel = channel('apm:http:client:response:finish')
 
 addHook({ name: 'http' }, hookFn)
@@ -78,10 +79,15 @@ function setupResponseInstrumentation (ctx, res) {
   let dataReadStarted = false
 
   const { shouldCollectBody } = ctx
-  const bodyChunks = shouldCollectBody ? [] : null
+
+  let bodyChunks = null
+
+  if (shouldCollectBody) {
+    bodyChunks = []
+  }
 
   const collectChunk = chunk => {
-    if (!shouldCollectBody || !chunk) return
+    if (!bodyChunks || !chunk) return
 
     if (typeof chunk === 'string') {
       bodyChunks.push(chunk)
@@ -229,6 +235,10 @@ function patch (http, methodName) {
                 res.once('end', finish)
                 res.once(errorMonitor, finish)
 
+                if (responseStartChannel.hasSubscribers) {
+                  responseStartChannel.publish({ ctx, res })
+                }
+
                 const instrumentation = setupResponseInstrumentation(ctx, res)
 
                 if (!instrumentation) {

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

@@ -26,7 +26,6 @@ function wrapRedis (Redis) {
     }
 
     const ctx = {
-      db: options.db,
       command: command.name,
       args: command.args,
       connectionOptions,

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

@@ -18,10 +18,9 @@ addHook({ name: 'iovalkey', versions: ['>=0.0.1'] }, Valkey => {
 
     const options = this.options || {}
     const connectionName = options.connectionName
-    const db = options.db
     const connectionOptions = { host: options.host, port: options.port }
 
-    const ctx = { db, command: command.name, args: command.args, connectionOptions, connectionName }
+    const ctx = { command: command.name, args: command.args, connectionOptions, connectionName }
     return startCh.runStores(ctx, () => {
       command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 

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

@@ -220,6 +220,40 @@ addHook({
   return NextRequestAdapter
 })
 
+// From next 15.4.1 each app-route build inlines its own copy of `fromNodeNextRequest`, so the hook
+// above no longer maps the node request to the app-route NextRequest and a thrown handler error
+// cannot reach `finish`. The app-route runtime reports real errors (redirect/notFound and other
+// control-flow signals excluded by next) through `RouteModule.onRequestError`, which next loads from
+// a precompiled `app-route*.runtime.{dev,prod}.js` bundle regardless of how the route chunk is
+// bundled. The bundler/experimental part of the name is matched with a pattern rather than
+// enumerated, so a variant next adds later is picked up without a code change.
+const patchedAppRouteModules = new WeakSet()
+
+function wrapOnRequestError (onRequestError) {
+  return function (req, error) {
+    if (error) {
+      errorChannel.publish({ error })
+    }
+    return onRequestError.apply(this, arguments)
+  }
+}
+
+function instrumentAppRouteRuntime (runtime) {
+  const AppRouteRouteModule = runtime.AppRouteRouteModule
+  const proto = AppRouteRouteModule?.prototype
+  if (proto && typeof proto.onRequestError === 'function' && !patchedAppRouteModules.has(AppRouteRouteModule)) {
+    patchedAppRouteModules.add(AppRouteRouteModule)
+    shimmer.wrap(proto, 'onRequestError', wrapOnRequestError)
+  }
+  return runtime
+}
+
+addHook({
+  name: 'next',
+  versions: ['>=15.4.1'],
+  filePattern: String.raw`dist/compiled/next-server/app-route[\w-]*\.runtime\.(?:dev|prod)\.js$`,
+}, instrumentAppRouteRuntime)
+
 addHook({
   name: 'next',
   versions: ['>=11.1'],