dd-trace 6.17.0 → 6.19.0

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

@@ -431,10 +431,74 @@ function getMessagesOutputMessages (body) {
   return convertAnthropicMessage({ role, content: body.content })
 }
 
+/**
+ * Combines Anthropic message stream events into regular output messages.
+ *
+ * Accumulates exactly the way the SDK does: every `content_block_start` appends a block, and
+ * deltas address blocks by position. Keying blocks by `event.index` instead would let a repeated
+ * or out-of-range index hide output that the caller still receives.
+ *
+ * @param {Array<object>} events
+ * @returns {Array<object>}
+ */
+function getStreamedMessagesOutputMessages (events) {
+  let message
+  let contentBlocks
+  // Keyed by block, not by index: distinct indices can resolve to one block, and a second
+  // message must not inherit partial JSON accumulated for the first.
+  const inputJson = new Map()
+
+  for (const event of events) {
+    if (!event || typeof event !== 'object') continue
+
+    if (event.type === 'message_start' && event.message && typeof event.message === 'object') {
+      contentBlocks = Array.isArray(event.message.content)
+        ? event.message.content.map(block => ({ ...block }))
+        : []
+      message = { role: event.message.role || 'assistant' }
+      continue
+    }
+
+    if (event.type === 'content_block_start' && event.content_block && typeof event.content_block === 'object') {
+      message ??= { role: 'assistant' }
+      contentBlocks ??= []
+      contentBlocks.push({ ...event.content_block })
+      continue
+    }
+
+    if (event.type !== 'content_block_delta' || !event.delta || typeof event.delta !== 'object') continue
+
+    const block = contentBlocks?.at(event.index ?? 0)
+    if (!block) continue
+
+    if (event.delta.type === 'text_delta' && block.type === 'text' && typeof event.delta.text === 'string') {
+      block.text = (block.text || '') + event.delta.text
+    } else if (event.delta.type === 'input_json_delta' && typeof event.delta.partial_json === 'string') {
+      inputJson.set(block, (inputJson.get(block) || '') + event.delta.partial_json)
+    }
+  }
+
+  if (!message) return []
+
+  for (const [block, json] of inputJson) {
+    // An empty buffer is what a no-argument tool call accumulates; the SDK keeps `{}` there.
+    if (!json) continue
+    try {
+      block.input = JSON.parse(json)
+    } catch {
+      block.input = json
+    }
+  }
+
+  message.content = contentBlocks
+  return getMessagesOutputMessages(message)
+}
+
 module.exports = {
   convertAnthropicSystem,
   convertAnthropicBlocksToContent,
   convertAnthropicMessage,
   getMessagesInputMessages,
   getMessagesOutputMessages,
+  getStreamedMessagesOutputMessages,
 }

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

