dd-trace 5.108.0 → 5.110.0

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

@@ -8,6 +8,7 @@ const tags = require('../../../ext/tags')
 const formats = require('../../../ext/formats')
 const HTTP_HEADERS = formats.HTTP_HEADERS
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
+const { buildClientHttpUrl } = require('../../dd-trace/src/plugins/util/url')
 const log = require('../../dd-trace/src/log')
 const { CLIENT_PORT_KEY, COMPONENT, ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
 
@@ -27,13 +28,17 @@ class HttpClientPlugin extends ClientPlugin {
     const protocol = options.protocol || agent.protocol || 'http:'
     const hostname = options.hostname || options.host || 'localhost'
     const host = options.port ? `${hostname}:${options.port}` : hostname
-    const pathname = options.path || options.pathname
+    const base = `${protocol}//${host}`
+    // A URL object (e.g. from the fetch integration) carries the query in
+    // `options.search`, not `options.path`; keep it so url.full retains the query.
+    const pathname = options.path || `${options.pathname || ''}${options.search || ''}`
     const path = pathname ? pathname.split(/[?#]/)[0] : '/'
-    const uri = `${protocol}//${host}${path}`
+    const uri = `${base}${path}`
 
     const allowed = this.config.filter(uri)
 
     const method = (options.method || 'GET').toUpperCase()
+    const otelSemantics = this.config.DD_TRACE_OTEL_SEMANTICS_ENABLED
     const childOf = store && allowed ? store.span : null
     // TODO delegate to super.startspan
     const span = this.startSpan(this.operationName(), {
@@ -46,7 +51,7 @@ class HttpClientPlugin extends ClientPlugin {
         'resource.name': method,
         'span.type': 'http',
         'http.method': method,
-        'http.url': uri,
+        'http.url': otelSemantics ? buildClientHttpUrl(this.config, base, pathname, uri) : uri,
         'out.host': hostname,
       },
       metrics: {

package/packages/datadog-plugin-http2/src/client.js

@@ -10,6 +10,7 @@ const kinds = require('../../../ext/kinds')
 const formats = require('../../../ext/formats')
 const { COMPONENT, CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
+const { buildClientHttpUrl } = require('../../dd-trace/src/plugins/util/url')
 
 const HTTP_HEADERS = formats.HTTP_HEADERS
 const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
@@ -33,8 +34,10 @@ class Http2ClientPlugin extends ClientPlugin {
     const path = headers[HTTP2_HEADER_PATH] || '/'
     const pathname = path.split(/[?#]/)[0]
     const method = headers[HTTP2_HEADER_METHOD] || HTTP2_METHOD_GET
-    const uri = `${sessionDetails.protocol}//${sessionDetails.host}:${sessionDetails.port}${pathname}`
+    const base = `${sessionDetails.protocol}//${sessionDetails.host}:${sessionDetails.port}`
+    const uri = `${base}${pathname}`
     const allowed = this.config.filter(uri)
+    const otelSemantics = this.config.DD_TRACE_OTEL_SEMANTICS_ENABLED
 
     const store = storage('legacy').getStore()
     const childOf = store && allowed ? store.span : null
@@ -48,7 +51,7 @@ class Http2ClientPlugin extends ClientPlugin {
         'resource.name': method,
         'span.type': 'http',
         'http.method': method,
-        'http.url': uri,
+        'http.url': otelSemantics ? buildClientHttpUrl(this.config, base, path, uri) : uri,
         'out.host': sessionDetails.host,
       },
       metrics: {

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

@@ -11,11 +11,16 @@ class MySQLPlugin extends DatabasePlugin {
   constructor () {
     super(...arguments)
 
+    // Capture into `currentStore` (not `parentStore`) so connection:finish can
+    // restore the caller context even when the connection resolves inside an
+    // instrumentation skip (a noop store), as the mariadb pool does: the store
+    // binding only honors an explicit `currentStore` through a noop store.
+    // Without a skip (mysql/mysql2) this is unchanged.
     this.addSub(`apm:${this.component}:connection:start`, ctx => {
-      ctx.parentStore = storage('legacy').getStore()
+      ctx.currentStore = storage('legacy').getStore()
     })
 
-    this.addBind(`apm:${this.component}:connection:finish`, ctx => ctx.parentStore)
+    this.addBind(`apm:${this.component}:connection:finish`, ctx => ctx.currentStore)
   }
 
   bindStart (ctx) {

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

@@ -47,10 +47,10 @@ class SchemaExtractor {
 
   static extractProperty (field, schemaName, fieldName, builder, depth) {
     let array = false
-    let description
     let ref
     let enumValues
 
+    const description = field.comment
     const resolvedType = field.resolvedType ? field.resolvedType.constructor.name : field.type
 
     const isRepeatedField = field.rule === 'repeated'
@@ -124,7 +124,7 @@ class SchemaExtractor {
   }
 
   iterateOverSchema (builder) {
-    this.constructor.extractSchema(this.schema, builder, 0)
+    SchemaExtractor.extractSchema(this.schema, builder, 0)
   }
 
   static attachSchemaOnSpan (args, span, operation, tracer) {

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

@@ -28,7 +28,7 @@ class RedisPlugin extends CachePlugin {
   }
 
   bindStart (ctx) {
-    const { db, command, args, argsStartIndex, connectionOptions, connectionName } = ctx
+    const { command, args, argsStartIndex, connectionOptions, connectionName } = ctx
 
     const resource = command
     const normalizedCommand = command.toUpperCase()
@@ -55,7 +55,6 @@ class RedisPlugin extends CachePlugin {
       type: this._spanType,
       meta: {
         'db.type': this._spanType,
-        'db.name': db || '0',
         [this.#rawCommandKey]: formatCommand(normalizedCommand, args, argsStartIndex),
         'out.host': connectionOptions.host,
         [CLIENT_PORT_KEY]: connectionOptions.port,

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

@@ -6,6 +6,7 @@ const tags = require('../../../ext/tags')
 const formats = require('../../../ext/formats')
 const HTTP_HEADERS = formats.HTTP_HEADERS
 const log = require('../../dd-trace/src/log')
+const { buildClientHttpUrl } = require('../../dd-trace/src/plugins/util/url')
 const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 
 const {
@@ -60,10 +61,12 @@ class UndiciPlugin extends HttpClientPlugin {
     }
 
     const host = port ? `${hostname}:${port}` : hostname
+    const base = `${protocol}//${host}`
     const pathname = path.split(/[?#]/)[0]
-    const uri = `${protocol}//${host}${pathname}`
+    const uri = `${base}${pathname}`
 
     const allowed = this.config.filter(uri)
+    const otelSemantics = this.config.DD_TRACE_OTEL_SEMANTICS_ENABLED
     const childOf = store && allowed ? store.span : null
 
     const span = this.startSpan(this.operationName(), {
@@ -71,7 +74,7 @@ class UndiciPlugin extends HttpClientPlugin {
       meta: {
         'span.kind': 'client',
         'http.method': method,
-        'http.url': uri,
+        'http.url': otelSemantics ? buildClientHttpUrl(this.config, base, path, uri) : uri,
         'out.host': hostname,
       },
       metrics: {

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

@@ -9,6 +9,7 @@ const {
   finishAllTraceSpans,
   getTestSuitePath,
   getTestSuiteCommonTags,
+  getTestLevelsMetadataTags,
   getTestSessionName,
   getIsFaultyEarlyFlakeDetection,
   TEST_SOURCE_FILE,
@@ -16,6 +17,7 @@ const {
   TEST_CODE_COVERAGE_LINES_PCT,
   TEST_CODE_OWNERS,
   TEST_COMMAND,
+  TEST_LEVELS_METADATA,
   TEST_SESSION_NAME,
   TEST_SOURCE_START,
   TEST_IS_NEW,
@@ -63,6 +65,8 @@ class VitestPlugin extends CiPlugin {
         testSessionId: testSessionSpanContext?.toTraceId(),
         testModuleId: testModuleSpanContext?.toSpanId(),
         testCommand: this.command,
+        repositoryRoot: this.repositoryRoot,
+        codeOwnersEntries: this.codeOwnersEntries,
       })
     })
 
@@ -307,10 +311,11 @@ class VitestPlugin extends CiPlugin {
     })
 
     this.addBind('ci:vitest:test-suite:start', (ctx) => {
-      const { testSuiteAbsolutePath, frameworkVersion } = ctx
+      const { codeOwnersEntries, repositoryRoot, testSuiteAbsolutePath, frameworkVersion } = ctx
 
       const testCommand = ctx.testCommand || 'vitest run'
       const { testSessionId, testModuleId } = ctx
+      this._setRepositoryRoot(repositoryRoot, codeOwnersEntries)
       this.command = testCommand
       this.frameworkVersion = frameworkVersion
       const testSessionSpanContext = testSessionId && testModuleId
@@ -325,7 +330,11 @@ class VitestPlugin extends CiPlugin {
       const testSessionName = getTestSessionName(this.config, trimmedCommand, this.testEnvironmentMetadata)
       if (this.tracer._exporter.addMetadataTags) {
         this.tracer._exporter.addMetadataTags({
-          '*': { [TEST_COMMAND]: testCommand, [TEST_SESSION_NAME]: testSessionName },
+          [TEST_LEVELS_METADATA]: {
+            [TEST_COMMAND]: testCommand,
+            [TEST_SESSION_NAME]: testSessionName,
+            ...getTestLevelsMetadataTags(this.testEnvironmentMetadata),
+          },
           test: getLibraryCapabilitiesTags(this.constructor.id),
         })
       }

package/packages/datadog-webpack/index.js

@@ -6,6 +6,7 @@ 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 { matchesOptionalPeerFile } = require('../datadog-instrumentations/src/helpers/optional-peer-bundler')
 const { isESMFile } = require('../datadog-esbuild/src/utils')
 const log = require('./src/log')
 
@@ -130,11 +131,26 @@ class DatadogWebpackPlugin {
       nmf.hooks.afterResolve.tap(PLUGIN_NAME, (resolveData) => {
         const { createData } = resolveData
         const resource = createData?.resource
-        if (!resource || !resource.includes('node_modules')) {
+        if (!resource) {
           return
         }
 
         const normalizedResource = resource.replaceAll('\\', '/')
+
+        // Rewrite optional-peer loads so installed peers get bundled and survive relocation
+        // (#8980); absent peers stay opaque, so a build that does not opt into the feature does
+        // not follow their dependency chain (#8635).
+        if (matchesOptionalPeerFile(normalizedResource)) {
+          createData.loaders = createData.loaders || []
+          createData.loaders.push({ loader: require.resolve('./src/optional-peer-loader') })
+          log.debug('INLINE: optional-peer loader applied to %s', normalizedResource)
+          return
+        }
+
+        if (!resource.includes('node_modules')) {
+          return
+        }
+
         const { pkg, path: modulePath, pkgJson } = extractPackageAndModulePath(normalizedResource)
         if (!pkg) {
           return

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const { rewriteOptionalPeerLoads } = require('../../datadog-instrumentations/src/helpers/optional-peer-bundler')
+
+/**
+ * Webpack loader applied to the optional-peer loader files. Rewrites each
+ * `requireOptionalPeer('name')` whose peer is installed at build time into a literal
+ * `require('name')` so webpack bundles the peer (#8980). Peers that are absent stay opaque, so
+ * builds that do not opt into the feature keep the #8635 guarantee.
+ *
+ * @param {string} source
+ * @returns {string}
+ */
+module.exports = function optionalPeerLoader (source) {
+  this.cacheable(false)
+  return rewriteOptionalPeerLoads(source, this.context)
+}

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

@@ -3,6 +3,5 @@
 const dc = require('dc-polyfill')
 
 module.exports = {
-  aiguardChannel: dc.channel('dd-trace:ai:aiguard'),
   incomingHttpRequestStart: dc.channel('dd-trace:incomingHttpRequestStart'),
 }

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

@@ -1,13 +1,16 @@
 'use strict'
 
 const log = require('../log')
-const { incomingHttpRequestStart, aiguardChannel } = require('./channels')
+const { incomingHttpRequestStart } = require('./channels')
+const openaiIntegration = require('./integrations/openai')
+const vercelAiIntegration = require('./integrations/vercel-ai')
 const AIGuard = require('./sdk')
-const { SOURCE_AUTO, INTEGRATION_NONE } = require('./tags')
 
 let isEnabled = false
 let aiguard
 let block
+let disableOpenAIIntegration
+let disableVercelAiIntegration
 
 function onIncomingHttpRequestStart () {
   // No-op: subscribing ensures the HTTP plugin spreads req onto the store
@@ -21,7 +24,8 @@ function enable (tracer, config) {
     block = config.experimental?.aiguard?.block !== false
 
     incomingHttpRequestStart.subscribe(onIncomingHttpRequestStart)
-    aiguardChannel.subscribe(onEvaluate)
+    disableOpenAIIntegration = openaiIntegration.enable(aiguard, block)
+    disableVercelAiIntegration = vercelAiIntegration.enable(aiguard, block)
 
     isEnabled = true
   } catch (err) {
@@ -34,56 +38,14 @@ function disable () {
   if (!isEnabled) return
 
   incomingHttpRequestStart.unsubscribe(onIncomingHttpRequestStart)
-  aiguardChannel.unsubscribe(onEvaluate)
+  disableOpenAIIntegration?.()
+  disableVercelAiIntegration?.()
 
   aiguard = undefined
   isEnabled = false
   block = false
-}
-
-/**
- * Handles channel messages with pre-converted messages.
- *
- * @param {object} ctx
- * @param {Array<object>} ctx.messages
- * @param {string} [ctx.integration]
- * @param {object} [ctx.parentSpan] - LLM span to parent the `ai_guard` span under.
- * @param {AbortController} ctx.abortController
- * @param {Array<Promise<void>>} ctx.pending - Subscribers push only when they evaluate.
- */
-function onEvaluate (ctx) {
-  // Decline to evaluate empty payloads by not pushing to pending.
-  if (!ctx.messages?.length) {
-    return
-  }
-
-  const opts = {
-    block,
-    source: SOURCE_AUTO,
-    integration: ctx.integration || INTEGRATION_NONE,
-    childOf: ctx.parentSpan,
-  }
-
-  try {
-    ctx.pending.push(aiguard.evaluate(ctx.messages, opts).catch(handleEvaluationError.bind(null, ctx)))
-  } catch (err) {
-    ctx.pending.push(Promise.resolve().then(() => handleEvaluationError(ctx, err)))
-  }
-}
-
-/**
- * Handles an AI Guard evaluation failure.
- *
- * @param {object} ctx
- * @param {AbortController} ctx.abortController
- * @param {Error} err
- */
-function handleEvaluationError (ctx, err) {
-  if (err.name === 'AIGuardAbortError') {
-    ctx.abortController.abort(err)
-  } else {
-    log.error('AIGuard: unexpected error during evaluation: %s', err.message)
-  }
+  disableOpenAIIntegration = undefined
+  disableVercelAiIntegration = undefined
 }
 
 module.exports = { enable, disable }

package/packages/dd-trace/src/aiguard/integrations/evaluate.js

@@ -0,0 +1,46 @@
+'use strict'
+
+const log = require('../../log')
+
+/**
+ * Starts one AI Guard evaluation for a lifecycle ctx.
+ *
+ * Async evaluations are pushed synchronously during channel publication. If
+ * evaluation throws synchronously, the error is handled before publish returns.
+ *
+ * @param {object} ctx
+ * @param {AbortController} ctx.abortController
+ * @param {object} [ctx.parentSpan]
+ * @param {Array<Promise<void>>} ctx.pending
+ * @param {object} aiguard
+ * @param {Array<object>|undefined} messages
+ * @param {object} opts
+ */
+function pushEvaluation (ctx, aiguard, messages, opts) {
+  if (!messages?.length) return
+
+  const evaluateOpts = ctx.parentSpan ? { ...opts, childOf: ctx.parentSpan } : opts
+
+  try {
+    ctx.pending.push(aiguard.evaluate(messages, evaluateOpts).catch(handleEvaluationError.bind(null, ctx)))
+  } catch (err) {
+    handleEvaluationError(ctx, err)
+  }
+}
+
+/**
+ * Handles an AI Guard evaluation failure.
+ *
+ * @param {object} ctx
+ * @param {AbortController} ctx.abortController
+ * @param {Error} err
+ */
+function handleEvaluationError (ctx, err) {
+  if (err.name === 'AIGuardAbortError') {
+    ctx.abortController.abort(err)
+  } else {
+    log.error('AIGuard: unexpected error during evaluation: %s', err.message)
+  }
+}
+
+module.exports = { pushEvaluation }

package/packages/dd-trace/src/aiguard/integrations/openai.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+
+const {
+  getChatCompletionsInputMessages,
+  getChatCompletionsOutputMessages,
+  getResponsesInputMessages,
+  getResponsesOutputMessages,
+} = require('../messages/openai')
+const { SOURCE_AUTO } = require('../tags')
+const { pushEvaluation } = require('./evaluate')
+
+const chatCompletionsBeforeChannel = channel('dd-trace:openai:chat.completions:before')
+const chatCompletionsAfterChannel = channel('dd-trace:openai:chat.completions:after')
+const responsesBeforeChannel = channel('dd-trace:openai:responses:before')
+const responsesAfterChannel = channel('dd-trace:openai:responses:after')
+
+/**
+ * Subscribes AI Guard to OpenAI lifecycle channels.
+ *
+ * @param {object} aiguard
+ * @param {boolean} block
+ * @returns {() => void}
+ */
+function enable (aiguard, block) {
+  const opts = { block, source: SOURCE_AUTO, integration: 'openai' }
+
+  function onChatCompletionsBefore (ctx) {
+    pushEvaluation(ctx, aiguard, getChatCompletionsInputMessages(ctx.args?.[0]), opts)
+  }
+
+  function onChatCompletionsAfter (ctx) {
+    const inputMessages = getChatCompletionsInputMessages(ctx.args?.[0])
+    if (!inputMessages?.length) return
+    for (const message of getChatCompletionsOutputMessages(ctx.body)) {
+      pushEvaluation(ctx, aiguard, [...inputMessages, message], opts)
+    }
+  }
+
+  function onResponsesBefore (ctx) {
+    pushEvaluation(ctx, aiguard, getResponsesInputMessages(ctx.args?.[0]), opts)
+  }
+
+  function onResponsesAfter (ctx) {
+    const inputMessages = getResponsesInputMessages(ctx.args?.[0])
+    if (!inputMessages?.length) return
+    const outputMessages = getResponsesOutputMessages(ctx.body)
+    if (!outputMessages.length) return
+    pushEvaluation(ctx, aiguard, [...inputMessages, ...outputMessages], opts)
+  }
+
+  chatCompletionsBeforeChannel.subscribe(onChatCompletionsBefore)
+  chatCompletionsAfterChannel.subscribe(onChatCompletionsAfter)
+  responsesBeforeChannel.subscribe(onResponsesBefore)
+  responsesAfterChannel.subscribe(onResponsesAfter)
+
+  return function disable () {
+    chatCompletionsBeforeChannel.unsubscribe(onChatCompletionsBefore)
+    chatCompletionsAfterChannel.unsubscribe(onChatCompletionsAfter)
+    responsesBeforeChannel.unsubscribe(onResponsesBefore)
+    responsesAfterChannel.unsubscribe(onResponsesAfter)
+  }
+}
+
+module.exports = { enable }

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

@@ -0,0 +1,78 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+
+const { buildOutputMessages, convertVercelPromptToMessages } = require('../messages/vercel-ai')
+const { SOURCE_AUTO } = require('../tags')
+const { pushEvaluation } = require('./evaluate')
+
+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')
+
+/**
+ * Subscribes AI Guard to Vercel AI lifecycle channels.
+ *
+ * @param {object} aiguard
+ * @param {boolean} block
+ * @returns {() => void}
+ */
+function enable (aiguard, block) {
+  const opts = { block, source: SOURCE_AUTO, integration: 'ai' }
+
+  function onBefore (ctx) {
+    pushEvaluation(ctx, aiguard, convertVercelPromptToMessages(ctx.prompt), opts)
+  }
+
+  function onGenerateAfter (ctx) {
+    const inputMessages = convertVercelPromptToMessages(ctx.prompt)
+    if (!inputMessages.length || !ctx.result?.content?.length) return
+
+    pushEvaluation(ctx, aiguard, buildOutputMessages(inputMessages, ctx.result.content), opts)
+  }
+
+  function onStreamAfter (ctx) {
+    const inputMessages = convertVercelPromptToMessages(ctx.prompt)
+    if (!inputMessages.length || !ctx.chunks?.length) return
+
+    pushEvaluation(ctx, aiguard, buildOutputMessages(inputMessages, getStreamContent(ctx.chunks)), opts)
+  }
+
+  doGenerateBeforeChannel.subscribe(onBefore)
+  doGenerateAfterChannel.subscribe(onGenerateAfter)
+  doStreamBeforeChannel.subscribe(onBefore)
+  doStreamAfterChannel.subscribe(onStreamAfter)
+
+  return function disable () {
+    doGenerateBeforeChannel.unsubscribe(onBefore)
+    doGenerateAfterChannel.unsubscribe(onGenerateAfter)
+    doStreamBeforeChannel.unsubscribe(onBefore)
+    doStreamAfterChannel.unsubscribe(onStreamAfter)
+  }
+}
+
+/**
+ * Converts Vercel stream chunks into the content shape used by doGenerate results.
+ *
+ * @param {Array<object>} chunks
+ * @returns {Array<object>}
+ */
+function getStreamContent (chunks) {
+  const toolCalls = []
+  const textParts = []
+
+  for (const chunk of chunks) {
+    if (chunk?.type === 'tool-call') {
+      toolCalls.push(chunk)
+    } else if (chunk?.type === 'text-delta') {
+      textParts.push(chunk.textDelta)
+    }
+  }
+
+  if (toolCalls.length) return toolCalls
+  const text = textParts.join('')
+  return text ? [{ type: 'text', text }] : []
+}
+
+module.exports = { enable }