dd-trace 6.16.0 → 6.17.0

package/packages/datadog-plugin-supabase/src/supabase-postgrest-js-postgrestbuilder-then.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const log = require('../../dd-trace/src/log')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+const { extractPathFromUrl } = require('../../dd-trace/src/plugins/util/url')
+const { stripQueryAndFragment } = require('../../dd-trace/src/util')
+const normalizeError = require('./error')
+
+const spanFinished = Symbol('spanFinished')
+
+const operationByMethod = {
+  DELETE: 'DELETE',
+  GET: 'SELECT',
+  HEAD: 'SELECT',
+  PATCH: 'UPDATE',
+  POST: 'INSERT',
+}
+
+/**
+ * @typedef {{
+ *   arguments: { [index: number]: unknown, length: number, 0?: Function, 1?: Function },
+ *   self: { method: string, url: URL, schema?: string },
+ *   currentStore?: { span: import('../../..').Span },
+ *   parentStore: import('../../datadog-core/src/storage').Store<unknown>,
+ *   result?: { error?: Error | { message?: string } | null },
+ *   error?: unknown
+ * } & Record<symbol, boolean | undefined>} PostgrestContext
+ */
+
+function finishSafely (plugin, ctx, hasError = false) {
+  try {
+    if (hasError) plugin.error(ctx)
+    plugin.finish(ctx)
+  } catch (error) {
+    log.error('Error in plugin handler:', error)
+    log.info('Disabling plugin: %s', plugin.constructor.name)
+    plugin.configure(false)
+  }
+}
+
+class SupabasePostgrestBuilderThenPlugin extends DatabasePlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/postgrest-js:PostgrestBuilder_then'
+
+  /** @param {PostgrestContext} ctx */
+  bindStart (ctx) {
+    const method = ctx.self?.method
+    const requestUrl = ctx.self?.url
+    const url = stripQueryAndFragment(String(requestUrl))
+    const path = extractPathFromUrl(url)
+    const operation = path.includes('/rpc/') ? 'CALL' : operationByMethod[method] || method
+    const resource = `${operation} ${path.slice(path.lastIndexOf('/') + 1)}`
+
+    this.startSpan('supabase.database.query', {
+      service: { name: this.tracer._service },
+      type: 'sql',
+      resource,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'client',
+        'db.type': 'postgres',
+        'db.name': ctx.self?.schema || 'public',
+        'db.operation': operation,
+        'out.host': requestUrl?.hostname,
+      },
+    }, ctx)
+
+    // PostgrestBuilder.then owns both the request and consumer callbacks. Finish the request span and
+    // restore its parent before invoking a callback so application failures and latency stay outside it.
+    const onFulfilled = ctx.arguments?.[0]
+    if (typeof onFulfilled === 'function') {
+      const plugin = this
+      ctx.arguments[0] = function (result) {
+        ctx.result = result
+        finishSafely(plugin, ctx)
+        return storage('legacy').run(ctx.parentStore, () => onFulfilled.apply(this, arguments))
+      }
+    }
+
+    const onRejected = ctx.arguments?.[1]
+    if (typeof onRejected === 'function') {
+      const plugin = this
+      ctx.arguments[1] = function (error) {
+        ctx.error = error
+        finishSafely(plugin, ctx, true)
+        return storage('legacy').run(ctx.parentStore, () => onRejected.apply(this, arguments))
+      }
+    }
+
+    return ctx.currentStore
+  }
+
+  /** @param {PostgrestContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  /** @param {PostgrestContext} ctx */
+  error (ctx) {
+    if (ctx[spanFinished]) return
+    super.error(ctx)
+  }
+
+  // You may modify this method, but the guard below is REQUIRED and MUST NOT be removed!
+  /** @param {PostgrestContext} ctx */
+  finish (ctx) {
+    // CRITICAL GUARD - DO NOT REMOVE: Ensures span only finishes when operation completes
+    if (ctx[spanFinished] || !ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+
+    const error = normalizeError(ctx.result?.error, 'PostgrestError')
+    if (error) {
+      ctx.error = error
+      super.error(ctx)
+    }
+
+    ctx[spanFinished] = true
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabasePostgrestBuilderThenPlugin

package/packages/datadog-plugin-supabase/src/supabase-realtime-js-realtimechannel-send.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const normalizeError = require('./error')
+
+/**
+ * @typedef {{
+ *   self: { subTopic: string },
+ *   currentStore?: { span: import('../../..').Span },
+ *   result?: 'ok' | 'error' | 'timed out',
+ *   error?: unknown
+ * }} RealtimeContext
+ */
+
+class SupabaseRealtimeChannelSendPlugin extends ProducerPlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/realtime-js:RealtimeChannel_send'
+  static peerServicePrecursors = ['messaging.destination.name']
+
+  /** @param {RealtimeContext} ctx */
+  bindStart (ctx) {
+    const destination = ctx.self?.subTopic
+
+    this.startSpan({
+      service: { name: this.tracer._service },
+      type: 'messaging',
+      resource: destination,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'producer',
+        'messaging.system': 'supabase',
+        'messaging.destination.name': destination,
+        'messaging.destination.kind': 'topic',
+        'messaging.operation': 'send',
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  operationName () {
+    return 'supabase.messaging.send'
+  }
+
+  /** @param {RealtimeContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  // You may modify this method, but the guard below is REQUIRED and MUST NOT be removed!
+  /** @param {RealtimeContext} ctx */
+  finish (ctx) {
+    // CRITICAL GUARD - DO NOT REMOVE: Ensures span only finishes when operation completes
+    if (!ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+
+    const result = ctx.result
+    if (result === 'error' || result === 'timed out') {
+      ctx.error = normalizeError(result, 'RealtimeSendError', `Realtime send returned ${result}`)
+      super.error(ctx)
+    }
+
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabaseRealtimeChannelSendPlugin

package/packages/datadog-plugin-supabase/src/supabase-storage-js-handle-request.js

@@ -0,0 +1,93 @@
+'use strict'
+
+const StoragePlugin = require('../../dd-trace/src/plugins/storage')
+const { extractPathFromUrl } = require('../../dd-trace/src/plugins/util/url')
+const { stripQueryAndFragment } = require('../../dd-trace/src/util')
+const getHostname = require('./url')
+
+/**
+ * @typedef {{
+ *   arguments: { [index: number]: unknown, length: number, 1: string, 2: string | URL },
+ *   currentStore?: { span: import('../../..').Span },
+ *   result?: unknown,
+ *   error?: Error & { status?: number }
+ * }} StorageContext
+ */
+
+const storageRoutes = [
+  'object/upload/sign',
+  'object/list-v2',
+  'object/list',
+  'object/sign',
+  'object/info',
+  'object/copy',
+  'object/move',
+  'render/image',
+  'bucket',
+  'object',
+  'cdn',
+]
+
+/**
+ * Returns a low-cardinality storage route for a request URL.
+ *
+ * @param {string|URL} url Request URL.
+ */
+function getStorageRoute (url) {
+  const path = extractPathFromUrl(stripQueryAndFragment(String(url)))
+  const marker = '/storage/v1/'
+  const markerIndex = path.indexOf(marker)
+  const storagePath = markerIndex === -1 ? path.replace(/^\/+/, '') : path.slice(markerIndex + marker.length)
+
+  for (const route of storageRoutes) {
+    if (storagePath === route || storagePath.startsWith(`${route}/`)) return route
+  }
+
+  return 'storage'
+}
+
+class SupabaseStorageHandleRequestPlugin extends StoragePlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/storage-js:handleRequest'
+
+  /** @param {StorageContext} ctx */
+  bindStart (ctx) {
+    const method = String(ctx.arguments?.[1] || 'GET').toUpperCase()
+    const url = ctx.arguments?.[2]
+
+    this.startSpan('supabase.storage.request', {
+      service: { name: this.tracer._service },
+      type: 'storage',
+      resource: `${method} ${getStorageRoute(url)}`,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'client',
+        'http.method': method,
+        'http.url': stripQueryAndFragment(String(url)),
+        'out.host': getHostname(url),
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  /** @param {StorageContext} ctx */
+  error (ctx) {
+    const status = ctx.error?.status
+    if (status) ctx.currentStore?.span.setTag('http.status_code', status)
+    super.error(ctx)
+  }
+
+  /** @param {StorageContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  /** @param {StorageContext} ctx */
+  finish (ctx) {
+    if (!ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabaseStorageHandleRequestPlugin

package/packages/datadog-plugin-supabase/src/url.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { URL } = require('node:url')
+
+/**
+ * Extracts a hostname without allowing malformed SDK input to break instrumentation.
+ *
+ * @param {string|URL} url Request URL.
+ * @returns {string|undefined} Parsed hostname.
+ */
+function getHostname (url) {
+  try {
+    return new URL(url).hostname
+  } catch {}
+}
+
+module.exports = getHostname

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

@@ -44,6 +44,7 @@ const {
   TEST_ITR_UNSKIPPABLE,
   TEST_ITR_FORCED_RUN,
   ITR_CORRELATION_ID,
+  setExpectedEmptyTestSessionTags,
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const id = require('../../dd-trace/src/id')
@@ -579,6 +580,7 @@ class VitestPlugin extends CiPlugin {
       requestErrorTags,
       vitestPool,
       isVitestNoWorkerInitActive,
+      isExpectedEmptySession,
       onDone,
     }) => {
       for (const [tag, value] of Object.entries(requestErrorTags)) {
@@ -587,6 +589,14 @@ class VitestPlugin extends CiPlugin {
       }
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
+      if (isExpectedEmptySession) {
+        setExpectedEmptyTestSessionTags(
+          this.testSessionSpan,
+          this.testModuleSpan,
+          'No tests were executed',
+          'zero_tests'
+        )
+      }
       if (error) {
         this.testModuleSpan.setTag('error', error)
         this.testSessionSpan.setTag('error', error)

package/packages/datadog-plugin-ws/src/util.js

@@ -36,7 +36,6 @@ function createWebSocketSpanContext (spanContext) {
 /**
  * Returns whether distributed trace headers are present.
  * @param {Record<string, string | string[] | undefined>} headers
- * @returns {boolean}
  */
 function hasTraceHeaders (headers) {
   return !!(headers && (readDatadogTraceId(headers) || readTraceparent(headers)))
@@ -59,7 +58,6 @@ function initWebSocketMessageCounters (socket) {
  * Increments and returns the WebSocket message counter.
  * @param {object} socket - The WebSocket socket object
  * @param {string} counterType - Either 'receiveCounter' or 'sendCounter'
- * @returns {number} The incremented counter value
  */
 function incrementWebSocketCounter (socket, counterType) {
   if (!socketCounters.has(socket)) {
@@ -81,7 +79,6 @@ function incrementWebSocketCounter (socket, counterType) {
  * @param {number} counter - The message counter
  * @param {boolean} isServer - Whether this is a server (true) or client (false)
  * @param {boolean} isIncoming - Whether this is an incoming message (true) or outgoing (false)
- * @returns {string} The span pointer hash
  */
 function buildWebSocketSpanPointerHash (handshakeTraceId, handshakeSpanId, counter, isServer, isIncoming) {
   // Determine prefix based on server/client and incoming/outgoing
@@ -110,7 +107,6 @@ function buildWebSocketSpanPointerHash (handshakeTraceId, handshakeSpanId, count
  *
  * @param {DatadogSpanContext} spanContext - The handshake span context
  * @param {{ hasTraceHeaders?: boolean } | undefined} socket - The WebSocket socket object
- * @returns {boolean} True if the span has distributed tracing context
  */
 function hasDistributedTracingContext (spanContext, socket) {
   if (!spanContext) return false

package/packages/datadog-turbopack/index.js

@@ -74,7 +74,6 @@ function normalizeConfig (config) {
 
 /**
  * @param {unknown} value
- * @returns {boolean}
  */
 function isObject (value) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
@@ -146,7 +145,6 @@ function createLoader () {
 
 /**
  * @param {unknown} value
- * @returns {boolean}
  */
 function hasDatadogLoader (value) {
   if (Array.isArray(value)) return value.some(hasDatadogLoader)
@@ -169,15 +167,11 @@ function createPackagePathPattern () {
 
 /**
  * @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)

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

@@ -120,7 +120,6 @@ module.exports = function loader (source, inputSourceMap) {
 
 /**
  * @param {LoaderContext} context
- * @returns {string}
  */
 function getResourcePath (context) {
   const { resourcePath } = context
@@ -185,7 +184,6 @@ function getPublications (resourcePath, packageInfo) {
 /**
  * @param {string} name
  * @param {string} packageJsonPath
- * @returns {string}
  */
 function getCommonJsEntrypoint (name, packageJsonPath) {
   const cached = entrypoints.get(packageJsonPath)
@@ -228,7 +226,6 @@ function getRewriter (dcModule) {
 
 /**
  * @param {string} source
- * @returns {boolean}
  */
 function hasUnsafeCommonJsBindings (source) {
   try {
@@ -248,7 +245,6 @@ function hasUnsafeCommonJsBindings (source) {
  * @param {number} shadowedBindings
  * @param {object} [parent]
  * @param {string} [parentKey]
- * @returns {boolean}
  */
 function hasUnsafeNode (node, functionDepth, shadowedBindings, parent, parentKey) {
   if (functionDepth === 0 && hasCommonJsDeclaration(node, parent)) return true
@@ -286,7 +282,6 @@ function hasUnsafeNode (node, functionDepth, shadowedBindings, parent, parentKey
 /**
  * @param {object} node
  * @param {object} [parent]
- * @returns {boolean}
  */
 function hasCommonJsDeclaration (node, parent) {
   if (node.type === 'VariableDeclarator') {
@@ -301,7 +296,6 @@ function hasCommonJsDeclaration (node, parent) {
 /**
  * @param {object} node
  * @param {number} shadowedBindings
- * @returns {boolean}
  */
 function mutatesCommonJsBinding (node, shadowedBindings) {
   return Boolean(getBindingMask(node) & COMMONJS_BINDINGS & ~shadowedBindings)
@@ -309,7 +303,6 @@ function mutatesCommonJsBinding (node, shadowedBindings) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getBindingMask (node) {
   if (!node) return 0
@@ -337,7 +330,6 @@ function getBindingMask (node) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getFunctionBindings (node) {
   let bindings = node.type === 'ArrowFunctionExpression' ? 0 : ARGUMENTS_BINDING
@@ -348,7 +340,6 @@ function getFunctionBindings (node) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getVarBindings (node) {
   if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration' ||
@@ -373,7 +364,6 @@ function getVarBindings (node) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getLexicalBindings (node) {
   let bindings = 0
@@ -397,7 +387,6 @@ function getLexicalBindings (node) {
 
 /**
  * @param {object} node
- * @returns {number}
  */
 function getStatementBindings (node) {
   if (node.type === 'VariableDeclaration') return getLexicalDeclarationBindings(node)
@@ -407,7 +396,6 @@ function getStatementBindings (node) {
 
 /**
  * @param {object} [node]
- * @returns {number}
  */
 function getLexicalDeclarationBindings (node) {
   if (node?.type !== 'VariableDeclaration' || node.kind === 'var') return 0
@@ -419,7 +407,6 @@ function getLexicalDeclarationBindings (node) {
 /**
  * @param {object} parent
  * @param {string} parentKey
- * @returns {boolean}
  */
 function isReferencedIdentifier (parent, parentKey) {
   if (parent.type === 'MemberExpression' && parentKey === 'property' && !parent.computed) return false
@@ -434,7 +421,6 @@ function isReferencedIdentifier (parent, parentKey) {
  * @param {string} source
  * @param {Array<{ package: string, path: string, version: string }>} payloads
  * @param {string} dcModule
- * @returns {string}
  */
 function appendCommonJsPublications (source, payloads, dcModule) {
   let publications = ''
@@ -466,7 +452,6 @@ ${publications}  }
  * @param {{ package: string, path: string, version: string }} payload
  * @param {string} dcModule
  * @param {boolean} esm
- * @returns {string}
  */
 function appendActivation (source, payload, dcModule, esm) {
   if (esm) {
@@ -491,7 +476,6 @@ import ddTraceTurbopackDc from ${JSON.stringify(dcModule)}
 /**
  * @param {string} from
  * @param {string} to
- * @returns {string}
  */
 function relativeImport (from, to) {
   let value = path.relative(from, to).replaceAll('\\', '/')

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

@@ -7,7 +7,6 @@ const CHANNEL = 'dd-trace:bundler:load'
  * Called for each module-of-interest identified by DatadogWebpackPlugin.
  *
  * @param {string} source
- * @returns {string}
  */
 module.exports = function loader (source) {
   this.cacheable(false)

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

@@ -9,7 +9,6 @@ const TAGS = require('./tags')
  * Resolves the AI Guard host for a Datadog site.
  *
  * @param {string} site
- * @returns {string}
  */
 function aiGuardHost (site) {
   return site.split('.').length === 2 ? `app.${site}` : site
@@ -60,9 +59,9 @@ class AIGuardClient {
       'DD-AI-GUARD-SOURCE': 'SDK',
       'DD-AI-GUARD-LANGUAGE': 'nodejs',
     }
-    const endpoint = config.experimental.aiguard.endpoint || `https://${aiGuardHost(config.site)}/api/v2/ai-guard`
+    const endpoint = config.aiguard.DD_AI_GUARD_ENDPOINT || `https://${aiGuardHost(config.site)}/api/v2/ai-guard`
     this.#evaluateUrl = `${endpoint}/evaluate`
-    this.#timeout = config.experimental.aiguard.timeout
+    this.#timeout = config.aiguard.DD_AI_GUARD_TIMEOUT
   }
 
   /**

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

@@ -9,6 +9,7 @@ const { keepTrace } = require('../priority_sampler')
 const { extractIp } = require('../plugins/util/ip_extractor')
 const { AI_GUARD } = require('../standalone/product')
 const telemetryMetrics = require('../telemetry/metrics')
+const { truncateString } = require('../util')
 const { normalizeRedactionReplacements, redactMessages } = require('./redaction')
 const TAGS = require('./tags')
 
@@ -96,7 +97,6 @@ function parseEvaluationResponse (body) {
  *
  * @param {boolean} block
  * @param {{ action: string, blockingEnabled: boolean }} evaluation
- * @returns {boolean}
  */
 function shouldBlockEvaluation (block, evaluation) {
   return block && evaluation.blockingEnabled && evaluation.action !== ALLOW
@@ -158,9 +158,9 @@ class EvaluationReporter {
    */
   constructor (config) {
     this.#config = config
-    this.#maxMessagesLength = config.experimental.aiguard.maxMessagesLength
-    this.#maxContentSize = config.experimental.aiguard.maxContentSize
-    this.#redactionEnabled = config.experimental.aiguard.redactionEnabled
+    this.#maxMessagesLength = config.aiguard.DD_AI_GUARD_MAX_MESSAGES_LENGTH
+    this.#maxContentSize = config.aiguard.DD_AI_GUARD_MAX_CONTENT_SIZE
+    this.#redactionEnabled = config.aiguard.DD_AI_GUARD_REDACTION_ENABLED
   }
 
   /**
@@ -211,7 +211,6 @@ class EvaluationReporter {
    *
    * @param {EvaluationReport} report
    * @param {string} errorType
-   * @returns {void}
    */
   fail (report, errorType) {
     report.metaStruct.messages = this.#buildMessagesForMetaStruct(report.messages, report.telemetryTags)
@@ -224,7 +223,6 @@ class EvaluationReporter {
    *
    * @param {EvaluationReport} report
    * @param {EvaluationOutcome} outcome
-   * @returns {void}
    */
   finish (report, outcome) {
     const { result, redaction, shouldBlock } = outcome
@@ -299,14 +297,13 @@ class EvaluationReporter {
    * Truncates text in a cloned message to one shared content-size limit.
    *
    * @param {{ content?: string|ContentPart[] }} message
-   * @returns {boolean}
    */
   #truncateMessageContent (message) {
     const { content } = message
     if (typeof content === 'string') {
       if (content.length <= this.#maxContentSize) return false
 
-      message.content = content.slice(0, this.#maxContentSize)
+      message.content = truncateString(content, this.#maxContentSize)
       return true
     }
 
@@ -319,7 +316,7 @@ class EvaluationReporter {
       if (typeof text !== 'string') continue
 
       if (text.length > remainingContentSize) {
-        part.text = text.slice(0, remainingContentSize)
+        part.text = truncateString(text, remainingContentSize)
         truncated = true
         remainingContentSize = 0
       } else {
@@ -333,7 +330,6 @@ class EvaluationReporter {
    * Returns whether a message represents a tool call or tool output.
    *
    * @param {Message} message
-   * @returns {boolean}
    */
   #isToolCall (message) {
     return Boolean(message.tool_calls || message.tool_call_id)
@@ -370,7 +366,6 @@ class EvaluationReporter {
    * Adds missing client IP tags to the service entry span.
    *
    * @param {Span} rootSpan
-   * @returns {void}
    */
   #setRootSpanClientIpTags (rootSpan) {
     const currentTags = rootSpan.context().getTags()
@@ -411,7 +406,6 @@ class EvaluationReporter {
    *
    * @param {Span} guardSpan
    * @param {Span} rootSpan
-   * @returns {void}
    */
   #copyServiceEntryTagsToGuardSpan (guardSpan, rootSpan) {
     const rootTags = rootSpan.context().getTags()

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

@@ -17,8 +17,8 @@ function enable (tracer, config) {
 
   try {
     aiguard = new AIGuard(tracer, config)
-    const block = config.experimental?.aiguard?.block !== false
-    const analyzeStreamResponses = config.DD_AI_GUARD_ANALYZE_STREAM_RESPONSES_ENABLED
+    const block = config.aiguard.DD_AI_GUARD_BLOCK !== false
+    const analyzeStreamResponses = config.aiguard.DD_AI_GUARD_ANALYZE_STREAM_RESPONSES_ENABLED
 
     incomingHttpRequestStart.subscribe(onIncomingHttpRequestStart)
     integrations.enable(aiguard, block, analyzeStreamResponses)

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

@@ -17,7 +17,7 @@ function enable (aiguard, block, analyzeStreamResponses) {
   if (isEnabled) return
 
   anthropic.enable(aiguard, block)
-  openai.enable(aiguard, block)
+  openai.enable(aiguard, block, analyzeStreamResponses)
   vercelAi.enable(aiguard, block, analyzeStreamResponses)
 
   isEnabled = true