dd-trace 6.15.0 → 6.17.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

@@ -70,7 +70,6 @@ const instrumentedProtos = new WeakSet()
  * 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
@@ -97,7 +96,6 @@ function instrumentDurablePromiseProto (proto) {
  * @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
@@ -105,7 +103,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/aws-sdk.js

@@ -77,7 +77,6 @@ const clientNameCache = new WeakMap()
 
 /**
  * @param {Function} clientCtor
- * @returns {string}
  */
 function getClientName (clientCtor) {
   let name = clientNameCache.get(clientCtor)
@@ -93,7 +92,6 @@ const operationCache = new WeakMap()
 
 /**
  * @param {Function} commandCtor
- * @returns {string}
  */
 function getOperationName (commandCtor) {
   let operation = operationCache.get(commandCtor)

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

@@ -353,7 +353,6 @@ function getToolResultContent (chunk, toolUseId) {
  * @param {SessionContext | null | undefined} sessionCtx
  * @param {GetLifecycle} getLifecycle
  * @param {ToolLifecycle} lifecycle
- * @returns {number} index in chunks where the next step should start iteration
  */
 function processTool (chunks, startIndex, toolUseId, sessionCtx, getLifecycle, lifecycle) {
   let chunkIndex = startIndex
@@ -412,7 +411,6 @@ function processTool (chunks, startIndex, toolUseId, sessionCtx, getLifecycle, l
  * @param {StepContext | null | undefined} stepCtx
  * @param {SessionContext | null | undefined} sessionCtx
  * @param {GetLifecycle} getLifecycle
- * @returns {number} index in chunks where the next step should start iteration
  */
 function processStep (
   chunks,
@@ -638,7 +636,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/console.js

@@ -0,0 +1,97 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel } = require('./helpers/instrument')
+
+const configureCh = channel('ci:log-submission:console:configure')
+const logSubmissionCh = channel('ci:log-submission:console')
+const vitestSuiteStartCh = channel('ci:vitest:test-suite:start')
+const methods = ['error', 'warn']
+const methodSet = new Set(methods)
+const wrappedTargets = new WeakSet()
+
+let callDepth = 0
+let configuredGetLogHolder
+let isVitestConsoleSubscribed = false
+
+/**
+ * @param {string} method
+ * @param {unknown[]} args
+ * @param {(() => { dd: object } | undefined) | undefined} getLogHolder
+ */
+function publishLog (method, args, getLogHolder) {
+  if (!logSubmissionCh.hasSubscribers) return
+
+  try {
+    const logHolder = (getLogHolder || configuredGetLogHolder)?.()
+    if (logHolder) logSubmissionCh.publish({ args, logHolder, method })
+  } catch {}
+}
+
+/**
+ * @param {object} target
+ * @param {(() => { dd: object } | undefined) | undefined} [getLogHolder]
+ */
+function wrapConsole (target, getLogHolder) {
+  if (!target || wrappedTargets.has(target)) return
+
+  wrappedTargets.add(target)
+  for (const method of methods) {
+    if (typeof target[method] !== 'function') continue
+
+    // Global console methods are bound at runtime, so source rewriting cannot intercept them.
+    try {
+      shimmer.wrap(target, method, original => function () {
+        const shouldPublish = callDepth++ === 0
+        try {
+          const result = original.apply(this, arguments)
+          if (shouldPublish) publishLog(method, [...arguments], getLogHolder)
+          return result
+        } finally {
+          callDepth--
+        }
+      })
+    } catch {}
+  }
+}
+
+/**
+ * @param {{ BufferedConsole?: Function, CustomConsole?: Function }} jestConsole
+ * @param {(() => { dd: object } | undefined) | undefined} [getLogHolder]
+ */
+function wrapJestConsole (jestConsole, getLogHolder) {
+  if (!getLogHolder && !configuredGetLogHolder) return
+
+  const { BufferedConsole, CustomConsole } = jestConsole
+
+  if (BufferedConsole && !wrappedTargets.has(BufferedConsole)) {
+    wrappedTargets.add(BufferedConsole)
+    // Jest bundles and exports these adapter classes differently across versions, so wrap their runtime exports.
+    shimmer.wrap(BufferedConsole, 'write', original => function (buffer, method, message) {
+      const result = original.apply(this, arguments)
+      if (methodSet.has(method)) publishLog(method, [message], getLogHolder)
+      return result
+    })
+  }
+
+  if (CustomConsole && !wrappedTargets.has(CustomConsole)) {
+    wrappedTargets.add(CustomConsole)
+    shimmer.wrap(CustomConsole.prototype, '_logError', original => function (method, message) {
+      const result = original.apply(this, arguments)
+      if (methodSet.has(method)) publishLog(method, [message], getLogHolder)
+      return result
+    })
+  }
+}
+
+configureCh.subscribe(({ getLogHolder } = {}) => {
+  configuredGetLogHolder = getLogHolder
+  wrapConsole(globalThis.console)
+  if (!isVitestConsoleSubscribed) {
+    isVitestConsoleSubscribed = true
+    // Vitest replaces the global console after tracer startup and before the first suite starts.
+    vitestSuiteStartCh.subscribe(() => wrapConsole(globalThis.console))
+  }
+})
+
+module.exports = { wrapConsole, wrapJestConsole }