dd-trace 6.15.0 → 6.17.0

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

@@ -2,35 +2,37 @@
 
 const { channel } = require('dc-polyfill')
 
-const { buildOutputMessages, convertVercelPromptToMessages } = require('../messages/vercel-ai')
+const {
+  buildOutputMessages,
+  convertVercelPromptToMessages,
+  getStreamedContent,
+} = require('../messages/vercel-ai')
+const { decode } = require('../messages/utils')
 const { SOURCE_AUTO } = require('../tags')
-const { pushEvaluation } = require('./evaluate')
+const { evaluate } = 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')
+const modelInterceptChannel = channel('dd-trace:vercel-ai:model:intercept')
 
 let isEnabled = false
 let aiguard
 let opts
+let analyzeStreamResponses
 
 /**
- * Subscribes AI Guard to Vercel AI lifecycle channels.
+ * Subscribes AI Guard to the Vercel AI model call channel.
  *
  * @param {object} aiguardInstance
  * @param {boolean} block
+ * @param {boolean} analyzeStreams
  */
-function enable (aiguardInstance, block) {
+function enable (aiguardInstance, block, analyzeStreams) {
   if (isEnabled) return
 
   aiguard = aiguardInstance
   opts = { block, source: SOURCE_AUTO, integration: 'ai' }
+  analyzeStreamResponses = analyzeStreams
 
-  doGenerateBeforeChannel.subscribe(onBefore)
-  doGenerateAfterChannel.subscribe(onGenerateAfter)
-  doStreamBeforeChannel.subscribe(onBefore)
-  doStreamAfterChannel.subscribe(onStreamAfter)
+  modelInterceptChannel.subscribe(onModelIntercept)
 
   isEnabled = true
 }
@@ -38,54 +40,126 @@ function enable (aiguardInstance, block) {
 function disable () {
   if (!isEnabled) return
 
-  doGenerateBeforeChannel.unsubscribe(onBefore)
-  doGenerateAfterChannel.unsubscribe(onGenerateAfter)
-  doStreamBeforeChannel.unsubscribe(onBefore)
-  doStreamAfterChannel.unsubscribe(onStreamAfter)
+  modelInterceptChannel.unsubscribe(onModelIntercept)
 
   aiguard = undefined
   opts = undefined
+  analyzeStreamResponses = undefined
   isEnabled = false
 }
 
-function onBefore (ctx) {
-  pushEvaluation(ctx, aiguard, convertVercelPromptToMessages(ctx.prompt), opts)
-}
+function onModelIntercept (ctx) {
+  const inputMessages = convertVercelPromptToMessages(ctx.arguments?.[0]?.prompt)
+  if (!inputMessages.length) return
+
+  // Called exactly once per model call by the instrumentation, so no memoization needed.
+  ctx.beforeResult = () => {
+    if (!isEnabled) return
+    return evaluate(ctx, aiguard, [inputMessages], opts)
+  }
 
-function onGenerateAfter (ctx) {
-  const inputMessages = convertVercelPromptToMessages(ctx.prompt)
-  if (!inputMessages.length || !ctx.result?.content?.length) return
+  if (ctx.method === 'doStream' && !analyzeStreamResponses) return
 
-  pushEvaluation(ctx, aiguard, buildOutputMessages(inputMessages, ctx.result.content), opts)
+  ctx.onResult = ctx.method === 'doStream'
+    ? result => {
+      if (!isEnabled) return result
+      return interceptStreamedResult(ctx, result, inputMessages)
+    }
+    : result => {
+      if (!isEnabled) return result
+
+      const outputMessages = decode(
+        () => buildOutputMessages(inputMessages, result?.content ?? []),
+        null,
+        'AIGuard: unable to decode the model result: %s'
+      )
+      if (outputMessages === null) return result
+      if (!outputMessages.length) return result
+
+      return evaluate(ctx, aiguard, [outputMessages], opts).then(() => result)
+    }
 }
 
-function onStreamAfter (ctx) {
-  const inputMessages = convertVercelPromptToMessages(ctx.prompt)
-  if (!inputMessages.length || !ctx.chunks?.length) return
+/**
+ * Judging a streamed response requires the whole output, so the stream is drained and replaced
+ * with a replay of the collected chunks. That trades streaming latency for output coverage.
+ *
+ * @param {object} ctx
+ * @param {object} result
+ * @param {Array<object>} inputMessages
+ * @returns {object|Promise<object>}
+ */
+function interceptStreamedResult (ctx, result, inputMessages) {
+  if (!result?.stream) return result
+
+  let drained
+  try {
+    drained = drainStream(result.stream)
+  } catch {
+    // Nothing was consumed, so the caller still has the stream they handed us.
+    return result
+  }
+
+  return drained.then(({ chunks, error }) => {
+    // The original stream is spent from here on, so the caller must get the replay either way.
+    const replayed = { ...result, stream: replayChunks(chunks, error) }
 
-  pushEvaluation(ctx, aiguard, buildOutputMessages(inputMessages, getStreamContent(ctx.chunks)), opts)
+    // A stream that failed part-way has no complete output to judge; the replay carries the error.
+    if (error) return replayed
+
+    const outputMessages = decode(
+      () => buildOutputMessages(inputMessages, getStreamedContent(chunks)),
+      null,
+      'AIGuard: unable to decode the streamed model result: %s'
+    )
+    if (outputMessages === null) return replayed
+    if (!outputMessages.length) return replayed
+
+    return evaluate(ctx, aiguard, [outputMessages], opts).then(() => replayed)
+  })
 }
 
 /**
- * Converts Vercel stream chunks into the content shape used by doGenerate results.
+ * Never rejects: a stream that fails part-way is already consumed, so its chunks and its error
+ * are both returned for the replay to hand back to the caller.
  *
- * @param {Array<object>} chunks
- * @returns {Array<object>}
+ * @param {ReadableStream} stream
+ * @returns {Promise<{ chunks: Array<object>, error?: unknown }>}
  */
-function getStreamContent (chunks) {
-  const toolCalls = []
-  let text = ''
-
-  for (const chunk of chunks) {
-    if (chunk?.type === 'tool-call') {
-      toolCalls.push(chunk)
-    } else if (chunk?.type === 'text-delta') {
-      text += chunk.delta ?? chunk.textDelta ?? ''
-    }
+function drainStream (stream) {
+  const chunks = []
+  const reader = stream.getReader()
+
+  function readAll () {
+    return reader.read().then(({ done, value }) => {
+      if (done) return { chunks }
+      chunks.push(value)
+      return readAll()
+    }, error => ({ chunks, error }))
   }
 
-  if (toolCalls.length) return toolCalls
-  return text ? [{ type: 'text', text }] : []
+  return readAll()
+}
+
+/**
+ * @param {Array<object>} chunks
+ * @param {unknown} [error]
+ * @returns {ReadableStream}
+ */
+function replayChunks (chunks, error) {
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+  return new ReadableStream({
+    start (controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(chunk)
+      }
+      if (error) {
+        controller.error(error)
+      } else {
+        controller.close()
+      }
+    },
+  })
 }
 
 module.exports = { enable, disable }

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

@@ -220,7 +220,6 @@ function partsToContent (parts, hasImages) {
 
 /**
  * @param {Array<object>} parts
- * @returns {boolean}
  */
 function hasImageParts (parts) {
   return parts.some(part => part.type === 'image_url')
@@ -267,7 +266,6 @@ function convertAnthropicToolResultContent (content) {
 
 /**
  * @param {unknown} content
- * @returns {string}
  */
 function convertServerToolResultContent (content) {
   if (typeof content === 'string') return content || '[tool result]'

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

@@ -195,6 +195,68 @@ function getResponsesOutputMessages (body) {
   return convertOpenAIResponseItemsToMessages(body?.output, 'assistant')
 }
 
+/**
+ * Combines streamed chat completion deltas into regular output messages.
+ *
+ * @param {Array<object>} chunks
+ * @returns {Array<object>}
+ */
+function getStreamedChatCompletionsOutputMessages (chunks) {
+  const messages = new Map()
+
+  for (const chunk of chunks) {
+    if (!Array.isArray(chunk?.choices)) continue
+    for (const choice of chunk.choices) {
+      const delta = choice.delta
+      if (!delta) continue
+
+      const index = choice.index ?? 0
+      const message = messages.get(index) ?? { role: 'assistant' }
+      messages.set(index, message)
+
+      if (typeof delta.role === 'string') message.role = delta.role
+      if (typeof delta.content === 'string') message.content = (message.content ?? '') + delta.content
+      if (typeof delta.refusal === 'string') message.refusal = (message.refusal ?? '') + delta.refusal
+
+      if (delta.function_call) {
+        const functionCall = message.function_call ??= {}
+        functionCall.name ??= delta.function_call.name
+        if (typeof delta.function_call.arguments === 'string') {
+          functionCall.arguments = (functionCall.arguments ?? '') + delta.function_call.arguments
+        }
+      }
+
+      if (!Array.isArray(delta.tool_calls)) continue
+      for (const toolCallDelta of delta.tool_calls) {
+        const toolCalls = message.tool_calls ??= []
+        const toolCall = toolCalls[toolCallDelta.index ?? 0] ??= { function: {} }
+        toolCall.id ??= toolCallDelta.id
+        toolCall.type ??= toolCallDelta.type
+        toolCall.function.name ??= toolCallDelta.function?.name
+        if (typeof toolCallDelta.function?.arguments === 'string') {
+          toolCall.function.arguments = (toolCall.function.arguments ?? '') + toolCallDelta.function.arguments
+        }
+      }
+    }
+  }
+
+  const choices = [...messages.values()].map(message => {
+    if (message.tool_calls) message.tool_calls = message.tool_calls.filter(Boolean)
+    return { message }
+  })
+  return getChatCompletionsOutputMessages({ choices })
+}
+
+/**
+ * Gets output messages from the final response snapshot in a Responses API stream.
+ *
+ * @param {Array<object>} chunks
+ * @returns {Array<object>}
+ */
+function getStreamedResponsesOutputMessages (chunks) {
+  return getResponsesOutputMessages(chunks.at(-1)?.response)
+}
+
 /**
  * Converts one OpenAI reusable prompt variable value to message content.
  *
@@ -348,7 +410,6 @@ function openAIResponseImageContentPart (part) {
  * Extracts a stable text marker from an OpenAI file content part.
  *
  * @param {{file_id?: string|null, file_url?: string, filename?: string, file_data?: string}} part
- * @returns {string}
  */
 function openAIResponseFileContentPart (part) {
   return part.file_id ?? part.file_url ?? part.filename ?? FILE_FALLBACK
@@ -362,5 +423,7 @@ module.exports = {
   convertOpenAIResponsePromptToMessages,
   getResponsesInputMessages,
   getResponsesOutputMessages,
+  getStreamedChatCompletionsOutputMessages,
+  getStreamedResponsesOutputMessages,
   openAIResponseContentToMessageContent,
 }

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const log = require('../../log')
+
 const FILE_FALLBACK = '[file]'
 const IMAGE_FALLBACK = '[image]'
 
@@ -9,20 +11,45 @@ const IMAGE_FALLBACK = '[image]'
  */
 function stringifyIfNeeded (value) {
   if (value == null) return value
-  return typeof value === 'string' ? value : JSON.stringify(value)
+  if (typeof value === 'string') return value
+
+  try {
+    return JSON.stringify(value)
+  } catch (error) {
+    log.debug('AIGuard: dropping an unserializable message field: %s', error.message)
+  }
 }
 
 /**
  * @param {unknown} value
- * @returns {string}
  */
 function stringifyOrEmpty (value) {
   return stringifyIfNeeded(value) ?? ''
 }
 
+/**
+ * Runs `attempt`, returning its value. On failure, logs and returns `fallback` instead of
+ * throwing — this runs inside the caller's promise chain, so a bad payload must not break them.
+ *
+ * @template T
+ * @param {() => T} attempt
+ * @param {T} fallback
+ * @param {string} logMessage printf-style, with a single %s for the error message
+ * @returns {T}
+ */
+function decode (attempt, fallback, logMessage) {
+  try {
+    return attempt()
+  } catch (error) {
+    log.error(logMessage, error.message)
+    return fallback
+  }
+}
+
 module.exports = {
   FILE_FALLBACK,
   IMAGE_FALLBACK,
   stringifyIfNeeded,
   stringifyOrEmpty,
+  decode,
 }

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

@@ -180,7 +180,32 @@ function buildOutputMessages (inputMessages, content) {
   return []
 }
 
+/**
+ * Converts Vercel stream chunks into the content shape a doGenerate result carries.
+ *
+ * @param {Array<object>} chunks
+ * @returns {Array<object>}
+ */
+function getStreamedContent (chunks) {
+  const toolCalls = []
+  let text = ''
+
+  for (const chunk of chunks) {
+    if (chunk?.type === 'tool-call') {
+      toolCalls.push(chunk)
+    } else if (chunk?.type === 'text-delta') {
+      // AI SDK 6 renamed `textDelta` to `delta`; both shapes are supported. Coalesced with `??`
+      // because a missing delta must contribute nothing, not "undefined".
+      text += chunk.delta ?? chunk.textDelta ?? ''
+    }
+  }
+
+  if (toolCalls.length) return toolCalls
+  return text ? [{ type: 'text', text }] : []
+}
+
 module.exports = {
+  getStreamedContent,
   convertVercelPromptToMessages,
   convertFilePartToImageUrl,
   buildToolCallOutputMessages,

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

@@ -49,7 +49,6 @@ function parsePath (path) {
  * Reports whether a parsed path targets an allowed message string.
  *
  * @param {Array<{ name: string, index: number|undefined }>} segments
- * @returns {boolean}
  */
 function isRedactablePath (segments) {
   const first = segments[0]

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

@@ -30,7 +30,7 @@ class AIGuard extends NoopAIGuard {
     this.#tracer = tracer
     this.#client = new AIGuardClient(config)
     this.#reporter = new EvaluationReporter(config)
-    this.#redactionEnabled = config.experimental.aiguard.redactionEnabled
+    this.#redactionEnabled = config.aiguard.DD_AI_GUARD_REDACTION_ENABLED
     this.#meta = { service: config.service, env: config.env }
     this.#initialized = true
   }

package/packages/dd-trace/src/appsec/activation.js

@@ -6,7 +6,7 @@ const Activation = {
   DISABLED: 'Disabled',
 
   fromConfig (config) {
-    switch (config.appsec.enabled) {
+    switch (config.appsec.DD_APPSEC_ENABLED) {
       // ASM is activated by an env var DD_APPSEC_ENABLED=true
       case true:
         return Activation.ENABLED

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

@@ -215,7 +215,6 @@ function compileRoute (route, parse, makeMatcher) {
  * @param {number} g
  * @param {Map<number, number>} groupParent
  * @param {Set<number>} present
- * @returns {boolean}
  */
 function groupActive (g, groupParent, present) {
   while (g !== 0) {
@@ -229,7 +228,6 @@ function groupActive (g, groupParent, present) {
  * URL-encode chars outside the RFC-1103 static alphabet [A-Za-z0-9.-~_]. The 'u' flag iterates whole
  * codepoints so surrogate pairs encode as correct multi-byte UTF-8.
  * @param {string} str
- * @returns {string}
  */
 function encodeStaticSegment (str) {
   return str.replaceAll(/[^A-Za-z0-9.\-~_]/gu, c => {
@@ -246,7 +244,6 @@ function encodeStaticSegment (str) {
 /**
  * URL-encode the 6 characters not allowed in a normalized param name (/?#+{}).
  * @param {string} name
- * @returns {string}
  */
 function encodeParamName (name) {
   return name.replaceAll(/[/?#+{}]/g, c => '%' + c.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0'))
@@ -256,7 +253,6 @@ function encodeParamName (name) {
  * Render the normalized route for a given set of present optional groups.
  * @param {CompiledRoute} compiled
  * @param {Set<number>} present
- * @returns {string}
  */
 function renderRoute (compiled, present) {
   const { segments, groupParent } = compiled
@@ -367,7 +363,6 @@ function resolvePresence (compiled, params) {
  * Stable bitmask key for a present-group set (group ids are small, route-local).
  * @param {number[]} optionalGroups
  * @param {Set<number>} present
- * @returns {number}
  */
 function presenceBitmask (optionalGroups, present) {
   let mask = 0

package/packages/dd-trace/src/appsec/api_security/sampler.js

@@ -122,7 +122,6 @@ function sampleRequest (req, res, record = false) {
  *
  * @param {string|undefined} route
  * @param {boolean} record
- * @returns {boolean}
  */
 function isRoutelessRecord (route, record) {
   return record && route === undefined
@@ -130,7 +129,6 @@ function isRoutelessRecord (route, record) {
 
 /**
  * @param {number|string} statusCode
- * @returns {boolean}
  */
 function isNotFound (statusCode) {
   return Number(statusCode) === 404
@@ -141,7 +139,6 @@ function isNotFound (statusCode) {
  * @param {string|undefined} route A route string, an empty string (still a valid route), or
  *   `undefined`
  * @param {number|string} statusCode
- * @returns {string}
  */
 function buildSamplingKey (method, route, statusCode) {
   return method + (route ?? '') + statusCode
@@ -176,7 +173,6 @@ function getRouteOrEndpoint (context, statusCode) {
  * regardless of the APM sampling decision.
  *
  * @param {DatadogSpan} rootSpan
- * @returns {boolean}
  */
 function isRejected (rootSpan) {
   if (asmStandaloneEnabled) return false

package/packages/dd-trace/src/appsec/blocking/index.js

@@ -204,9 +204,9 @@ function handleResults (actions, req, res, rootSpan, abortController) {
  * @param {import('../../config/config-base')} [config] - Tracer configuration
  */
 function setTemplates (config) {
-  templates.html.body = config?.appsec?.blockedTemplateHtml
-  templates.json.body = config?.appsec?.blockedTemplateJson
-  templates.graphqlJson.body = config?.appsec?.blockedTemplateGraphql
+  templates.html.body = config?.appsec?.DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML
+  templates.json.body = config?.appsec?.DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON
+  templates.graphqlJson.body = config?.appsec?.DD_APPSEC_GRAPHQL_BLOCKED_TEMPLATE_JSON
 
   for (const type of Object.keys(templates)) {
     const template = templates[type]

package/packages/dd-trace/src/appsec/downstream_requests.js

@@ -102,7 +102,6 @@ function recordResponseBodyIgnored (req, tag) {
 /**
  * @param {import('http').IncomingMessage} originatingReq inbound request (for metrics).
  * @param {import('http').IncomingMessage} res downstream response.
- * @returns {boolean} whether downstream response body should be collected for AppSec.
  */
 function evaluateResponseBodyCollection (originatingReq, res) {
   const maxBytes = config.appsec.DD_API_SECURITY_MAX_DOWNSTREAM_BODY_BYTES
@@ -131,7 +130,6 @@ function evaluateResponseBodyCollection (originatingReq, res) {
  * Probabilistic gate for downstream response body capture (rate + per-request cap).
  * Only used from {@link planResponseBodyCollection}; does not increment {@link bodyAnalysisCount}.
  * @param {import('http').IncomingMessage} req originating server request.
- * @returns {boolean}
  */
 function shouldSampleBody (req) {
   globalRequestCounter = (globalRequestCounter + 1n) & UINT64_MAX
@@ -150,7 +148,6 @@ function shouldSampleBody (req) {
 
 /**
  * @param {import('http').IncomingMessage} res downstream HTTP response.
- * @returns {boolean}
  */
 function isRedirectResponse (res) {
   const location = res.headers?.location || ''
@@ -271,7 +268,6 @@ function incrementDownstreamAnalysisCount (req) {
 /**
  * Returns the HTTP method to use for a downstream request, defaulting to GET.
  * @param {string} method method supplied in the outgoing request options.
- * @returns {string} validated HTTP method.
  */
 function getMethod (method) {
   return typeof method === 'string' && method ? method : 'GET'
@@ -351,6 +347,7 @@ module.exports = {
   disable,
   planResponseBodyCollection,
   incrementDownstreamAnalysisCount,
+  extractMimeType,
   extractRequestData,
   extractResponseData,
 }

package/packages/dd-trace/src/appsec/iast/index.js

@@ -31,7 +31,7 @@ let isEnabled = false
 function enable (config, _tracer) {
   if (isEnabled) return
 
-  iastTelemetry.configure(config, config.iast?.telemetryVerbosity)
+  iastTelemetry.configure(config, config.iast?.DD_IAST_TELEMETRY_VERBOSITY)
   enableFsPlugin(IAST_MODULE)
   enableAllAnalyzers(config)
   enableTaintTracking(config.iast, iastTelemetry.verbosity)

package/packages/dd-trace/src/appsec/iast/overhead-controller.js

@@ -73,7 +73,7 @@ const OPERATIONS = {
     },
     name: REPORT_VULNERABILITY,
     initialTokenBucketSize () {
-      return typeof config.maxContextOperations === 'number' ? config.maxContextOperations : 2
+      return typeof config.DD_IAST_MAX_CONTEXT_OPERATIONS === 'number' ? config.DD_IAST_MAX_CONTEXT_OPERATIONS : 2
     },
     initContext: function (context) {
       context.tokens[REPORT_VULNERABILITY] = this.initialTokenBucketSize()
@@ -146,8 +146,8 @@ function _resetGlobalContext () {
 
 function acquireRequest (rootSpan) {
   if (availableRequest > 0 && rootSpan) {
-    const sampling = config && typeof config.requestSampling === 'number'
-      ? config.requestSampling
+    const sampling = config && typeof config.DD_IAST_REQUEST_SAMPLING === 'number'
+      ? config.DD_IAST_REQUEST_SAMPLING
       : 30
     if (rootSpan.context().toSpanId().slice(-2) <= sampling) {
       availableRequest--
@@ -158,7 +158,7 @@ function acquireRequest (rootSpan) {
 }
 
 function releaseRequest () {
-  if (availableRequest < config.maxConcurrentRequests) {
+  if (availableRequest < config.DD_IAST_MAX_CONCURRENT_REQUESTS) {
     availableRequest++
   }
 }
@@ -174,7 +174,7 @@ function initializeRequestContext (iastContext) {
 
 function configure (cfg) {
   config = cfg
-  availableRequest = config.maxConcurrentRequests
+  availableRequest = config.DD_IAST_MAX_CONCURRENT_REQUESTS
 }
 
 function startGlobalContext () {

package/packages/dd-trace/src/appsec/iast/taint-tracking/index.js

@@ -20,7 +20,7 @@ module.exports = {
     kafkaContextPlugin.enable(config)
     kafkaConsumerPlugin.enable(config)
 
-    setMaxTransactions(config.maxConcurrentRequests)
+    setMaxTransactions(config.DD_IAST_MAX_CONCURRENT_REQUESTS)
   },
   disableTaintTracking () {
     disableTaintOperations()

package/packages/dd-trace/src/appsec/iast/taint-tracking/plugin.js

@@ -30,7 +30,7 @@ class TaintTrackingPlugin extends SourceIastPlugin {
   configure (config) {
     super.configure(config)
 
-    let rowsToTaint = this.iastConfig?.dbRowsToTaint
+    let rowsToTaint = this.iastConfig?.DD_IAST_DB_ROWS_TO_TAINT
     if (typeof rowsToTaint !== 'number') {
       rowsToTaint = 1
     }

package/packages/dd-trace/src/appsec/iast/taint-tracking/rewriter.js

@@ -97,7 +97,7 @@ function getPrepareStackTraceAccessor () {
 
 function getCompileMethodFn (compileMethod) {
   let delegate = function (content, filename) {
-    if (isDdTrace(filename) || !isPrivateModule(filename) || !config.iast?.enabled) {
+    if (isDdTrace(filename) || !isPrivateModule(filename) || !config.iast?.DD_IAST_ENABLED) {
       return compileMethod.apply(this, [content, filename])
     }
 
@@ -163,7 +163,7 @@ function shimPrepareStackTrace () {
 
 function enableRewriter (telemetryVerbosity) {
   try {
-    if (config.iast?.enabled) {
+    if (config.iast?.DD_IAST_ENABLED) {
       const rewriter = getRewriter(telemetryVerbosity)
       if (rewriter) {
         shimPrepareStackTrace()
@@ -218,7 +218,7 @@ let enableEsmRewriter = function (telemetryVerbosity) {
           telemetryVerbosity,
           chainSourceMap: isFlagPresent('--enable-source-maps'),
           orchestrionConfig,
-          iastEnabled: config?.iast?.enabled,
+          iastEnabled: config?.iast?.DD_IAST_ENABLED,
         },
       })
     } catch (e) {