@@ -414,27 +414,21 @@ export interface GeneratedConfig {
   };
   dsmEnabled: boolean;
   dynamicInstrumentation: {
-    captureTimeoutMs: number;
-    enabled: boolean;
-    probeFile: string | undefined;
-    redactedIdentifiers: string[];
-    redactionExcludedIdentifiers: string[];
-    uploadIntervalSeconds: number;
+    DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS: number;
+    DD_DYNAMIC_INSTRUMENTATION_ENABLED: boolean;
+    DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE: string | undefined;
+    DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS: string[];
+    DD_DYNAMIC_INSTRUMENTATION_REDACTION_EXCLUDED_IDENTIFIERS: string[];
+    DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS: number;
   };
   env: string | undefined;
   experimental: {
     b3: boolean;
-    enableGetRumData: boolean;
-    exporter: string;
-    flaggingProvider: {
-      enabled: boolean;
-      initializationTimeoutMs: number;
-      spanEnrichment: {
-        enabled: boolean;
-      };
-    };
   };
   featureFlags: {
+    DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED: boolean;
+    DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS: number;
+    DD_EXPERIMENTAL_FLAGGING_PROVIDER_SPAN_ENRICHMENT_ENABLED: boolean;
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE: string;
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL: string | undefined;
     DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: number;
@@ -522,6 +516,9 @@ export interface GeneratedConfig {
     pollInterval: number;
   };
   reportHostname: boolean;
+  rum: {
+    DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED: boolean;
+  };
   runtimeMetrics: {
     enabled: boolean;
     eventLoop: boolean;
@@ -577,8 +574,8 @@ export interface GeneratedConfig {
     DD_CODE_COVERAGE_FLAGS: string | undefined;
     DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT: number | undefined;
     DD_TEST_FAILED_TEST_REPLAY_ENABLED: boolean;
-    DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean | undefined;
-    DD_TEST_FAILURE_VIDEOS_ENABLED: boolean | undefined;
+    DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean;
+    DD_TEST_FAILURE_VIDEOS_ENABLED: boolean;
     DD_TEST_FLEET_CONFIG_PATH: string | undefined;
     DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
     DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;
@@ -594,6 +591,9 @@ export interface GeneratedConfig {
   traceWebsocketMessagesEnabled: boolean;
   traceWebsocketMessagesInheritSampling: boolean;
   traceWebsocketMessagesSeparateTraces: boolean;
+  tracing: {
+    DD_TRACE_EXPERIMENTAL_EXPORTER: string;
+  };
   url: string | URL;
   version: string | undefined;
   vertexai: {
@@ -835,8 +835,8 @@ export interface GeneratedEnvVarConfig {
   DD_TELEMETRY_METRICS_ENABLED: boolean;
   DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT: number | undefined;
   DD_TEST_FAILED_TEST_REPLAY_ENABLED: boolean;
-  DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean | undefined;
-  DD_TEST_FAILURE_VIDEOS_ENABLED: boolean | undefined;
+  DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean;
+  DD_TEST_FAILURE_VIDEOS_ENABLED: boolean;
   DD_TEST_FLEET_CONFIG_PATH: string | undefined;
   DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
   DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: number;

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

@@ -370,8 +370,8 @@ class Config extends ConfigBase {
 
     if (this.featureFlags.DD_FEATURE_FLAGS_ENABLED &&
         !trackedConfigOrigins.has('featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE') &&
-        trackedConfigOrigins.has('experimental.flaggingProvider.enabled')) {
-      if (this.experimental.flaggingProvider.enabled) {
+        trackedConfigOrigins.has('featureFlags.DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED')) {
+      if (this.featureFlags.DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED) {
         setAndTrack(this, 'featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE', 'remote_config')
       } else {
         setAndTrack(this, 'featureFlags.DD_FEATURE_FLAGS_ENABLED', false)
@@ -505,7 +505,8 @@ class Config extends ConfigBase {
     // dd-trace's own sampling policy in that case.
     if (!trackedConfigOrigins.has('sampleRate') &&
         (trackedConfigOrigins.has('OTEL_TRACES_SAMPLER') ||
-          (this.OTEL_TRACES_EXPORTER === 'otlp' && this.experimental.exporter !== 'electron'))) {
+          (this.OTEL_TRACES_EXPORTER === 'otlp' &&
+            this.tracing.DD_TRACE_EXPERIMENTAL_EXPORTER !== 'electron'))) {
       setAndTrack(this, 'sampleRate',
         getFromOtelSamplerMap(this.OTEL_TRACES_SAMPLER, this.OTEL_TRACES_SAMPLER_ARG))
     }
@@ -638,7 +639,7 @@ class Config extends ConfigBase {
     }
 
     const isTestOptimizationWorker = this.isCiVisibility &&
-      TEST_OPTIMIZATION_WORKER_EXPORTERS.has(this.experimental.exporter)
+      TEST_OPTIMIZATION_WORKER_EXPORTERS.has(this.tracing.DD_TRACE_EXPERIMENTAL_EXPORTER)
     if (isTestOptimizationWorker) {
       setAndTrack(this, 'telemetry.DD_INSTRUMENTATION_TELEMETRY_ENABLED', false)
     }
@@ -651,7 +652,7 @@ class Config extends ConfigBase {
       setAndTrack(this, 'llmobs.DD_LLMOBS_AGENTLESS_ENABLED', true)
       setAndTrack(this, 'featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE', 'agentless')
       if (this.DD_API_KEY === undefined) {
-        setAndTrack(this, 'dynamicInstrumentation.enabled', false)
+        setAndTrack(this, 'dynamicInstrumentation.DD_DYNAMIC_INSTRUMENTATION_ENABLED', false)
       }
       setAndTrack(this, 'runtimeMetrics.enabled', false)
       setAndTrack(this, 'dsmEnabled', false)
@@ -667,7 +668,7 @@ class Config extends ConfigBase {
     }
 
     if (agentlessTracingEnabled && !this.isCiVisibility) {
-      setAndTrack(this, 'experimental.exporter', 'agentless')
+      setAndTrack(this, 'tracing.DD_TRACE_EXPERIMENTAL_EXPORTER', 'agentless')
       // Disable client-side stats computation
       setAndTrack(this, 'stats.DD_TRACE_STATS_COMPUTATION_ENABLED', false)
       // Enable hostname reporting

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

@@ -59,7 +59,7 @@
         "type": "boolean",
         "namespace": "aiguard",
         "default": "false",
-        "description": "Analyze streamed OpenAI and Vercel AI responses with AI Guard After Model evaluation."
+        "description": "Analyze streamed Anthropic, OpenAI, and Vercel AI responses with AI Guard After Model evaluation."
       }
     ],
     "DD_AI_GUARD_BLOCK": [
@@ -802,6 +802,7 @@
       {
         "implementation": "A",
         "type": "int",
+        "namespace": "dynamicInstrumentation",
         "configurationNames": [
           "dynamicInstrumentation.captureTimeoutMs"
         ],
@@ -812,6 +813,7 @@
       {
         "implementation": "A",
         "type": "boolean",
+        "namespace": "dynamicInstrumentation",
         "configurationNames": [
           "dynamicInstrumentation.enabled"
         ],
@@ -822,6 +824,7 @@
       {
         "implementation": "B",
         "type": "string",
+        "namespace": "dynamicInstrumentation",
         "configurationNames": [
           "dynamicInstrumentation.probeFile"
         ],
@@ -832,6 +835,7 @@
       {
         "implementation": "A",
         "type": "array",
+        "namespace": "dynamicInstrumentation",
         "configurationNames": [
           "dynamicInstrumentation.redactedIdentifiers"
         ],
@@ -842,6 +846,7 @@
       {
         "implementation": "C",
         "type": "array",
+        "namespace": "dynamicInstrumentation",
         "configurationNames": [
           "dynamicInstrumentation.redactionExcludedIdentifiers"
         ],
@@ -852,6 +857,7 @@
       {
         "implementation": "C",
         "type": "decimal",
+        "namespace": "dynamicInstrumentation",
         "configurationNames": [
           "dynamicInstrumentation.uploadIntervalSeconds"
         ],
@@ -890,6 +896,7 @@
       {
         "implementation": "A",
         "type": "int",
+        "namespace": "featureFlags",
         "configurationNames": [
           "experimental.flaggingProvider.initializationTimeoutMs"
         ],
@@ -900,6 +907,7 @@
       {
         "implementation": "A",
         "type": "boolean",
+        "namespace": "featureFlags",
         "configurationNames": [
           "experimental.flaggingProvider.enabled"
         ],
@@ -910,6 +918,7 @@
       {
         "implementation": "A",
         "type": "boolean",
+        "namespace": "featureFlags",
         "configurationNames": [
           "experimental.flaggingProvider.spanEnrichment.enabled"
         ],
@@ -2046,17 +2055,17 @@
     ],
     "DD_TEST_FAILURE_SCREENSHOTS_ENABLED": [
       {
-        "implementation": "A",
+        "implementation": "B",
         "type": "boolean",
-        "default": null,
+        "default": "true",
         "namespace": "testOptimization"
       }
     ],
     "DD_TEST_FAILURE_VIDEOS_ENABLED": [
       {
-        "implementation": "A",
+        "implementation": "B",
         "type": "boolean",
-        "default": null,
+        "default": "true",
         "namespace": "testOptimization"
       }
     ],
@@ -2871,6 +2880,7 @@
         "configurationNames": [
           "experimental.exporter"
         ],
+        "namespace": "tracing",
         "default": ""
       }
     ],
@@ -2881,6 +2891,7 @@
         "configurationNames": [
           "experimental.enableGetRumData"
         ],
+        "namespace": "rum",
         "default": "false"
       }
     ],

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

@@ -22,6 +22,8 @@ module.exports = {
   SPAN_SAMPLING_RULE_RATE: '_dd.span_sampling.rule_rate',
   SPAN_SAMPLING_MAX_PER_SECOND: '_dd.span_sampling.max_per_second',
   SVC_SRC_KEY: '_dd.svc_src',
+  SDK_OTLP_EXPORT_KEY: '_dd.sdk.otlp_export',
+  SDK_SEMANTICS_KEY: 'datadog.sdk.semantics',
   DATADOG_LAMBDA_EXTENSION_PATH: '/opt/extensions/datadog-agent',
   DATADOG_MINI_AGENT_PATH: '/tmp/datadog/mini_agent_ready',
   DECISION_MAKER_KEY: '_dd.p.dm',

package/packages/dd-trace/src/debugger/devtools_client/config.js

@@ -25,5 +25,6 @@ function updateConfig (updates) {
   // The worker receives a serialized config (see ../config.js) where `url` is a string, so it is
   // reconstructed into a URL here rather than read directly off a Config instance.
   config.url = new URL(updates.url)
-  config.dynamicInstrumentation.captureTimeoutNs = BigInt(updates.dynamicInstrumentation.captureTimeoutMs) * 1_000_000n
+  config.dynamicInstrumentation.captureTimeoutNs =
+    BigInt(updates.dynamicInstrumentation.DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS) * 1_000_000n
 }

package/packages/dd-trace/src/debugger/devtools_client/send.js

@@ -32,7 +32,7 @@ setInputPath(config.inputPath)
 const jsonBuffer = new JSONBuffer({
   size: config.maxTotalPayloadSize,
   maxQueueBytes: config.queueMaxBytes,
-  timeout: config.dynamicInstrumentation.uploadIntervalSeconds * 1000,
+  timeout: config.dynamicInstrumentation.DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS * 1000,
   onFlush,
 })
 

package/packages/dd-trace/src/debugger/devtools_client/snapshot/redaction.js

@@ -2,8 +2,10 @@
 
 const config = require('../config')
 
-const excludedIdentifiers = new Set(config.dynamicInstrumentation.redactionExcludedIdentifiers
-  .map((name) => normalizeName(name)))
+const excludedIdentifiers = new Set(
+  config.dynamicInstrumentation.DD_DYNAMIC_INSTRUMENTATION_REDACTION_EXCLUDED_IDENTIFIERS
+    .map((name) => normalizeName(name))
+)
 
 const REDACTED_IDENTIFIERS = new Set(
   [
@@ -95,7 +97,7 @@ const REDACTED_IDENTIFIERS = new Set(
     'x_forwarded_for',
     'x_real_ip',
     'XSRF-TOKEN',
-    ...config.dynamicInstrumentation.redactedIdentifiers,
+    ...config.dynamicInstrumentation.DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS,
   ]
     .map(normalizeIdentifier)
     .filter(isIncludedIdentifier)

package/packages/dd-trace/src/debugger/devtools_client/status.js

@@ -35,7 +35,7 @@ const cache = new TTLSet(60 * 60 * 1000) // 1 hour
 const jsonBuffer = new JSONBuffer({
   size: config.maxTotalPayloadSize,
   maxQueueBytes: DIAGNOSTICS_QUEUE_MAX_BYTES,
-  timeout: config.dynamicInstrumentation.uploadIntervalSeconds * 1000,
+  timeout: config.dynamicInstrumentation.DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS * 1000,
   onFlush,
 })
 

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

@@ -96,7 +96,7 @@ function start (config, rcInstance) {
 
   const probeSamplerBuffer = installProbeSampler(guardrailMetrics)
 
-  readProbeFile(config.dynamicInstrumentation.probeFile, (probes) => {
+  readProbeFile(config.dynamicInstrumentation.DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE, (probes) => {
     const action = 'apply'
     for (const probe of probes) {
       probeChannel.port2.postMessage({ action, probe })

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

@@ -1,6 +1,8 @@
 'use strict'
 
 module.exports = {
+  EVP_ORIGIN_HEADER_NAME: 'DD-EVP-ORIGIN',
+  EVP_ORIGIN_VERSION_HEADER_NAME: 'DD-EVP-ORIGIN-VERSION',
   EVP_PROXY_PATH_V2: '/evp_proxy/v2',
   EVP_PROXY_PATH_V4: '/evp_proxy/v4',
   EVP_SUBDOMAIN_HEADER_NAME: 'X-Datadog-EVP-Subdomain',

package/packages/dd-trace/src/evp_proxy/direct.js

@@ -3,6 +3,8 @@
 const { createSiteUrl } = require('../exporters/common/url')
 const log = require('../log')
 
+let invalidSiteWarningLogged = false
+
 /**
  * @typedef {object} DirectEVPRoute
  * @property {URL} url - Direct intake URL
@@ -21,21 +23,23 @@ const log = require('../log')
  */
 function createDirectEVPRoute (config, intake) {
   const apiKey = config.DD_API_KEY
-  if (!apiKey || !config.site) return
-
-  try {
-    const url = createSiteUrl(config.site, intake)
-    if (url === undefined) throw new Error('Invalid direct EVP intake URL')
+  if (!apiKey) return
 
-    return {
-      url,
-      basePath: '',
-      headers: {
-        'DD-API-KEY': apiKey,
-      },
+  const url = createSiteUrl(config.site, intake)
+  if (url === undefined) {
+    if (!invalidSiteWarningLogged) {
+      invalidSiteWarningLogged = true
+      log.warn('Feature Flags direct event delivery is disabled because DD_SITE is invalid.')
     }
-  } catch (error) {
-    log.debug('Unable to configure direct EVP intake: %s', error.message)
+    return
+  }
+
+  return {
+    url,
+    basePath: '',
+    headers: {
+      'DD-API-KEY': apiKey,
+    },
   }
 }
 

package/packages/dd-trace/src/evp_proxy/discovery.js

@@ -2,7 +2,7 @@
 
 const { fetchAgentInfo } = require('../agent/info')
 const log = require('../log')
-const { stripTrailingSlashes } = require('./path')
+const { joinAgentURLPath, stripTrailingSlashes } = require('./path')
 
 /**
  * Receiver discovery contract
@@ -25,13 +25,13 @@ const { stripTrailingSlashes } = require('./path')
  * serverless-init image or deployment type.
  *
  * This module only discovers a candidate route. A missing or unresponsive
- * `/info` endpoint returns an error through the shared request timeout and
- * retry policy. A valid response without a compatible path returns no route.
+ * `/info` endpoint returns an error after the request's bounded retry policy.
+ * Callers can disable retries to make discovery a single attempt. A valid
+ * response without a compatible path returns no route.
  * Discovery sends no events, so the caller can safely select direct intake
  * after either result. The caller also owns later delivery failures. Exposure
- * delivery uses retries and can therefore produce duplicates. After local
- * retries fail, the caller can retry through direct intake and use that route
- * for future batches.
+ * delivery decides whether a failed batch can be replayed and which route
+ * future batches use.
  *
  * Reference implementations:
  *
@@ -62,17 +62,17 @@ function selectEVPProxyPath (agentInfo, { supportedPaths, requiredHeaders = [] }
   }
 
   const allowedHeaders = agentInfo.evp_proxy_allowed_headers
-  if (allowedHeaders !== undefined) {
+  if (requiredHeaders.length > 0 || allowedHeaders !== undefined) {
     if (!Array.isArray(allowedHeaders)) return
 
     const normalizedHeaders = new Set()
     for (const header of allowedHeaders) {
       if (typeof header === 'string') {
-        normalizedHeaders.add(header.toLowerCase())
+        normalizedHeaders.add(header.trim().toLowerCase())
       }
     }
 
-    if (requiredHeaders.some(header => !normalizedHeaders.has(header.toLowerCase()))) {
+    if (requiredHeaders.some(header => !normalizedHeaders.has(header.trim().toLowerCase()))) {
       return
     }
   }
@@ -105,6 +105,7 @@ function selectEVPProxyPath (agentInfo, { supportedPaths, requiredHeaders = [] }
  * @param {string[]} options.supportedPaths - Supported paths in preference order
  * @param {string[]} [options.requiredHeaders] - Headers that the proxy must forward unchanged to intake. Each
  * header must appear in `evp_proxy_allowed_headers`. Do not include routing headers that the Agent consumes.
+ * @param {boolean} [options.retry] - Set false to disable the request's default bounded retries
  * @param {(error: Error|null, route?: {url: URL, basePath: string}) => void} callback - Result callback
  */
 function discoverEVPProxy (url, options, callback) {
@@ -121,7 +122,10 @@ function discoverEVPProxy (url, options, callback) {
     }
 
     log.debug('EVP proxy route %s discovered through the configured local receiver', basePath)
-    callback(null, { url, basePath })
+    callback(null, { url, basePath: joinAgentURLPath(url, basePath) })
+  }, {
+    path: joinAgentURLPath(url, '/info'),
+    retry: options.retry,
   })
 }
 

package/packages/dd-trace/src/evp_proxy/path.js

@@ -16,14 +16,28 @@ function stripTrailingSlashes (value) {
  *
  * This utility does not perform EVP proxy discovery.
  *
- * @param {string} basePath - EVP proxy base path
- * @param {string} endpoint - Product intake endpoint
+ * @param {...string} paths - URL path components
  */
-function joinEVPProxyPath (basePath, endpoint) {
-  const normalizedBasePath = stripTrailingSlashes(basePath)
-  const normalizedEndpoint = endpoint.replace(LEADING_SLASHES, '')
+function joinEVPProxyPath (...paths) {
+  let joined = ''
+  for (const path of paths) {
+    const normalized = stripTrailingSlashes(path).replace(LEADING_SLASHES, '')
+    if (normalized) joined += `/${normalized}`
+  }
 
-  return `${normalizedBasePath}/${normalizedEndpoint}`
+  return joined || '/'
 }
 
-module.exports = { joinEVPProxyPath, stripTrailingSlashes }
+/**
+ * Joins an HTTP Agent URL path prefix with an EVP proxy path.
+ * Unix URL pathnames identify the socket itself and are not HTTP path prefixes.
+ *
+ * @param {URL} url - Configured Agent URL
+ * @param {...string} paths - EVP path components
+ */
+function joinAgentURLPath (url, ...paths) {
+  const prefix = url.protocol === 'http:' || url.protocol === 'https:' ? url.pathname : ''
+  return joinEVPProxyPath(prefix, ...paths)
+}
+
+module.exports = { joinAgentURLPath, joinEVPProxyPath, stripTrailingSlashes }

package/packages/dd-trace/src/exporters/common/url.js

@@ -5,6 +5,9 @@ const { format } = require('node:url')
 
 const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
 
+const DEFAULT_SITE = 'datadoghq.com'
+const DNS_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/
+
 /**
  * @param {string} hostname
  */
@@ -31,7 +34,11 @@ function canSendApiKey (protocol, hostname) {
  * @returns {URL | undefined}
  */
 function createSiteUrl (site, intake) {
-  const hostname = `${intake === undefined ? '' : `${intake}.`}${site}`.toLowerCase()
+  const normalizedSite = normalizeSite(site)
+  if (normalizedSite === undefined) return
+
+  const hostname = `${intake === undefined ? '' : `${intake}.`}${normalizedSite}`
+  if (hostname.length > 253) return
 
   try {
     const url = new URL(format({
@@ -53,6 +60,30 @@ function createSiteUrl (site, intake) {
   } catch {}
 }
 
+/**
+ * Normalizes a Datadog site as a DNS suffix.
+ *
+ * @param {string | undefined} site
+ * @returns {string | undefined}
+ */
+function normalizeSite (site) {
+  if (site === undefined) return DEFAULT_SITE
+  if (typeof site !== 'string') return
+  for (let index = 0; index < site.length; index++) {
+    if (site.charCodeAt(index) > 127) return
+  }
+
+  const normalized = site.trim().toLowerCase() || DEFAULT_SITE
+  if (normalized.length > 253) return
+
+  const labels = normalized.split('.')
+  for (const label of labels) {
+    if (!DNS_LABEL.test(label)) return
+  }
+
+  return normalized
+}
+
 /**
  * Convert an agent/intake URL into Node http(s) request options.
  *
@@ -80,4 +111,4 @@ function parseUrl (urlObjOrString) {
   return url
 }
 
-module.exports = { canSendApiKey, createSiteUrl, isLoopbackHost, parseUrl }
+module.exports = { canSendApiKey, createSiteUrl, isLoopbackHost, normalizeSite, parseUrl }

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

@@ -1,5 +1,14 @@
 'use strict'
 
+const INPUT_TOKENS_METRIC_KEY = 'input_tokens'
+const OUTPUT_TOKENS_METRIC_KEY = 'output_tokens'
+const TOTAL_TOKENS_METRIC_KEY = 'total_tokens'
+const CACHE_READ_INPUT_TOKENS_METRIC_KEY = 'cache_read_input_tokens'
+const CACHE_WRITE_INPUT_TOKENS_METRIC_KEY = 'cache_write_input_tokens'
+const CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY = 'ephemeral_5m_input_tokens'
+const CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY = 'ephemeral_1h_input_tokens'
+const REASONING_OUTPUT_TOKENS_METRIC_KEY = 'reasoning_output_tokens'
+
 module.exports = {
   SPAN_KINDS: ['llm', 'agent', 'workflow', 'task', 'tool', 'embedding', 'retrieval', 'experiment'],
   SPAN_KIND: '_ml_obs.meta.span.kind',
@@ -42,6 +51,7 @@ module.exports = {
   MODEL_NAME: '_ml_obs.meta.model_name',
   MODEL_PROVIDER: '_ml_obs.meta.model_provider',
   UNKNOWN_MODEL_PROVIDER: 'unknown',
+  DEFAULT_MODEL: 'custom',
 
   INPUT_DOCUMENTS: '_ml_obs.meta.input.documents',
   INPUT_MESSAGES: '_ml_obs.meta.input.messages',
@@ -52,14 +62,27 @@ module.exports = {
   OUTPUT_MESSAGES: '_ml_obs.meta.output.messages',
   OUTPUT_VALUE: '_ml_obs.meta.output.value',
 
-  INPUT_TOKENS_METRIC_KEY: 'input_tokens',
-  OUTPUT_TOKENS_METRIC_KEY: 'output_tokens',
-  TOTAL_TOKENS_METRIC_KEY: 'total_tokens',
-  CACHE_READ_INPUT_TOKENS_METRIC_KEY: 'cache_read_input_tokens',
-  CACHE_WRITE_INPUT_TOKENS_METRIC_KEY: 'cache_write_input_tokens',
-  CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY: 'ephemeral_5m_input_tokens',
-  CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY: 'ephemeral_1h_input_tokens',
-  REASONING_OUTPUT_TOKENS_METRIC_KEY: 'reasoning_output_tokens',
+  INPUT_TOKENS_METRIC_KEY,
+  OUTPUT_TOKENS_METRIC_KEY,
+  TOTAL_TOKENS_METRIC_KEY,
+  CACHE_READ_INPUT_TOKENS_METRIC_KEY,
+  CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
+  CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY,
+  CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY,
+  REASONING_OUTPUT_TOKENS_METRIC_KEY,
+
+  // integrations build metric objects with these camelCase spellings. Null prototype: a metric
+  // named after an `Object.prototype` member must not resolve to an inherited property.
+  METRIC_KEY_ALIASES: Object.assign(Object.create(null), {
+    inputTokens: INPUT_TOKENS_METRIC_KEY,
+    outputTokens: OUTPUT_TOKENS_METRIC_KEY,
+    totalTokens: TOTAL_TOKENS_METRIC_KEY,
+    cacheReadTokens: CACHE_READ_INPUT_TOKENS_METRIC_KEY,
+    cacheWriteTokens: CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
+    cacheWrite5mTokens: CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY,
+    cacheWrite1hTokens: CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY,
+    reasoningOutputTokens: REASONING_OUTPUT_TOKENS_METRIC_KEY,
+  }),
 
   DROPPED_IO_COLLECTION_ERROR: 'dropped_io',