dd-trace 6.8.0 → 6.10.0

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

@@ -3,7 +3,6 @@
 const { channel } = require('dc-polyfill')
 
 const { isError } = require('../util')
-const tracerVersion = require('../../../../package.json').version
 const logger = require('../log')
 const { getValueFromEnvSources } = require('../config/helper')
 const Span = require('../opentracing/span')
@@ -13,6 +12,17 @@ const {
   INPUT_VALUE,
   TRACE_ID,
 } = require('./constants/tags')
+const {
+  FEEDBACK_METRIC_TYPES,
+  FEEDBACK_TARGET_KEYS,
+  buildMetricTags,
+  validateAssessment,
+  validateLabel,
+  validateMetricType,
+  validateMetricValue,
+  validateReasoning,
+  validateTimestamp,
+} = require('./eval-metric')
 const {
   getFunctionArguments,
   validateKind,
@@ -392,92 +402,35 @@ class LLMObs extends NoopLLMObs {
       }
 
       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')
-      }
+      validateTimestamp(timestampMs, 'evaluation')
 
       const { label, value, tags, reasoning, assessment, metadata } = 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', 'boolean', 'json'].includes(metricType)) {
-        err = 'invalid_metric_type'
-        throw new Error('metricType must be one of "categorical", "score", "boolean" or "json"')
-      }
-      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.')
-      }
-      if (metricType === 'boolean' && typeof value !== 'boolean') {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a boolean for a boolean metric')
-      }
-      if (metricType === 'json' && (typeof value !== 'object' || value == null || Array.isArray(value))) {
-        err = 'invalid_metric_value'
-        throw new Error('value must be a JSON object for a json metric')
-      }
-      if (assessment != null && assessment !== 'pass' && assessment !== 'fail') {
-        err = 'invalid_assessment'
-        throw new Error('assessment must be pass or fail')
-      }
-      if (reasoning != null && typeof reasoning !== 'string') {
-        err = 'invalid_reasoning'
-        throw new Error('reasoning must be a string')
-      }
+      const labelValue = validateLabel(label, 'evaluation')
+      validateMetricType(metricType, 'evaluation')
+      validateMetricValue(metricType, value)
+      validateAssessment(assessment)
+      validateReasoning(reasoning)
       if (metadata != null && (typeof metadata !== 'object' || Array.isArray(metadata))) {
         err = 'invalid_metadata'
         throw new Error('metadata must be a JSON object')
       }
 
-      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
-            err = 'invalid_tags'
-            throw new Error('Failed to parse tags. Tags for evaluation metrics must be strings')
-          }
-        }
-      }
-
-      // When OTel tracing is enabled, add source:otel tag to allow backend to wait for OTel span conversion
-      if (this._config.DD_TRACE_OTEL_ENABLED) {
-        evaluationTags.source = 'otel'
-      }
-
       const payload = {
+        event_kind: 'evaluation',
         join_on: {
           span: {
             span_id: spanId,
             trace_id: traceId,
           },
         },
-        label,
+        label: labelValue,
         metric_type: metricType,
         ml_app: mlApp,
         [`${metricType}_value`]: value,
         timestamp_ms: timestampMs,
-        tags: Object.entries(evaluationTags).map(([key, value]) => `${key}:${value}`),
+        // When OTel tracing is enabled, `source:otel` lets the backend wait for OTel span conversion
+        tags: buildMetricTags(tags, mlApp, 'evaluation', this._config.DD_TRACE_OTEL_ENABLED),
       }
       if (reasoning != null) {
         payload.reasoning = reasoning
@@ -491,11 +444,139 @@ class LLMObs extends NoopLLMObs {
       const currentStore = storage.getStore()
       const routing = currentStore?.routingContext
       evalMetricAppendCh.publish({ payload, routing })
+    } catch (e) {
+      if (e.ddErrorTag) err = e.ddErrorTag
+      throw e
     } finally {
       telemetry.recordSubmitEvaluation(options, err)
     }
   }
 
