dd-trace 6.14.0 → 6.16.0

package/packages/datadog-instrumentations/src/vitest-worker.js

@@ -718,7 +718,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
     const isAtf = attemptToFixTasks.has(task)
     const isEfd = efdRetryTasks.has(task)
     const shouldTrackStatuses = isEfd || isAtf
-    const shouldFlipStatus = isEfd || isAtf
+    const shouldResetStatus = isEfd || isAtf
     const statuses = isAtf ? attemptToFixTaskToStatuses.get(task) : taskToStatuses.get(task)
 
     // These clauses handle task.repeats, whether EFD is enabled or not
@@ -738,13 +738,10 @@ function wrapVitestTestRunner (VitestTestRunner) {
         if (shouldTrackStatuses && statuses) {
           statuses.push(lastExecutionStatus)
         }
-        if (shouldFlipStatus) {
-          // If we don't "reset" the result.state to "pass", once a repetition fails,
-          // vitest will always consider the test as failed, so we can't read the actual status
-          // This means that we change vitest's behavior:
-          // if the last attempt passes, vitest would consider the test as failed
-          // but after this change, it will consider the test as passed
-          task.result.state = 'pass'
+        if (shouldResetStatus) {
+          // Reset to Vitest's neutral state so a previous failure does not affect the next repetition.
+          // A terminal pass state can leak into reporters before the next repetition determines its status.
+          task.result.state = 'run'
         }
       }
     } else if (numRepetition === task.repeats) {
@@ -759,8 +756,8 @@ function wrapVitestTestRunner (VitestTestRunner) {
       } else {
         testPassCh.publish({ task, ...ctx.currentStore })
       }
-      if (shouldFlipStatus) {
-        task.result.state = 'pass'
+      if (shouldResetStatus) {
+        task.result.state = 'run'
       }
     }
 

package/packages/datadog-plugin-aws-sdk/src/services/bedrockruntime/utils.js

@@ -500,6 +500,8 @@ function extractMessagesFromConverseContent (role, contentBlocks) {
       if (block == null || typeof block !== 'object') continue
       if (typeof block.text === 'string') {
         content += block.text
+      } else if (typeof block.guardContent?.text?.text === 'string') {
+        content += block.guardContent.text.text
       } else if (block.toolUse) {
         toolCalls.push(buildToolCall(block.toolUse))
       } else if (block.toolResult) {
@@ -611,7 +613,11 @@ function extractRequestParamsConverse (params) {
   const prompt = []
   if (params.system) {
     for (const block of params.system) {
-      if (typeof block?.text === 'string') prompt.push({ content: block.text, role: 'system' })
+      if (typeof block?.text === 'string') {
+        prompt.push({ content: block.text, role: 'system' })
+      } else if (typeof block?.guardContent?.text?.text === 'string') {
+        prompt.push({ content: block.guardContent.text.text, role: 'system' })
+      }
     }
   }
   if (params.messages) {

package/packages/datadog-plugin-azure-cosmos/src/index.js

@@ -26,7 +26,7 @@ class AzureCosmosPlugin extends DatabasePlugin {
       const result = ctx.result
       if (result?.code) span.setTag('db.response.status_code', (result.code).toString())
       if (result?.substatus) span.setTag('cosmosdb.response.sub_status_code', result.substatus)
-      span.finish()
+      this.finish(ctx)
     }
   }
 

package/packages/datadog-plugin-azure-durable-functions/src/index.js

@@ -1,6 +1,12 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { AUTO_KEEP } = require('../../../ext/priority')
+const { writeTraceparent, writeTracestate } = require('../../dd-trace/src/carrier')
+
+const ORCHESTRATION_FAILURE_END_CHANNEL =
+  'tracing:orchestrion:durable-functions:TaskOrchestrationExecutor_failure:end'
+const ORCHESTRATOR_COMPLETED_EVENT_TYPE = 13
 
 class AzureDurableFunctionsPlugin extends TracingPlugin {
   static get id () { return 'azure-durable-functions' }
@@ -9,9 +15,35 @@ class AzureDurableFunctionsPlugin extends TracingPlugin {
   static get type () { return 'serverless' }
   static get kind () { return 'server' }
 
+  addTraceSubs () {
+    super.addTraceSubs()
+    this.addSub(ORCHESTRATION_FAILURE_END_CHANNEL, this.orchestrationFailure)
+  }
+
   bindStart (ctx) {
+    // Continue the trace propagated by the Durable Functions host (W3C traceparent
+    // supplied on the invocation's traceContext) so activity/entity invocations join
+    // the same trace as the HTTP root instead of each starting a new root.
+    let childOf
+    if (ctx.traceparent) {
+      // extract() returns null when the carrier can't be parsed. Normalize to
+      // undefined so startSpan still falls back to any active in-process parent
+      // rather than being forced to start a brand new root span.
+      const carrier = {}
+
+      writeTraceparent(carrier, ctx.traceparent)
+      if (ctx.tracestate) {
+        writeTracestate(carrier, ctx.tracestate)
+      }
+
+      childOf = this.tracer.extract('text_map', carrier) ?? undefined
+    }
+    const extractedAsDrop = childOf?._sampling.priority < AUTO_KEEP
+
     const span = this.startSpan(this.operationName(), {
-      kind: 'internal',
+      startTime: ctx.startTime,
+      childOf,
+      kind: ctx.trigger === 'Orchestration' ? 'server' : 'internal',
       type: 'serverless',
 
       meta: {
@@ -29,6 +61,19 @@ class AzureDurableFunctionsPlugin extends TracingPlugin {
       )
     }
 
+    // The host clears the W3C sampled flag in traceparent while datadog tracestate
+    // still says keep, so extraction would drop this chunk. Re-apply only the propagated
+    // `s` priority when it indicates keep, preserving the extracted sampling mechanism.
+    if (span._prioritySampler && childOf && extractedAsDrop) {
+      const propagatedPriority = propagatedSamplingPriority(childOf._tracestate)
+      if (propagatedPriority >= AUTO_KEEP) {
+        const spanContext = span.context()
+        if (spanContext._parentId === childOf._spanId) {
+          spanContext._sampling.priority = propagatedPriority
+        }
+      }
+    }
+
     ctx.span = span
     return ctx.currentStore
   }
@@ -44,6 +89,56 @@ class AzureDurableFunctionsPlugin extends TracingPlugin {
   asyncStart (ctx) {
     super.finish(ctx)
   }
+
+  /**
+   * Tags the active initial orchestration span or creates a failure-only span after
+   * a resumed orchestration throws. The executor publishes synchronously before
+   * Durable Functions serializes the error, so this does not add a promise to
+   * orchestration activations.
+   *
+   * @param {{ arguments?: unknown[], error?: unknown }} executorCtx
+   * @returns {void}
+   */
+  orchestrationFailure (executorCtx) {
+    const args = executorCtx?.arguments
+    if (!Array.isArray(args)) return
+
+    const invocationContext = args[0]
+    const history = args[1]
+    if (!Array.isArray(history)) return
+
+    const hasPreviousActivation = history.some(
+      event => event?.EventType === ORCHESTRATOR_COMPLETED_EVENT_TYPE
+    )
+
+    if (!hasPreviousActivation) {
+      this.addError(executorCtx.error)
+      return
+    }
+
+    const traceContext = invocationContext?.traceContext
+    const ctx = {
+      trigger: 'Orchestration',
+      functionName: invocationContext?.functionName,
+      traceparent: traceContext?.traceParent,
+      tracestate: traceContext?.traceState,
+      error: executorCtx.error,
+    }
+
+    this.bindStart(ctx)
+    this.error(ctx)
+    super.finish(ctx)
+  }
+}
+
+// Read the datadog-propagated sampling priority (`dd=...;s:<n>`) from a W3C
+// tracestate. Returns undefined when there is no datadog tracestate or no valid
+// `s` value, so callers can distinguish "no propagated decision" from a drop.
+function propagatedSamplingPriority (tracestate) {
+  return tracestate?.forVendor('dd', state => {
+    const priority = Number(state.get('s'))
+    return Number.isInteger(priority) ? priority : undefined
+  })
 }
 
 module.exports = AzureDurableFunctionsPlugin

package/packages/datadog-plugin-google-cloud-pubsub/src/consumer.js

@@ -2,9 +2,8 @@
 
 const { getMessageSize } = require('../../dd-trace/src/datastreams')
 const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
-const SpanContext = require('../../dd-trace/src/opentracing/span_context')
-const id = require('../../dd-trace/src/id')
 const { storage } = require('../../datadog-core')
+const reconstructPubSubRequestContext = require('./pubsub-request-context')
 
 /**
  * PULL SUBSCRIPTION: Service explicitly pulls messages from Pub/Sub and processes them.
@@ -75,27 +74,6 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
     })
   }
 
-  #reconstructPubSubRequestContext (attrs) {
-    const traceIdLower = attrs['_dd.pubsub_request.trace_id']
-    const spanId = attrs['_dd.pubsub_request.span_id']
-    const traceIdUpper = attrs['_dd.pubsub_request.p.tid']
-
-    if (!traceIdLower || !spanId) return null
-
-    const traceId128 = traceIdUpper ? traceIdUpper + traceIdLower : traceIdLower.padStart(32, '0')
-    const traceId = id(traceId128, 16)
-    const parentId = id(spanId, 16)
-
-    const tags = {}
-    if (traceIdUpper) tags['_dd.p.tid'] = traceIdUpper
-
-    return new SpanContext({
-      traceId,
-      spanId: parentId,
-      tags,
-    })
-  }
-
   start (ctx) {
     if (!this.config.dsmEnabled) return
     const { message } = ctx
@@ -128,7 +106,7 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
 
     const isFirstMessage = batchIndex === 0
     if (isFirstMessage && batchRequestSpanId) {
-      const pubsubRequestContext = this.#reconstructPubSubRequestContext(message.attributes)
+      const pubsubRequestContext = reconstructPubSubRequestContext(message.attributes)
       if (pubsubRequestContext) {
         childOf = pubsubRequestContext
       }

package/packages/datadog-plugin-google-cloud-pubsub/src/pubsub-push-subscription.js

@@ -1,9 +1,8 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
-const SpanContext = require('../../dd-trace/src/opentracing/span_context')
-const id = require('../../dd-trace/src/id')
 const log = require('../../dd-trace/src/log')
+const reconstructPubSubRequestContext = require('./pubsub-request-context')
 
 // WeakMap to track push receive spans by request
 const pushReceiveSpans = new WeakMap()
@@ -69,7 +68,7 @@ class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
     }
 
     const originalContext = this.#extractContext(messageData)
-    const pubsubRequestContext = this.#reconstructPubSubContext(messageData.attrs) || originalContext
+    const pubsubRequestContext = reconstructPubSubRequestContext(messageData.attrs) || originalContext
     const isSameTrace = pubsubRequestContext &&
       originalContext?.toTraceId() === pubsubRequestContext.toTraceId()
 
@@ -109,39 +108,6 @@ class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
     return this.tracer.extract('text_map', messageData.attrs)
   }
 
-  #reconstructPubSubContext (attrs) {
-    /**
-     * Reconstruct the batch publish span context from message attributes.
-     *
-     * When a batch is published, the producer injects:
-     * - _dd.pubsub_request.trace_id: lower 64 bits of the batch span's trace ID (hex)
-     * - _dd.pubsub_request.span_id: the batch span's span ID (hex)
-     * - _dd.pubsub_request.p.tid: upper 64 bits of trace ID (hex, optional for 128-bit traces)
-     *
-     * This context represents the "pubsub.request" span on the producer side.
-     * We use it to create span links, connecting each pubsub.push.receive span back to the original batch.
-     */
-    const traceIdLower = attrs['_dd.pubsub_request.trace_id']
-    const spanId = attrs['_dd.pubsub_request.span_id']
-    const traceIdUpper = attrs['_dd.pubsub_request.p.tid']
-
-    if (!traceIdLower || !spanId) return null
-
-    // Reconstruct full 128-bit trace ID (or pad 64-bit to 128-bit)
-    const traceId128 = traceIdUpper ? traceIdUpper + traceIdLower : traceIdLower.padStart(32, '0')
-    const traceId = id(traceId128, 16)
-    const parentId = id(spanId, 16)
-
-    const tags = {}
-    if (traceIdUpper) tags['_dd.p.tid'] = traceIdUpper
-
-    return new SpanContext({
-      traceId,
-      spanId: parentId,
-      tags,
-    })
-  }
-
   #createPushReceiveSpan (messageData, parentContext, linkContext) {
     const { message, subscription, topicName, attrs } = messageData
     const subscriptionName = subscription?.slice(subscription.lastIndexOf('/') + 1) ?? subscription

package/packages/datadog-plugin-google-cloud-pubsub/src/pubsub-request-context.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const SpanContext = require('../../dd-trace/src/opentracing/span_context')
+const id = require('../../dd-trace/src/id')
+
+/**
+ * @param {Record<string, string>} attributes
+ * @returns {import('../../dd-trace/src/opentracing/span_context') | null}
+ */
+function reconstructPubSubRequestContext (attributes) {
+  const traceIdLower = attributes['_dd.pubsub_request.trace_id']
+  const spanId = attributes['_dd.pubsub_request.span_id']
+  const traceIdUpper = attributes['_dd.pubsub_request.p.tid']
+
+  if (!traceIdLower || !spanId) return null
+
+  const traceId128 = traceIdUpper ? traceIdUpper + traceIdLower : traceIdLower.padStart(32, '0')
+  const traceId = id(traceId128, 16)
+  const parentId = id(spanId, 16)
+
+  const tags = {}
+  if (traceIdUpper) tags['_dd.p.tid'] = traceIdUpper
+
+  return new SpanContext({
+    traceId,
+    spanId: parentId,
+    tags,
+  })
+}
+
+module.exports = reconstructPubSubRequestContext

package/packages/datadog-plugin-graphql/src/resolve-error.js

@@ -61,28 +61,50 @@ class GraphQLToolsResolveErrorPlugin extends TracingPlugin {
  * @param {readonly object[]} [fieldNodes]
  */
 function recordResolveErrorForPath (error, path, fieldNodes) {
-  const fieldNode = fieldNodes?.[0]
   const rootCtx = legacyStorage.getStore()?.graphqlRootCtx
-  for (let field = rootCtx?.resolveFields; field; field = field.nextResolveField) {
-    if ((!fieldNode || field.fieldNode === fieldNode) && matchesPath(field.pathString, path)) {
-      recordResolveError(field, error)
-      return
-    }
-  }
+  if (!rootCtx?.config.collapse || !rootCtx.fields) return
+
+  const field = findResolveField(rootCtx.fields, getPathString(path), fieldNodes?.[0])
+  if (field) recordResolveError(field, error)
 }
 
 /**
- * @param {string} fieldPath
  * @param {(string | number)[]} path
- * @returns {boolean}
+ * @returns {string}
  */
-function matchesPath (fieldPath, path) {
+function getPathString (path) {
   let pathString = ''
   for (let index = 0; index < path.length; index++) {
     if (index !== 0) pathString += '.'
     pathString += typeof path[index] === 'number' ? '*' : path[index]
   }
-  return pathString === fieldPath
+  return pathString
+}
+
+/**
+ * @param {Map<unknown, object>} fields
+ * @param {string} pathString
+ * @param {object} [fieldNode]
+ * @returns {object | undefined}
+ */
+function findResolveField (fields, pathString, fieldNode) {
+  const field = fields.get(pathString)
+  if (field === undefined) return
+
+  const parentTypeFields = field.parentTypeFields
+  if (parentTypeFields === undefined) {
+    return fieldNode === undefined || field.fieldNode === fieldNode ? field : undefined
+  }
+  if (parentTypeFields.parentTypeName !== undefined) {
+    if (fieldNode === undefined || parentTypeFields.fieldNode === fieldNode) return parentTypeFields
+    return field.fieldNode === fieldNode ? field : undefined
+  }
+
+  let matchingField
+  for (const candidate of parentTypeFields.values()) {
+    if (fieldNode === undefined || candidate.fieldNode === fieldNode) matchingField = candidate
+  }
+  return matchingField
 }
 
 /**

package/packages/datadog-turbopack/index.js

@@ -0,0 +1,212 @@
+'use strict'
+
+const fs = require('node:fs')
+const Module = require('node:module')
+const path = require('node:path')
+
+const satisfies = require('../../vendor/dist/semifies')
+const hooks = require('../datadog-instrumentations/src/helpers/hooks')
+const { SYNTHETIC_EXTENSION } = require('./src/constants')
+
+const BUILTIN_MODULES = new Set(Module.builtinModules)
+const loader = path.join(__dirname, 'src/loader.js')
+const EXTENSIONLESS_PATH_PATTERN = /(?:^|\/)[^/.]+$/
+const PHASE_PRODUCTION_SERVER = 'phase-production-server'
+const SOURCE_EXTENSIONS = ['*.js', '*.cjs', '*.mjs', '*.jsx', '*.ts', '*.cts', '*.mts', '*.tsx']
+const SOURCE_PATH_PATTERN = /\.(?:cjs|cts|js|jsx|mjs|mts|ts|tsx)$/
+const PACKAGE_PATH_PATTERN = createPackagePathPattern()
+
+/**
+ * Adds Datadog instrumentation to a Next.js Turbopack configuration.
+ *
+ * @param {object|Promise<object>|Function} [nextConfig]
+ * @returns {Function}
+ */
+function withDatadogTurbopack (nextConfig = {}) {
+  const nextMajor = getNextMajor()
+
+  return function datadogNextConfig (...args) {
+    const config = typeof nextConfig === 'function'
+      ? nextConfig.apply(this, args)
+      : nextConfig
+    if (config && typeof config.then === 'function') {
+      return config.then(config => configureTurbopack(config, args[0], nextMajor))
+    }
+    return configureTurbopack(config, args[0], nextMajor)
+  }
+}
+
+/**
+ * @param {object|undefined} config
+ * @param {unknown} phase
+ * @param {number} nextMajor
+ * @returns {object}
+ */
+function configureTurbopack (config, phase, nextMajor) {
+  const normalized = normalizeConfig(config)
+  if (phase === PHASE_PRODUCTION_SERVER || hasDatadogLoader(normalized.turbopack?.rules)) return normalized
+
+  const turbopack = normalized.turbopack ?? {}
+  const configured = nextMajor === 15 ? addLegacyRule(turbopack) : addModernRules(turbopack)
+  return { ...normalized, turbopack: configured }
+}
+
+/**
+ * @param {object|undefined} config
+ * @returns {object}
+ */
+function normalizeConfig (config) {
+  if (config === undefined) return {}
+  if (!isObject(config)) {
+    throw new TypeError('withDatadogTurbopack expects a Next.js configuration object, promise, or function')
+  }
+  if (config.turbopack !== undefined && !isObject(config.turbopack)) {
+    throw new TypeError('nextConfig.turbopack must be an object')
+  }
+  if (config.turbopack?.rules !== undefined && !isObject(config.turbopack.rules)) {
+    throw new TypeError('nextConfig.turbopack.rules must be an object')
+  }
+  if (config.turbopack?.conditions !== undefined && !isObject(config.turbopack.conditions)) {
+    throw new TypeError('nextConfig.turbopack.conditions must be an object')
+  }
+  return config
+}
+
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isObject (value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+/**
+ * @param {object} turbopack
+ * @returns {object}
+ */
+function addModernRules (turbopack) {
+  const rules = { ...turbopack.rules }
+  for (const extension of SOURCE_EXTENSIONS) {
+    appendRule(rules, extension, {
+      condition: { all: ['node', 'foreign', { path: PACKAGE_PATH_PATTERN }] },
+      loaders: [createLoader()],
+    })
+  }
+  appendRule(rules, '*', {
+    as: `*${SYNTHETIC_EXTENSION}`,
+    condition: {
+      all: ['node', 'foreign', { path: PACKAGE_PATH_PATTERN }, { path: EXTENSIONLESS_PATH_PATTERN }],
+    },
+    loaders: [createLoader()],
+  })
+  return { ...turbopack, rules }
+}
+
+/**
+ * @param {Record<string, object|object[]>} rules
+ * @param {string} extension
+ * @param {object} rule
+ */
+function appendRule (rules, extension, rule) {
+  const existing = rules[extension]
+  if (existing === undefined) {
+    rules[extension] = rule
+  } else {
+    rules[extension] = Array.isArray(existing) ? [...existing, rule] : [existing, rule]
+  }
+}
+
+/**
+ * @param {object} turbopack
+ * @returns {object}
+ */
+function addLegacyRule (turbopack) {
+  const name = '#dd-trace/modules'
+  const conditions = { ...turbopack.conditions }
+  const rules = { ...turbopack.rules }
+  if (Object.hasOwn(conditions, name) || Object.hasOwn(rules, name)) {
+    throw new Error(`Next.js Turbopack configuration already uses the reserved condition ${name}`)
+  }
+  conditions[name] = {
+    all: [
+      { path: PACKAGE_PATH_PATTERN },
+      { any: [{ path: SOURCE_PATH_PATTERN }, { path: EXTENSIONLESS_PATH_PATTERN }] },
+    ],
+  }
+  rules[name] = { node: { foreign: { loaders: [createLoader()] } } }
+  return { ...turbopack, conditions, rules }
+}
+
+/**
+ * @returns {{ loader: string, options: object }}
+ */
+function createLoader () {
+  return { loader, options: {} }
+}
+
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function hasDatadogLoader (value) {
+  if (Array.isArray(value)) return value.some(hasDatadogLoader)
+  if (!value || typeof value !== 'object') return false
+  if (/** @type {{ loader?: unknown }} */ (value).loader === loader) return true
+  return Object.values(value).some(hasDatadogLoader)
+}
+
+/**
+ * @returns {RegExp}
+ */
+function createPackagePathPattern () {
+  const names = []
+  for (const name of Object.keys(hooks)) {
+    if (!name.startsWith('.') && !BUILTIN_MODULES.has(name)) names.push(escapeRegExp(name))
+  }
+  names.sort()
+  return new RegExp(`(?:^|/)(?:${names.join('|')})(?:/|$)`)
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function escapeRegExp (value) {
+  return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+}
+
+/**
+ * @returns {number}
+ */
+function getNextMajor () {
+  const entrypoints = []
+  if (require.main?.filename) entrypoints.push(require.main.filename)
+  entrypoints.push(path.join(process.cwd(), 'package.json'))
+
+  let version
+  let resolutionError
+  for (const entrypoint of entrypoints) {
+    try {
+      const appRequire = Module.createRequire(entrypoint)
+      version = JSON.parse(fs.readFileSync(appRequire.resolve('next/package.json'), 'utf8')).version
+      break
+    } catch (error) {
+      resolutionError = error
+    }
+  }
+  if (!version) {
+    throw new Error('withDatadogTurbopack could not resolve the active Next.js installation', {
+      cause: resolutionError,
+    })
+  }
+
+  if (!satisfies(version, '>=0')) {
+    throw new Error(`withDatadogTurbopack could not parse Next.js version ${version}`)
+  }
+  if (!satisfies(version, '>=15.5.0')) {
+    throw new RangeError(`withDatadogTurbopack requires Next.js 15.5 or newer; found ${version}`)
+  }
+  return Number.parseInt(version, 10)
+}
+
+module.exports = { withDatadogTurbopack }

package/packages/datadog-turbopack/src/constants.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const SYNTHETIC_EXTENSION = '.__dd_trace_turbopack.js'
+
+module.exports = { SYNTHETIC_EXTENSION }