dd-trace 5.95.0 → 5.96.0

package/index.d.ts

@@ -786,6 +786,15 @@ declare namespace tracer {
          * Programmatic configuration takes precedence over the environment variables listed above.
          */
         enabled?: boolean,
+        /**
+         * Whether to request blocking mode when evaluating prompts via auto-instrumentation.
+         * When `true`, AI Guard will block requests that violate security policies.
+         * When `false`, AI Guard evaluates but never blocks (monitor-only mode).
+         * @default false
+         * @env DD_AI_GUARD_BLOCK
+         * Programmatic configuration takes precedence over the environment variables listed above.
+         */
+        block?: boolean,
         /**
          * URL of the AI Guard REST API.
          * @env DD_AI_GUARD_ENDPOINT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.95.0",
+  "version": "5.96.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -139,7 +139,7 @@
   ],
   "dependencies": {
     "dc-polyfill": "^0.1.10",
-    "import-in-the-middle": "^3.0.0"
+    "import-in-the-middle": "^3.0.1"
   },
   "optionalDependencies": {
     "@datadog/libdatadog": "0.9.2",

package/packages/datadog-instrumentations/src/ai.js

@@ -3,11 +3,113 @@
 const { channel, tracingChannel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, getHooks } = require('./helpers/instrument')
+const { convertVercelPromptToMessages, buildOutputMessages } = require('./helpers/ai-messages')
 
 const vercelAiTracingChannel = tracingChannel('dd-trace:vercel-ai')
 const vercelAiSpanSetAttributesChannel = channel('dd-trace:vercel-ai:span:setAttributes')
+const aiguardChannel = channel('dd-trace:ai:aiguard')
 
 const tracers = new WeakSet()
+const wrappedModels = new WeakSet()
+
+/**
+ * Publishes already-converted AI guard style messages to the AIGuard channel.
+ *
+ * @param {Array<object>} messages - AI guard style messages to evaluate
+ * @returns {Promise<void>}
+ */
+function publishToAIGuard (messages) {
+  return new Promise((resolve, reject) => {
+    aiguardChannel.publish({ messages, resolve, reject })
+  })
+}
+
+/**
+ * Wraps a Vercel AI language model's doGenerate and doStream methods to evaluate
+ * messages with AIGuard.
+ *
+ * @param {object} model - A Vercel AI language model instance
+ */
+function wrapModelWithAIGuard (model) {
+  if (!model || wrappedModels.has(model)) return
+  wrappedModels.add(model)
+
+  if (typeof model.doGenerate === 'function') {
+    shimmer.wrap(model, 'doGenerate', function (original) {
+      return function (options) {
+        const originalResult = original.call(this, options)
+
+        if (!aiguardChannel.hasSubscribers) return originalResult
+        if (!options.prompt?.length) return originalResult
+
+        const inputMessages = convertVercelPromptToMessages(options.prompt)
+        if (!inputMessages.length) return originalResult
+
+        // Run AI Guard input evaluation and LLM call in parallel.
+        // The LLM has no side effects so it is safe to discard its result if AI Guard blocks.
+        return Promise.all([publishToAIGuard(inputMessages), originalResult])
+          .then(([, result]) => {
+            if (!result.content?.length) return result
+            return publishToAIGuard(buildOutputMessages(inputMessages, result.content))
+              .then(() => result)
+          })
+      }
+    })
+  }
+
+  if (typeof model.doStream === 'function') {
+    shimmer.wrap(model, 'doStream', function (original) {
+      return function (options) {
+        const originalResult = original.call(this, options)
+
+        if (!aiguardChannel.hasSubscribers) return originalResult
+        if (!options.prompt?.length) return originalResult
+
+        const inputMessages = convertVercelPromptToMessages(options.prompt)
+        if (!inputMessages.length) return originalResult
+
+        // Run AI Guard input evaluation and LLM call in parallel.
+        // The LLM has no side effects so it is safe to discard its result if AI Guard blocks.
+        return Promise.all([publishToAIGuard(inputMessages), originalResult])
+          .then(([, result]) => {
+            const chunks = []
+            const reader = result.stream.getReader()
+
+            function readAll () {
+              return reader.read().then(({ done, value }) => {
+                if (done) return
+                chunks.push(value)
+                return readAll()
+              })
+            }
+
+            return readAll().then(() => {
+              const toolCalls = chunks.filter(c => c?.type === 'tool-call')
+              const text = chunks.filter(c => c?.type === 'text-delta').map(c => c.textDelta).join('')
+              const content = toolCalls.length ? toolCalls : text ? [{ type: 'text', text }] : []
+
+              const evaluate = content.length
+                ? publishToAIGuard(buildOutputMessages(inputMessages, content))
+                : Promise.resolve()
+
+              return evaluate.then(() => {
+                // eslint-disable-next-line n/no-unsupported-features/node-builtins
+                const stream = new ReadableStream({
+                  start (controller) {
+                    for (const chunk of chunks) {
+                      controller.enqueue(chunk)
+                    }
+                    controller.close()
+                  },
+                })
+                return { ...result, stream }
+              })
+            })
+          })
+      }
+    })
+  }
+}
 
 function wrapTracer (tracer) {
   if (tracers.has(tracer)) {
@@ -114,6 +216,16 @@ for (const hook of getHooks('ai')) {
       },
     })
 
+    // resolveLanguageModel is called by all LLM entry points (generateText, streamText,
+    // generateObject, streamObject)
+    tracingChannel('orchestrion:ai:resolveLanguageModel').subscribe({
+      end (ctx) {
+        wrapModelWithAIGuard(ctx.result)
+      },
+    })
+
     return exports
   })
 }
