dd-trace 5.132.0 → 5.134.0

package/packages/datadog-plugin-openai-agents/src/processor.js

@@ -64,8 +64,7 @@ class DDOpenAIAgentsProcessor {
 
   onSpanStart (oaiSpan) {
     const integration = this._getIntegration()
-    if (!integration?.enabled) return RESOLVED
-    if (!oaiSpan?.spanData) return RESOLVED // guard NoopSpan
+    if (!integration?.enabled || !oaiSpan?.spanData) return RESOLVED // guard NoopSpan
     const type = oaiSpan.spanData.type
     const kind = SPAN_KIND_BY_TYPE[type]
     try {
@@ -84,8 +83,7 @@ class DDOpenAIAgentsProcessor {
 
   onSpanEnd (oaiSpan) {
     const integration = this._getIntegration()
-    if (!integration?.enabled) return RESOLVED
-    if (!oaiSpan?.spanData) return RESOLVED
+    if (!integration?.enabled || !oaiSpan?.spanData) return RESOLVED
     const type = oaiSpan.spanData.type
     const kind = SPAN_KIND_BY_TYPE[type]
     try {

package/packages/datadog-plugin-postgres/src/index.js

@@ -1,9 +1,12 @@
 'use strict'
 
+const { performance } = require('node:perf_hooks')
+
 const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 const Plugin = require('../../dd-trace/src/plugins/plugin')
 
+const ACQUIRE_START_CHANNEL = 'tracing:orchestrion:postgres:query:acquire:start'
 const PREPARE_START_CHANNEL = 'tracing:orchestrion:postgres:query:prepare:start'
 
 /**
@@ -14,6 +17,8 @@ const PREPARE_START_CHANNEL = 'tracing:orchestrion:postgres:query:prepare:start'
  * @property {string} [host]
  * @property {number} [pid]
  * @property {number} [port]
+ * @property {boolean} [poolWaitFinished]
+ * @property {number} [poolWaitStartMs]
  * @property {PostgresQuery} query
  * @property {string} [statement]
  * @property {string} user
@@ -63,12 +68,16 @@ class PostgresPlugin extends DatabasePlugin {
   /** @type {WeakMap<PostgresQuery, import('../../..').Span>} */
   #spans = new WeakMap()
 
+  /** @type {WeakMap<PostgresQuery, PostgresContext>} */
+  #waitContexts = new WeakMap()
+
   /**
    * @param {object} tracer
    * @param {import('../../dd-trace/src/config/config-base')} tracerConfig
    */
   constructor (tracer, tracerConfig) {
     super(tracer, tracerConfig)
+    this.addSub(ACQUIRE_START_CHANNEL, ctx => this.#finishPoolWait(ctx.query))
     this.#preparation = new PostgresPreparationPlugin(this.#prepare.bind(this), tracer, tracerConfig)
   }
 
@@ -112,12 +121,26 @@ class PostgresPlugin extends DatabasePlugin {
     }
 
     this.#spans.set(query, span)
+    this.#waitContexts.set(query, ctx)
     if (this.#dbmEnabled) {
       this.#dbmQueries.set(query, { service: service.name })
     }
     return ctx.currentStore
   }
 
+  /**
+   * @param {PostgresQuery} query
+   */
+  #finishPoolWait (query) {
+    const ctx = this.#waitContexts.get(query)
+    if (ctx === undefined) return
+
+    this.#waitContexts.delete(query)
+    ctx.poolWaitFinished = true
+    const waitTime = ctx.poolWaitStartMs === undefined ? 0 : performance.now() - ctx.poolWaitStartMs
+    ctx.currentStore.span.setTag('db.pool.wait_time_ms', waitTime)
+  }
+
   /**
    * @param {PostgresPreparationContext} ctx
    */
@@ -152,6 +175,7 @@ class PostgresPlugin extends DatabasePlugin {
     this.#dbmQueries.delete(query)
     if (span === undefined) return
 
+    this.#finishPoolWait(query)
     this.#spans.delete(query)
 
     const statement = dbmState?.statement ?? result.statement

package/packages/datadog-plugin-protobufjs/src/schema_iterator.js

@@ -144,12 +144,8 @@ class SchemaExtractor {
     span.setTag(SCHEMA_NAME, removeLeadingPeriod(descriptor.fullName))
     span.setTag(SCHEMA_OPERATION, operation)
 
-    if (!tracer._dataStreamsProcessor.canSampleSchema(operation)) {
-      return
-    }
-
     // if the span is unsampled, do not sample the schema
-    if (!tracer._prioritySampler.isSampled(span)) {
+    if (!tracer._dataStreamsProcessor.canSampleSchema(operation) || !tracer._prioritySampler.isSampled(span)) {
       return
     }
 

package/packages/datadog-plugin-rhea/src/consumer.js

@@ -52,10 +52,7 @@ class RheaConsumerPlugin extends ConsumerPlugin {
 
 function getResourceNameFromMessage (msgObj) {
   let resourceName = 'amq.topic'
-  let options = {}
-  if (msgObj.receiver && msgObj.receiver.options) {
-    options = msgObj.receiver.options
-  }
+  const options = msgObj.receiver && msgObj.receiver.options ? msgObj.receiver.options : {}
   if (options.source && options.source.address) {
     resourceName = options.source.address
   }

package/packages/datadog-plugin-vitest/src/index.js

@@ -354,6 +354,8 @@ class VitestPlugin extends CiPlugin {
       browserProjectName,
       testExecutionId,
       testStartLine,
+      startTime,
+      duration,
     }) => {
       const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
       const extraTags = {
@@ -380,10 +382,11 @@ class VitestPlugin extends CiPlugin {
         testSuite,
         testSuiteSpan || this.testSuiteSpan,
         extraTags,
-        testExecutionId
+        testExecutionId,
+        startTime
       )
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', this.getTestTelemetryTags(testSpan))
-      testSpan.finish()
+      testSpan.finish(Number.isFinite(duration) && duration >= 0 ? testSpan._startTime + duration : undefined)
     })
 
     this.addBind('ci:vitest:test-suite:start', (ctx) => {

package/packages/datadog-shimmer/src/shimmer.js

@@ -314,11 +314,11 @@ function assertMethod (target, name, method) {
     let message = 'No target object provided'
 
     if (target) {
-      if (typeof target !== 'object' && typeof target !== 'function') {
-        message = 'Invalid target'
-      } else {
+      if (typeof target === 'object' || typeof target === 'function') {
         name = String(name)
         message = method ? `Original method ${name} is not a function` : `No original method ${name}`
+      } else {
+        message = 'Invalid target'
       }
     }
 
@@ -335,7 +335,8 @@ function assertMethod (target, name, method) {
 function assertNotClass (target) {
   // Frozen functions also have a non-writable `prototype`; inspect their source only then.
   if ('prototype' in target &&
-      Object.getOwnPropertyDescriptor(target, 'prototype').writable === false &&
+      // Bound generators inherit `prototype` without owning one, so the descriptor may still be missing.
+      Object.getOwnPropertyDescriptor(target, 'prototype')?.writable === false &&
       (!Object.isFrozen(target) || Function.prototype.toString.call(target).startsWith('class'))) {
     throw new TypeError('Target is a native class constructor and cannot be wrapped.')
   }

package/packages/datadog-webpack/index.js

@@ -6,11 +6,15 @@ const fs = require('node:fs')
 const instrumentations = require('../datadog-instrumentations/src/helpers/instrumentations')
 const extractPackageAndModulePath = require('../datadog-instrumentations/src/helpers/extract-package-and-module-path')
 const hooks = require('../datadog-instrumentations/src/helpers/hooks')
+const { getRewriteTarget } = require('../datadog-instrumentations/src/helpers/rewriter/targets')
 const { isESMFile } = require('../datadog-esbuild/src/utils')
+const { getValueFromEnvSources } = require('../dd-trace/src/config/helper')
 const log = require('./src/log')
 
 const PLUGIN_NAME = 'DatadogWebpackPlugin'
 
+const DD_BUNDLER_INJECT_GIT_METADATA = getValueFromEnvSources('DD_BUNDLER_INJECT_GIT_METADATA') !== false
+
 for (const hook of Object.values(hooks)) {
   if (hook !== null && typeof hook === 'object') {
     hook.fn()
@@ -80,50 +84,55 @@ class DatadogWebpackPlugin {
       }
     })
 
-    const gitMetadata = getGitMetadata()
-    if (gitMetadata.repositoryURL || gitMetadata.commitSHA) {
-      const banner =
-        'if (typeof process === \'object\' && process !== null &&\n' +
-        '    process.env !== null && typeof process.env === \'object\') {\n' +
-        (gitMetadata.repositoryURL
-          ? `  process.env.DD_GIT_REPOSITORY_URL = ${JSON.stringify(gitMetadata.repositoryURL)};\n`
-          : '') +
-        (gitMetadata.commitSHA
-          ? `  process.env.DD_GIT_COMMIT_SHA = ${JSON.stringify(gitMetadata.commitSHA)};\n`
-          : '') +
-        '}\n'
-
-      compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
-        compilation.hooks.processAssets.tap(
-          { name: PLUGIN_NAME, stage: -2000 },
-          () => {
-            for (const chunk of compilation.chunks) {
-              if (!chunk.canBeInitial()) continue
-              for (const filename of chunk.files) {
-                if (!filename.endsWith('.js') && !filename.endsWith('.mjs')) continue
-                compilation.updateAsset(filename, (old) => {
-                  const content = banner + old.source()
-                  return {
-                    source () { return content },
-                    size () { return Buffer.byteLength(content, 'utf8') },
-                    map () { return old.map() },
-                    sourceAndMap () { return { source: content, map: old.map() } },
-                    updateHash (hash) { hash.update(content) },
-                  }
-                })
+    // Bake DD_GIT_* into assets unless DD_BUNDLER_INJECT_GIT_METADATA=false (stable artifact hashes).
+    if (DD_BUNDLER_INJECT_GIT_METADATA) {
+      const gitMetadata = getGitMetadata()
+      if (gitMetadata.repositoryURL || gitMetadata.commitSHA) {
+        const banner =
+          'if (typeof process === \'object\' && process !== null &&\n' +
+          '    process.env !== null && typeof process.env === \'object\') {\n' +
+          (gitMetadata.repositoryURL
+            ? `  process.env.DD_GIT_REPOSITORY_URL = ${JSON.stringify(gitMetadata.repositoryURL)};\n`
+            : '') +
+          (gitMetadata.commitSHA
+            ? `  process.env.DD_GIT_COMMIT_SHA = ${JSON.stringify(gitMetadata.commitSHA)};\n`
+            : '') +
+          '}\n'
+
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+          compilation.hooks.processAssets.tap(
+            { name: PLUGIN_NAME, stage: -2000 },
+            () => {
+              for (const chunk of compilation.chunks) {
+                if (!chunk.canBeInitial()) continue
+                for (const filename of chunk.files) {
+                  if (!filename.endsWith('.js') && !filename.endsWith('.mjs')) continue
+                  compilation.updateAsset(filename, (old) => {
+                    const content = banner + old.source()
+                    return {
+                      source () { return content },
+                      size () { return Buffer.byteLength(content, 'utf8') },
+                      map () { return old.map() },
+                      sourceAndMap () { return { source: content, map: old.map() } },
+                      updateHash (hash) { hash.update(content) },
+                    }
+                  })
+                }
               }
             }
-          }
-        )
-      })
+          )
+        })
 
-      log.debug(
-        'Automatically injected git metadata (DD_GIT_REPOSITORY_URL: %s, DD_GIT_COMMIT_SHA: %s)',
-        gitMetadata.repositoryURL || 'not available',
-        gitMetadata.commitSHA || 'not available'
-      )
+        log.debug(
+          'Automatically injected git metadata (DD_GIT_REPOSITORY_URL: %s, DD_GIT_COMMIT_SHA: %s)',
+          gitMetadata.repositoryURL || 'not available',
+          gitMetadata.commitSHA || 'not available'
+        )
+      } else {
+        log.warn('No git metadata available - skipping injection')
+      }
     } else {
-      log.warn('No git metadata available - skipping injection')
+      log.debug('Skipping git metadata injection (DD_BUNDLER_INJECT_GIT_METADATA=false)')
     }
 
     compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => {
@@ -146,8 +155,9 @@ class DatadogWebpackPlugin {
         }
 
         const request = resolveData.request
+        const isModuleOfInterest = modulesOfInterest.has(request) || modulesOfInterest.has(`${pkg}/${modulePath}`)
 
-        if (!modulesOfInterest.has(request) && !modulesOfInterest.has(`${pkg}/${modulePath}`)) {
+        if (!isModuleOfInterest && getRewriteTarget(normalizedResource) === undefined) {
           return
         }
 
@@ -177,10 +187,12 @@ class DatadogWebpackPlugin {
         const version = packageJson.version
         const pkgPath = request === pkg ? pkg : `${pkg}/${modulePath}`
 
+        // Webpack runs loaders right-to-left, so appending makes this loader see the package's original source
+        // before any user transpiler lowers the syntax Orchestrion function queries match on.
         createData.loaders ||= []
-        createData.loaders.unshift({
+        createData.loaders.push({
           loader: require.resolve('./src/loader'),
-          options: { pkg, version, path: pkgPath },
+          options: { pkg, version, path: pkgPath, rewriteOnly: !isModuleOfInterest },
         })
 
         log.debug('LOAD: %s@%s, pkg "%s"', pkg, version, pkgPath)

package/packages/datadog-webpack/src/loader.js

@@ -1,26 +1,74 @@
 'use strict'
 
+const { filename } = require('../../datadog-instrumentations/src/helpers/instrumentation-utils')
+const { createBundlerRewriter } = require('../../datadog-instrumentations/src/helpers/rewriter')
+const { getRewriteTarget } = require('../../datadog-instrumentations/src/helpers/rewriter/targets')
+
 const CHANNEL = 'dd-trace:bundler:load'
+// Resolved from dd-trace so the injected require works even when dc-polyfill is not hoisted next to the target.
+const DC_MODULE = require.resolve('dc-polyfill').replaceAll('\\', '/')
+const DC_MODULE_LITERAL = JSON.stringify(DC_MODULE)
+
+let rewrite
 
 /**
- * Webpack loader that appends a dc-polyfill channel publish to a CJS module.
- * Called for each module-of-interest identified by DatadogWebpackPlugin.
+ * Webpack loader called for each module-of-interest identified by DatadogWebpackPlugin.
+ * Orchestrion rewrite targets are rewritten and, for pure Orchestrion integrations, get an activation publish
+ * appended. Modules with export hooks get a dc-polyfill channel publish of their CJS exports appended.
  *
  * @param {string} source
+ * @param {string|object} [inputSourceMap]
  */
-module.exports = function loader (source) {
+module.exports = function loader (source, inputSourceMap) {
   this.cacheable(false)
-  const { pkg, version, path: pkgPath } = this.getOptions()
+  const { pkg, version, path: pkgPath, rewriteOnly } = this.getOptions()
+  const target = getRewriteTarget(this.resourcePath.replaceAll('\\', '/'))
+
+  let code = source
+  let map = inputSourceMap
+
+  if (target) {
+    rewrite ??= createBundlerRewriter(DC_MODULE)
+    const result = rewrite(source, this.resourcePath, 'commonjs', target, inputSourceMap)
+    code = result.code
+    map = result.map
+
+    if (code !== source && target.activate) {
+      const payload = JSON.stringify({
+        activate: true,
+        package: target.moduleName,
+        version,
+        path: filename(target.moduleName, target.filePath),
+      })
+      this.callback(
+        null,
+        `${code}\n;{\n` +
+        `  const __dd_ch = require(${DC_MODULE_LITERAL}).channel('${CHANNEL}');\n` +
+        `  if (__dd_ch.hasSubscribers) __dd_ch.publish(${payload});\n` +
+        '}\n',
+        map
+      )
+      return
+    }
+  }
+
+  // Rewrite-only targets have no export hook, so publishing their exports would only report a missing hook.
+  if (rewriteOnly) {
+    this.callback(null, code, map)
+    return
+  }
 
-  return (
-    source +
+  this.callback(
+    null,
+    code +
     '\n;{\n' +
-    '  const __dd_dc = require(\'dc-polyfill\');\n' +
+    `  const __dd_dc = require(${DC_MODULE_LITERAL});\n` +
     `  const __dd_ch = __dd_dc.channel('${CHANNEL}');\n` +
     '  const __dd_mod = module.exports;\n' +
     `  const __dd_payload = { module: __dd_mod, version: '${version}', package: '${pkg}', path: '${pkgPath}' };\n` +
     '  __dd_ch.publish(__dd_payload);\n' +
     '  module.exports = __dd_payload.module;\n' +
-    '}\n'
+    '}\n',
+    map
   )
 }

package/packages/dd-trace/src/aiguard/evaluation.js

@@ -1,10 +1,24 @@
 'use strict'
 
-const { HTTP_CLIENT_IP, HTTP_USERAGENT, NETWORK_CLIENT_IP } = require('../../../../ext/tags')
+const {
+  ERROR,
+  HTTP_CLIENT_IP,
+  HTTP_USERAGENT,
+  MANUAL_DROP,
+  MANUAL_KEEP,
+  NETWORK_CLIENT_IP,
+  RESOURCE_NAME,
+  SAMPLING_PRIORITY,
+  SERVICE_NAME,
+  SPAN_KIND,
+  SPAN_TYPE,
+} = require('../../../../ext/tags')
 const createRfdc = require('../../../../vendor/dist/rfdc')
 const clone = createRfdc({ proto: false, circles: false })
 const { USER_ID, USER_SESSION_ID } = require('../appsec/addresses')
 const { getActiveRequest } = require('../appsec/store')
+const { ERROR_MESSAGE, ERROR_STACK, ERROR_TYPE, PROCESS_ID, SAMPLING_PRIORITY_KEY } = require('../constants')
+const log = require('../log')
 const { keepTrace } = require('../priority_sampler')
 const { extractIp } = require('../plugins/util/ip_extractor')
 const { AI_GUARD } = require('../standalone/product')
@@ -20,6 +34,12 @@ const ALLOW = 'ALLOW'
 /** @typedef {import('../../../../index').aiguard.RedactionReplacement} RedactionReplacement */
 /** @typedef {import('../opentracing/span')} Span */
 
+/**
+ * @typedef {object} ExtraEntry
+ * @property {string} key
+ * @property {unknown} value
+ */
+
 /**
  * @typedef {object} EvaluationResponse
  * @property {string} action
@@ -30,6 +50,8 @@ const ALLOW = 'ALLOW'
  * @property {boolean} hasTagProbabilities
  * @property {boolean} blockingEnabled
  * @property {unknown} redactionReplacements
+ * @property {ExtraEntry[]} extraTags
+ * @property {ExtraEntry[]} extraMetastruct
  */
 
 /**
@@ -40,6 +62,8 @@ const ALLOW = 'ALLOW'
  * @property {boolean} shouldBlock
  * @property {boolean} hasTagProbabilities
  * @property {{ enabled: boolean, applied: boolean, failures: number }} redaction
+ * @property {ExtraEntry[]} extraTags
+ * @property {ExtraEntry[]} extraMetastruct
  */
 
 /**
@@ -68,6 +92,38 @@ function isRecord (value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
 
+// Shared by every evaluation without extra entries, so the common case allocates nothing.
+const NO_EXTRA_ENTRIES = /** @type {ExtraEntry[]} */ (/** @type {unknown} */ (Object.freeze([])))
+
+/**
+ * Normalizes a backend extra field into well-formed key/value entries. The backend sends lists of
+ * entries rather than objects because the dotted keys are not valid JSON:API member names. Values
+ * are kept as-is: which of them reach the span is decided when they are applied.
+ *
+ * @param {string} field
+ * @param {unknown} entries
+ * @returns {ExtraEntry[]}
+ */
+function normalizeExtraEntries (field, entries) {
+  if (entries === undefined) return NO_EXTRA_ENTRIES
+  if (!Array.isArray(entries)) {
+    log.debug('AI Guard: ignoring %s of type %s', field, entries === null ? 'null' : typeof entries)
+    return NO_EXTRA_ENTRIES
+  }
+
+  const normalized = []
+  for (const entry of entries) {
+    const key = isRecord(entry) ? entry.key : undefined
+    // A __proto__ key is never valid: it cannot become an own property on the span tags or the meta-struct.
+    if (typeof key === 'string' && key.length > 0 && key !== '__proto__') {
+      normalized.push({ key, value: entry.value })
+    } else {
+      log.debug('AI Guard: ignoring malformed %s entry', field)
+    }
+  }
+  return normalized.length === 0 ? NO_EXTRA_ENTRIES : normalized
+}
+
 /**
  * Parses the backend evaluation response into the tracer's internal contract.
  *
@@ -89,6 +145,9 @@ function parseEvaluationResponse (body) {
     hasTagProbabilities: isRecord(attributes.tag_probs),
     blockingEnabled: attributes.is_blocking_enabled === true,
     redactionReplacements: attributes.redaction_replacements,
+    // Malformed extra entries are dropped here instead of turning the response into a bad_response.
+    extraTags: normalizeExtraEntries('extra_tags', attributes.extra_tags),
+    extraMetastruct: normalizeExtraEntries('extra_metastruct', attributes.extra_metastruct),
   }
 }
 
@@ -132,6 +191,8 @@ function createEvaluationOutcome (messages, evaluation, options) {
       applied: redaction.redacted,
       failures: redaction.failures,
     },
+    extraTags: evaluation.extraTags,
+    extraMetastruct: evaluation.extraMetastruct,
   }
 }
 
@@ -147,6 +208,86 @@ const SERVICE_ENTRY_TAG_MAPPINGS = [
   [USER_SESSION_ID, TAGS.USR_SESSION_ID_TAG_KEY],
 ]
 
+// Backend extra tags never override what the tracer computes itself, nor keys that control the
+// span or its trace (sampling, service, resource, error state). Internal _dd keys are covered by
+// isReservedExtraTag instead of being listed here.
+const RESERVED_EXTRA_TAGS = new Set([
+  TAGS.ACTION_TAG_KEY,
+  TAGS.REASON_TAG_KEY,
+  TAGS.TARGET_TAG_KEY,
+  TAGS.TOOL_NAME_TAG_KEY,
+  TAGS.BLOCKED_TAG_KEY,
+  TAGS.REDACTED_TAG_KEY,
+  TAGS.EVENT_TAG_KEY,
+  ...SERVICE_ENTRY_TAG_MAPPINGS.map(([, destinationTag]) => destinationTag),
+  MANUAL_KEEP,
+  MANUAL_DROP,
+  SAMPLING_PRIORITY,
+  SERVICE_NAME,
+  RESOURCE_NAME,
+  SPAN_TYPE,
+  SPAN_KIND,
+  ERROR,
+  ERROR_TYPE,
+  ERROR_MESSAGE,
+  ERROR_STACK,
+  SAMPLING_PRIORITY_KEY,
+  PROCESS_ID,
+  'analytics.event',
+  'language',
+  'runtime-id',
+  'service.version',
+  'version',
+  'env',
+])
+
+/**
+ * Returns whether a backend extra tag key must not be set on the span.
+ *
+ * @param {string} key
+ */
+function isReservedExtraTag (key) {
+  // _dd is the tracer's internal namespace (_dd.*, _dd1.*): the span formatter writes sampling,
+  // top-level and propagation keys there and a span tag with the same key would overwrite them.
+  // This is not an AI Guard namespace filter; the backend owns ai_guard.* keys.
+  return key.startsWith('_dd') || RESERVED_EXTRA_TAGS.has(key)
+}
+
+const RESERVED_EXTRA_META_STRUCT_KEYS = new Set(['messages', 'attack_categories', 'sds', 'tag_probs'])
+
+/**
+ * Copies backend-provided extra_tags to the span and extra_metastruct to the AI Guard meta-struct,
+ * skipping values and keys the span must not receive. Keys are used verbatim and entries are
+ * applied in order, so a repeated key keeps its last value.
+ *
+ * @param {Span} span
+ * @param {EvaluationMetaStruct} metaStruct
+ * @param {ExtraEntry[]} extraTags
+ * @param {ExtraEntry[]} extraMetastruct
+ */
+function applyExtraSpanData (span, metaStruct, extraTags, extraMetastruct) {
+  // The client decodes values with JSON.parse, so a string check and a null check cover every JSON type.
+  for (const { key, value } of extraTags) {
+    if (typeof value !== 'string') {
+      log.debug('AI Guard: ignoring extra_tags entry %s with non-string value', key)
+    } else if (isReservedExtraTag(key)) {
+      log.debug('AI Guard: ignoring reserved extra tag %s', key)
+    } else {
+      span.setTag(key, value)
+    }
+  }
+
+  for (const { key, value } of extraMetastruct) {
+    if (value === undefined || value === null) {
+      log.debug('AI Guard: ignoring extra_metastruct entry %s with null value', key)
+    } else if (RESERVED_EXTRA_META_STRUCT_KEYS.has(key)) {
+      log.debug('AI Guard: ignoring reserved extra_metastruct key %s', key)
+    } else {
+      metaStruct[key] = value
+    }
+  }
+}
+
 class EvaluationReporter {
   #config
   #maxMessagesLength
@@ -230,6 +371,7 @@ class EvaluationReporter {
     if (result.tags.length > 0) report.metaStruct.attack_categories = result.tags
     if (result.sds.length > 0) report.metaStruct.sds = result.sds
     if (outcome.hasTagProbabilities) report.metaStruct.tag_probs = result.tagProbabilities
+    applyExtraSpanData(report.span, report.metaStruct, outcome.extraTags, outcome.extraMetastruct)
 
     if (redaction.enabled) {
       report.span.setTag(TAGS.REDACTED_TAG_KEY, redaction.applied ? 'true' : 'false')

package/packages/dd-trace/src/aiguard/integrations/vercel-ai.js

@@ -73,8 +73,7 @@ function onModelIntercept (ctx) {
         null,
         'AIGuard: unable to decode the model result: %s'
       )
-      if (outputMessages === null) return result
-      if (!outputMessages.length) return result
+      if (outputMessages === null || !outputMessages.length) return result
 
       return evaluate(ctx, aiguard, [outputMessages], opts).then(() => result)
     }
@@ -112,8 +111,7 @@ function interceptStreamedResult (ctx, result, inputMessages) {
       null,
       'AIGuard: unable to decode the streamed model result: %s'
     )
-    if (outputMessages === null) return replayed
-    if (!outputMessages.length) return replayed
+    if (outputMessages === null || !outputMessages.length) return replayed
 
     return evaluate(ctx, aiguard, [outputMessages], opts).then(() => replayed)
   })

package/packages/dd-trace/src/aiguard/messages/utils.js

@@ -10,8 +10,7 @@ const IMAGE_FALLBACK = '[image]'
  * @returns {string|undefined|null}
  */
 function stringifyIfNeeded (value) {
-  if (value == null) return value
-  if (typeof value === 'string') return value
+  if (value == null || typeof value === 'string') return value
 
   try {
     return JSON.stringify(value)

package/packages/dd-trace/src/aiguard/redaction.js

@@ -102,8 +102,14 @@ function resolveWritableString (root, path) {
     }
   }
 
-  if (!node || typeof node !== 'object') return
-  if (!Object.hasOwn(node, terminal.name) || typeof node[terminal.name] !== 'string') return
+  if (
+    !node ||
+    typeof node !== 'object' ||
+    !Object.hasOwn(node, terminal.name) ||
+    typeof node[terminal.name] !== 'string'
+  ) {
+    return
+  }
   return { container: node, key: terminal.name }
 }
 

package/packages/dd-trace/src/appsec/api_security/normalized-route.js

@@ -383,8 +383,9 @@ function presenceBitmask (optionalGroups, present) {
  * @returns {string|null}
  */
 function normalizeRouteExpress (route, params, urlPath, parse, makeMatcher) {
-  if (typeof route !== 'string' || !route) return null
-  if (typeof parse !== 'function' || typeof makeMatcher !== 'function') return null
+  if (typeof route !== 'string' || !route || typeof parse !== 'function' || typeof makeMatcher !== 'function') {
+    return null
+  }
 
   let entry = routeCache.get(route)
   if (entry === undefined) {