dd-trace 5.49.1 → 5.50.0

package/README.md

@@ -69,21 +69,11 @@ Changes associated with each individual release are documented on the [GitHub Re
 Please read the [CONTRIBUTING.md](https://github.com/DataDog/dd-trace-js/blob/master/CONTRIBUTING.md) document before contributing to this open source project.
 
 
-## EcmaScript Modules (ESM) Support
+## ECMAScript Modules (ESM) Support
 
-ESM support requires an additional command-line argument. Use the following to enable experimental ESM support with your application:
+ESM support requires an _additional_ command line argument when starting the Node.js process.
+For more information, see the [section on ESM support](https://docs.datadoghq.com/tracing/trace_collection/automatic_instrumentation/dd_libraries/nodejs/#esm-applications-only-import-the-loader) in the Node.js tracer documentation.
 
-Node.js < v20.6
-
-```sh
-node --loader dd-trace/loader-hook.mjs entrypoint.js
-```
-
-Node.js >= v20.6
-
-```sh
-node --import dd-trace/register.js entrypoint.js
-```
 
 ## Serverless / Lambda
 

package/index.d.ts

@@ -2251,6 +2251,7 @@ declare namespace tracer {
     /**
      * Defines the pattern to ignore cookie names in the vulnerability hash calculation
      * @default ".{32,}"
+     * @deprecated This property has no effect because hash calculation algorithm has been updated for cookie vulnerabilities
      */
     cookieFilterPattern?: string,
 

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "dd-trace",
-  "version": "5.49.1",
+  "version": "5.50.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
   "scripts": {
     "env": "bash ./plugin-env",
     "preinstall": "node scripts/preinstall.js",
-    "bench": "node benchmark",
-    "bench:e2e": "SERVICES=mongo yarn services && cd benchmark/e2e && node benchmark-run.js --duration=30",
+    "bench": "node benchmark/index.js",
     "bench:e2e:ci-visibility": "node benchmark/e2e-ci/benchmark-run.js",
     "type:doc": "cd docs && yarn && yarn build",
     "type:test": "cd docs && yarn && yarn test",

package/packages/datadog-core/src/storage.js

@@ -47,15 +47,16 @@ class DatadogStorage extends AsyncLocalStorage {
    * key. This is useful if you've stashed a handle somewhere and want to
    * retrieve the store with it.
    *
-   * @param handle {{}}
+   * @param [handle] {{}}
    * @returns {T | undefined}
    */
   getStore (handle) {
     if (!handle) {
       handle = super.getStore()
     }
-
-    return stores.get(handle)
+    if (handle) {
+      return stores.get(handle)
+    }
   }
 
   /**

package/packages/datadog-shimmer/src/shimmer.js

@@ -1,85 +1,105 @@
 'use strict'
 
+const skipMethods = new Set([
+  'caller',
+  'arguments',
+  'name',
+  'length'
+])
+
 function copyProperties (original, wrapped) {
-  // TODO getPrototypeOf is not fast. Should we instead do this in specific
-  // instrumentations where needed?
-  const proto = Object.getPrototypeOf(original)
-  if (proto !== Function.prototype) {
+  if (original.constructor !== wrapped.constructor) {
+    const proto = Object.getPrototypeOf(original)
     Object.setPrototypeOf(wrapped, proto)
   }
-  const props = Object.getOwnPropertyDescriptors(original)
-  const keys = Reflect.ownKeys(props)
-
-  for (const key of keys) {
-    try {
-      Object.defineProperty(wrapped, key, props[key])
-    } catch (e) {
-      // TODO: figure out how to handle this without a try/catch
+
+  const ownKeys = Reflect.ownKeys(original)
+  if (original.length !== wrapped.length) {
+    Object.defineProperty(wrapped, 'length', { value: original.length, configurable: true })
+  }
+  if (original.name !== wrapped.name) {
+    Object.defineProperty(wrapped, 'name', { value: original.name, configurable: true })
+  }
+  if (ownKeys.length !== 2) {
+    for (const key of ownKeys) {
+      if (skipMethods.has(key)) continue
+      const descriptor = Object.getOwnPropertyDescriptor(original, key)
+      if (descriptor.writable && descriptor.enumerable && descriptor.configurable) {
+        wrapped[key] = original[key]
+      } else if (descriptor.writable || descriptor.configurable || !Object.hasOwn(wrapped, key)) {
+        Object.defineProperty(wrapped, key, descriptor)
+      }
     }
   }
 }
 
 function wrapFunction (original, wrapper) {
-  if (typeof original === 'function') assertNotClass(original)
-
   const wrapped = wrapper(original)
 
-  if (typeof original === 'function') copyProperties(original, wrapped)
+  if (typeof original === 'function') {
+    assertNotClass(original)
+    copyProperties(original, wrapped)
+  }
 
   return wrapped
 }
 
-const wrapFn = function (original, delegate) {
-  throw new Error('calling `wrap()` with 2 args is deprecated. Use wrapFunction instead.')
-}
-
-function wrapMethod (target, name, wrapper, noAssert) {
-  if (!noAssert) {
-    assertMethod(target, name)
-    assertFunction(wrapper)
+function wrap (target, name, wrapper) {
+  assertMethod(target, name)
+  if (typeof wrapper !== 'function') {
+    throw new Error(wrapper ? 'Target is not a function' : 'No function provided')
   }
 
   const original = target[name]
   const wrapped = wrapper(original)
 
-  const descriptor = Object.getOwnPropertyDescriptor(target, name)
-
-  const attributes = {
-    configurable: true,
-    ...descriptor
-  }
-
   if (typeof original === 'function') copyProperties(original, wrapped)
 
-  if (descriptor) {
+  let descriptor = Object.getOwnPropertyDescriptor(target, name)
+
+  // No descriptor means original was on the prototype
+  if (descriptor === undefined) {
+    descriptor = {
+      value: wrapped,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    }
+  } else if (descriptor.writable) {
+    // Fast path for assigned properties.
+    if (descriptor.configurable && descriptor.enumerable) {
+      target[name] = wrapped
+      return target
+    }
+    descriptor.value = wrapped
+  } else {
     if (descriptor.get || descriptor.set) {
-      attributes.get = () => wrapped
+      // TODO(BridgeAR): What happens in case there is a setter? This seems wrong?
+      // What happens in case the user does indeed set this to a different value?
+      // In that case the getter would potentially return the wrong value?
+      descriptor.get = () => wrapped
     } else {
-      attributes.value = wrapped
+      descriptor.value = wrapped
     }
 
-    // TODO: create a single object for multiple wrapped methods
     if (descriptor.configurable === false) {
+      // TODO(BridgeAR): Bail out instead (throw). It is unclear if the newly
+      // created object is actually used. If it's not used, the wrapping would
+      // have had no effect without noticing. It is also unclear what would happen
+      // in case user code would check for properties to be own properties. That
+      // would fail with this code. A function being replaced with an object is
+      // also not possible.
       return Object.create(target, {
-        [name]: attributes
+        [name]: descriptor
       })
     }
-  } else { // no descriptor means original was on the prototype
-    attributes.value = wrapped
-    attributes.writable = true
   }
 
-  Object.defineProperty(target, name, attributes)
+  Object.defineProperty(target, name, descriptor)
 
   return target
 }
 
-function wrap (target, name, wrapper) {
-  return typeof name === 'function'
-    ? wrapFn(target, name)
-    : wrapMethod(target, name, wrapper)
-}
-
 function massWrap (targets, names, wrapper) {
   targets = toArray(targets)
   names = toArray(names)
@@ -96,30 +116,18 @@ function toArray (maybeArray) {
 }
 
 function assertMethod (target, name) {
-  if (!target) {
-    throw new Error('No target object provided.')
-  }
-
-  if (typeof target !== 'object' && typeof target !== 'function') {
-    throw new Error('Invalid target.')
-  }
-
-  if (!target[name]) {
-    throw new Error(`No original method ${name}.`)
-  }
-
-  if (typeof target[name] !== 'function') {
-    throw new Error(`Original method ${name} is not a function.`)
-  }
-}
-
-function assertFunction (target) {
-  if (!target) {
-    throw new Error('No function provided.')
-  }
+  if (typeof target?.[name] !== 'function') {
+    let message = 'No target object provided'
+
+    if (target) {
+      if (typeof target !== 'object' && typeof target !== 'function') {
+        message = 'Invalid target'
+      } else {
+        message = target[name] ? `Original method ${name} is not a function` : `No original method ${name}`
+      }
+    }
 
-  if (typeof target !== 'function') {
-    throw new Error('Target is not a function.')
+    throw new Error(message)
   }
 }
 

package/packages/dd-trace/src/appsec/iast/analyzers/cookie-analyzer.js

@@ -2,7 +2,6 @@
 
 const Analyzer = require('./vulnerability-analyzer')
 const { getNodeModulesPaths } = require('../path-line')
-const log = require('../../../log')
 
 const EXCLUDED_PATHS = getNodeModulesPaths('express/lib/response.js')
 
@@ -12,14 +11,7 @@ class CookieAnalyzer extends Analyzer {
     this.propertyToBeSafe = propertyToBeSafe.toLowerCase()
   }
 
-  onConfigure (config) {
-    try {
-      this.cookieFilterRegExp = new RegExp(config.iast.cookieFilterPattern)
-    } catch {
-      log.error('[ASM] Invalid regex in cookieFilterPattern')
-      this.cookieFilterRegExp = /.{32,}/
-    }
-
+  onConfigure () {
     this.addSub(
       { channelName: 'datadog:iast:set-cookie', moduleName: 'http' },
       (cookieInfo) => this.analyze(cookieInfo)
@@ -35,14 +27,6 @@ class CookieAnalyzer extends Analyzer {
     return { value: cookieName }
   }
 
-  _createHashSource (type, evidence, location) {
-    if (typeof evidence.value === 'string' && evidence.value.match(this.cookieFilterRegExp)) {
-      return 'FILTERED_' + this._type
-    }
-
-    return `${type}:${evidence.value}`
-  }
-
   _getExcludedPaths () {
     return EXCLUDED_PATHS
   }

package/packages/dd-trace/src/appsec/iast/iast-plugin.js

@@ -114,7 +114,7 @@ class IastPlugin extends Plugin {
       config = { enabled: config }
     }
     if (config.enabled && !this.configured) {
-      this.onConfigure(config.tracerConfig)
+      this.onConfigure()
       this.configured = true
     }
 

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

@@ -181,8 +181,7 @@ function validateNamingVersion (versionString) {
  * If a blank path is provided a null is returned to signal that the feature is disabled.
  * An empty array means the feature is enabled but that no rules need to be applied.
  *
- * @param {string} input
- * @returns {[string]|null}
+ * @param {string | string[]} input
  */
 function splitJSONPathRules (input) {
   if (!input) return null
@@ -289,8 +288,7 @@ class Config {
     }
     const PROPAGATION_STYLE_INJECT = propagationStyle(
       'inject',
-      options.tracePropagationStyle,
-      this._getDefaultPropagationStyle(options)
+      options.tracePropagationStyle
     )
 
     validateOtelPropagators(PROPAGATION_STYLE_INJECT)
@@ -299,8 +297,6 @@ class Config {
       options.appsec = {
         enabled: options.appsec
       }
-    } else if (options.appsec == null) {
-      options.appsec = {}
     }
 
     const DD_INSTRUMENTATION_INSTALL_ID = coalesce(
@@ -505,7 +501,6 @@ class Config {
     this._setValue(defaults, 'grpc.server.error.statuses', GRPC_SERVER_ERROR_STATUSES)
     this._setValue(defaults, 'headerTags', [])
     this._setValue(defaults, 'hostname', '127.0.0.1')
-    this._setValue(defaults, 'iast.cookieFilterPattern', '.{32,}')
     this._setValue(defaults, 'iast.dbRowsToTaint', 1)
     this._setValue(defaults, 'iast.deduplicationEnabled', true)
     this._setValue(defaults, 'iast.enabled', false)
@@ -680,7 +675,6 @@ class Config {
       DD_GRPC_CLIENT_ERROR_STATUSES,
       DD_GRPC_SERVER_ERROR_STATUSES,
       JEST_WORKER_ID,
-      DD_IAST_COOKIE_FILTER_PATTERN,
       DD_IAST_DB_ROWS_TO_TAINT,
       DD_IAST_DEDUPLICATION_ENABLED,
       DD_IAST_ENABLED,
@@ -855,7 +849,6 @@ class Config {
     this._setIntegerRangeSet(env, 'grpc.server.error.statuses', DD_GRPC_SERVER_ERROR_STATUSES)
     this._setArray(env, 'headerTags', DD_TRACE_HEADER_TAGS)
     this._setString(env, 'hostname', coalesce(DD_AGENT_HOST, DD_TRACE_AGENT_HOSTNAME))
-    this._setString(env, 'iast.cookieFilterPattern', DD_IAST_COOKIE_FILTER_PATTERN)
     this._setValue(env, 'iast.dbRowsToTaint', maybeInt(DD_IAST_DB_ROWS_TO_TAINT))
     this._setBoolean(env, 'iast.deduplicationEnabled', DD_IAST_DEDUPLICATION_ENABLED)
     this._setBoolean(env, 'iast.enabled', DD_IAST_ENABLED)
@@ -1010,27 +1003,27 @@ class Config {
       options.apmTracingEnabled,
       options.experimental?.appsec?.standalone && !options.experimental.appsec.standalone.enabled
     ))
-    this._setBoolean(opts, 'appsec.apiSecurity.enabled', options.appsec.apiSecurity?.enabled)
-    this._setValue(opts, 'appsec.blockedTemplateGraphql', maybeFile(options.appsec.blockedTemplateGraphql))
-    this._setValue(opts, 'appsec.blockedTemplateHtml', maybeFile(options.appsec.blockedTemplateHtml))
-    this._optsUnprocessed['appsec.blockedTemplateHtml'] = options.appsec.blockedTemplateHtml
-    this._setValue(opts, 'appsec.blockedTemplateJson', maybeFile(options.appsec.blockedTemplateJson))
-    this._optsUnprocessed['appsec.blockedTemplateJson'] = options.appsec.blockedTemplateJson
-    this._setBoolean(opts, 'appsec.enabled', options.appsec.enabled)
-    this._setString(opts, 'appsec.eventTracking.mode', options.appsec.eventTracking?.mode)
-    this._setString(opts, 'appsec.obfuscatorKeyRegex', options.appsec.obfuscatorKeyRegex)
-    this._setString(opts, 'appsec.obfuscatorValueRegex', options.appsec.obfuscatorValueRegex)
-    this._setBoolean(opts, 'appsec.rasp.enabled', options.appsec.rasp?.enabled)
-    this._setValue(opts, 'appsec.rateLimit', maybeInt(options.appsec.rateLimit))
-    this._optsUnprocessed['appsec.rateLimit'] = options.appsec.rateLimit
-    this._setString(opts, 'appsec.rules', options.appsec.rules)
-    this._setBoolean(opts, 'appsec.stackTrace.enabled', options.appsec.stackTrace?.enabled)
-    this._setValue(opts, 'appsec.stackTrace.maxDepth', maybeInt(options.appsec.stackTrace?.maxDepth))
-    this._optsUnprocessed['appsec.stackTrace.maxDepth'] = options.appsec.stackTrace?.maxDepth
-    this._setValue(opts, 'appsec.stackTrace.maxStackTraces', maybeInt(options.appsec.stackTrace?.maxStackTraces))
-    this._optsUnprocessed['appsec.stackTrace.maxStackTraces'] = options.appsec.stackTrace?.maxStackTraces
-    this._setValue(opts, 'appsec.wafTimeout', maybeInt(options.appsec.wafTimeout))
-    this._optsUnprocessed['appsec.wafTimeout'] = options.appsec.wafTimeout
+    this._setBoolean(opts, 'appsec.apiSecurity.enabled', options.appsec?.apiSecurity?.enabled)
+    this._setValue(opts, 'appsec.blockedTemplateGraphql', maybeFile(options.appsec?.blockedTemplateGraphql))
+    this._setValue(opts, 'appsec.blockedTemplateHtml', maybeFile(options.appsec?.blockedTemplateHtml))
+    this._optsUnprocessed['appsec.blockedTemplateHtml'] = options.appsec?.blockedTemplateHtml
+    this._setValue(opts, 'appsec.blockedTemplateJson', maybeFile(options.appsec?.blockedTemplateJson))
+    this._optsUnprocessed['appsec.blockedTemplateJson'] = options.appsec?.blockedTemplateJson
+    this._setBoolean(opts, 'appsec.enabled', options.appsec?.enabled)
+    this._setString(opts, 'appsec.eventTracking.mode', options.appsec?.eventTracking?.mode)
+    this._setString(opts, 'appsec.obfuscatorKeyRegex', options.appsec?.obfuscatorKeyRegex)
+    this._setString(opts, 'appsec.obfuscatorValueRegex', options.appsec?.obfuscatorValueRegex)
+    this._setBoolean(opts, 'appsec.rasp.enabled', options.appsec?.rasp?.enabled)
+    this._setValue(opts, 'appsec.rateLimit', maybeInt(options.appsec?.rateLimit))
+    this._optsUnprocessed['appsec.rateLimit'] = options.appsec?.rateLimit
+    this._setString(opts, 'appsec.rules', options.appsec?.rules)
+    this._setBoolean(opts, 'appsec.stackTrace.enabled', options.appsec?.stackTrace?.enabled)
+    this._setValue(opts, 'appsec.stackTrace.maxDepth', maybeInt(options.appsec?.stackTrace?.maxDepth))
+    this._optsUnprocessed['appsec.stackTrace.maxDepth'] = options.appsec?.stackTrace?.maxDepth
+    this._setValue(opts, 'appsec.stackTrace.maxStackTraces', maybeInt(options.appsec?.stackTrace?.maxStackTraces))
+    this._optsUnprocessed['appsec.stackTrace.maxStackTraces'] = options.appsec?.stackTrace?.maxStackTraces
+    this._setValue(opts, 'appsec.wafTimeout', maybeInt(options.appsec?.wafTimeout))
+    this._optsUnprocessed['appsec.wafTimeout'] = options.appsec?.wafTimeout
     this._setBoolean(opts, 'clientIpEnabled', options.clientIpEnabled)
     this._setString(opts, 'clientIpHeader', options.clientIpHeader?.toLowerCase())
     this._setValue(opts, 'baggageMaxBytes', options.baggageMaxBytes)
@@ -1063,7 +1056,6 @@ class Config {
     this._optsUnprocessed.flushMinSpans = options.flushMinSpans
     this._setArray(opts, 'headerTags', options.headerTags)
     this._setString(opts, 'hostname', options.hostname)
-    this._setString(opts, 'iast.cookieFilterPattern', options.iast?.cookieFilterPattern)
     this._setValue(opts, 'iast.dbRowsToTaint', maybeInt(options.iast?.dbRowsToTaint))
     this._setBoolean(opts, 'iast.deduplicationEnabled', options.iast && options.iast.deduplicationEnabled)
     this._setBoolean(opts, 'iast.enabled',

package/packages/dd-trace/src/datastreams/processor.js

@@ -13,16 +13,14 @@ const log = require('../log')
 
 const ENTRY_PARENT_HASH = Buffer.from('0000000000000000', 'hex')
 
-const HIGH_ACCURACY_DISTRIBUTION = 0.0075
-
 class StatsPoint {
   constructor (hash, parentHash, edgeTags) {
     this.hash = hash.readBigUInt64BE()
     this.parentHash = parentHash.readBigUInt64BE()
     this.edgeTags = edgeTags
-    this.edgeLatency = new LogCollapsingLowestDenseDDSketch(HIGH_ACCURACY_DISTRIBUTION)
-    this.pathwayLatency = new LogCollapsingLowestDenseDDSketch(HIGH_ACCURACY_DISTRIBUTION)
-    this.payloadSize = new LogCollapsingLowestDenseDDSketch(HIGH_ACCURACY_DISTRIBUTION)
+    this.edgeLatency = new LogCollapsingLowestDenseDDSketch()
+    this.pathwayLatency = new LogCollapsingLowestDenseDDSketch()
+    this.payloadSize = new LogCollapsingLowestDenseDDSketch()
   }
 
   addLatencies (checkpoint) {

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

@@ -308,12 +308,16 @@ class MetricsAggregationClient {
     }
 
     for (const [tag, next] of node.nodes) {
-      this._captureNode(next, name, tags.concat(tag), fn)
+      tags.push(tag)
+      this._captureNode(next, name, tags, fn)
+      tags.pop()
     }
   }
 
-  _ensureTree (tree, name, tags, value) {
-    tags = tags ? [].concat(tags) : []
+  _ensureTree (tree, name, tags = [], value) {
+    if (!Array.isArray(tags)) {
+      tags = [tags]
+    }
 
     let node = this._ensureNode(tree, name, value)
 
@@ -331,7 +335,10 @@ class MetricsAggregationClient {
 
     if (!node) {
       node = { nodes: new Map(), touched: false, value }
-      container.set(key, node)
+
+      if (typeof key === 'string') {
+        container.set(key, node)
+      }
     }
 
     return node

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

@@ -4,9 +4,9 @@ const log = require('../log')
 const { PROPAGATED_PARENT_ID_KEY } = require('./constants/tags')
 const { storage } = require('./storage')
 
+const telemetry = require('./telemetry')
 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')
@@ -94,12 +94,15 @@ function handleLLMObsParentIdInjection ({ carrier }) {
 }
 
 function handleFlush () {
+  let err = ''
   try {
     spanWriter.flush()
     evalWriter.flush()
   } catch (e) {
+    err = 'writer_flush_error'
     log.warn(`Failed to flush LLMObs spans and evaluation metrics: ${e.message}`)
   }
+  telemetry.recordUserFlush(err)
 }
 
 function handleSpanProcess (data) {

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

@@ -201,7 +201,7 @@ class LLMObs extends NoopLLMObs {
     return this._tracer.wrap(name, spanOptions, wrapped)
   }
 
-  annotate (span, options) {
+  annotate (span, options, autoinstrumented = false) {
     if (!this.enabled) return
 
     if (!span) {
@@ -213,150 +213,184 @@ class LLMObs extends NoopLLMObs {
       span = this._active()
     }
 
-    if (!span) {
-      throw new Error('No span provided and no active LLMObs-generated span found')
-    }
-    if (!options) {
-      throw new Error('No options provided for annotation.')
-    }
+    let err = ''
 
-    if (!LLMObsTagger.tagMap.has(span)) {
-      throw new Error('Span must be an LLMObs-generated span')
-    }
-    if (span._duration !== undefined) {
-      throw new Error('Cannot annotate a finished span')
-    }
+    try {
+      if (!span) {
+        err = 'invalid_span_no_active_spans'
+        throw new Error('No span provided and no active LLMObs-generated span found')
+      }
+      if (!options) {
+        err = 'invalid_options'
+        throw new Error('No options provided for annotation.')
+      }
 
-    const spanKind = LLMObsTagger.tagMap.get(span)[SPAN_KIND]
-    if (!spanKind) {
-      throw new Error('LLMObs span must have a span kind specified')
-    }
+      if (!LLMObsTagger.tagMap.has(span)) {
+        err = 'invalid_span_type'
+        throw new Error('Span must be an LLMObs-generated span')
+      }
+      if (span._duration !== undefined) {
+        err = 'invalid_finished_span'
+        throw new Error('Cannot annotate a finished span')
+      }
 
-    const { inputData, outputData, metadata, metrics, tags } = options
-
-    if (inputData || outputData) {
-      if (spanKind === 'llm') {
-        this._tagger.tagLLMIO(span, inputData, outputData)
-      } else if (spanKind === 'embedding') {
-        this._tagger.tagEmbeddingIO(span, inputData, outputData)
-      } else if (spanKind === 'retrieval') {
-        this._tagger.tagRetrievalIO(span, inputData, outputData)
-      } else {
-        this._tagger.tagTextIO(span, inputData, outputData)
+      const spanKind = LLMObsTagger.tagMap.get(span)[SPAN_KIND]
+      if (!spanKind) {
+        err = 'invalid_no_span_kind'
+        throw new Error('LLMObs span must have a span kind specified')
       }
-    }
 
-    if (metadata) {
-      this._tagger.tagMetadata(span, metadata)
-    }
+      const { inputData, outputData, metadata, metrics, tags } = options
 
-    if (metrics) {
-      this._tagger.tagMetrics(span, metrics)
-    }
+      if (inputData || outputData) {
+        if (spanKind === 'llm') {
+          this._tagger.tagLLMIO(span, inputData, outputData)
+        } else if (spanKind === 'embedding') {
+          this._tagger.tagEmbeddingIO(span, inputData, outputData)
+        } else if (spanKind === 'retrieval') {
+          this._tagger.tagRetrievalIO(span, inputData, outputData)
+        } else {
+          this._tagger.tagTextIO(span, inputData, outputData)
+        }
+      }
 
-    if (tags) {
-      this._tagger.tagSpanTags(span, tags)
+      if (metadata) {
+        this._tagger.tagMetadata(span, metadata)
+      }
+      if (metrics) {
+        this._tagger.tagMetrics(span, metrics)
+      }
+      if (tags) {
+        this._tagger.tagSpanTags(span, tags)
+      }
+    } catch (e) {
+      if (e.ddErrorTag) {
+        err = e.ddErrorTag
+      }
+      throw e
+    } finally {
+      if (autoinstrumented === false) {
+        telemetry.recordLLMObsAnnotate(span, err)
+      }
     }
   }
 
   exportSpan (span) {
     span = span || this._active()
-
-    if (!span) {
-      throw new Error('No span provided and no active LLMObs-generated span found')
-    }
-
-    if (!(span instanceof Span)) {
-      throw new Error('Span must be a valid Span object.')
-    }
-
-    if (!LLMObsTagger.tagMap.has(span)) {
-      throw new Error('Span must be an LLMObs-generated span')
+    let err = ''
+    try {
+      if (!span) {
+        err = 'no_active_span'
+        throw new Error('No span provided and no active LLMObs-generated span found')
+      }
+      if (!(span instanceof Span)) {
+        err = 'invalid_span'
+        throw new Error('Span must be a valid Span object.')
+      }
+      if (!LLMObsTagger.tagMap.has(span)) {
+        err = 'invalid_span'
+        throw new Error('Span must be an LLMObs-generated span')
+      }
+    } catch (e) {
+      telemetry.recordExportSpan(span, err)
+      throw e
     }
-
     try {
       return {
         traceId: span.context().toTraceId(true),
         spanId: span.context().toSpanId()
       }
     } catch {
-      logger.warn('Faild to export span. Span must be a valid Span object.')
+      err = 'invalid_span'
+      logger.warn('Failed to export span. Span must be a valid Span object.')
+    } finally {
+      telemetry.recordExportSpan(span, err)
     }
   }
 
   submitEvaluation (llmobsSpanContext, options = {}) {
     if (!this.enabled) return
 
+    let err = ''
     const { traceId, spanId } = llmobsSpanContext
-    if (!traceId || !spanId) {
-      throw new Error(
-        'spanId and traceId must both be specified for the given evaluation metric to be submitted.'
-      )
-    }
-
-    const mlApp = options.mlApp || this._config.llmobs.mlApp
-    if (!mlApp) {
-      throw new Error(
-        'ML App name is required for sending evaluation metrics. Evaluation metric data will not be sent.'
-      )
-    }
-
-    const timestampMs = options.timestampMs || Date.now()
-    if (typeof timestampMs !== 'number' || timestampMs < 0) {
-      throw new Error('timestampMs must be a non-negative integer. Evaluation metric data will not be sent')
-    }
+    try {
+      if (!traceId || !spanId) {
+        err = 'invalid_span'
+        throw new Error(
+          'spanId and traceId must both be specified for the given evaluation metric to be submitted.'
+        )
+      }
+      const mlApp = options.mlApp || this._config.llmobs.mlApp
+      if (!mlApp) {
+        err = 'missing_ml_app'
+        throw new Error(
+          'ML App name is required for sending evaluation metrics. Evaluation metric data will not be sent.'
+        )
+      }
 
-    const { label, value, tags } = options
-    const metricType = options.metricType?.toLowerCase()
-    if (!label) {
-      throw new Error('label must be the specified name of the evaluation metric')
-    }
-    if (!metricType || !['categorical', 'score'].includes(metricType)) {
-      throw new Error('metricType must be one of "categorical" or "score"')
-    }
+      const timestampMs = options.timestampMs || Date.now()
+      if (typeof timestampMs !== 'number' || timestampMs < 0) {
+        err = 'invalid_timestamp'
+        throw new Error('timestampMs must be a non-negative integer. Evaluation metric data will not be sent')
+      }
 
-    if (metricType === 'categorical' && typeof value !== 'string') {
-      throw new Error('value must be a string for a categorical metric.')
-    }
-    if (metricType === 'score' && typeof value !== 'number') {
-      throw new Error('value must be a number for a score metric.')
-    }
+      const { label, value, tags } = options
+      const metricType = options.metricType?.toLowerCase()
+      if (!label) {
+        err = 'invalid_metric_label'
+        throw new Error('label must be the specified name of the evaluation metric')
+      }
+      if (!metricType || !['categorical', 'score'].includes(metricType)) {
+        err = 'invalid_metric_type'
+        throw new Error('metricType must be one of "categorical" or "score"')
+      }
+      if (metricType === 'categorical' && typeof value !== 'string') {
+        err = 'invalid_metric_value'
+        throw new Error('value must be a string for a categorical metric.')
+      }
+      if (metricType === 'score' && typeof value !== 'number') {
+        err = 'invalid_metric_value'
+        throw new Error('value must be a number for a score metric.')
+      }
 
-    const evaluationTags = {
-      'ddtrace.version': tracerVersion,
-      ml_app: mlApp
-    }
+      const evaluationTags = {
+        'ddtrace.version': tracerVersion,
+        ml_app: mlApp
+      }
 
-    if (tags) {
-      for (const key in tags) {
-        const tag = tags[key]
-        if (typeof tag === 'string') {
-          evaluationTags[key] = tag
-        } else if (typeof tag.toString === 'function') {
-          evaluationTags[key] = tag.toString()
-        } else if (tag == null) {
-          evaluationTags[key] = Object.prototype.toString.call(tag)
-        } else {
-          // should be a rare case
-          // every object in JS has a toString, otherwise every primitive has its own toString
-          // null and undefined are handled above
-          throw new Error('Failed to parse tags. Tags for evaluation metrics must be strings')
+      if (tags) {
+        for (const key in tags) {
+          const tag = tags[key]
+          if (typeof tag === 'string') {
+            evaluationTags[key] = tag
+          } else if (typeof tag.toString === 'function') {
+            evaluationTags[key] = tag.toString()
+          } else if (tag == null) {
+            evaluationTags[key] = Object.prototype.toString.call(tag)
+          } else {
+            // should be a rare case
+            // every object in JS has a toString, otherwise every primitive has its own toString
+            // null and undefined are handled above
+            err = 'invalid_tags'
+            throw new Error('Failed to parse tags. Tags for evaluation metrics must be strings')
+          }
         }
       }
-    }
 
-    const payload = {
-      span_id: spanId,
-      trace_id: traceId,
-      label,
-      metric_type: metricType,
-      ml_app: mlApp,
-      [`${metricType}_value`]: value,
-      timestamp_ms: timestampMs,
-      tags: Object.entries(evaluationTags).map(([key, value]) => `${key}:${value}`)
+      const payload = {
+        span_id: spanId,
+        trace_id: traceId,
+        label,
+        metric_type: metricType,
+        ml_app: mlApp,
+        [`${metricType}_value`]: value,
+        timestamp_ms: timestampMs,
+        tags: Object.entries(evaluationTags).map(([key, value]) => `${key}:${value}`)
+      }
+      evalMetricAppendCh.publish(payload)
+    } finally {
+      telemetry.recordSubmitEvaluation(options, err)
     }
-
-    evalMetricAppendCh.publish(payload)
   }
 
   flush () {
@@ -375,7 +409,7 @@ class LLMObs extends NoopLLMObs {
       annotations.outputData = output
     }
 
-    this.annotate(span, annotations)
+    this.annotate(span, annotations, true)
   }
 
   _active () {

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

@@ -135,7 +135,7 @@ class LLMObsTagger {
       if (typeof value === 'number') {
         filterdMetrics[processedKey] = value
       } else {
-        this._handleFailure(`Value for metric '${key}' must be a number, instead got ${value}`)
+        this._handleFailure(`Value for metric '${key}' must be a number, instead got ${value}`, 'invalid_metrics')
       }
     }
 
@@ -169,7 +169,7 @@ class LLMObsTagger {
           this._setTag(span, key, JSON.stringify(data))
         } catch {
           const type = key === INPUT_VALUE ? 'input' : 'output'
-          this._handleFailure(`Failed to parse ${type} value, must be JSON serializable.`)
+          this._handleFailure(`Failed to parse ${type} value, must be JSON serializable.`, 'invalid_io_text')
         }
       }
     }
@@ -187,7 +187,7 @@ class LLMObsTagger {
         }
 
         if (document == null || typeof document !== 'object') {
-          this._handleFailure('Documents must be a string, object, or list of objects.')
+          this._handleFailure('Documents must be a string, object, or list of objects.', 'invalid_embedding_io')
           return undefined
         }
 
@@ -195,7 +195,7 @@ class LLMObsTagger {
         let validDocument = true
 
         if (typeof text !== 'string') {
-          this._handleFailure('Document text must be a string.')
+          this._handleFailure('Document text must be a string.', 'invalid_embedding_io')
           validDocument = false
         }
 
@@ -226,7 +226,7 @@ class LLMObsTagger {
         }
 
         if (message == null || typeof message !== 'object') {
-          this._handleFailure('Messages must be a string, object, or list of objects')
+          this._handleFailure('Messages must be a string, object, or list of objects', 'invalid_io_messages')
           return undefined
         }
 
@@ -237,7 +237,7 @@ class LLMObsTagger {
         const messageObj = { content }
 
         if (typeof content !== 'string') {
-          this._handleFailure('Message content must be a string.')
+          this._handleFailure('Message content must be a string.', 'invalid_io_messages')
           validMessage = false
         }
 
@@ -250,7 +250,7 @@ class LLMObsTagger {
 
           const filteredToolCalls = toolCalls.map(toolCall => {
             if (typeof toolCall !== 'object') {
-              this._handleFailure('Tool call must be an object.')
+              this._handleFailure('Tool call must be an object.', 'invalid_io_messages')
               return undefined
             }
 
@@ -313,11 +313,15 @@ class LLMObsTagger {
 
   // any public-facing LLMObs APIs using this tagger should not soft fail
   // auto-instrumentation should soft fail
-  _handleFailure (msg) {
+  _handleFailure (msg, errorTag) {
     if (this.softFail) {
       log.warn(msg)
     } else {
-      throw new Error(msg)
+      const err = new Error(msg)
+      if (errorTag) {
+        Object.defineProperty(err, 'ddErrorTag', { get () { return errorTag } })
+      }
+      throw err
     }
   }
 

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

@@ -109,11 +109,60 @@ function recordDroppedPayload (numEvents, eventType, error) {
   llmobsMetrics.count(metricName, tags).inc(numEvents)
 }
 
+function recordLLMObsAnnotate (span, err, value = 1) {
+  const mlObsTags = LLMObsTagger.tagMap.get(span) || {}
+  const spanKind = mlObsTags[SPAN_KIND] || 'N/A'
+  const isRootSpan = mlObsTags[PARENT_ID_KEY] === ROOT_PARENT_ID
+
+  const tags = {
+    error: Number(!!err),
+    span_kind: spanKind,
+    is_root_span: Number(isRootSpan)
+  }
+  if (err) tags.error_type = err
+  llmobsMetrics.count('annotations', tags).inc(value)
+}
+
+function recordUserFlush (err, value = 1) {
+  const tags = { error: Number(!!err) }
+  if (err) tags.error_type = err
+  llmobsMetrics.count('user_flush', tags).inc(value)
+}
+
+function recordExportSpan (span, err, value = 1) {
+  const mlObsTags = LLMObsTagger.tagMap.get(span) || {}
+  const spanKind = mlObsTags[SPAN_KIND] || 'N/A'
+  const isRootSpan = mlObsTags[PARENT_ID_KEY] === ROOT_PARENT_ID
+
+  const tags = {
+    error: Number(!!err),
+    span_kind: spanKind,
+    is_root_span: Number(isRootSpan)
+  }
+  if (err) tags.error_type = err
+  llmobsMetrics.count('spans_exported', tags).inc(value)
+}
+
+function recordSubmitEvaluation (options, err, value = 1) {
+  const tags = {
+    error: Number(!!err),
+    custom_joining_key: 0
+  }
+  const metricType = options?.metricType?.toLowerCase()
+  if (metricType !== 'categorical' && metricType !== 'score') tags.metric_type = 'other'
+  if (err) tags.error_type = err
+  llmobsMetrics.count('evals_submitted', tags).inc(value)
+}
+
 module.exports = {
   recordLLMObsEnabled,
   incrementLLMObsSpanStartCount,
   incrementLLMObsSpanFinishedCount,
   recordLLMObsRawSpanSize,
   recordLLMObsSpanSize,
-  recordDroppedPayload
+  recordDroppedPayload,
+  recordLLMObsAnnotate,
+  recordUserFlush,
+  recordExportSpan,
+  recordSubmitEvaluation
 }

package/packages/dd-trace/src/payload-tagging/jsonpath-plus.js

@@ -1694,7 +1694,7 @@ JSONPath.prototype._handleCallback = function (fullRetObj, callback, type) {
  * @param {string} parentPropName
  * @param {JSONPathCallback} callback
  * @param {boolean} hasArrExpr
- * @param {boolean} literalPriority
+ * @param {boolean} [literalPriority]
  * @returns {ReturnObject|ReturnObject[]}
  */
 JSONPath.prototype._trace = function (expr, val, path, parent, parentPropName, callback, hasArrExpr, literalPriority) {

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

@@ -15,7 +15,6 @@ const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { tagger } = require('./tagger')
 const { isFalse, isTrue } = require('../util')
 const { getAzureTagsFromMetadata, getAzureAppMetadata } = require('../azure_metadata')
-const satisfies = require('semifies')
 
 class Config {
   constructor (options = {}) {
@@ -23,7 +22,6 @@ class Config {
       DD_AGENT_HOST,
       DD_ENV,
       DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, // used for testing
-      DD_PROFILING_ASYNC_ID_ENABLED,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_CPU_ENABLED,
       DD_PROFILING_DEBUG_SOURCE_MAPS,
@@ -181,10 +179,6 @@ class Config {
     this.timelineSamplingEnabled = isTrue(coalesce(options.timelineSamplingEnabled,
       DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, true))
 
-    // Async ID gathering only works reliably on Node >= 22.10.0
-    this.asyncIdEnabled = isTrue(coalesce(options.asyncIdEnabled,
-      DD_PROFILING_ASYNC_ID_ENABLED, this.timelineEnabled && satisfies(process.versions.node, '>=22.10.0')))
-
     this.codeHotspotsEnabled = isTrue(coalesce(options.codeHotspotsEnabled,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED, samplingContextsAvailable))

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

@@ -70,16 +70,12 @@ function ensureChannelsActivated () {
 class NativeWallProfiler {
   constructor (options = {}) {
     this.type = 'wall'
-    // Currently there's a crash sometimes on worker threads trying to collect async IDs so for the
-    // time being we'll constrain it to only the main thread.
-    this._asyncIdEnabled = !!options.asyncIdEnabled && require('worker_threads').isMainThread
+    this._samplingIntervalMicros = options.samplingInterval || 1e6 / 99 // 99hz
+    this._flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
     this._codeHotspotsEnabled = !!options.codeHotspotsEnabled
-    this._cpuProfilingEnabled = !!options.cpuProfilingEnabled
     this._endpointCollectionEnabled = !!options.endpointCollectionEnabled
-    this._flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
-    this._samplingIntervalMicros = options.samplingInterval || 1e6 / 99 // 99hz
     this._timelineEnabled = !!options.timelineEnabled
-    this._v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
+    this._cpuProfilingEnabled = !!options.cpuProfilingEnabled
     // We need to capture span data into the sample context for either code hotspots
     // or endpoint collection.
     this._captureSpanData = this._codeHotspotsEnabled || this._endpointCollectionEnabled
@@ -88,6 +84,7 @@ class NativeWallProfiler {
     // timestamps require the sample contexts feature in the pprof wall profiler), or
     // cpu profiling is enabled.
     this._withContexts = this._captureSpanData || this._timelineEnabled || this._cpuProfilingEnabled
+    this._v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
     this._mapper = undefined
     this._pprof = undefined
 
@@ -128,14 +125,13 @@ class NativeWallProfiler {
     }
 
     this._pprof.time.start({
-      collectAsyncId: this._asyncIdEnabled,
-      collectCpuTime: this._cpuProfilingEnabled,
-      durationMillis: this._flushIntervalMillis,
       intervalMicros: this._samplingIntervalMicros,
-      lineNumbers: false,
+      durationMillis: this._flushIntervalMillis,
       sourceMapper: this._mapper,
       withContexts: this._withContexts,
-      workaroundV8Bug: this._v8ProfilerBugWorkaroundEnabled
+      lineNumbers: false,
+      workaroundV8Bug: this._v8ProfilerBugWorkaroundEnabled,
+      collectCpuTime: this._cpuProfilingEnabled
     })
 
     if (this._withContexts) {

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

@@ -23,8 +23,8 @@ class SpanAggStats {
     this.topLevelHits = 0
     this.errors = 0
     this.duration = 0
-    this.okDistribution = new LogCollapsingLowestDenseDDSketch(0.00775)
-    this.errorDistribution = new LogCollapsingLowestDenseDDSketch(0.00775)
+    this.okDistribution = new LogCollapsingLowestDenseDDSketch()
+    this.errorDistribution = new LogCollapsingLowestDenseDDSketch()
   }
 
   record (span) {