dd-trace 5.96.0 → 5.97.0

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -23,6 +23,9 @@ class Crashtracker {
     }
   }
 
+  /**
+   * @param {import('../config/config-base')} config - Tracer configuration
+   */
   start (config) {
     if (this.#started) return this.configure(config)
 
@@ -35,7 +38,7 @@ class Crashtracker {
         this.#getMetadata(config)
       )
     } catch (e) {
-      log.error('Error initialising crashtracker', e)
+      log.error('Error initializing crashtracker', e)
     }
   }
 
@@ -49,6 +52,9 @@ class Crashtracker {
   }
 
   // TODO: Send only configured values when defaults are fixed.
+  /**
+   * @param {import('../config/config-base')} config - Tracer configuration
+   */
   #getConfig (config) {
     const url = getAgentUrl(config)
 

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

@@ -1,15 +1,9 @@
 'use strict'
 
-const { existsSync } = require('node:fs')
 const { isMainThread } = require('worker_threads')
 const log = require('../log')
 
-// libdatadog v29 crashtracker segfaults during init on ARM64 musl (Alpine).
-// The segfault bypasses JS try/catch so we must avoid loading it entirely.
-// See: https://github.com/DataDog/libdatadog-nodejs/issues/114
-const isArm64Musl = process.arch === 'arm64' && existsSync('/etc/alpine-release')
-
-if (isMainThread && !isArm64Musl) {
+if (isMainThread) {
   try {
     module.exports = require('./crashtracker')
   } catch (e) {

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

@@ -147,7 +147,7 @@ function start (config, rcInstance) {
  * Sends the new configuration to the worker thread via the config channel.
  * Does nothing if the worker is not started.
  *
- * @param {Config} config - The updated tracer configuration object
+ * @param {import('../config/config-base')} config - The updated tracer configuration object
  */
 function configure (config) {
   if (configChannel === null) return

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

@@ -1,13 +1,11 @@
 'use strict'
 
-const lookup = require('dns').lookup // cache to avoid instrumentation
 const dgram = require('dgram')
 const isIP = require('net').isIP
 
 const request = require('./exporters/common/request')
 const log = require('./log')
 const Histogram = require('./histogram')
-const defaults = require('./config/defaults')
 const { getAgentUrl } = require('./agent/url')
 const { entityId } = require('./exporters/common/docker')
 
@@ -23,7 +21,9 @@ const TYPE_HISTOGRAM = 'h'
  * @implements {DogStatsD}
  */
 class DogStatsDClient {
-  constructor (options = {}) {
+  #lookup
+  constructor (options) {
+    this.#lookup = options.lookup
     if (options.metricsProxyUrl) {
       this._httpOptions = {
         method: 'POST',
@@ -32,11 +32,10 @@ class DogStatsDClient {
       }
     }
 
-    this._host = options.host || defaults['dogstatsd.hostname']
+    this._host = options.host
     this._family = isIP(this._host)
-    this._port = options.port || defaults['dogstatsd.port']
-    this._prefix = options.prefix || ''
-    this._tags = options.tags || []
+    this._port = options.port
+    this._tags = options.tags
     this._queue = []
     this._buffer = ''
     this._offset = 0
@@ -99,7 +98,7 @@ class DogStatsDClient {
 
   _sendUdp (queue) {
     if (this._family === 0) {
-      lookup(this._host, (err, address, family) => {
+      this.#lookup(this._host, (err, address, family) => {
         if (err) return log.error('DogStatsDClient: Host not found', err)
         this._sendUdpFromQueue(queue, address, family)
       })
@@ -118,7 +117,7 @@ class DogStatsDClient {
   }
 
   _add (stat, value, type, tags) {
-    let message = `${this._prefix + stat}:${value}|${type}`
+    let message = `${stat}:${value}|${type}`
 
     // Don't manipulate this._tags as it is still used
     tags = tags ? [...this._tags, ...tags] : this._tags
@@ -164,6 +163,9 @@ class DogStatsDClient {
     return socket
   }
 
+  /**
+   * @param {import('./config/config-base')} config - Tracer configuration
+   */
   static generateClientConfig (config) {
     const tags = []
 
@@ -183,6 +185,7 @@ class DogStatsDClient {
       host: config.dogstatsd.hostname,
       port: config.dogstatsd.port,
       tags,
+      lookup: config.lookup,
     }
 
     if (config.url || config.port) {

package/packages/dd-trace/src/encode/0.4.js

@@ -140,7 +140,7 @@ class AgentEncoder {
     this._traceBytes.length = 0
     this._stringCount = 0
     this._stringBytes.length = 0
-    this._stringMap = {}
+    this._stringMap = Object.create(null)
 
     this._cacheString('')
   }

package/packages/dd-trace/src/exporters/agent/writer.js

@@ -1,6 +1,8 @@
 'use strict'
 
 const { inspect } = require('node:util')
+const { channel } = require('dc-polyfill')
+
 const request = require('../common/request')
 const { logIntegrations, logAgentError } = require('../../startup-log')
 const runtimeMetrics = require('../../runtime_metrics')
@@ -10,10 +12,14 @@ const BaseWriter = require('../common/writer')
 const propagationHash = require('../../propagation-hash')
 
 const METRIC_PREFIX = 'datadog.tracer.node.exporter.agent'
+const firstFlushChannel = channel('dd-trace:exporter:first-flush')
 
 class AgentWriter extends BaseWriter {
   constructor (...args) {
-    super(...args)
+    super({
+      ...args[0],
+      beforeFirstFlush: () => firstFlushChannel.publish(),
+    })
     const { prioritySampler, lookup, protocolVersion, headers, config = {} } = args[0]
     const AgentEncoder = getEncoder(protocolVersion)
 

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

@@ -18,6 +18,10 @@ const maxActiveBufferSize = 1024 * 1024 * 64
 
 let activeBufferSize = 0
 
+/**
+ * @param {string|URL|object} urlObjOrString
+ * @returns {object}
+ */
 function parseUrl (urlObjOrString) {
   if (urlObjOrString !== null && typeof urlObjOrString === 'object') return urlToHttpOptions(urlObjOrString)
 
@@ -33,6 +37,11 @@ function parseUrl (urlObjOrString) {
   return url
 }
 
+/**
+ * @param {Buffer|string|Readable|Array<Buffer|string>} data
+ * @param {object} options
+ * @param {(error: Error|null, result: string, statusCode: number) => void} callback
+ */
 function request (data, options, callback) {
   if (!options.headers) {
     options.headers = {}

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

@@ -1,14 +1,21 @@
 'use strict'
 
+const { channel } = require('dc-polyfill')
+
 const log = require('../../log')
 const request = require('./request')
 const { safeJSONStringify } = require('./util')
 
+const firstFlushChannel = channel('dd-trace:exporter:first-flush')
+
 class Writer {
-  constructor ({ url }) {
+  constructor ({ url, beforeFirstFlush }) {
     this._url = url
+    this._beforeFirstFlush = beforeFirstFlush
   }
 
+  #isFirstFlush = true
+
   flush (done = () => {}) {
     const count = this._encoder.count()
 
@@ -16,8 +23,11 @@ class Writer {
       this._encoder.reset()
       done()
     } else if (count > 0) {
+      if (this.#isFirstFlush && firstFlushChannel.hasSubscribers && this._beforeFirstFlush) {
+        this.#isFirstFlush = false
+        this._beforeFirstFlush()
+      }
       const payload = this._encoder.makePayload()
-
       this._sendPayload(payload, count, done)
     } else {
       done()

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

@@ -45,6 +45,9 @@ function getName (destination) {
 }
 
 module.exports = {
+  /**
+   * @param {import('./config/config-base')} config - Tracer configuration
+   */
   async start (config) {
     const destination = config.heapSnapshot.destination
 

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { getValueFromEnvSources } = require('./config/helper')
-const { isFalse } = require('./util')
+const { isFalse, isTrue } = require('./util')
 
 // Global `jest` is only present in Jest workers.
 const inJestWorker = typeof jest !== 'undefined'
@@ -9,7 +9,10 @@ const inJestWorker = typeof jest !== 'undefined'
 const ddTraceDisabled = getValueFromEnvSources('DD_TRACE_ENABLED')
   ? isFalse(getValueFromEnvSources('DD_TRACE_ENABLED'))
   : String(getValueFromEnvSources('OTEL_TRACES_EXPORTER')).toLowerCase() === 'none'
+const shouldUseProxyWhenTracingDisabled =
+  isTrue(getValueFromEnvSources('DD_DYNAMIC_INSTRUMENTATION_ENABLED')) ||
+  isTrue(getValueFromEnvSources('DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED'))
 
-module.exports = ddTraceDisabled || inJestWorker
+module.exports = (ddTraceDisabled && !shouldUseProxyWhenTracingDisabled) || inJestWorker
   ? require('./noop/proxy')
   : require('./proxy')

package/packages/dd-trace/src/lambda/runtime/ritm.js

@@ -89,12 +89,12 @@ const registerLambdaHook = () => {
     const lambdaFilePaths = _getLambdaFilePaths(lambdaStylePath)
 
     // TODO: Redo this like any other instrumentation.
-    Hook(lambdaFilePaths, (moduleExports, name) => {
+    Hook(lambdaFilePaths, (moduleExports, name, _, moduleVersion) => {
       require('./patch')
 
       for (const { hook } of instrumentations[name]) {
         try {
-          moduleExports = hook(moduleExports)
+          moduleExports = hook(moduleExports, moduleVersion) ?? moduleExports
         } catch (e) {
           log.error('Error executing lambda hook', e)
         }
@@ -104,16 +104,16 @@ const registerLambdaHook = () => {
     })
   } else {
     const moduleToPatch = 'datadog-lambda-js'
-    Hook([moduleToPatch], (moduleExports, moduleName, _) => {
+    Hook([moduleToPatch], (moduleExports, moduleName, _, moduleVersion) => {
       moduleName = moduleName.replace(pathSepExpr, '/')
 
       require('./patch')
 
-      for (const { name, file, hook } of instrumentations[moduleToPatch]) {
-        const fullFilename = filename(name, file)
+      for (const { file, hook } of instrumentations[moduleToPatch]) {
+        const fullFilename = filename(moduleToPatch, file)
         if (moduleName === fullFilename) {
           try {
-            moduleExports = hook(moduleExports)
+            moduleExports = hook(moduleExports, moduleVersion) ?? moduleExports
           } catch (e) {
             log.error('Error executing lambda hook for datadog-lambda-js', e)
           }

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

@@ -43,9 +43,12 @@ let spanWriter
 /** @type {LLMObsEvalMetricsWriter | null} */
 let evalWriter
 
-/** @type {import('../config')} */
+/** @type {import('../config/config-base')} */
 let globalTracerConfig
 
+/**
+ * @param {@type import('../config/config-base')} config
+ */
 function enable (config) {
   globalTracerConfig = config
 

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

@@ -18,6 +18,7 @@ const {
   getToolNameFromTags,
   getToolCallResultContent,
   getLlmObsSpanName,
+  getTelemetryMetadata,
 } = require('./util')
 
 /**
@@ -216,6 +217,9 @@ class VercelAILLMObsPlugin extends BaseLLMObsPlugin {
 
     this._tagger.tagEmbeddingIO(span, parsedInputs, output)
 
+    const metadata = getTelemetryMetadata(tags)
+    this._tagger.tagMetadata(span, metadata)
+
     const usage = tags['ai.usage.tokens']
     this._tagger.tagMetrics(span, {
       inputTokens: usage,
@@ -234,7 +238,7 @@ class VercelAILLMObsPlugin extends BaseLLMObsPlugin {
 
     this._tagger.tagTextIO(span, prompt, output)
 
-    const metadata = getGenerationMetadata(tags) ?? {}
+    const metadata = getGenerationMetadata(tags)
     metadata.schema = getJsonStringValue(tags['ai.schema'], {})
     this._tagger.tagMetadata(span, metadata)
   }

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

@@ -10,6 +10,10 @@ const MODEL_METADATA_KEYS = new Set([
   'stop_sequences',
 ])
 
+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.'
+
 /**
  * @typedef {import('../../../opentracing/span')} Span
  *
@@ -107,17 +111,29 @@ function getJsonStringValue (str, defaultValue) {
 
 /**
  * Get the model metadata from the span tags (top_p, top_k, temperature, etc.)
+ * Additionally, set telemetry metadata from manual telemetry tags.
  * @param {SpanTags} tags
  * @returns {Record<string, unknown> | null}
  */
 function getModelMetadata (tags) {
   /** @type {Record<string, unknown>} */
   const modelMetadata = {}
-  for (const metadata of MODEL_METADATA_KEYS) {
-    const metadataTagKey = `gen_ai.request.${metadata}`
-    const metadataValue = tags[metadataTagKey]
-    if (metadataValue) {
-      modelMetadata[metadata] = metadataValue
+  for (const tag of Object.keys(tags)) {
+    const isModelMetadata = tag.startsWith(VERCEL_AI_MODEL_METADATA_PREFIX)
+    if (isModelMetadata) {
+      const lastCommaPosition = tag.lastIndexOf('.')
+      const metadataKey = lastCommaPosition === -1 ? tag : tag.slice(lastCommaPosition + 1)
+      if (metadataKey && MODEL_METADATA_KEYS.has(metadataKey)) {
+        modelMetadata[metadataKey] = tags[tag]
+      }
+    } else {
+      const isTelemetryMetadata = tag.startsWith(VERCEL_AI_TELEMETRY_METADATA_PREFIX)
+      if (isTelemetryMetadata) {
+        const metadataKey = tag.slice(VERCEL_AI_TELEMETRY_METADATA_PREFIX.length)
+        if (metadataKey) {
+          modelMetadata[metadataKey] = tags[tag]
+        }
+      }
     }
   }
 
@@ -126,6 +142,7 @@ function getModelMetadata (tags) {
 
 /**
  * Get the generation metadata from the span tags (maxSteps, maxRetries, etc.)
+ * Additionally, set telemetry metadata from manual telemetry tags.
  * @param {SpanTags} tags
  * @returns {Record<string, unknown> | null}
  */
@@ -134,14 +151,24 @@ function getGenerationMetadata (tags) {
   const metadata = {}
 
   for (const tag of Object.keys(tags)) {
-    if (!tag.startsWith('ai.settings')) continue
-
-    const settingKey = tag.split('.').pop()
-    const transformedKey = settingKey.replaceAll(/[A-Z]/g, letter => '_' + letter.toLowerCase())
-    if (MODEL_METADATA_KEYS.has(transformedKey)) continue
+    const isGenerationMetadata = tag.startsWith(VERCEL_AI_GENERATION_METADATA_PREFIX)
+    if (isGenerationMetadata) {
+      const lastCommaPosition = tag.lastIndexOf('.')
+      const settingKey = lastCommaPosition === -1 ? tag : tag.slice(lastCommaPosition + 1)
+      const transformedKey = settingKey.replaceAll(/[A-Z]/g, letter => '_' + letter.toLowerCase())
+      if (MODEL_METADATA_KEYS.has(transformedKey)) continue
 
-    const settingValue = tags[tag]
-    metadata[settingKey] = settingValue
+      const settingValue = tags[tag]
+      metadata[settingKey] = settingValue
+    } else {
+      const isTelemetryMetadata = tag.startsWith(VERCEL_AI_TELEMETRY_METADATA_PREFIX)
+      if (isTelemetryMetadata) {
+        const metadataKey = tag.slice(VERCEL_AI_TELEMETRY_METADATA_PREFIX.length)
+        if (metadataKey) {
+          metadata[metadataKey] = tags[tag]
+        }
+      }
+    }
   }
 
   return Object.keys(metadata).length ? metadata : null
@@ -205,6 +232,26 @@ function getLlmObsSpanName (operation, functionId) {
   return functionId ? `${functionId}.${operation}` : operation
 }
 
+/**
+ * Get custom telemetry metadata from ai.telemetry.metadata.* attributes
+ * @param {Record<string, unknown>} tags
+ * @returns {Record<string, unknown> | null}
+ */
+function getTelemetryMetadata (tags) {
+  const metadata = {}
+
+  for (const tag of Object.keys(tags)) {
+    if (!tag.startsWith(VERCEL_AI_TELEMETRY_METADATA_PREFIX)) continue
+
+    const metadataKey = tag.slice(VERCEL_AI_TELEMETRY_METADATA_PREFIX.length)
+    if (metadataKey) {
+      metadata[metadataKey] = tags[tag]
+    }
+  }
+
+  return Object.keys(metadata).length ? metadata : null
+}
+
 module.exports = {
   getSpanTags,
   getOperation,
@@ -215,4 +262,5 @@ module.exports = {
   getToolNameFromTags,
   getToolCallResultContent,
   getLlmObsSpanName,
+  getTelemetryMetadata,
 }

package/packages/dd-trace/src/llmobs/plugins/bedrockruntime.js

@@ -65,10 +65,12 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
     telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: 'bedrock' })
 
     const parent = llmobsStore.getStore()?.span
+    // Use full modelId and unified provider for LLMObs (required for backend cost estimation).
+    // Split modelProvider/modelName from parseModelId() are still used below for response parsing.
     this._tagger.registerLLMObsSpan(span, {
       parent,
-      modelName: modelName.toLowerCase(),
-      modelProvider: modelProvider.toLowerCase(),
+      modelName: request.params.modelId.toLowerCase(),
+      modelProvider: 'amazon_bedrock',
       kind: 'llm',
       name: 'bedrock-runtime.command',
       integration: 'bedrock',

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

@@ -29,16 +29,23 @@ class LLMObs extends NoopLLMObs {
    */
   #hasUserSpanProcessor = false
 
+  /**
+   * @param {import('../tracer')} tracer - Tracer instance
+   * @param {import('./index')} llmobsModule - LLMObs module instance
+   * @param {import('../config/config-base')} config - Tracer configuration
+   */
   constructor (tracer, llmobsModule, config) {
     super(tracer)
 
+    /** @type {import('../config/config-base')} */
     this._config = config
+
     this._llmobsModule = llmobsModule
     this._tagger = new LLMObsTagger(config)
   }
 
   get enabled () {
-    return this._config.llmobs.enabled
+    return this._config.llmobs.enabled ?? false
   }
 
   enable (options = {}) {
@@ -56,13 +63,10 @@ class LLMObs extends NoopLLMObs {
       return
     }
 
-    const llmobs = {
-      mlApp: options.mlApp,
-      agentlessEnabled: options.agentlessEnabled,
-    }
-    // TODO: This will update config telemetry with the origin 'code', which is not ideal when `enable()` is called
-    // based on `APM_TRACING` RC product updates.
-    this._config.updateOptions({ llmobs })
+    // TODO: These configs should be passed through directly at construction time instead.
+    this._config.llmobs.enabled = true
+    this._config.llmobs.mlApp = options.mlApp
+    this._config.llmobs.agentlessEnabled = options.agentlessEnabled
 
     // configure writers and channel subscribers
     this._llmobsModule.enable(this._config)

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

@@ -49,7 +49,7 @@ class LLMObservabilitySpan {
 }
 
 class LLMObsSpanProcessor {
-  /** @type {import('../config')} */
+  /** @type {import('../config/config-base')} */
   #config
 
   /** @type {((span: LLMObservabilitySpan) => LLMObservabilitySpan | null) | null} */

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

@@ -47,8 +47,11 @@ const { storage } = require('./storage')
 const registry = new WeakMap()
 
 class LLMObsTagger {
+  /** @type {import('../config/config-base')} */
+  #config
+
   constructor (config, softFail = false) {
-    this._config = config
+    this.#config = config
 
     this.softFail = softFail
   }
@@ -72,15 +75,15 @@ class LLMObsTagger {
     integration,
     _decorator,
   } = {}) {
-    if (!this._config.llmobs.enabled) return
+    if (!this.#config.llmobs.enabled) return
     if (!kind) return // do not register it in the map if it doesn't have an llmobs span kind
 
     const spanMlApp =
       mlApp ||
       registry.get(parent)?.[ML_APP] ||
       span.context()._trace.tags[PROPAGATED_ML_APP_KEY] ||
-      this._config.llmobs.mlApp ||
-      this._config.service // this should always have a default
+      this.#config.llmobs.mlApp ||
+      this.#config.service // this should always have a default
 
     if (!spanMlApp) {
       throw new Error(
@@ -624,7 +627,7 @@ class LLMObsTagger {
   }
 
   _register (span) {
-    if (!this._config.llmobs.enabled) return
+    if (!this.#config.llmobs.enabled) return
     if (registry.has(span)) {
       this.#handleFailure(`LLMObs Span "${span._name}" already registered.`)
       return
@@ -634,7 +637,7 @@ class LLMObsTagger {
   }
 
   _setTag (span, key, value) {
-    if (!this._config.llmobs.enabled) return
+    if (!this.#config.llmobs.enabled) return
     if (!registry.has(span)) {
       this.#handleFailure(`Span "${span._name}" must be an LLMObs generated span.`)
       return

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -45,7 +45,9 @@ class BaseLLMObsWriter {
     /** @type {LLMObsBuffer} */
     this._buffer = new LLMObsBuffer({ events: [], size: 0, isDefault: true })
 
+    /** @type {import('../../config/config-base')} */
     this._config = config
+
     this._endpoint = endpoint
     this._baseEndpoint = endpoint // should not be unset
     this._intake = intake

package/packages/dd-trace/src/llmobs/writers/util.js

@@ -6,6 +6,9 @@ const telemetry = require('../telemetry')
 const { fetchAgentInfo } = require('../../agent/info')
 const { getAgentUrl } = require('../../agent/url')
 
+/**
+ * @param {import('../../config/config-base')} config
+ */
 function setAgentStrategy (config, setWritersAgentlessValue) {
   const agentlessEnabled = config.llmobs.agentlessEnabled