dd-trace 5.44.0 → 5.46.0

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

@@ -194,7 +194,6 @@ class DogStatsDClient {
   }
 }
 
-// TODO: Handle arrays of tags and tags translation.
 class MetricsAggregationClient {
   constructor (client) {
     this._client = client
@@ -211,98 +210,132 @@ class MetricsAggregationClient {
   }
 
   reset () {
-    this._counters = {}
-    this._gauges = {}
-    this._histograms = {}
+    this._counters = new Map()
+    this._gauges = new Map()
+    this._histograms = new Map()
   }
 
-  distribution (name, value, tag) {
-    this._client.distribution(name, value, tag && [tag])
+  // TODO: Aggerate with a histogram and send the buckets to the client.
+  distribution (name, value, tags) {
+    this._client.distribution(name, value, tags)
   }
 
-  boolean (name, value, tag) {
-    this.gauge(name, value ? 1 : 0, tag)
+  boolean (name, value, tags) {
+    this.gauge(name, value ? 1 : 0, tags)
   }
 
-  histogram (name, value, tag) {
-    this._histograms[name] = this._histograms[name] || new Map()
+  histogram (name, value, tags) {
+    const node = this._ensureTree(this._histograms, name, tags, null)
 
-    if (!this._histograms[name].has(tag)) {
-      this._histograms[name].set(tag, new Histogram())
+    if (!node.value) {
+      node.value = new Histogram()
     }
 
-    this._histograms[name].get(tag).record(value)
+    node.value.record(value)
   }
 
-  count (name, count, tag, monotonic = true) {
-    if (typeof tag === 'boolean') {
-      monotonic = tag
-      tag = undefined
+  count (name, count, tags = [], monotonic = true) {
+    if (typeof tags === 'boolean') {
+      monotonic = tags
+      tags = []
     }
 
-    const map = monotonic ? this._counters : this._gauges
+    const container = monotonic ? this._counters : this._gauges
+    const node = this._ensureTree(container, name, tags, 0)
 
-    map[name] = map[name] || new Map()
-
-    const value = map[name].get(tag) || 0
-
-    map[name].set(tag, value + count)
+    node.value = node.value + count
   }
 
-  gauge (name, value, tag) {
-    this._gauges[name] = this._gauges[name] || new Map()
-    this._gauges[name].set(tag, value)
+  gauge (name, value, tags) {
+    const node = this._ensureTree(this._gauges, name, tags, 0)
+
+    node.value = value
   }
 
-  increment (name, count = 1, tag) {
-    this.count(name, count, tag)
+  increment (name, count = 1, tags) {
+    this.count(name, count, tags)
   }
 
-  decrement (name, count = 1, tag) {
-    this.count(name, -count, tag)
+  decrement (name, count = 1, tags) {
+    this.count(name, -count, tags)
   }
 
   _captureGauges () {
-    Object.keys(this._gauges).forEach(name => {
-      this._gauges[name].forEach((value, tag) => {
-        this._client.gauge(name, value, tag && [tag])
-      })
+    this._captureTree(this._gauges, (node, name, tags) => {
+      this._client.gauge(name, node.value, tags)
     })
   }
 
   _captureCounters () {
-    Object.keys(this._counters).forEach(name => {
-      this._counters[name].forEach((value, tag) => {
-        this._client.increment(name, value, tag && [tag])
-      })
+    this._captureTree(this._counters, (node, name, tags) => {
+      this._client.increment(name, node.value, tags)
     })
 
-    this._counters = {}
+    this._counters.clear()
   }
 
   _captureHistograms () {
-    Object.keys(this._histograms).forEach(name => {
-      this._histograms[name].forEach((stats, tag) => {
-        const tags = tag && [tag]
+    this._captureTree(this._histograms, (node, name, tags) => {
+      let stats = node.value
 
-        // Stats can contain garbage data when a value was never recorded.
-        if (stats.count === 0) {
-          stats = { max: 0, min: 0, sum: 0, avg: 0, median: 0, p95: 0, count: 0, reset: stats.reset }
-        }
+      // Stats can contain garbage data when a value was never recorded.
+      if (stats.count === 0) {
+        stats = { max: 0, min: 0, sum: 0, avg: 0, median: 0, p95: 0, count: 0 }
+      }
 
-        this._client.gauge(`${name}.min`, stats.min, tags)
-        this._client.gauge(`${name}.max`, stats.max, tags)
-        this._client.increment(`${name}.sum`, stats.sum, tags)
-        this._client.increment(`${name}.total`, stats.sum, tags)
-        this._client.gauge(`${name}.avg`, stats.avg, tags)
-        this._client.increment(`${name}.count`, stats.count, tags)
-        this._client.gauge(`${name}.median`, stats.median, tags)
-        this._client.gauge(`${name}.95percentile`, stats.p95, tags)
+      this._client.gauge(`${name}.min`, stats.min, tags)
+      this._client.gauge(`${name}.max`, stats.max, tags)
+      this._client.increment(`${name}.sum`, stats.sum, tags)
+      this._client.increment(`${name}.total`, stats.sum, tags)
+      this._client.gauge(`${name}.avg`, stats.avg, tags)
+      this._client.increment(`${name}.count`, stats.count, tags)
+      this._client.gauge(`${name}.median`, stats.median, tags)
+      this._client.gauge(`${name}.95percentile`, stats.p95, tags)
 
-        stats.reset()
-      })
+      node.value.reset()
     })
   }
+
+  _captureTree (tree, fn) {
+    for (const [name, root] of tree) {
+      this._captureNode(root, name, [], fn)
+    }
+  }
+
+  _captureNode (node, name, tags, fn) {
+    if (node.touched) {
+      fn(node, name, tags)
+    }
+
+    for (const [tag, next] of node.nodes) {
+      this._captureNode(next, name, tags.concat(tag), fn)
+    }
+  }
+
+  _ensureTree (tree, name, tags, value) {
+    tags = tags ? [].concat(tags) : []
+
+    let node = this._ensureNode(tree, name, value)
+
+    for (const tag of tags) {
+      node = this._ensureNode(node.nodes, tag, value)
+    }
+
+    node.touched = true
+
+    return node
+  }
+
+  _ensureNode (container, key, value) {
+    let node = container.get(key)
+
+    if (!node) {
+      node = { nodes: new Map(), touched: false, value }
+      container.set(key, node)
+    }
+
+    return node
+  }
 }
 
 /**
@@ -324,45 +357,29 @@ class CustomMetrics {
   }
 
   increment (stat, value = 1, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.increment(stat, value, tag)
-    }
+    this._client.increment(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   decrement (stat, value = 1, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.decrement(stat, value, tag)
-    }
+    this._client.decrement(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   gauge (stat, value, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.gauge(stat, value, tag)
-    }
+    this._client.gauge(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   distribution (stat, value, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.distribution(stat, value, tag)
-    }
+    this._client.distribution(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   histogram (stat, value, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.histogram(stat, value, tag)
-    }
+    this._client.histogram(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   flush () {
     return this._client.flush()
   }
 
-  _normalizeTags (tags) {
-    tags = CustomMetrics.tagTranslator(tags)
-
-    return tags.length === 0 ? [undefined] : tags
-  }
-
   /**
    * Exposing { tagName: 'tagValue' } to the end user
    * These are translated into [ 'tagName:tagValue' ] for internal use

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

@@ -357,7 +357,7 @@ function formatSpanEvents (span) {
           delete spanEvent.attributes[key] // delete from attributes if undefined
         }
       }
-      if (Object.entries(spanEvent.attributes).length === 0) {
+      if (Object.keys(spanEvent.attributes).length === 0) {
         delete spanEvent.attributes
       }
     }
@@ -370,48 +370,55 @@ function convertSpanEventAttributeValues (key, value, depth = 0) {
       type: 0,
       string_value: value
     }
-  } else if (typeof value === 'boolean') {
+  }
+
+  if (typeof value === 'boolean') {
     return {
       type: 1,
       bool_value: value
     }
-  } else if (Number.isInteger(value)) {
-    return {
-      type: 2,
-      int_value: value
+  }
+
+  if (typeof value === 'number') {
+    if (Number.isInteger(value)) {
+      return {
+        type: 2,
+        int_value: value
+      }
     }
-  } else if (typeof value === 'number') {
     return {
       type: 3,
       double_value: value
     }
-  } else if (Array.isArray(value)) {
+  }
+
+  if (Array.isArray(value)) {
     if (depth === 0) {
-      const convertedArray = value
-        .map((val) => convertSpanEventAttributeValues(key, val, 1))
-        .filter((convertedVal) => convertedVal !== undefined)
+      const convertedArray = []
+      for (const val of value) {
+        const convertedVal = convertSpanEventAttributeValues(key, val, 1)
+        if (convertedVal !== undefined) {
+          convertedArray.push(convertedVal)
+        }
+      }
 
       // Only include array_value if there are valid elements
       if (convertedArray.length > 0) {
         return {
           type: 4,
-          array_value: convertedArray
+          array_value: { values: convertedArray }
         }
-      } else {
-        // If all elements were unsupported, return undefined
-        return undefined
       }
+      // If all elements were unsupported, return undefined
     } else {
       memoizedLogDebug(key, 'Encountered nested array data type for span event v0.4 encoding. ' +
         `Skipping encoding key: ${key}: with value: ${typeof value}.`
       )
-      return undefined
     }
   } else {
     memoizedLogDebug(key, 'Encountered unsupported data type for span event v0.4 encoding, key: ' +
        `${key}: with value: ${typeof value}. Skipping encoding of pair.`
     )
-    return undefined
   }
 }
 

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

@@ -20,6 +20,7 @@ module.exports = name => {
     case exporters.JEST_WORKER:
     case exporters.CUCUMBER_WORKER:
     case exporters.MOCHA_WORKER:
+    case exporters.PLAYWRIGHT_WORKER:
       return require('./ci-visibility/exporters/test-worker')
     default:
       return inAWSLambda && !usingLambdaExtension ? require('./exporters/log') : require('./exporters/agent')

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

@@ -22,7 +22,9 @@ const PROCESS_ID = constants.PROCESS_ID
 const ERROR_MESSAGE = constants.ERROR_MESSAGE
 const ERROR_STACK = constants.ERROR_STACK
 const ERROR_TYPE = constants.ERROR_TYPE
+const { IGNORE_OTEL_ERROR } = constants
 
+// TODO(BridgeAR)[31.03.2025]: Should these land in the constants file?
 const map = {
   'operation.name': 'name',
   'service.name': 'service',
@@ -69,48 +71,46 @@ function setSingleSpanIngestionTags (span, options) {
 }
 
 function extractSpanLinks (formattedSpan, span) {
-  const links = []
-  if (span._links) {
-    for (const link of span._links) {
-      const { context, attributes } = link
-      const formattedLink = {}
-
-      formattedLink.trace_id = context.toTraceId(true)
-      formattedLink.span_id = context.toSpanId(true)
-
-      if (attributes && Object.keys(attributes).length > 0) {
-        formattedLink.attributes = attributes
-      }
-      if (context?._sampling?.priority >= 0) formattedLink.flags = context._sampling.priority > 0 ? 1 : 0
-      if (context?._tracestate) formattedLink.tracestate = context._tracestate.toString()
+  if (!span._links?.length) {
+    return
+  }
+  const links = span._links.map(link => {
+    const { context, attributes } = link
+    const formattedLink = {
+      trace_id: context.toTraceId(true),
+      span_id: context.toSpanId(true)
+    }
 
-      links.push(formattedLink)
+    if (attributes && Object.keys(attributes).length > 0) {
+      formattedLink.attributes = attributes
     }
-  }
-  if (links.length > 0) { formattedSpan.meta['_dd.span_links'] = JSON.stringify(links) }
+    if (context?._sampling?.priority >= 0) formattedLink.flags = context._sampling.priority > 0 ? 1 : 0
+    if (context?._tracestate) formattedLink.tracestate = context._tracestate.toString()
+
+    return formattedLink
+  })
+  formattedSpan.meta['_dd.span_links'] = JSON.stringify(links)
 }
 
 function extractSpanEvents (formattedSpan, span) {
-  const events = []
-  if (span._events) {
-    for (const event of span._events) {
-      const formattedEvent = {
-        name: event.name,
-        time_unix_nano: Math.round(event.startTime * 1e6),
-        attributes: event.attributes && Object.keys(event.attributes).length > 0 ? event.attributes : undefined
-      }
-
-      events.push(formattedEvent)
-    }
-  }
-  if (events.length > 0) {
-    formattedSpan.span_events = events
+  if (!span._events?.length) {
+    return
   }
+  const events = span._events.map(event => {
+    return {
+      name: event.name,
+      time_unix_nano: Math.round(event.startTime * 1e6),
+      attributes: event.attributes && Object.keys(event.attributes).length > 0 ? event.attributes : undefined
+    }
+  })
+  formattedSpan.span_events = events
 }
 
 function extractTags (formattedSpan, span) {
   const context = span.context()
   const origin = context._trace.origin
+  // TODO(BridgeAR)[31.03.2025]: Look into changing the way we store tags. Using
+  // a map is likely faster short term.
   const tags = context._tags
   const hostname = context._hostname
   const priority = context._sampling.priority
@@ -126,43 +126,48 @@ function extractTags (formattedSpan, span) {
     registerExtraService(tags['service.name'])
   }
 
-  for (const tag in tags) {
+  for (const [tag, value] of Object.entries(tags)) {
+    // TODO(BridgeAR)[31.03.2025]: Check how many tags are defined in average.
+    // In case there are more than 2 tags in average, check for all special
+    // cases up front and loop over the tags afterwards, skipping the already
+    // visited property names by checking a map with these keys.
     switch (tag) {
       case 'service.name':
       case 'span.type':
       case 'resource.name':
-        addTag(formattedSpan, {}, map[tag], tags[tag])
+        addTag(formattedSpan, {}, map[tag], value)
         break
       // HACK: remove when Datadog supports numeric status code
       case 'http.status_code':
-        addTag(formattedSpan.meta, {}, tag, tags[tag] && String(tags[tag]))
+        addTag(formattedSpan.meta, {}, tag, value && String(value))
         break
       case 'analytics.event':
-        addTag({}, formattedSpan.metrics, ANALYTICS, tags[tag] === undefined || tags[tag] ? 1 : 0)
+        addTag({}, formattedSpan.metrics, ANALYTICS, value === undefined || value ? 1 : 0)
         break
       case HOSTNAME_KEY:
       case MEASURED:
-        addTag({}, formattedSpan.metrics, tag, tags[tag] === undefined || tags[tag] ? 1 : 0)
+        addTag({}, formattedSpan.metrics, tag, value === undefined || value ? 1 : 0)
         break
+      // TODO(BridgeAR)[31.03.2025]: How come we use two different ways to pass
+      // through errors? Can we just unify the behavior to always use one way?
       case 'error':
         if (context._name !== 'fs.operation') {
-          extractError(formattedSpan, tags[tag])
+          extractError(formattedSpan, value)
         }
         break
       case ERROR_TYPE:
       case ERROR_MESSAGE:
       case ERROR_STACK:
         // HACK: remove when implemented in the backend
-        if (context._name !== 'fs.operation') {
-          // HACK: to ensure otel.recordException does not influence formattedSpan.error
-          if (tags.setTraceError) {
-            formattedSpan.error = 1
-          }
-        } else {
+        if (context._name === 'fs.operation') {
           break
         }
+        // otel.recordException should not influence trace.error
+        if (!tags[IGNORE_OTEL_ERROR]) {
+          formattedSpan.error = 1
+        }
       default: // eslint-disable-line no-fallthrough
-        addTag(formattedSpan.meta, formattedSpan.metrics, tag, tags[tag])
+        addTag(formattedSpan.meta, formattedSpan.metrics, tag, value)
     }
   }
   setSingleSpanIngestionTags(formattedSpan, context._spanSampling)
@@ -193,8 +198,8 @@ function extractChunkTags (formattedSpan, span) {
 
   if (!isLocalRoot) return
 
-  for (const key in context._trace.tags) {
-    addTag(formattedSpan.meta, formattedSpan.metrics, key, context._trace.tags[key])
+  for (const [key, value] of Object.entries(context._trace.tags)) {
+    addTag(formattedSpan.meta, formattedSpan.metrics, key, value)
   }
 }
 
@@ -205,6 +210,8 @@ function extractError (formattedSpan, error) {
 
   if (isError(error)) {
     // AggregateError only has a code and no message.
+    // TODO(BridgeAR)[31.03.2025]: An AggregateError can have a message. Should
+    // the code just generally be added, if available?
     addTag(formattedSpan.meta, formattedSpan.metrics, ERROR_MESSAGE, error.message || error.code)
     addTag(formattedSpan.meta, formattedSpan.metrics, ERROR_TYPE, error.name)
     addTag(formattedSpan.meta, formattedSpan.metrics, ERROR_STACK, error.stack)
@@ -223,30 +230,21 @@ function addTag (meta, metrics, key, value, nested) {
     case 'boolean':
       metrics[key] = value ? 1 : 0
       break
-    case 'undefined':
-      break
-    case 'object':
-      if (value === null) break
+    default:
+      if (value == null) break
 
       // Special case for Node.js Buffer and URL
+      // TODO(BridgeAR)[31.03.2025]: Figure out if all typed arrays should be treated as buffers.
       if (isNodeBuffer(value) || isUrl(value)) {
         metrics[key] = value.toString()
       } else if (!Array.isArray(value) && !nested) {
-        for (const prop in value) {
-          if (!hasOwn(value, prop)) continue
-
-          addTag(meta, metrics, `${key}.${prop}`, value[prop], true)
+        for (const [prop, val] of Object.entries(value)) {
+          addTag(meta, metrics, `${key}.${prop}`, val, true)
         }
       }
-
-      break
   }
 }
 
-function hasOwn (object, prop) {
-  return Object.prototype.hasOwnProperty.call(object, prop)
-}
-
 function isNodeBuffer (obj) {
   return obj.constructor && obj.constructor.name === 'Buffer' &&
     typeof obj.readInt8 === 'function' &&

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

@@ -7,39 +7,28 @@ class Histogram {
     this.reset()
   }
 
-  get min () { return this._min }
-  get max () { return this._max }
-  get avg () { return this._count === 0 ? 0 : this._sum / this._count }
-  get sum () { return this._sum }
-  get count () { return this._count }
+  get min () { return this._sketch.count === 0 ? 0 : this._sketch.min }
+  get max () { return this._sketch.count === 0 ? 0 : this._sketch.max }
+  get avg () { return this._sketch.count === 0 ? 0 : this._sketch.sum / this._sketch.count }
+  get sum () { return this._sketch.sum }
+  get count () { return this._sketch.count }
   get median () { return this.percentile(50) }
   get p95 () { return this.percentile(95) }
 
   percentile (percentile) {
-    return this._histogram.getValueAtQuantile(percentile / 100) || 0
+    return this._sketch.getValueAtQuantile(percentile / 100) || 0
   }
 
-  record (value) {
-    if (this._count === 0) {
-      this._min = this._max = value
-    } else {
-      this._min = Math.min(this._min, value)
-      this._max = Math.max(this._max, value)
-    }
-
-    this._count++
-    this._sum += value
+  merge (histogram) {
+    return this._sketch.merge(histogram._sketch)
+  }
 
-    this._histogram.accept(value)
+  record (value) {
+    this._sketch.accept(value)
   }
 
   reset () {
-    this._min = 0
-    this._max = 0
-    this._sum = 0
-    this._count = 0
-
-    this._histogram = new DDSketch()
+    this._sketch = new DDSketch()
   }
 }
 

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

@@ -6,6 +6,7 @@ const { storage } = require('./storage')
 
 const LLMObsSpanProcessor = require('./span_processor')
 
+const telemetry = require('./telemetry')
 const { channel } = require('dc-polyfill')
 const spanProcessCh = channel('dd-trace:span:process')
 const evalMetricAppendCh = channel('llmobs:eval-metric:append')
@@ -29,6 +30,7 @@ let spanWriter
 let evalWriter
 
 function enable (config) {
+  const startTime = performance.now()
   // create writers and eval writer append and flush channels
   // span writer append is handled by the span processor
   evalWriter = new LLMObsEvalMetricsWriter(config)
@@ -44,6 +46,7 @@ function enable (config) {
 
   // distributed tracing for llmobs
   injectCh.subscribe(handleLLMObsParentIdInjection)
+  telemetry.recordLLMObsEnabled(startTime, config)
 }
 
 function disable () {

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

@@ -74,6 +74,23 @@ function incrementLLMObsSpanFinishedCount (span, value = 1) {
   llmobsMetrics.count('span.finished', tags).inc(value)
 }
 
+function recordLLMObsEnabled (startTime, config, value = 1) {
+  const initTimeMs = performance.now() - startTime
+  // There isn't an easy way to determine if a user automatically enabled LLMObs via
+  // in-code or command line setup. We'll use the presence of DD_LLMOBS_ENABLED env var
+  // as a rough heuristic, but note that this isn't perfect since
+  // a user may have env vars but enable manually in code.
+  const autoEnabled = !!config._env?.['llmobs.enabled']
+  const tags = {
+    error: 0,
+    agentless: Number(config.llmobs.agentlessEnabled),
+    site: config.site,
+    auto: Number(autoEnabled)
+  }
+  llmobsMetrics.count('product_enabled', tags).inc(value)
+  llmobsMetrics.distribution('init_time', tags).track(initTimeMs)
+}
+
 function recordLLMObsRawSpanSize (event, rawEventSize) {
   const tags = extractTagsFromSpanEvent(event)
   llmobsMetrics.distribution('span.raw_size', tags).track(rawEventSize)
@@ -85,9 +102,18 @@ function recordLLMObsSpanSize (event, eventSize, shouldTruncate) {
   llmobsMetrics.distribution('span.size', tags).track(eventSize)
 }
 
+function recordDroppedPayload (numEvents, eventType, error) {
+  if (eventType !== 'span' && eventType !== 'evaluation_metric') return
+  const metricName = eventType === 'span' ? 'dropped_span_event' : 'dropped_eval_event'
+  const tags = { error }
+  llmobsMetrics.count(metricName, tags).inc(numEvents)
+}
+
 module.exports = {
+  recordLLMObsEnabled,
   incrementLLMObsSpanStartCount,
   incrementLLMObsSpanFinishedCount,
   recordLLMObsRawSpanSize,
-  recordLLMObsSpanSize
+  recordLLMObsSpanSize,
+  recordDroppedPayload
 }