+
+module.exports = { wrapModelWithAIGuard }

package/packages/datadog-instrumentations/src/helpers/ai-messages.js

@@ -0,0 +1,182 @@
+'use strict'
+
+/**
+ * Converts a LanguageModelV2FilePart with an image mediaType to an AI guard style image_url content part.
+ *
+ * @param {{type: 'file', data: URL|string|Uint8Array, mediaType: string}} part
+ * @returns {{type: 'image_url', image_url: {url: string}}|undefined}
+ */
+function convertFilePartToImageUrl (part) {
+  const { data, mediaType } = part
+
+  if (data instanceof URL) {
+    return { type: 'image_url', image_url: { url: data.toString() } }
+  }
+
+  if (typeof data === 'string') {
+    if (data.startsWith('http') || data.startsWith('data:')) {
+      return { type: 'image_url', image_url: { url: data } }
+    }
+    return { type: 'image_url', image_url: { url: `data:${mediaType};base64,${data}` } }
+  }
+
+  if (data instanceof Uint8Array) {
+    return { type: 'image_url', image_url: { url: `data:${mediaType};base64,${Buffer.from(data).toString('base64')}` } }
+  }
+}
+
+/**
+ * Converts a LanguageModelV2Prompt to the AI guard style message format.
+ *
+ * Vercel AI v2 prompt entries use content arrays with typed parts (e.g. { type: 'text', text },
+ * { type: 'file', data, mediaType }). This function converts them to AI guard style messages.
+ * When file parts with image media types are present, the content is an array of text and
+ * image_url parts; otherwise it is a plain string.
+ *
+ * @param {Array<{role: string, content: string|Array<{type: string}>}>} prompt
+ * @returns {Array<{role: string, content?: string|Array<{type: string}>, tool_calls?: Array, tool_call_id?: string}>}
+ */
+function convertVercelPromptToMessages (prompt) {
+  if (!Array.isArray(prompt)) return []
+
+  const messages = []
+  for (const msg of prompt) {
+    switch (msg.role) {
+      case 'system':
+        messages.push({ role: 'system', content: typeof msg.content === 'string' ? msg.content : '' })
+        break
+
+      case 'user': {
+        if (!Array.isArray(msg.content)) break
+
+        const contentParts = []
+        for (const part of msg.content) {
+          if (part.type === 'text') {
+            contentParts.push({ type: 'text', text: part.text })
+          } else if (part.type === 'file' && part.mediaType?.startsWith('image/')) {
+            const converted = convertFilePartToImageUrl(part)
+            if (converted) contentParts.push(converted)
+          }
+        }
+
+        if (contentParts.length === 0) break
+
+        const hasImages = contentParts.some(p => p.type === 'image_url')
+        if (hasImages) {
+          messages.push({ role: 'user', content: contentParts })
+        } else {
+          messages.push({ role: 'user', content: contentParts.map(p => p.text).join('\n') })
+        }
+        break
+      }
+
+      case 'assistant': {
+        const textParts = []
+        const toolCalls = []
+        if (!Array.isArray(msg.content)) break
+
+        for (const part of msg.content) {
+          if (part.type === 'text') {
+            textParts.push(part.text)
+          } else if (part.type === 'tool-call') {
+            const args = part.args ?? part.input
+            toolCalls.push({
+              id: part.toolCallId,
+              function: {
+                name: part.toolName,
+                arguments: typeof args === 'string' ? args : JSON.stringify(args),
+              },
+            })
+          }
+        }
+
+        if (toolCalls.length > 0) {
+          messages.push({ role: 'assistant', tool_calls: toolCalls })
+        } else if (textParts.length > 0) {
+          messages.push({ role: 'assistant', content: textParts.join('\n') })
+        }
+        break
+      }
+
+      case 'tool': {
+        if (!Array.isArray(msg.content)) break
+
+        for (const part of msg.content) {
+          if (part.type === 'tool-result') {
+            const result = part.result ?? part.output
+            messages.push({
+              role: 'tool',
+              tool_call_id: part.toolCallId,
+              content: typeof result === 'string' ? result : JSON.stringify(result),
+            })
+          }
+        }
+        break
+      }
+    }
+  }
+  return messages
+}
+
+/**
+ * Converts LLM output tool calls to AI guard style message format.
+ *
+ * @param {Array<object>} inputMessages - The input messages already in AI guard style format
+ * @param {Array<{toolCallId: string, toolName: string, args?: unknown, input?: unknown}>} toolCalls
+ * @returns {Array<object>}
+ */
+function buildToolCallOutputMessages (inputMessages, toolCalls) {
+  return [
+    ...inputMessages,
+    {
+      role: 'assistant',
+      tool_calls: toolCalls.map(tc => {
+        const args = tc.args ?? tc.input
+        return {
+          id: tc.toolCallId,
+          function: {
+            name: tc.toolName,
+            arguments: typeof args === 'string' ? args : JSON.stringify(args),
+          },
+        }
+      }),
+    },
+  ]
+}
+
+/**
+ * Builds OpenAI-style output messages for the assistant's text response.
+ *
+ * @param {Array<object>} inputMessages - The input messages already in AI guard style format
+ * @param {string} text - The assistant's text response
+ * @returns {Array<object>}
+ */
+function buildTextOutputMessages (inputMessages, text) {
+  return [
+    ...inputMessages,
+    { role: 'assistant', content: text },
+  ]
+}
+
+/**
+ * Parses a Vercel AI content array and dispatches to the appropriate output message builder.
+ *
+ * @param {Array<object>} inputMessages - The input messages already in AI guard style format
+ * @param {Array<{type: string}>} content - Vercel AI content array from doGenerate/doStream result
+ * @returns {Array<object>}
+ */
+function buildOutputMessages (inputMessages, content) {
+  const toolCalls = content.filter(c => c.type === 'tool-call')
+  const text = content.filter(c => c.type === 'text').map(c => c.text).join('\n')
+  if (toolCalls.length) return buildToolCallOutputMessages(inputMessages, toolCalls)
+  if (text) return buildTextOutputMessages(inputMessages, text)
+  return inputMessages
+}
+
+module.exports = {
+  convertVercelPromptToMessages,
+  convertFilePartToImageUrl,
+  buildToolCallOutputMessages,
+  buildTextOutputMessages,
+  buildOutputMessages,
+}

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/ai.js

