dd-trace 5.62.0 → 5.63.0

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

@@ -0,0 +1,179 @@
+'use strict'
+
+const MODEL_METADATA_KEYS = new Set([
+  'frequency_penalty',
+  'max_tokens',
+  'presence_penalty',
+  'temperature',
+  'top_p',
+  'top_k',
+  'stop_sequences'
+])
+
+/**
+ * Get the span tags from the context (either the attributes or the span tags).
+ *
+ * @param {Record<string, any>} ctx
+ * @returns {Record<string, any>}
+ */
+function getSpanTags (ctx) {
+  const span = ctx.currentStore?.span
+  const carrier = ctx.attributes ?? span?.context()._tags ?? {}
+  return carrier
+}
+
+/**
+ * Get the operation name from the span name
+ *
+ * @example
+ * span._name = 'ai.generateText'
+ * getOperation(span) // 'generateText'
+ *
+ * @example
+ * span._name = 'ai.generateText.doGenerate'
+ * getOperation(span) // 'doGenerate'
+ *
+ * @param {import('../../../opentracing/span')} span
+ * @returns {string}
+ */
+function getOperation (span) {
+  const name = span._name
+  if (!name) return
+
+  return name.split('.').pop()
+}
+
+/**
+ * Get the LLM token usage from the span tags
+ * @param {Record<string, string>} tags
+ * @returns {{inputTokens: number, outputTokens: number, totalTokens: number}}
+ */
+function getUsage (tags) {
+  const usage = {}
+  const inputTokens = tags['ai.usage.promptTokens']
+  const outputTokens = tags['ai.usage.completionTokens']
+
+  if (inputTokens != null) usage.inputTokens = inputTokens
+  if (outputTokens != null) usage.outputTokens = outputTokens
+
+  const totalTokens = inputTokens + outputTokens
+  if (!Number.isNaN(totalTokens)) usage.totalTokens = totalTokens
+
+  return usage
+}
+
+/**
+ * Safely JSON parses a string value with a default fallback
+ * @param {string} str
+ * @param {any} defaultValue
+ * @returns {Record<string, any> | string | Array<any>}
+ */
+function getJsonStringValue (str, defaultValue) {
+  let maybeValue = defaultValue
+  try {
+    maybeValue = JSON.parse(str)
+  } catch {
+    // do nothing
+  }
+
+  return maybeValue
+}
+
+/**
+ * Get the model metadata from the span tags (top_p, top_k, temperature, etc.)
+ * @param {import('../../../opentracing/span')} span
+ * @returns {Record<string, string> | null}
+ */
+function getModelMetadata (tags) {
+  const modelMetadata = {}
+  for (const metadata of MODEL_METADATA_KEYS) {
+    const metadataTagKey = `gen_ai.request.${metadata}`
+    const metadataValue = tags[metadataTagKey]
+    if (metadataValue) {
+      modelMetadata[metadata] = metadataValue
+    }
+  }
+
+  return Object.keys(modelMetadata).length ? modelMetadata : null
+}
+
+/**
+ * Get the generation metadata from the span tags (maxSteps, maxRetries, etc.)
+ * @param {Record<string, string>} tags
+ * @returns {Record<string, string> | null}
+ */
+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 settingValue = tags[tag]
+    metadata[settingKey] = settingValue
+  }
+
+  return Object.keys(metadata).length ? metadata : null
+}
+
+/**
+ * Get the tool name from the span tags.
+ * If the tool name is a parsable number, or is not found, null is returned.
+ * Older versions of the ai sdk would tag the tool name as its index in the tools array.
+ *
+ * @param {Record<string, string>} tags
+ * @returns {string | null}
+ */
+function getToolNameFromTags (tags) {
+  const toolName = tags['ai.toolCall.name']
+  if (!toolName) return null
+
+  const parsedToolName = Number.parseInt(toolName)
+  if (!Number.isNaN(parsedToolName)) return null
+
+  return toolName
+}
+
+/**
+ * Get the content of a tool call result.
+ * Version 5 of the ai sdk sets this tag as `content.output`, with a `
+ * @param {Record<string, any>} 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)
+    }
+    return '[Unparsable Tool Result]'
+  } else if (result) {
+    if (typeof result === 'string') {
+      return result
+    }
+
+    try {
+      return JSON.stringify(result)
+    } catch {
+      return '[Unparsable Tool Result]'
+    }
+  } else {
+    return '[Unsupported Tool Result]'
+  }
+}
+
+module.exports = {
+  getSpanTags,
+  getOperation,
+  getUsage,
+  getJsonStringValue,
+  getModelMetadata,
+  getGenerationMetadata,
+  getToolNameFromTags,
+  getToolCallResultContent
+}

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const request = require('../../exporters/common/request')
+const { getEnvironmentVariable } = require('../../config-helper')
 const { URL, format } = require('node:url')
 const path = require('node:path')
 
@@ -17,8 +18,8 @@ const { parseResponseAndLog } = require('./util')
 
 class BaseLLMObsWriter {
   constructor ({ interval, timeout, eventType, config, endpoint, intake }) {
-    this._interval = interval || 1000 // 1s
-    this._timeout = timeout || 5000 // 5s
+    this._interval = interval ?? getEnvironmentVariable('_DD_LLMOBS_FLUSH_INTERVAL') ?? 1000 // 1s
+    this._timeout = timeout ?? getEnvironmentVariable('_DD_LLMOBS_TIMEOUT') ?? 5000 // 5s
     this._eventType = eventType
 
     this._buffer = []

package/packages/dd-trace/src/opentracing/span_context.js

@@ -59,6 +59,10 @@ class DatadogSpanContext {
     return this._spanId.toString(10)
   }
 
+  toBigIntSpanId () {
+    return this._spanId.toBigInt()
+  }
+
   toTraceparent () {
     const flags = this._sampling.priority >= AUTO_KEEP ? '01' : '00'
     const traceId = this.toTraceId(true)

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { channel } = require('dc-polyfill')
-const { isFalse, normalizePluginEnvName } = require('./util')
+const { isFalse, isTrue, normalizePluginEnvName } = require('./util')
 const plugins = require('./plugins')
 const log = require('./log')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
@@ -32,8 +32,7 @@ loadChannel.subscribe(({ name }) => {
 function maybeEnable (Plugin) {
   if (!Plugin || typeof Plugin !== 'function') return
   if (!pluginClasses[Plugin.id]) {
-    const envName = `DD_TRACE_${Plugin.id.toUpperCase()}_ENABLED`
-    const enabled = getEnvironmentVariable(normalizePluginEnvName(envName))
+    const enabled = getEnvEnabled(Plugin)
 
     // TODO: remove the need to load the plugin class in order to disable the plugin
     if (isFalse(enabled) || disabledPlugins.has(Plugin.id)) {
@@ -46,6 +45,11 @@ function maybeEnable (Plugin) {
   }
 }
 
+function getEnvEnabled (Plugin) {
+  const envName = `DD_TRACE_${Plugin.id.toUpperCase()}_ENABLED`
+  return getEnvironmentVariable(normalizePluginEnvName(envName))
+}
+
 // TODO this must always be a singleton.
 module.exports = class PluginManager {
   constructor (tracer) {
@@ -74,7 +78,7 @@ module.exports = class PluginManager {
       this._pluginsByName[name] = new Plugin(this._tracer, this._tracerConfig)
     }
     const pluginConfig = this._configsByName[name] || {
-      enabled: this._tracerConfig.plugins !== false
+      enabled: this._tracerConfig.plugins !== false && (!Plugin.experimental || isTrue(getEnvEnabled(Plugin)))
     }
 
     // extracts predetermined configuration from tracer and combines it with plugin-specific config

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

@@ -26,6 +26,7 @@ module.exports = {
   get '@smithy/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@vitest/runner' () { return require('../../../datadog-plugin-vitest/src') },
   get aerospike () { return require('../../../datadog-plugin-aerospike/src') },
+  get ai () { return require('../../../datadog-plugin-ai/src') },
   get amqp10 () { return require('../../../datadog-plugin-amqp10/src') },
   get amqplib () { return require('../../../datadog-plugin-amqplib/src') },
   get avsc () { return require('../../../datadog-plugin-avsc/src') },

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

@@ -3,11 +3,14 @@
 const { BlockList } = require('net')
 const net = require('net')
 
+const FORWARED_HEADER_NAME = 'forwarded'
+
 const ipHeaderList = [
   'x-forwarded-for',
   'x-real-ip',
   'true-client-ip',
   'x-client-ip',
+  FORWARED_HEADER_NAME,
   'forwarded-for',
   'x-cluster-client-ip',
   'fastly-client-ip',
@@ -49,7 +52,8 @@ function extractIp (config, req) {
   let firstPrivateIp
   if (headers) {
     for (const ipHeaderName of ipHeaderList) {
-      const firstIp = findFirstIp(headers[ipHeaderName])
+      const header = headers[ipHeaderName]
+      const firstIp = ipHeaderName === FORWARED_HEADER_NAME ? findFirstIpForwardedFormat(header) : findFirstIp(header)
 
       if (firstIp.public) {
         return firstIp.public
@@ -62,6 +66,10 @@ function extractIp (config, req) {
   return firstPrivateIp || req.socket?.remoteAddress
 }
 
+function isPublicIp (ip, type) {
+  return !privateIPMatcher.check(ip, type === 6 ? 'ipv6' : 'ipv4')
+}
+
 function findFirstIp (str) {
   const result = {}
   if (!str) return result
@@ -76,10 +84,10 @@ function findFirstIp (str) {
     const type = net.isIP(chunk)
     if (!type) continue
 
-    if (!privateIPMatcher.check(chunk, type === 6 ? 'ipv6' : 'ipv4')) {
+    if (isPublicIp(chunk, type)) {
       // it's public, return it immediately
       result.public = chunk
-      break
+      return result
     }
 
     // it's private, only save the first one found
@@ -89,6 +97,39 @@ function findFirstIp (str) {
   return result
 }
 
+const forwardedForRegexp = /for="?\[?(([0-9]+\.)+[0-9]+|[0-9a-f:]*:[0-9a-f]*)/i
+const forwardedByRegexp = /by="?\[?(([0-9]+\.)+[0-9]+|[0-9a-f:]*:[0-9a-f]*)/i
+const forwardedRegexps = [forwardedForRegexp, forwardedByRegexp]
+
+function findFirstIpForwardedFormat (str) {
+  const result = {}
+  if (!str) return result
+
+  const splitted = str.split(',')
+
+  for (const part of splitted) {
+    const chunk = part.trim()
+
+    for (const regex of forwardedRegexps) {
+      const ip = regex.exec(chunk)?.[1]
+
+      const type = net.isIP(ip)
+      if (!type) continue
+
+      if (isPublicIp(ip, type)) {
+        // it's public, return it immediately
+        result.public = ip
+        return result
+      }
+
+      // it's private, only save the first one found
+      if (!result.private) result.private = ip
+    }
+  }
+
+  return result
+}
+
 module.exports = {
   extractIp,
   ipHeaderList

package/packages/dd-trace/src/profiling/profilers/event_plugins/event.js

@@ -7,54 +7,55 @@ const { performance } = require('perf_hooks')
 // start/error/finish methods to the appropriate diagnostic channels.
 // TODO: Decouple this from TracingPlugin.
 class EventPlugin extends TracingPlugin {
+  #eventHandler
+  #eventFilter
+  #dataSymbol
+  #entryType
+
   constructor (eventHandler, eventFilter) {
     super()
-    this.eventHandler = eventHandler
-    this.eventFilter = eventFilter
-    this.contextData = new WeakMap()
-    this.entryType = this.constructor.entryType
+    this.#eventHandler = eventHandler
+    this.#eventFilter = eventFilter
+    this.#entryType = this.constructor.entryType
+    this.#dataSymbol = Symbol(`dd-trace.profiling.event.${this.#entryType}.${this.constructor.operation}`)
   }
 
   start (ctx) {
-    this.contextData.set(ctx, {
-      startEvent: ctx,
-      startTime: performance.now()
-    })
+    ctx[this.#dataSymbol] = performance.now()
   }
 
   error (ctx) {
-    const data = this.contextData.get(ctx)
-    if (data) {
-      data.error = true
-    }
+    // We don't emit perf events for failed operations
+    ctx[this.#dataSymbol] = undefined
   }
 
   finish (ctx) {
-    const data = this.contextData.get(ctx)
-
-    if (!data) return
+    const startTime = ctx[this.#dataSymbol]
+    if (startTime === undefined) {
+      return
+    }
+    ctx[this.#dataSymbol] = undefined
 
-    const { startEvent, startTime, error } = data
-    if (error || this.ignoreEvent(startEvent)) {
-      return // don't emit perf events for failed operations or ignored events
+    if (this.ignoreEvent(ctx)) {
+      return // don't emit perf events for ignored events
     }
 
     const duration = performance.now() - startTime
     const event = {
-      entryType: this.entryType,
+      entryType: this.#entryType,
       startTime,
       duration
     }
 
-    if (!this.eventFilter(event)) {
+    if (!this.#eventFilter(event)) {
       return
     }
 
     const context = (ctx.currentStore?.span || this.activeSpan)?.context()
-    event._ddSpanId = context?.toSpanId()
-    event._ddRootSpanId = context?._trace.started[0]?.context().toSpanId() || event._ddSpanId
+    event._ddSpanId = context?.toBigIntSpanId()
+    event._ddRootSpanId = context?._trace.started[0]?.context().toBigIntSpanId() || event._ddSpanId
 
-    this.eventHandler(this.extendEvent(event, startEvent))
+    this.#eventHandler(this.extendEvent(event, ctx))
   }
 
   ignoreEvent () {

package/packages/dd-trace/src/profiling/profilers/events.js

@@ -273,10 +273,11 @@ class EventSerializer {
       new Label({ key: this.timestampLabelKey, num: dateOffset + BigInt(Math.round(endTime * MS_TO_NS)) })
     ]
     if (_ddSpanId) {
-      label.push(labelFromStr(this.stringTable, this.spanIdKey, _ddSpanId))
+      label.push(
+        new Label({ key: this.spanIdKey, num: _ddSpanId }))
     }
     if (_ddRootSpanId) {
-      label.push(labelFromStr(this.stringTable, this.rootSpanIdKey, _ddRootSpanId))
+      label.push(new Label({ key: this.rootSpanIdKey, num: _ddRootSpanId }))
     }
 
     const sampleInput = {

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -215,10 +215,10 @@ class NativeWallProfiler {
 
   _updateContext (context) {
     if (context.spanId !== null && typeof context.spanId === 'object') {
-      context.spanId = context.spanId.toString(10)
+      context.spanId = context.spanId.toBigInt()
     }
     if (context.rootSpanId !== null && typeof context.rootSpanId === 'object') {
-      context.rootSpanId = context.rootSpanId.toString(10)
+      context.rootSpanId = context.rootSpanId.toBigInt()
     }
     if (context.webTags !== undefined && context.endpoint === undefined) {
       // endpoint may not be determined yet, but keep it as fallback

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

@@ -129,6 +129,7 @@
     "DD_PROFILING_HEAP_ENABLED": ["A"],
     "DD_PROFILING_PROFILERS": ["A"],
     "DD_PROFILING_SOURCE_MAP": ["A"],
+    "DD_PROFILING_TIMELINE_ENABLED": ["A"],
     "DD_PROFILING_UPLOAD_PERIOD": ["A"],
     "DD_PROFILING_V8_PROFILER_BUG_WORKAROUND": ["A"],
     "DD_PROFILING_WALLTIME_ENABLED": ["A"],
@@ -160,6 +161,7 @@
     "DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED": ["A"],
     "DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED": ["A"],
     "DD_TRACE_AEROSPIKE_ENABLED": ["A"],
+    "DD_TRACE_AI_ENABLED": ["A"],
     "DD_TRACE_AGENT_PORT": ["A"],
     "DD_TRACE_AGENT_PROTOCOL_VERSION": ["A"],
     "DD_TRACE_AGENT_URL": ["A"],

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

@@ -14,7 +14,7 @@ function storeConfig (config) {
     config.tags['runtime-id'],
     tracerVersion,
     config.hostname,
-    config.server || null,
+    config.service || null,
     config.env || null,
     config.version || null
   )