dd-trace 5.117.0 → 5.118.0

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -20,6 +20,7 @@ const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../../plugins/util/tags'
 const { sendGitMetadata: sendGitMetadataRequest } = require('./git/git_metadata')
 
 const hostname = getHostname()
+const EMPTY_SETTINGS = Object.freeze({})
 
 function getTestConfigurationTags (tags) {
   if (!tags) {
@@ -308,60 +309,58 @@ class CiVisibilityExporter extends BufferingExporter {
   }
 
   // Takes into account potential kill switches
-  filterConfiguration (remoteConfiguration) {
-    if (!remoteConfiguration) {
-      return {}
-    }
+  filterConfiguration (remoteConfiguration = EMPTY_SETTINGS) {
+    const { testOptimization } = this._config
     const {
-      isCodeCoverageEnabled,
-      isSuitesSkippingEnabled,
-      isItrEnabled,
-      requireGit,
-      isEarlyFlakeDetectionEnabled,
+      DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED: isEarlyFlakeDetectionAllowed,
+      DD_CIVISIBILITY_FLAKY_RETRY_COUNT: flakyTestRetriesCount = 0,
+      DD_CIVISIBILITY_FLAKY_RETRY_ENABLED: isFlakyTestRetriesAllowed,
+      DD_CIVISIBILITY_IMPACTED_TESTS_DETECTION_ENABLED: isImpactedTestsAllowed,
+      DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT: earlyFlakeDetectionRetryCount,
+      DD_TEST_FAILED_TEST_REPLAY_ENABLED: isFailedTestReplayAllowed,
+      DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: configuredAttemptToFixRetries = 0,
+      DD_TEST_MANAGEMENT_ENABLED: isTestManagementAllowed,
+    } = testOptimization
+    const hasEarlyFlakeDetectionRetryCount = earlyFlakeDetectionRetryCount !== undefined
+    const configuredSlowTestRetries = remoteConfiguration.earlyFlakeDetectionSlowTestRetries ?? EMPTY_SETTINGS
+    const earlyFlakeDetectionSlowTestRetries = hasEarlyFlakeDetectionRetryCount
+      ? Object.freeze({
+        '5s': earlyFlakeDetectionRetryCount,
+        '10s': earlyFlakeDetectionRetryCount,
+        '30s': earlyFlakeDetectionRetryCount,
+        '5m': earlyFlakeDetectionRetryCount,
+      })
+      : Object.isFrozen(configuredSlowTestRetries)
+        ? configuredSlowTestRetries
+        : Object.freeze({ ...configuredSlowTestRetries })
+    const earlyFlakeDetectionNumRetries = hasEarlyFlakeDetectionRetryCount
+      ? earlyFlakeDetectionRetryCount
+      : remoteConfiguration.earlyFlakeDetectionNumRetries ?? 0
+    const testManagementAttemptToFixRetries =
+      remoteConfiguration.testManagementAttemptToFixRetries ?? configuredAttemptToFixRetries
+
+    return Object.freeze({
+      isCodeCoverageEnabled: remoteConfiguration.isCodeCoverageEnabled === true,
+      isSuitesSkippingEnabled: remoteConfiguration.isSuitesSkippingEnabled === true,
+      isItrEnabled: remoteConfiguration.isItrEnabled === true,
+      requireGit: remoteConfiguration.requireGit === true,
+      isEarlyFlakeDetectionEnabled:
+        remoteConfiguration.isEarlyFlakeDetectionEnabled === true && isEarlyFlakeDetectionAllowed === true,
       earlyFlakeDetectionNumRetries,
       earlyFlakeDetectionSlowTestRetries,
-      earlyFlakeDetectionFaultyThreshold,
-      isFlakyTestRetriesEnabled,
-      isDiEnabled,
-      isKnownTestsEnabled,
-      isTestManagementEnabled,
+      earlyFlakeDetectionFaultyThreshold: remoteConfiguration.earlyFlakeDetectionFaultyThreshold ?? 30,
+      isFlakyTestRetriesEnabled:
+        remoteConfiguration.isFlakyTestRetriesEnabled === true && isFlakyTestRetriesAllowed === true,
+      flakyTestRetriesCount,
+      isDiEnabled: remoteConfiguration.isDiEnabled === true && isFailedTestReplayAllowed === true,
+      isKnownTestsEnabled: remoteConfiguration.isKnownTestsEnabled === true,
+      isTestManagementEnabled:
+        remoteConfiguration.isTestManagementEnabled === true && isTestManagementAllowed === true,
       testManagementAttemptToFixRetries,
-      isImpactedTestsEnabled,
-      isCoverageReportUploadEnabled,
-    } = remoteConfiguration
-    const { testOptimization } = this._config
-    const earlyFlakeDetectionRetryCount =
-      testOptimization.DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT
-    const hasEarlyFlakeDetectionRetryCount = earlyFlakeDetectionRetryCount !== undefined
-    return {
-      isCodeCoverageEnabled,
-      isSuitesSkippingEnabled,
-      isItrEnabled,
-      requireGit,
-      isEarlyFlakeDetectionEnabled:
-        isEarlyFlakeDetectionEnabled && testOptimization.DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED,
-      earlyFlakeDetectionNumRetries:
-        hasEarlyFlakeDetectionRetryCount ? earlyFlakeDetectionRetryCount : earlyFlakeDetectionNumRetries,
-      earlyFlakeDetectionSlowTestRetries: hasEarlyFlakeDetectionRetryCount
-        ? {
-            '5s': earlyFlakeDetectionRetryCount,
-            '10s': earlyFlakeDetectionRetryCount,
-            '30s': earlyFlakeDetectionRetryCount,
-            '5m': earlyFlakeDetectionRetryCount,
-          }
-        : earlyFlakeDetectionSlowTestRetries,
-      earlyFlakeDetectionFaultyThreshold,
-      isFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled && testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_ENABLED,
-      flakyTestRetriesCount: testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_COUNT,
-      isDiEnabled: isDiEnabled && testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED,
-      isKnownTestsEnabled,
-      isTestManagementEnabled: isTestManagementEnabled && testOptimization.DD_TEST_MANAGEMENT_ENABLED,
-      testManagementAttemptToFixRetries:
-        testManagementAttemptToFixRetries ?? testOptimization.DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES,
       isImpactedTestsEnabled:
-        isImpactedTestsEnabled && testOptimization.DD_CIVISIBILITY_IMPACTED_TESTS_DETECTION_ENABLED,
-      isCoverageReportUploadEnabled,
-    }
+        remoteConfiguration.isImpactedTestsEnabled === true && isImpactedTestsAllowed === true,
+      isCoverageReportUploadEnabled: remoteConfiguration.isCoverageReportUploadEnabled === true,
+    })
   }
 
   sendGitMetadata (repositoryUrl) {

package/packages/dd-trace/src/ci-visibility/requests/get-library-configuration.js

@@ -12,12 +12,145 @@ const {
   TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE,
 } = require('../telemetry')
 const { writeSettingsToCache } = require('../test-optimization-cache')
-const { validateSettingsResponse } = require('../test-optimization-http-cache-schema')
+const { MAX_RETRIES, validateSettingsResponse } = require('../test-optimization-http-cache-schema')
 const request = require('./request')
 
 const DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES = 2
-const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
+const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = Object.freeze({
+  '5s': 10,
+  '10s': 5,
+  '30s': 3,
+  '5m': 2,
+})
 const DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD = 30
+const EARLY_FLAKE_DETECTION_RETRY_BUCKETS = Object.keys(DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES)
+
+/**
+ * @typedef {object} EarlyFlakeDetectionSettings
+ * @property {boolean} enabled
+ * @property {number} numRetries
+ * @property {Readonly<Record<string, number>>} slowTestRetries
+ * @property {number} faultyThreshold
+ */
+
+/**
+ * @typedef {object} TestManagementSettings
+ * @property {boolean} enabled
+ * @property {number|undefined} attemptToFixRetries
+ */
+
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isRecord (value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+function isNonNegativeInteger (value) {
+  return Number.isInteger(value) && value >= 0
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+function isRetryCount (value) {
+  return isNonNegativeInteger(value) && value <= MAX_RETRIES
+}
+
+/**
+ * @param {unknown} value
+ * @returns {Readonly<Record<string, number>>|undefined}
+ */
+function parseSlowTestRetries (value) {
+  if (!isRecord(value)) return
+
+  const slowTestRetries = {}
+  for (const bucket of EARLY_FLAKE_DETECTION_RETRY_BUCKETS) {
+    if (!Object.hasOwn(value, bucket)) continue
+
+    const retries = value[bucket]
+    if (!isRetryCount(retries)) return
+    slowTestRetries[bucket] = retries
+  }
+  return Object.freeze(slowTestRetries)
+}
+
+/**
+ * @param {unknown} value
+ * @param {boolean} isKnownTestsEnabled
+ * @returns {EarlyFlakeDetectionSettings}
+ */
+function parseEarlyFlakeDetectionSettings (value, isKnownTestsEnabled) {
+  if (!isRecord(value) || value.enabled !== true) {
+    return {
+      enabled: false,
+      numRetries: DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
+      slowTestRetries: DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
+      faultyThreshold: DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
+    }
+  }
+
+  let isValid = true
+  let numRetries = DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES
+  let slowTestRetries = DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES
+  if (Object.hasOwn(value, 'slow_test_retries')) {
+    const parsedSlowTestRetries = parseSlowTestRetries(value.slow_test_retries)
+    if (parsedSlowTestRetries) {
+      slowTestRetries = parsedSlowTestRetries
+      numRetries = parsedSlowTestRetries['5s'] ?? DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES
+    } else {
+      isValid = false
+    }
+  }
+
+  let faultyThreshold = DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD
+  if (Object.hasOwn(value, 'faulty_session_threshold')) {
+    if (isNonNegativeInteger(value.faulty_session_threshold) && value.faulty_session_threshold <= 100) {
+      faultyThreshold = value.faulty_session_threshold
+    } else {
+      isValid = false
+    }
+  }
+
+  return {
+    enabled: isKnownTestsEnabled && isValid,
+    numRetries,
+    slowTestRetries,
+    faultyThreshold,
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @returns {TestManagementSettings}
+ */
+function parseTestManagementSettings (value) {
+  if (!isRecord(value) || value.enabled !== true) {
+    return {
+      enabled: false,
+      attemptToFixRetries: undefined,
+    }
+  }
+
+  const attemptToFixRetries = value.attempt_to_fix_retries
+  if (attemptToFixRetries !== undefined && !isRetryCount(attemptToFixRetries)) {
+    return {
+      enabled: false,
+      attemptToFixRetries: undefined,
+    }
+  }
+
+  return {
+    enabled: true,
+    attemptToFixRetries,
+  }
+}
 
 function parseJsonResponse (rawJson) {
   return typeof rawJson === 'string' ? JSON.parse(rawJson) : rawJson
@@ -28,40 +161,35 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
   if (options.validateRequiredFields) {
     validateSettingsResponse(parsedResponse, options)
   }
-  const {
-    code_coverage: isCodeCoverageEnabled,
-    tests_skipping: isSuitesSkippingEnabled,
-    itr_enabled: isItrEnabled,
-    require_git: requireGit,
-    early_flake_detection: earlyFlakeDetectionConfig,
-    flaky_test_retries_enabled: isFlakyTestRetriesEnabled,
-    di_enabled: isDiEnabled,
-    known_tests_enabled: isKnownTestsEnabled,
-    test_management: testManagementConfig,
-    impacted_tests_enabled: isImpactedTestsEnabled,
-    coverage_report_upload_enabled: isCoverageReportUploadEnabled,
-  } = parsedResponse?.data?.attributes ?? parsedResponse
+  const parsedAttributes = parsedResponse?.data?.attributes ?? parsedResponse
+  if (!isRecord(parsedAttributes)) {
+    throw new TypeError('Invalid settings response: attributes must be an object')
+  }
+  const attributes = parsedAttributes
+  const isKnownTestsEnabled = attributes.known_tests_enabled === true
+  const isFlakyTestRetriesEnabled = attributes.flaky_test_retries_enabled === true
+  const earlyFlakeDetection = parseEarlyFlakeDetectionSettings(
+    attributes.early_flake_detection,
+    isKnownTestsEnabled
+  )
+  const testManagement = parseTestManagementSettings(attributes.test_management)
 
   const settings = {
-    isCodeCoverageEnabled,
-    isSuitesSkippingEnabled,
-    isItrEnabled,
-    requireGit,
-    isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
-    earlyFlakeDetectionNumRetries:
-      earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] ?? DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
-    earlyFlakeDetectionSlowTestRetries:
-      earlyFlakeDetectionConfig?.slow_test_retries ?? DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
-    earlyFlakeDetectionFaultyThreshold:
-      earlyFlakeDetectionConfig?.faulty_session_threshold ?? DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
+    isCodeCoverageEnabled: attributes.code_coverage === true,
+    isSuitesSkippingEnabled: attributes.tests_skipping === true,
+    isItrEnabled: attributes.itr_enabled === true,
+    requireGit: attributes.require_git === true,
+    isEarlyFlakeDetectionEnabled: earlyFlakeDetection.enabled,
+    earlyFlakeDetectionNumRetries: earlyFlakeDetection.numRetries,
+    earlyFlakeDetectionSlowTestRetries: earlyFlakeDetection.slowTestRetries,
+    earlyFlakeDetectionFaultyThreshold: earlyFlakeDetection.faultyThreshold,
     isFlakyTestRetriesEnabled,
-    isDiEnabled: isDiEnabled && isFlakyTestRetriesEnabled,
+    isDiEnabled: attributes.di_enabled === true && isFlakyTestRetriesEnabled,
     isKnownTestsEnabled,
-    isTestManagementEnabled: (testManagementConfig?.enabled ?? false),
-    testManagementAttemptToFixRetries:
-      testManagementConfig?.attempt_to_fix_retries,
-    isImpactedTestsEnabled,
-    isCoverageReportUploadEnabled: isCoverageReportUploadEnabled ?? false,
+    isTestManagementEnabled: testManagement.enabled,
+    testManagementAttemptToFixRetries: testManagement.attemptToFixRetries,
+    isImpactedTestsEnabled: attributes.impacted_tests_enabled === true,
+    isCoverageReportUploadEnabled: attributes.coverage_report_upload_enabled === true,
   }
 
   log.debug('Remote settings: %j', settings)
@@ -82,7 +210,7 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
     log.debug('Code coverage report upload was disabled by the environment variable')
   }
 
-  return settings
+  return Object.freeze(settings)
 }
 
 function getLibraryConfiguration ({

package/packages/dd-trace/src/ci-visibility/test-optimization-http-cache-schema.js

@@ -30,7 +30,7 @@ const RETRY_THRESHOLD_PATTERN = /^\d+(?:ms|s|m|h)$/
 const MAX_VALIDATION_MODULES = 1000
 const MAX_VALIDATION_SUITES = 10_000
 const MAX_VALIDATION_TESTS = 100_000
-const MAX_VALIDATION_RETRIES = 100
+const MAX_RETRIES = 100
 const MAX_VALIDATION_STRING_BYTES = 4096
 
 function isObject (value) {
@@ -75,7 +75,8 @@ function validateSettingsResponse (response, options = {}) {
   assertBooleanFields(attributes.test_management, ['enabled'], 'settings test_management')
   assertOptionalBoundedNumber(
     attributes.early_flake_detection.faulty_session_threshold,
-    'settings early_flake_detection faulty_session_threshold'
+    'settings early_flake_detection faulty_session_threshold',
+    { integer: true }
   )
   assertRetryMap(attributes.early_flake_detection.slow_test_retries)
   assertOptionalBoundedNumber(
@@ -216,8 +217,8 @@ function assertBooleanFields (object, keys, endpoint) {
 function assertOptionalBoundedNumber (value, endpoint, { integer = false } = {}) {
   if (value === undefined) return
   if (!Number.isFinite(value) || (integer && !Number.isInteger(value)) ||
-    value < 0 || value > MAX_VALIDATION_RETRIES) {
-    throw new TypeError(`Invalid ${endpoint}: value must be between 0 and ${MAX_VALIDATION_RETRIES}`)
+    value < 0 || value > MAX_RETRIES) {
+    throw new TypeError(`Invalid ${endpoint}: value must be between 0 and ${MAX_RETRIES}`)
   }
 }
 
@@ -249,6 +250,7 @@ function assertValidationString (value, field) {
 }
 
 module.exports = {
+  MAX_RETRIES,
   validateKnownTestsResponse,
   validateSettingsResponse,
   validateSkippableTestsResponse,

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -333,6 +333,7 @@ export interface GeneratedConfig {
   DD_TRACE_NODE_SERIALIZE_ENABLED: boolean;
   DD_TRACE_NYC_ENABLED: boolean;
   DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP: string;
+  DD_TRACE_OPENAI_AGENTS_ENABLED: boolean;
   DD_TRACE_OPENAI_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_PROJECT_OPENSEARCH_ENABLED: boolean;
@@ -1028,6 +1029,7 @@ export interface GeneratedEnvVarConfig {
   DD_TRACE_NODE_SERIALIZE_ENABLED: boolean;
   DD_TRACE_NYC_ENABLED: boolean;
   DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP: string;
+  DD_TRACE_OPENAI_AGENTS_ENABLED: boolean;
   DD_TRACE_OPENAI_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_PROJECT_OPENSEARCH_ENABLED: boolean;

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

@@ -3452,6 +3452,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_OPENAI_AGENTS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
     "DD_TRACE_OPENSEARCH_ENABLED": [
       {
         "implementation": "A",

package/packages/dd-trace/src/encode/span-stats.js

@@ -31,7 +31,7 @@ class SpanStatsEncoder extends AgentEncoder {
   }
 
   _encodeStat (bytes, stat) {
-    bytes.writeMapPrefix(15)
+    bytes.writeMapPrefix(17)
 
     this._encodeString(bytes, 'Service')
     const service = stat.Service || DEFAULT_SERVICE_NAME
@@ -79,6 +79,12 @@ class SpanStatsEncoder extends AgentEncoder {
 
     this._encodeString(bytes, 'srv_src')
     this._encodeString(bytes, stat.srv_src || '')
+
+    this._encodeString(bytes, 'SpanKind')
+    this._encodeString(bytes, stat.SpanKind || '')
+
+    this._encodeString(bytes, 'GRPCStatusCode')
+    this._encodeString(bytes, stat.GRPCStatusCode || '')
   }
 
   _encodeBucket (bytes, bucket) {

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

@@ -4,6 +4,7 @@ const fs = require('fs')
 const exporters = require('../../../ext/exporters')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const constants = require('./constants')
+const { isTrue } = require('./util')
 
 module.exports = function getExporter (name) {
   switch (name) {
@@ -20,20 +21,26 @@ module.exports = function getExporter (name) {
     case exporters.AGENT_PROXY:
       return require('./ci-visibility/exporters/agent-proxy')
     case exporters.CI_VALIDATION:
-      return require('./ci-visibility/exporters/ci-validation')
+      if (hasCiValidationEnvironment()) return require('./ci-visibility/exporters/ci-validation')
+      break
     case exporters.JEST_WORKER:
     case exporters.CUCUMBER_WORKER:
     case exporters.MOCHA_WORKER:
     case exporters.PLAYWRIGHT_WORKER:
     case exporters.VITEST_WORKER:
       return require('./ci-visibility/exporters/test-worker')
-    default: {
-      const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
-      const usingAgent = inAWSLambda && (
-        fs.existsSync(constants.DATADOG_LAMBDA_EXTENSION_PATH) ||
-        fs.existsSync(constants.DATADOG_MINI_AGENT_PATH)
-      )
-      return inAWSLambda && !usingAgent ? require('./exporters/log') : require('./exporters/agent')
-    }
   }
+
+  const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
+  const usingAgent = inAWSLambda && (
+    fs.existsSync(constants.DATADOG_LAMBDA_EXTENSION_PATH) ||
+    fs.existsSync(constants.DATADOG_MINI_AGENT_PATH)
+  )
+  return inAWSLambda && !usingAgent ? require('./exporters/log') : require('./exporters/agent')
+}
+
+function hasCiValidationEnvironment () {
+  return isTrue(getEnvironmentVariable('_DD_TEST_OPTIMIZATION_VALIDATION_MODE')) &&
+    getEnvironmentVariable('_DD_TEST_OPTIMIZATION_VALIDATION_MANIFEST_FILE') &&
+    getEnvironmentVariable('_DD_TEST_OPTIMIZATION_VALIDATION_OUTPUT_DIR')
 }

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

@@ -16,6 +16,8 @@ const {
   SAMPLING_DECISION,
   PROPAGATED_SAMPLE_RATE_KEY,
   PROPAGATED_SAMPLING_DECISION_KEY,
+  TRACE_ID,
+  PROPAGATED_TRACE_ID_KEY,
 } = require('./constants/tags')
 const { storage } = require('./storage')
 const telemetry = require('./telemetry')
@@ -25,6 +27,7 @@ const LLMObsTagger = require('./tagger')
 const LLMObsSpanWriter = require('./writers/spans')
 const { setAgentStrategy } = require('./writers/util')
 const { INCOMPATIBLE_INITIALIZATION } = require('./constants/text')
+const { llmObsTraceIdToWire } = require('./util')
 
 const spanFinishCh = channel('dd-trace:span:finish')
 const evalMetricAppendCh = channel('llmobs:eval-metric:append')
@@ -137,8 +140,12 @@ function handleLLMObsInjection ({ carrier }) {
     mlObsSpanTags?.[SESSION_ID] ??
     parentContext?._trace?.tags?.[SESSION_ID_TRACE_DEFAULT_KEY] ??
     parentContext?._trace?.tags?.[PROPAGATED_SESSION_ID_KEY]
+  const llmobsTraceId = mlObsSpanTags?.[TRACE_ID]
+  const propagatedTraceId = llmobsTraceId === undefined
+    ? parentContext?._trace?.tags?.[PROPAGATED_TRACE_ID_KEY]
+    : llmObsTraceIdToWire(llmobsTraceId)
 
-  if (!parentId && !mlApp && samplingDecision == null && !sessionId) return
+  if (!parentId && !mlApp && samplingDecision == null && !sessionId && !propagatedTraceId) return
 
   // `_injectTags` only writes `x-datadog-tags` when the trace has `_dd.p.*`
   // tags, so it may be undefined here — coalesce before appending.
@@ -149,6 +156,7 @@ function handleLLMObsInjection ({ carrier }) {
   if (sessionId) tags += `${tags ? ',' : ''}${PROPAGATED_SESSION_ID_KEY}=${sessionId}`
   if (sampleRate != null) tags += `${tags ? ',' : ''}${PROPAGATED_SAMPLE_RATE_KEY}=${sampleRate}`
   if (samplingDecision != null) tags += `${tags ? ',' : ''}${PROPAGATED_SAMPLING_DECISION_KEY}=${samplingDecision}`
+  if (propagatedTraceId != null) tags += `${tags ? ',' : ''}${PROPAGATED_TRACE_ID_KEY}=${propagatedTraceId}`
   if (tags !== existing) carrier['x-datadog-tags'] = tags
 }
 

package/packages/dd-trace/src/llmobs/plugins/ai/util.js

@@ -13,6 +13,8 @@ const MODEL_METADATA_KEYS = new Set([
 const VERCEL_AI_TELEMETRY_METADATA_PREFIX = 'ai.telemetry.metadata.'
 const VERCEL_AI_MODEL_METADATA_PREFIX = 'gen_ai.request.'
 const VERCEL_AI_GENERATION_METADATA_PREFIX = 'ai.settings.'
+const UNPARSABLE_TOOL_RESULT = '[Unparsable Tool Result]'
+const UNSUPPORTED_TOOL_RESULT = '[Unsupported Tool Result]'
 
 /**
  * @typedef {import('../../../opentracing/span')} Span
@@ -26,8 +28,31 @@ const VERCEL_AI_GENERATION_METADATA_PREFIX = 'ai.settings.'
 
 /**
  * @typedef {{
- *   type: string,
- *   value?: unknown
+ *   type: 'text',
+ *   text: string
+ * } | {
+ *   type: 'media' | 'file',
+ *   mediaType: string
+ * } | {
+ *   type: 'file-data' | 'file-url' | 'file-id' | 'file-reference'
+ * } | {
+ *   type: 'image-data' | 'image-url' | 'image-file-id' | 'image-file-reference'
+ * } | {
+ *   type: 'custom'
+ * }} ToolCallContentPart
+ *
+ * @typedef {{
+ *   type: 'text' | 'error-text',
+ *   value: string
+ * } | {
+ *   type: 'json' | 'error-json',
+ *   value: unknown
+ * } | {
+ *   type: 'content',
+ *   value: ToolCallContentPart[]
+ * } | {
+ *   type: 'execution-denied',
+ *   reason?: string
  * }} ToolCallOutput
  *
  * @typedef {{ output?: ToolCallOutput, result?: unknown } & Record<string, unknown>} ToolCallResultContent
@@ -304,32 +329,89 @@ function getToolNameFromTags (tags) {
 }
 
 /**
- * Get the content of a tool call result.
- * Version 5 of the ai sdk sets this tag as `content.output`, with a `
- * @param {{ output?: { type: string, value: unknown }, result?: unknown }} content
+ * @param {unknown} value
+ * @returns {string}
+ */
+function stringifyToolCallResult (value) {
+  return JSON.stringify(value) ?? UNPARSABLE_TOOL_RESULT
+}
+
+/**
+ * @param {ToolCallContentPart[]} value
+ * @returns {string}
+ */
+function formatToolCallContent (value) {
+  if (!Array.isArray(value)) return UNPARSABLE_TOOL_RESULT
+
+  let result = ''
+  for (const part of value) {
+    if (typeof part !== 'object' || part === null) return UNPARSABLE_TOOL_RESULT
+
+    const { type } = part
+    if (type === 'text') {
+      if (typeof part.text !== 'string') return UNPARSABLE_TOOL_RESULT
+      result += part.text
+    } else if (type === 'media' || type === 'file') {
+      const { mediaType } = part
+      if (typeof mediaType !== 'string') return UNPARSABLE_TOOL_RESULT
+      result += mediaType === 'image' || mediaType.startsWith('image/') ? '[Image]' : '[File]'
+    } else if (
+      type === 'file-data' ||
+      type === 'file-url' ||
+      type === 'file-id' ||
+      type === 'file-reference'
+    ) {
+      result += '[File]'
+    } else if (
+      type === 'image-data' ||
+      type === 'image-url' ||
+      type === 'image-file-id' ||
+      type === 'image-file-reference'
+    ) {
+      result += '[Image]'
+    } else if (type === 'custom') {
+      result += '[Custom Content]'
+    } else {
+      return UNPARSABLE_TOOL_RESULT
+    }
+  }
+
+  return result
+}
+
+/**
+ * @param {ToolCallResultContent | null | undefined} content
  * @returns {string}
  */
 function getToolCallResultContent (content) {
-  const { output, result } = content
-  if (output) {
-    if (output.type === 'text') {
-      return output.value
-    } else if (output.type === 'json') {
-      return JSON.stringify(output.value)
+  try {
+    if (typeof content !== 'object' || content === null) return UNPARSABLE_TOOL_RESULT
+
+    const { output, result } = content
+    if (output !== undefined) {
+      if (typeof output !== 'object' || output === null) return UNPARSABLE_TOOL_RESULT
+
+      const { type, value } = output
+      if (type === 'text' || type === 'error-text') {
+        return typeof value === 'string' ? value : UNPARSABLE_TOOL_RESULT
+      } else if (type === 'json' || type === 'error-json') {
+        return stringifyToolCallResult(value)
+      } else if (type === 'content') {
+        return formatToolCallContent(value)
+      } else if (type === 'execution-denied') {
+        const { reason } = output
+        if (reason === undefined) return '[Tool Execution Denied]'
+        return typeof reason === 'string' ? reason : UNPARSABLE_TOOL_RESULT
+      }
+      return UNPARSABLE_TOOL_RESULT
     }
-    return '[Unparsable Tool Result]'
-  } else if (result) {
-    if (typeof result === 'string') {
-      return result
+    if (result !== undefined) {
+      return typeof result === 'string' ? result : stringifyToolCallResult(result)
     }
 
-    try {
-      return JSON.stringify(result)
-    } catch {
-      return '[Unparsable Tool Result]'
-    }
-  } else {
-    return '[Unsupported Tool Result]'
+    return UNSUPPORTED_TOOL_RESULT
+  } catch {
+    return UNPARSABLE_TOOL_RESULT
   }
 }