@@ -75,6 +75,31 @@ module.exports = [
     },
     channelName: 'selectTelemetryAttributes',
   },
+  // resolveLanguageModel called by all LLM entry points, its result is the resolved model instance.
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=6.0.0',
+      filePath: 'dist/index.js',
+    },
+    functionQuery: {
+      functionName: 'resolveLanguageModel',
+      kind: 'Sync',
+    },
+    channelName: 'resolveLanguageModel',
+  },
+  {
+    module: {
+      name: 'ai',
+      versionRange: '>=6.0.0',
+      filePath: 'dist/index.mjs',
+    },
+    functionQuery: {
+      functionName: 'resolveLanguageModel',
+      kind: 'Sync',
+    },
+    channelName: 'resolveLanguageModel',
+  },
   // tool
   {
     module: {

package/packages/datadog-instrumentations/src/mocha/utils.js

@@ -384,6 +384,11 @@ function getOnTestEndHandler (config) {
       })
     } else if (ctx) { // if there is an afterEach to run, let's store the finalStatus for getOnHookEndHandler
       ctx.finalStatus = finalStatus
+      ctx.hasFailedAllRetries = hasFailedAllRetries
+      ctx.attemptToFixPassed = attemptToFixPassed
+      ctx.attemptToFixFailed = attemptToFixFailed
+      ctx.isAttemptToFixRetry = isAttemptToFixRetry
+      ctx.isAtrRetry = isAtrRetry
     }
   }
 }