+  /**
+   * Submits end-user feedback for a span, trace, session, or customer-defined entity.
+   *
+   * Exactly one target must be provided: `span` (as returned by `llmobs.exportSpan()`) or
+   * `spanId` to target a span, `traceId` a trace, `sessionId` a session, or `feedbackJoinKey`
+   * a customer-defined entity.
+   * `label`, `metricType`, `value` and `submitter` are required, and are validated at call time.
+   * @param {object} [options] - The feedback options.
+   * @param {string} [options.label] - The name of the feedback metric.
+   * @param {'categorical' | 'score' | 'boolean' | 'json' | 'text'} [options.metricType] - The value type.
+   * @param {string | number | boolean | Record<string, unknown>} [options.value] - The feedback value,
+   *   matching `metricType`.
+   * @param {{ id: string, type?: string }} [options.submitter] - Who submitted the feedback.
+   * @param {{ traceId: string, spanId: string }} [options.span] - Span context to attach the feedback to.
+   * @param {string} [options.spanId] - ID of the span to attach the feedback to.
+   * @param {string} [options.traceId] - ID of the trace to attach the feedback to.
+   * @param {string} [options.sessionId] - ID of the session to attach the feedback to.
+   * @param {string} [options.feedbackJoinKey] - Customer-defined key to attach the feedback to.
+   * @param {Record<string, string>} [options.tags] - Tags to attach to the feedback.
+   * @param {string} [options.mlApp] - The ML app name. Defaults to the configured one.
+   * @param {number} [options.timestampMs] - When the feedback was generated. Defaults to now.
+   * @param {'pass' | 'fail'} [options.assessment] - Assessment of the feedback.
+   * @param {string} [options.reasoning] - Explanation of the feedback.
+   * @returns {void}
+   */
+  submitFeedback (options = {}) {
+    if (!this.enabled) return
+
+    let err = ''
+    let targetType = 'other'
+    let metricTypeTag = 'other'
+    try {
+      const { span, spanId, traceId, sessionId, feedbackJoinKey, submitter } = options
+
+      // Resolved before any validation so telemetry still reports the metric type of a
+      // submission that fails on an unrelated field.
+      const metricType = options.metricType?.toLowerCase()
+      if (FEEDBACK_METRIC_TYPES.includes(metricType)) metricTypeTag = metricType
+
+      // The intake keys feedback off a single top-level identifier, so more than one target
+      // would be ambiguous and none would leave the feedback unattached. `span` also carries a
+      // traceId, but passing it is wire-equivalent to passing its `spanId` directly.
+      let targetName, targetValue
+      let targetCount = 0
+      if (span != null) { targetName = 'span'; targetValue = span.spanId; targetCount++ }
+      if (spanId != null) { targetName = 'spanId'; targetValue = spanId; targetCount++ }
+      if (traceId != null) { targetName = 'traceId'; targetValue = traceId; targetCount++ }
+      if (sessionId != null) { targetName = 'sessionId'; targetValue = sessionId; targetCount++ }
+      if (feedbackJoinKey != null) { targetName = 'feedbackJoinKey'; targetValue = feedbackJoinKey; targetCount++ }
+
+      if (targetCount !== 1) {
+        err = 'invalid_target_count'
+        throw new Error(
+          'Exactly one of `span`, `spanId`, `traceId`, `sessionId` or `feedbackJoinKey` ' +
+          'must be specified to submit feedback.'
+        )
+      }
+
+      targetType = FEEDBACK_TARGET_KEYS[targetName]
+      if (typeof targetValue !== 'string' || !targetValue) {
+        if (targetName === 'span') {
+          err = 'invalid_span'
+          throw new TypeError(
+            '`span` must be an object containing a non-empty string spanId. ' +
+            '`llmobs.exportSpan()` can be used to generate this object from a given span.'
+          )
+        }
+        err = `invalid_${targetType}`
+        throw new TypeError(`\`${targetName}\` must be a non-empty string`)
+      }
+
+      if (typeof submitter?.id !== 'string' || !submitter.id) {
+        err = 'invalid_submitter'
+        throw new TypeError('submitter must be an object containing a non-empty string id')
+      }
+      if (submitter.type != null && typeof submitter.type !== 'string') {
+        err = 'invalid_submitter'
+        throw new TypeError('submitter.type must be a string')
+      }
+
+      const mlApp = options.mlApp || this._config.llmobs.mlApp
+      if (!mlApp) {
+        err = 'missing_ml_app'
+        throw new Error('ML App name is required for sending feedback. Feedback data will not be sent.')
+      }
+
+      const timestampMs = options.timestampMs || Date.now()
+      validateTimestamp(timestampMs, 'feedback')
+
+      const { label, value, tags, reasoning, assessment } = options
+      const labelValue = validateLabel(label, 'feedback')
+      validateMetricType(metricType, 'feedback')
+      validateMetricValue(metricType, value)
+      validateAssessment(assessment)
+      validateReasoning(reasoning)
+
+      const payload = {
+        event_kind: 'feedback',
+        [targetType]: targetValue,
+        label: labelValue,
+        metric_type: metricType,
+        ml_app: mlApp,
+        [`${metricType}_value`]: value,
+        timestamp_ms: timestampMs,
+        tags: buildMetricTags(tags, mlApp, 'feedback'),
+        submitter: submitter.type == null ? { id: submitter.id } : { id: submitter.id, type: submitter.type },
+      }
+      if (reasoning != null) {
+        payload.reasoning = reasoning
+      }
+      if (assessment != null) {
+        payload.assessment = assessment
+      }
+
+      const currentStore = storage.getStore()
+      const routing = currentStore?.routingContext
+      evalMetricAppendCh.publish({ payload, routing })
+    } catch (e) {
+      if (e.ddErrorTag) err = e.ddErrorTag
+      throw e
+    } finally {
+      telemetry.recordSubmitFeedback(metricTypeTag, targetType, err)
+    }
+  }
+
   annotationContext (options, fn) {
     if (!this.enabled) return fn()
 

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

@@ -27,6 +27,8 @@ const {
   ML_APP,
   TAGS,
   PARENT_ID_KEY,
+  PARENT_AGENT_NAME,
+  PARENT_AGENT_SPAN_ID,
   SESSION_ID,
   NAME,
   INPUT_PROMPT,
@@ -157,6 +159,20 @@ class LLMObsSpanProcessor {
       this.#addObject(mlObsTags[TOOL_DEFINITIONS], meta.tool_definitions)
     }
 
+    // Surface the agent attribution resolved at registration, but only on spans that actually
+    // have an agent ancestor. The id is always present in that case; the name may be missing when
+    // it arrived id-only over distributed propagation (older/unsafe upstream). Emit the name as
+    // explicit `null` then, matching the cross-language wire shape (dd-trace-py sends null, not an
+    // absent key) so the shared backend and system-tests see the same payload.
+    const parentAgentName = mlObsTags[PARENT_AGENT_NAME]
+    const parentAgentSpanId = mlObsTags[PARENT_AGENT_SPAN_ID]
+    if (parentAgentName != null || parentAgentSpanId != null) {
+      meta.agent_attribution = {
+        pagent_name: parentAgentName ?? null,
+        pagent_span_id: parentAgentSpanId,
+      }
+    }
+
     const llmObsSpan = new LLMObservabilitySpan(spanKind)
 
     if (spanKind === 'llm' && mlObsTags[INPUT_MESSAGES]) {

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

@@ -23,7 +23,11 @@ const {
   OUTPUT_MESSAGES,
   TAGS,
   NAME,
+  PARENT_AGENT_NAME,
+  PARENT_AGENT_SPAN_ID,
   PROPAGATED_PARENT_ID_KEY,
+  PROPAGATED_PARENT_AGENT_ID_KEY,
+  PROPAGATED_PARENT_AGENT_NAME_KEY,
   ROOT_PARENT_ID,
   CACHE_READ_INPUT_TOKENS_METRIC_KEY,
   CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
@@ -57,6 +61,7 @@ const {
 const { storage } = require('./storage')
 const {
   findGenAIAncestorSpanId,
+  resolveAgentAttribution,
   validateCostTags,
   writeBridgeTags,
   validateToolDefinitions,
@@ -173,6 +178,7 @@ class LLMObsTagger {
     this._setTag(span, PARENT_ID_KEY, parentId)
 
     this.#tagSamplingDecision(span, parent)
+    this.#tagAgentAttribution(span, parent)
 
     // apply annotation context
     const annotationContext = storage.getStore()?.annotationContext
@@ -229,6 +235,34 @@ class LLMObsTagger {
     if (samplingDecision != null) this._setTag(span, SAMPLING_DECISION, samplingDecision)
   }
 
+  /**
+   * Store the nearest agent ancestor on the span so it can be surfaced as
+   * `meta.agent_attribution` at finish. Resolved once here, at registration, so downstream
+   * children inherit it with a single lookup rather than walking the ancestor chain.
+   *
+   * @param {import('../opentracing/span')} span
+   * @param {import('../opentracing/span')} [parent] the LLMObs parent span, if any
+   */
+  // TODO: spans whose kind changes after registration (e.g. claude-agent-sdk tools promoted to
+  // sub-agents) will not retroactively update already-finished children's attribution. Follow up.
+  #tagAgentAttribution (span, parent) {
+    let name, spanId
+    if (registry.has(parent)) {
+      // Local LLMObs parent: attribute to it if it is an agent, else inherit its resolution.
+      ({ name, spanId } = resolveAgentAttribution(registry.get(parent), parent))
+    } else if (span.context()._trace.tags[PROPAGATED_PARENT_ID_KEY]) {
+      // Distributed LLMObs parent: inherit the nearest agent propagated from upstream. The
+      // name may be absent when the upstream hop ran an older SDK or its name was not
+      // wire-safe; the id-only case is expected and the backend resolves the name by span id.
+      const traceTags = span.context()._trace.tags
+      name = traceTags[PROPAGATED_PARENT_AGENT_NAME_KEY]
+      spanId = traceTags[PROPAGATED_PARENT_AGENT_ID_KEY]
+    }
+
+    if (name != null) this._setTag(span, PARENT_AGENT_NAME, name)
+    if (spanId != null) this._setTag(span, PARENT_AGENT_SPAN_ID, spanId)
+  }
+
   // TODO: similarly for the following `tag` methods,
   // how can we transition from a span weakmap to core API functionality
   tagLLMIO (span, inputData, outputData) {
@@ -696,6 +730,59 @@ class LLMObsTagger {
     return filteredAudioParts
   }
 
+  // Image counterpart of #filterAudioParts, with the same wire shape and validation.
+  #filterImageParts (imageParts) {
+    if (!Array.isArray(imageParts)) {
+      imageParts = [imageParts]
+    }
+
+    const filteredImageParts = []
+    for (const imagePart of imageParts) {
+      if (imagePart == null || typeof imagePart !== 'object') {
+        this.#handleFailure('Image part must be an object.', 'invalid_io_messages')
+        continue
+      }
+
+      const { mimeType, content, attachmentKey } = imagePart
+
+      if (typeof mimeType !== 'string' || !mimeType) {
+        this.#handleFailure('Image part mimeType must be a non-empty string.', 'invalid_io_messages')
+        continue
+      }
+
+      if (content == null && attachmentKey == null) {
+        this.#handleFailure("Image part must have either 'content' or 'attachmentKey'.", 'invalid_io_messages')
+        continue
+      }
+
+      if (content != null && attachmentKey != null) {
+        this.#handleFailure(
+          "Image part must have only one of 'content' or 'attachmentKey', not both.", 'invalid_io_messages'
+        )
+        continue
+      }
+
+      const imagePartObj = { mime_type: mimeType }
+
+      if (content == null) {
+        if (typeof attachmentKey !== 'string') {
+          this.#handleFailure('Image part attachmentKey must be a string.', 'invalid_io_messages')
+          continue
+        }
+        imagePartObj.attachment_key = attachmentKey
+      } else {
+        if (typeof content !== 'string') {
+          this.#handleFailure('Image part content must be a base64-encoded string.', 'invalid_io_messages')
+          continue
+        }
+        imagePartObj.content = content
+      }
+
+      filteredImageParts.push(imagePartObj)
+    }
+    return filteredImageParts
+  }
+
   #tagMessages (span, data, key) {
     if (!data) {
       return
@@ -723,6 +810,7 @@ class LLMObsTagger {
         toolResults,
         toolId,
         audioParts,
+        imageParts,
       } = message
       const messageObj = {}
 
@@ -764,6 +852,14 @@ class LLMObsTagger {
         }
       }
 
+      if (imageParts != null) {
+        const filteredImageParts = this.#filterImageParts(imageParts)
+
+        if (filteredImageParts.length) {
+          messageObj.image_parts = filteredImageParts
+        }
+      }
+
       if (toolId) {
         if (role === 'tool') {
           condition = this.#tagConditionalString(toolId, 'Tool ID', messageObj, 'tool_id') && condition

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

@@ -183,6 +183,23 @@ function recordSubmitEvaluation (options, err, value = 1) {
   llmobsMetrics.count('evals_submitted', tags).inc(value)
 }
 
+/**
+ * @param {string} metricType - The submitted metric type, `'other'` if unrecognized.
+ * @param {string} targetType - The payload key the feedback was attached to, `'other'` if unresolved.
+ * @param {string} err - The telemetry error tag, empty when the submission succeeded.
+ * @param {number} [value]
+ * @returns {void}
+ */
+function recordSubmitFeedback (metricType, targetType, err, value = 1) {
+  const tags = {
+    error: Number(!!err),
+    metric_type: metricType,
+    target_type: targetType,
+  }
+  if (err) tags.error_type = err
+  llmobsMetrics.count('feedback_submitted', tags).inc(value)
+}
+
 function recordLLMObsUserProcessorCalled (error, value = 1) {
   const tags = { error: error ? 1 : 0 }
   llmobsMetrics.count('user_processor_called', tags).inc(value)
@@ -201,5 +218,6 @@ module.exports = {
   recordUserFlush,
   recordExportSpan,
   recordSubmitEvaluation,
+  recordSubmitFeedback,
   recordLLMObsUserProcessorCalled,
 }

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

@@ -6,6 +6,10 @@ const {
   LLMOBS_PARENT_ID_BRIDGE_KEY,
   LLMOBS_TRACE_ID_BRIDGE_KEY,
   SPAN_KINDS,
+  SPAN_KIND,
+  NAME,
+  PARENT_AGENT_NAME,
+  PARENT_AGENT_SPAN_ID,
 } = require('./constants/tags')
 
 const DECIMAL_TRACE_ID_REGEX = /^\d+$/
@@ -294,6 +298,76 @@ function getFunctionArguments (fn, args = []) {
   }
 }
 
+// The `x-datadog-tags` tagset encoder rejects commas (the entry delimiter) and any byte
+// outside 0x20-0x7E, and a raise there drops the ENTIRE header (taking ml_app,
+// llmobs_trace_id, parent_id, sampling with it). An agent name is arbitrary user text, so it
+// must be skipped rather than sanitized when unsafe: only the digit-safe id then propagates and
+// the backend resolves the real name by span id. `=` is legal in tagset values (illegal only in
+// keys), so a name containing `=` is safe and must not be dropped.
+/**
+ * @param {string} name
+ * @returns {boolean}
+ */
+function agentNameWireSafe (name) {
+  // Conservative slice of the 512B shared tagset budget, mirroring dd-trace-py.
+  if (Buffer.byteLength(name, 'utf8') > 256) return false
+  for (let index = 0; index < name.length; index++) {
+    const code = name.charCodeAt(index)
+    if (code < 0x20 || code > 0x7E || code === 0x2C /* comma */) return false
+  }
+  return true
+}
+
+/**
+ * Resolve the nearest agent that a *child* of `span` should be attributed to.
+ *
+ * If `span` is itself an agent, the child attributes directly to `span`. Otherwise `span`
+ * already resolved its own nearest agent at registration, so the child inherits that with a
+ * single lookup rather than walking the ancestor chain. An agent never attributes itself.
+ *
+ * @param {Record<string, unknown> | undefined} tags - Registry entry for the parent span.
+ * @param {import('../opentracing/span')} [span] - The parent span itself (needed for span id / name).
+ * @returns {{ name: string | undefined, spanId: string | undefined }}
+ */
+function resolveAgentAttribution (tags, span) {
+  if (!tags) return { name: undefined, spanId: undefined }
+  if (tags[SPAN_KIND] === 'agent') {
+    return { name: tags[NAME] || span._name, spanId: span.context().toSpanId() }
+  }
+  return { name: tags[PARENT_AGENT_NAME], spanId: tags[PARENT_AGENT_SPAN_ID] }
+}
+
+/**
+ * Removes all `key=value` entries for the given key from a comma-separated tagset string.
+ *
+ * @param {string} tags - Existing tagset string (may be empty).
+ * @param {string} key
+ * @returns {string}
+ */
+function stripTagsetEntry (tags, key) {
+  if (!tags.includes(key)) return tags
+  return tags.split(',').filter(entry => !entry.startsWith(`${key}=`)).join(',')
+}
+
+/**
+ * Appends `key=value` to the tagset string with a comma separator, but only when `value` is
+ * truthy, passes the optional `safeguard` predicate, and fits within `maxTagSetLength`. Returns
+ * the original `tags` unchanged when the value is absent, unsafe, or would overflow the budget.
+ *
+ * @param {string} tags - Existing tagset string (may be empty).
+ * @param {string} key
+ * @param {string | undefined} value
+ * @param {((v: string) => boolean) | null} [safeguard]
+ * @param {number} [maxTagSetLength]
+ * @returns {string}
+ */
+function appendOptionalPropagatedTag (tags, key, value, safeguard, maxTagSetLength) {
+  if (!value || (safeguard && !safeguard(value))) return tags
+  const entry = `${tags ? ',' : ''}${key}=${value}`
+  if (maxTagSetLength != null && tags.length + entry.length > maxTagSetLength) return tags
+  return `${tags}${entry}`
+}
+
 function spanHasError (span) {
   const spanContext = span.context()
   return !!(spanContext.getTag('error') || spanContext.getTag('error.type'))
@@ -443,6 +517,8 @@ function formatAudioPart (data, mimeType) {
 }
 
 module.exports = {
+  agentNameWireSafe,
+  appendOptionalPropagatedTag,
   audioMimeTypeFromFormat,
   encodeUnicode,
   findGenAIAncestorSpanId,
@@ -450,6 +526,8 @@ module.exports = {
   llmObsTraceIdToWire,
   normalizeLlmObsTraceId,
   formatAudioPart,
+  resolveAgentAttribution,
+  stripTagsetEntry,
   validateCostTags,
   validateKind,
   getFunctionArguments,

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

@@ -88,6 +88,9 @@ class BaseLLMObsWriter {
   }
 
   /**
+   * @param {Record<string, unknown>} event
+   * @param {{ apiKey?: string, site?: string }} [routing]
+   * @param {number} [byteLength]
    * @returns {boolean} `true` if the event was buffered, `false` if it was dropped
    * (e.g. the per-routing buffer was full). Callers that depend on the event
    * actually being submitted should check this value.

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

@@ -7,6 +7,8 @@ const { fetchAgentInfo } = require('../../agent/info')
 
 /**
  * @param {import('../../config/config-base')} config
+ * @param {(agentless: boolean) => void} setWritersAgentlessValue
+ * @returns {void}
  */
 function setAgentStrategy (config, setWritersAgentlessValue) {
   const agentlessEnabled = config.llmobs.agentlessEnabled

package/packages/dd-trace/src/log/channels.js

@@ -2,15 +2,7 @@
 
 const { channel } = require('dc-polyfill')
 
-const Level = {
-  trace: 10,
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  critical: 50,
-  off: 100,
-}
+const Level = require('./levels')
 
 const traceChannel = channel('datadog:log:trace')
 const debugChannel = channel('datadog:log:debug')

package/packages/dd-trace/src/log/levels.js

@@ -0,0 +1,12 @@
+'use strict'
+
+// The guardrails logger requires this file, so it has to parse on Node.js 0.8.
+module.exports = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  critical: 50,
+  off: 100
+}

package/packages/dd-trace/src/openfeature/writers/exposures.js

@@ -63,7 +63,7 @@ class ExposuresWriter extends BaseFFEWriter {
    * @param {import('../../config/config-base')} config - Tracer configuration object
    */
   constructor (config) {
-    const basePath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/+$/, '')
+    const basePath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/$/, '')
     const endpoint = EXPOSURES_ENDPOINT.replace(/^\/+/, '')
     const fullEndpoint = `${basePath}/${endpoint}`
 

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

@@ -18,7 +18,7 @@ function setAgentStrategy (config, setWriterEnabledValue) {
     }
 
     const endpoints = agentInfo.endpoints
-    const normalizedPath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/+$/, '')
+    const normalizedPath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/$/, '')
     const hasEndpoint = Array.isArray(endpoints) &&
       endpoints.includes(normalizedPath) || endpoints.includes(normalizedPath + '/')
 

package/packages/dd-trace/src/opentelemetry/logs/batch_log_processor.js

@@ -22,7 +22,7 @@ class BatchLogRecordProcessor {
   /**
    * Creates a new BatchLogRecordProcessor instance.
    *
-   * @param {OtlpHttpLogExporter} exporter - Log processor for exporting batches to Datadog Agent
+   * @param {import('./otlp_http_log_exporter')} exporter - Log processor for exporting batches to Datadog Agent
    * @param {number} batchTimeout - Timeout in milliseconds for batch processing
    * @param {number} maxExportBatchSize - Maximum number of log records per batch
    */