@@ -404,6 +409,11 @@ function getOnHookEndHandler () {
             status,
             hasBeenRetried: isMochaRetry(test),
             isLastRetry: getIsLastRetry(test),
+            hasFailedAllRetries: ctx.hasFailedAllRetries,
+            attemptToFixPassed: ctx.attemptToFixPassed,
+            attemptToFixFailed: ctx.attemptToFixFailed,
+            isAttemptToFixRetry: ctx.isAttemptToFixRetry,
+            isAtrRetry: ctx.isAtrRetry,
             ...ctx.currentStore,
             finalStatus: ctx.finalStatus,
           })

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

@@ -0,0 +1,64 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+const log = require('../log')
+const AIGuard = require('./sdk')
+
+const aiguardChannel = channel('dd-trace:ai:aiguard')
+
+let isEnabled = false
+let aiguard
+let block
+
+function enable (tracer, config) {
+  if (isEnabled) return
+
+  try {
+    aiguard = new AIGuard(tracer, config)
+    block = config.experimental?.aiguard?.block !== false
+
+    aiguardChannel.subscribe(onEvaluate)
+
+    isEnabled = true
+  } catch (err) {
+    log.error('AIGuard: unexpected error during initialization: %s', err.message)
+    disable()
+  }
+}
+
+function disable () {
+  if (!isEnabled) return
+
+  aiguardChannel.unsubscribe(onEvaluate)
+
+  aiguard = undefined
+  isEnabled = false
+  block = false
+}
+
+/**
+ * Handles channel messages with pre-converted messages.
+ *
+ * @param {{messages: Array<object>, resolve: Function, reject: Function}} ctx
+ */
+function onEvaluate (ctx) {
+  if (!ctx.messages?.length) {
+    ctx.resolve()
+    return
+  }
+
+  aiguard.evaluate(ctx.messages, { block })
+    .then(() => {
+      ctx.resolve()
+    })
+    .catch(err => {
+      if (err.name === 'AIGuardAbortError') {
+        ctx.reject(err)
+      } else {
+        log.error('AIGuard: unexpected error during evaluation: %s', err.message)
+        ctx.resolve()
+      }
+    })
+}
+
+module.exports = { enable, disable }

package/packages/dd-trace/src/ci-visibility/lage.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const { getEnvironmentVariable } = require('../config/helper')
+const { isTrue } = require('../util')
+
+/**
+ * Returns the current Lage package name if the Lage package name override is enabled.
+ *
+ * @returns {string|undefined}
+ */
+function getLagePackageName () {
+  if (!isTrue(getEnvironmentVariable('DD_ENABLE_LAGE_PACKAGE_NAME'))) {
+    return
+  }
+
+  const packageName = getEnvironmentVariable('LAGE_PACKAGE_NAME')
+  if (!packageName) {
+    return
+  }
+
+  return packageName
+}
+
+/**
+ * Returns the current Lage package name as the test session name unless the user set one explicitly.
+ *
+ * @returns {string|undefined}
+ */
+function getLageTestSessionName () {
+  if (getEnvironmentVariable('DD_TEST_SESSION_NAME')) {
+    return
+  }
+
+  return getLagePackageName()
+}
+
+module.exports = {
+  getLageTestSessionName,
+}

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

@@ -21,7 +21,7 @@ const {
   getIsAzureFunction,
   enableGCPPubSubPushSubscription,
 } = require('../serverless')
-const { ORIGIN_KEY } = require('../constants')
+const { ORIGIN_KEY, DATADOG_MINI_AGENT_PATH } = require('../constants')
 const { appendRules } = require('../payload-tagging/config')
 const { getGitMetadataFromGitProperties, removeUserSensitiveInfo, getRemoteOriginURL, resolveGitHeadSHA } =
   require('./git_properties')
@@ -251,6 +251,7 @@ class Config {
     const {
       AWS_LAMBDA_FUNCTION_NAME,
       DD_AGENT_HOST,
+      DD_AI_GUARD_BLOCK,
       DD_AI_GUARD_ENABLED,
       DD_AI_GUARD_ENDPOINT,
       DD_AI_GUARD_MAX_CONTENT_SIZE,
@@ -608,6 +609,7 @@ class Config {
         maybeInt(DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS)
     }
     setBoolean(target, 'traceEnabled', DD_TRACE_ENABLED)
+    setBoolean(target, 'experimental.aiguard.block', DD_AI_GUARD_BLOCK)
     setBoolean(target, 'experimental.aiguard.enabled', DD_AI_GUARD_ENABLED)
     setString(target, 'experimental.aiguard.endpoint', DD_AI_GUARD_ENDPOINT)
     target['experimental.aiguard.maxContentSize'] = maybeInt(DD_AI_GUARD_MAX_CONTENT_SIZE)
@@ -618,7 +620,7 @@ class Config {
     unprocessedTarget['experimental.aiguard.timeout'] = DD_AI_GUARD_TIMEOUT
     setBoolean(target, 'experimental.enableGetRumData', DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED)
     setString(target, 'experimental.exporter', DD_TRACE_EXPERIMENTAL_EXPORTER)
-    if (AWS_LAMBDA_FUNCTION_NAME) {
+    if (AWS_LAMBDA_FUNCTION_NAME && !fs.existsSync(DATADOG_MINI_AGENT_PATH)) {
       target.flushInterval = 0
     } else if (DD_TRACE_FLUSH_INTERVAL) {
       target.flushInterval = maybeInt(DD_TRACE_FLUSH_INTERVAL)
@@ -939,6 +941,7 @@ class Config {
     this.#optsUnprocessed['dynamicInstrumentation.uploadIntervalSeconds'] =
       options.dynamicInstrumentation?.uploadIntervalSeconds
     setString(opts, 'env', options.env || tags.env)
+    setBoolean(opts, 'experimental.aiguard.block', options.experimental?.aiguard?.block)
     setBoolean(opts, 'experimental.aiguard.enabled', options.experimental?.aiguard?.enabled)
     setString(opts, 'experimental.aiguard.endpoint', options.experimental?.aiguard?.endpoint)
     opts['experimental.aiguard.maxMessagesLength'] = maybeInt(options.experimental?.aiguard?.maxMessagesLength)

package/packages/dd-trace/src/config/supported-configurations.json

@@ -46,6 +46,16 @@
         ]
       }
     ],
+    "DD_AI_GUARD_BLOCK": [
+      {
+        "implementation": "B",
+        "type": "boolean",
+        "configurationNames": [
+          "experimental.aiguard.block"
+        ],
+        "default": "false"
+      }
+    ],
     "DD_AI_GUARD_ENABLED": [
       {
         "implementation": "A",
@@ -510,6 +520,13 @@
         ]
       }
     ],
+    "DD_ENABLE_LAGE_PACKAGE_NAME": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "false"
+      }
+    ],
     "DD_CIVISIBILITY_MANUAL_API_ENABLED": [
       {
         "implementation": "A",

package/packages/dd-trace/src/constants.js

@@ -22,6 +22,7 @@ module.exports = {
   SPAN_SAMPLING_RULE_RATE: '_dd.span_sampling.rule_rate',
   SPAN_SAMPLING_MAX_PER_SECOND: '_dd.span_sampling.max_per_second',
   DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent',
+  DATADOG_MINI_AGENT_PATH: '/tmp/datadog/mini_agent_ready',
   DECISION_MAKER_KEY: '_dd.p.dm',
   SAMPLING_KNUTH_RATE: '_dd.p.ksr',
   PROCESS_ID: 'process_id',

package/packages/dd-trace/src/exporter.js

@@ -25,8 +25,11 @@ module.exports = function getExporter (name) {
       return require('./ci-visibility/exporters/test-worker')
     default: {
       const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
-      const usingLambdaExtension = inAWSLambda && fs.existsSync(constants.DATADOG_LAMBDA_EXTENSION_PATH)
-      return require(inAWSLambda && !usingLambdaExtension ? './exporters/log' : './exporters/agent')
+      const usingAgent = inAWSLambda && (
+        fs.existsSync(constants.DATADOG_LAMBDA_EXTENSION_PATH) ||
+        fs.existsSync(constants.DATADOG_MINI_AGENT_PATH)
+      )
+      return require(inAWSLambda && !usingAgent ? './exporters/log' : './exporters/agent')
     }
   }
 }

package/packages/dd-trace/src/llmobs/constants/text.js

@@ -3,4 +3,7 @@
 module.exports = {
   DROPPED_VALUE_TEXT: "[This value has been dropped because this span's size exceeds the 5MB size limit.]",
   UNSERIALIZABLE_VALUE_TEXT: 'Unserializable value',
+  INCOMPATIBLE_INITIALIZATION:
+    'Cannot send LLM Observability data without a running agent or without both a Datadog API key and site. ' +
+    'Ensure these configurations are set before running your application.',
 }

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

@@ -3,6 +3,8 @@
 const { channel } = require('dc-polyfill')
 
 const log = require('../log')
+const { DD_MAJOR } = require('../../../../version')
+const startupLogs = require('../startup-log')
 const {
   ML_APP,
   PROPAGATED_ML_APP_KEY,
@@ -15,6 +17,7 @@ const LLMObsEvalMetricsWriter = require('./writers/evaluations')
 const LLMObsTagger = require('./tagger')
 const LLMObsSpanWriter = require('./writers/spans')
 const { setAgentStrategy } = require('./writers/util')
+const { INCOMPATIBLE_INITIALIZATION } = require('./constants/text')
 
 const spanFinishCh = channel('dd-trace:span:finish')
 const evalMetricAppendCh = channel('llmobs:eval-metric:append')
@@ -66,10 +69,12 @@ function enable (config) {
 
   setAgentStrategy(config, useAgentless => {
     if (useAgentless && !(config.apiKey && config.site)) {
-      throw new Error(
-        'Cannot send LLM Observability data without a running agent or without both a Datadog API key and site.\n' +
-        'Ensure these configurations are set before running your application.'
-      )
+      if (DD_MAJOR < 6 || !config?.startupLogs) {
+        // eslint-disable-next-line no-console
+        console.error(INCOMPATIBLE_INITIALIZATION)
+      } else {
+        startupLogs.logGenericError(INCOMPATIBLE_INITIALIZATION)
+      }
     }
 
     evalWriter?.setAgentless(useAgentless)

package/packages/dd-trace/src/plugins/util/test.js

@@ -3,6 +3,7 @@
 const path = require('path')
 const fs = require('fs')
 const { URL } = require('url')
+const { getLageTestSessionName } = require('../../ci-visibility/lage')
 const log = require('../../log')
 const { getEnvironmentVariable } = require('../../config/helper')
 const satisfies = require('../../../../../vendor/dist/semifies')
@@ -934,6 +935,10 @@ function getTestSessionName (config, trimmedCommand, envTags) {
   if (config.ciVisibilityTestSessionName) {
     return config.ciVisibilityTestSessionName
   }
+  const lageTestSessionName = getLageTestSessionName()
+  if (lageTestSessionName) {
+    return lageTestSessionName
+  }
   if (envTags[CI_JOB_NAME]) {
     return `${envTags[CI_JOB_NAME]}-${trimmedCommand}`
   }

package/packages/dd-trace/src/proxy.js

@@ -85,6 +85,7 @@ class Tracer extends NoopProxy {
     // these requires must work with esm bundler
     this._modules = {
       appsec: new LazyModule(() => require('./appsec')),
+      aiguard: new LazyModule(() => require('./aiguard')),
       iast: new LazyModule(() => require('./appsec/iast')),
       llmobs: new LazyModule(() => require('./llmobs')),
       rewriter: new LazyModule(() => require('./appsec/iast/taint-tracking/rewriter')),
@@ -272,7 +273,9 @@ class Tracer extends NoopProxy {
         this.dataStreamsCheckpointer = this._tracer.dataStreamsCheckpointer
         lazyProxy(this, 'appsec', () => require('./appsec/sdk'), this._tracer, config)
         lazyProxy(this, 'llmobs', () => require('./llmobs/sdk'), this._tracer, this._modules.llmobs, config)
+
         if (config.experimental?.aiguard?.enabled) {
+          this._modules.aiguard.enable(this._tracer, config)
           lazyProxy(this, 'aiguard', () => require('./aiguard/sdk'), this._tracer, config)
         }
         this._tracingInitialized = true
@@ -287,6 +290,7 @@ class Tracer extends NoopProxy {
       // This needs to be after the IAST module is enabled
     } else if (this._tracingInitialized) {
       this._modules.appsec.disable()
+      this._modules.aiguard.disable()
       this._modules.iast.disable()
       this._modules.llmobs.disable()
       this._modules.openfeature.disable()

package/packages/dd-trace/src/startup-log.js

@@ -63,6 +63,14 @@ function logAgentError (agentError) {
   }
 }
 
+function logGenericError (message) {
+  if (!config?.startupLogs) {
+    return
+  }
+
+  warn('DATADOG TRACER DIAGNOSTIC - Generic Error: ' + message)
+}
+
 /**
  * Returns config info without integrations (used by startupLog).
  * @returns {Record<string, unknown>}
@@ -143,4 +151,5 @@ module.exports = {
   setSamplingRules,
   tracerInfo,
   errors,
+  logGenericError,
 }