dd-trace 5.80.0 → 5.81.0

package/packages/dd-trace/src/llmobs/plugins/openai/utils.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const IMAGE_FALLBACK = '[image]'
+const FILE_FALLBACK = '[file]'
+
+const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g
+
+/**
+ * Extracts chat templates from OpenAI response instructions by replacing variable values with placeholders.
+ *
+ * Performs reverse templating: reconstructs the template by replacing actual values with {{variable_name}}.
+ * For images/files: uses {{variable_name}} when values are available, falls back to [image]/[file] when stripped.
+ *
+ * @param {Array<Object>} instructions - From Response.instructions (array of ResponseInputMessageItem)
+ * @param {Object<string, string>} variables - Normalized variables (output of normalizePromptVariables)
+ * @returns {Array<{role: string, content: string}>} Chat template with placeholders
+ */
+function extractChatTemplateFromInstructions (instructions, variables) {
+  if (!Array.isArray(instructions) || !variables) return []
+
+  const chatTemplate = []
+
+  // Build map of values to placeholders - exclude fallback markers so they remain as-is
+  const valueToPlaceholder = {}
+  for (const [varName, varValue] of Object.entries(variables)) {
+    // Exclude fallback markers - they should remain as [image]/[file] in the template
+    if (varValue && varValue !== IMAGE_FALLBACK && varValue !== FILE_FALLBACK) {
+      valueToPlaceholder[varValue] = `{{${varName}}}`
+    }
+  }
+
+  // Sort values by length (longest first) to handle overlapping values correctly
+  const sortedValues = Object.keys(valueToPlaceholder).sort((a, b) => b.length - a.length)
+
+  for (const instruction of instructions) {
+    const role = instruction.role
+    if (!role) continue
+
+    const contentItems = instruction.content
+    if (!Array.isArray(contentItems)) continue
+
+    // Extract text from all content items (uses actual values for images/files when available)
+    const textParts = contentItems
+      .map(extractTextFromContentItem)
+      .filter(Boolean)
+
+    if (textParts.length === 0) continue
+
+    // Combine text and replace variable values with placeholders (longest first)
+    let fullText = textParts.join('')
+    for (const valueStr of sortedValues) {
+      const placeholder = valueToPlaceholder[valueStr]
+      const escapedValue = valueStr.replaceAll(REGEX_SPECIAL_CHARS, String.raw`\$&`)
+      fullText = fullText.replaceAll(new RegExp(escapedValue, 'g'), placeholder)
+    }
+
+    chatTemplate.push({ role, content: fullText })
+  }
+
+  return chatTemplate
+}
+
+/**
+ * Extracts text content from a content item, using actual image_url/file_id values when available.
+ *
+ * Used for both input messages and chat template extraction. Falls back to [image]/[file] markers
+ * when the actual values are stripped (e.g., by OpenAI's default URL stripping behavior).
+ *
+ * @param {Object} contentItem - Content item from Response.instructions[].content (ResponseInputContentItem)
+ * @returns {string|null} Text content, URL/file reference, or [image]/[file] fallback marker
+ */
+function extractTextFromContentItem (contentItem) {
+  if (!contentItem) return null
+
+  if (contentItem.text) {
+    return contentItem.text
+  }
+
+  // For image/file items, extract the actual reference value
+  if (contentItem.type === 'input_image') {
+    return contentItem.image_url || contentItem.file_id || IMAGE_FALLBACK
+  }
+
+  if (contentItem.type === 'input_file') {
+    return contentItem.file_id || contentItem.file_url || contentItem.filename || FILE_FALLBACK
+  }
+
+  return null
+}
+
+/**
+ * Normalizes prompt variables by extracting meaningful values from OpenAI SDK response objects.
+ *
+ * Converts ResponseInputText, ResponseInputImage, and ResponseInputFile objects to simple string values.
+ *
+ * @param {Object<string, string|Object>} variables - From ResponsePrompt.variables
+ * @returns {Object<string, string>} Normalized variables with simple string values
+ */
+function normalizePromptVariables (variables) {
+  if (!variables) return {}
+
+  return Object.fromEntries(
+    Object.entries(variables).map(([key, value]) => [
+      key,
+      extractTextFromContentItem(value) ?? String(value ?? '')
+    ])
+  )
+}
+
+module.exports = {
+  extractChatTemplateFromInstructions,
+  normalizePromptVariables,
+  extractTextFromContentItem
+}

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

@@ -410,6 +410,11 @@ class LLMObs extends NoopLLMObs {
         }
       }
 
+      // When OTel tracing is enabled, add source:otel tag to allow backend to wait for OTel span conversion
+      if (isTrue(getEnvironmentVariable('DD_TRACE_OTEL_ENABLED'))) {
+        evaluationTags.source = 'otel'
+      }
+
       const payload = {
         span_id: spanId,
         trace_id: traceId,

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

@@ -126,6 +126,11 @@ class LLMObsSpanProcessor {
       inputType = 'value'
     }
 
+    // Handle prompt metadata for reusable prompts
+    if (mlObsTags['_ml_obs.meta.input.prompt']) {
+      input.prompt = mlObsTags['_ml_obs.meta.input.prompt']
+    }
+
     if (spanKind === 'llm' && mlObsTags[OUTPUT_MESSAGES]) {
       llmObsSpan.output = mlObsTags[OUTPUT_MESSAGES]
       outputType = 'messages'
@@ -207,7 +212,7 @@ class LLMObsSpanProcessor {
     const seenObjects = new WeakSet([obj])
 
     const isCircular = value => {
-      if (typeof value !== 'object') return false
+      if (value == null || typeof value !== 'object') return false
       if (seenObjects.has(value)) return true
       seenObjects.add(value)
       return false

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

@@ -25,6 +25,7 @@ const {
   INPUT_TOKENS_METRIC_KEY,
   OUTPUT_TOKENS_METRIC_KEY,
   TOTAL_TOKENS_METRIC_KEY,
+  REASONING_OUTPUT_TOKENS_METRIC_KEY,
   INTEGRATION,
   DECORATOR,
   PROPAGATED_ML_APP_KEY
@@ -164,6 +165,9 @@ class LLMObsTagger {
         case 'cacheWriteTokens':
           processedKey = CACHE_WRITE_INPUT_TOKENS_METRIC_KEY
           break
+        case 'reasoningOutputTokens':
+          processedKey = REASONING_OUTPUT_TOKENS_METRIC_KEY
+          break
       }
 
       if (typeof value === 'number') {

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

@@ -70,8 +70,8 @@ function initializeOpenTelemetryLogs (config) {
   // Create batch processor for exporting logs to Datadog Agent
   const processor = new BatchLogRecordProcessor(
     exporter,
-    config.otelLogsBatchTimeout,
-    config.otelLogsMaxExportBatchSize
+    config.otelBatchTimeout,
+    config.otelMaxExportBatchSize
   )
 
   // Create logger provider with processor for Datadog Agent export

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

@@ -1,8 +1,9 @@
 'use strict'
 
-const { sanitizeAttributes } = require('@opentelemetry/core')
+const { sanitizeAttributes } = require('../../../../../vendor/dist/@opentelemetry/core')
 const { context } = require('@opentelemetry/api')
-const packageVersion = require('../../../../../package.json').version
+const { VERSION: packageVersion } = require('../../../../../version')
+
 /**
  * @typedef {import('@opentelemetry/api-logs').LogRecord} LogRecord
  * @typedef {import('@opentelemetry/api-logs').LoggerProvider} LoggerProvider

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

@@ -11,7 +11,7 @@ const OtlpTransformer = require('./otlp_transformer')
 /**
  * OtlpHttpLogExporter exports log records via OTLP over HTTP.
  *
- * This implementation follows the OTLP HTTP specification:
+ * This implementation follows the OTLP HTTP v1.7.0 specification:
  * https://opentelemetry.io/docs/specs/otlp/#otlphttp
  *
  * @class OtlpHttpLogExporter
@@ -37,6 +37,8 @@ class OtlpHttpLogExporter extends OtlpHttpExporterBase {
    *
    * @param {LogRecord[]} logRecords - Array of enriched log records to export
    * @param {Function} resultCallback - Callback function for export result
+   *
+   * @returns {void}
    */
   export (logRecords, resultCallback) {
     if (logRecords.length === 0) {
@@ -45,8 +47,8 @@ class OtlpHttpLogExporter extends OtlpHttpExporterBase {
     }
 
     const payload = this.transformer.transformLogRecords(logRecords)
-    this._sendPayload(payload, resultCallback)
-    this._recordTelemetry('otel.log_records', logRecords.length)
+    this.sendPayload(payload, resultCallback)
+    this.recordTelemetry('otel.log_records', logRecords.length)
   }
 }
 

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

@@ -40,7 +40,7 @@ const SEVERITY_MAP = {
 /**
  * OtlpTransformer transforms log records to OTLP format.
  *
- * This implementation follows the OTLP Logs Data Model specification:
+ * This implementation follows the OTLP Logs v1.7.0 Data Model specification:
  * https://opentelemetry.io/docs/specs/otlp/#log-data-model
  *
  * @class OtlpTransformer
@@ -79,12 +79,12 @@ class OtlpTransformer extends OtlpTransformerBase {
 
     const logsData = {
       resourceLogs: [{
-        resource: this._transformResource(),
+        resource: this.transformResource(),
         scopeLogs: this.#transformScope(logRecords),
       }]
     }
 
-    return this._serializeToProtobuf(protoLogsService, logsData)
+    return this.serializeToProtobuf(protoLogsService, logsData)
   }
 
   /**
@@ -95,11 +95,11 @@ class OtlpTransformer extends OtlpTransformerBase {
   #transformToJson (logRecords) {
     const logsData = {
       resourceLogs: [{
-        resource: this._transformResource(),
+        resource: this.transformResource(),
         scopeLogs: this.#transformScope(logRecords)
       }]
     }
-    return this._serializeToJson(logsData)
+    return this.serializeToJson(logsData)
   }
 
   /**
@@ -108,7 +108,7 @@ class OtlpTransformer extends OtlpTransformerBase {
    * @returns {Object[]} Array of scope log objects
    */
   #transformScope (logRecords) {
-    const groupedRecords = this._groupByInstrumentationScope(logRecords)
+    const groupedRecords = this.groupByInstrumentationScope(logRecords)
     const scopeLogs = []
 
     for (const records of groupedRecords.values()) {
@@ -155,7 +155,7 @@ class OtlpTransformer extends OtlpTransformerBase {
     }
 
     if (logRecord.attributes) {
-      result.attributes = this._transformAttributes(logRecord.attributes)
+      result.attributes = this.transformAttributes(logRecord.attributes)
     }
 
     if (spanContext?.traceFlags !== undefined) {
@@ -232,7 +232,7 @@ class OtlpTransformer extends OtlpTransformerBase {
         kvlistValue: {
           values: Object.entries(body).map(([key, value]) => ({
             key,
-            value: this._transformAnyValue(value)
+            value: this.transformAnyValue(value)
           }))
         }
       }

package/packages/dd-trace/src/opentelemetry/metrics/constants.js

@@ -0,0 +1,34 @@
+'use strict'
+
+// Metric type constants
+const METRIC_TYPES = {
+  HISTOGRAM: 'histogram',
+  COUNTER: 'counter',
+  UPDOWNCOUNTER: 'updowncounter',
+  OBSERVABLECOUNTER: 'observable-counter',
+  OBSERVABLEUPDOWNCOUNTER: 'observable-updowncounter',
+  GAUGE: 'gauge'
+}
+
+// Temporality constants
+const TEMPORALITY = {
+  DELTA: 'DELTA',
+  CUMULATIVE: 'CUMULATIVE',
+  GAUGE: 'GAUGE',
+  LOWMEMORY: 'LOWMEMORY'
+}
+
+// Default histogram bucket boundaries (in milliseconds for latency metrics)
+const DEFAULT_HISTOGRAM_BUCKETS = [0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10_000]
+
+// Maximum number of measurements to queue before dropping
+// This limit corresponds to the maximum number of items
+// that be reliably added to a single Array.
+const DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE = 65_536
+
+module.exports = {
+  METRIC_TYPES,
+  TEMPORALITY,
+  DEFAULT_HISTOGRAM_BUCKETS,
+  DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE
+}

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

@@ -0,0 +1,81 @@
+'use strict'
+
+const os = require('os')
+
+/**
+ * @typedef {import('../../config')} Config
+ */
+
+/**
+ * @file OpenTelemetry Metrics Implementation for dd-trace-js
+ *
+ * This package provides a custom OpenTelemetry Metrics implementation that integrates
+ * with the Datadog tracing library. It includes all necessary components for
+ * creating instruments, recording measurements, and exporting metrics via OTLP.
+ *
+ * Key Components:
+ * - MeterProvider: Main entry point for creating meters
+ * - Meter: Provides methods to create metric instruments
+ * - Instruments: Gauge, Counter, UpDownCounter, ObservableGauge, ObservableCounter, ObservableUpDownCounter, Histogram
+ * - PeriodicMetricReader: Collects and exports instruments (metrics) at regular intervals
+ * - OtlpHttpMetricExporter: Exports instruments (metrics) via OTLP over HTTP
+ * - OtlpTransformer: Transforms instruments (metrics) to OTLP format
+ *
+ * This is a custom implementation to avoid pulling in the full OpenTelemetry SDK,
+ * based on OTLP Protocol v1.7.0. It supports both protobuf and JSON serialization
+ * formats and integrates with Datadog's configuration system.
+ *
+ * @package
+ */
+
+const { metrics } = require('@opentelemetry/api')
+const MeterProvider = require('./meter_provider')
+const PeriodicMetricReader = require('./periodic_metric_reader')
+const OtlpHttpMetricExporter = require('./otlp_http_metric_exporter')
+
+/**
+ * Initializes OpenTelemetry Metrics support
+ * @param {Config} config - Tracer configuration instance
+ */
+function initializeOpenTelemetryMetrics (config) {
+  const resourceAttributes = {
+    'service.name': config.service,
+    'service.version': config.version,
+    'deployment.environment': config.env
+  }
+
+  if (config.tags) {
+    const filteredTags = { ...config.tags }
+    delete filteredTags.service
+    delete filteredTags.version
+    delete filteredTags.env
+    Object.assign(resourceAttributes, filteredTags)
+  }
+
+  if (config.reportHostname) {
+    resourceAttributes['host.name'] = os.hostname()
+  }
+
+  const exporter = new OtlpHttpMetricExporter(
+    config.otelMetricsUrl,
+    config.otelMetricsHeaders,
+    config.otelMetricsTimeout,
+    config.otelMetricsProtocol,
+    resourceAttributes
+  )
+
+  const reader = new PeriodicMetricReader(
+    exporter,
+    config.otelMetricsExportInterval,
+    config.otelMetricsTemporalityPreference,
+    config.otelMaxQueueSize
+  )
+
+  const meterProvider = new MeterProvider({ reader })
+  metrics.setGlobalMeterProvider(meterProvider)
+}
+
+module.exports = {
+  MeterProvider,
+  initializeOpenTelemetryMetrics
+}

package/packages/dd-trace/src/opentelemetry/metrics/instruments.js

@@ -0,0 +1,225 @@
+'use strict'
+
+const { sanitizeAttributes } = require('../../../../../vendor/dist/@opentelemetry/core')
+const { METRIC_TYPES } = require('./constants')
+
+/**
+ * @typedef {import('@opentelemetry/api').Attributes} Attributes
+ * @typedef {import('@opentelemetry/core').InstrumentationScope} InstrumentationScope
+ */
+
+/**
+ * @typedef {Object} Measurement
+ * @property {string} name - Instrument name
+ * @property {string} description - Instrument description
+ * @property {string} unit - Measurement unit
+ * @property {InstrumentationScope} instrumentationScope - Instrumentation scope
+ * @property {string} type - Metric type from METRIC_TYPES
+ * @property {number} value - Measured value
+ * @property {Attributes} attributes - Sanitized metric attributes
+ * @property {number} timestamp - Timestamp in nanoseconds
+ */
+
+/**
+ * Base class for all metric instruments.
+ *
+ *
+ */
+class Instrument {
+  /**
+   * Creates a new instrument instance.
+   *
+   * @param {string} name - Instrument name (e.g., 'http.request.duration')
+   * @param {Object} options - Instrument configuration options
+   * @param {string} [options.description] - Human-readable description of the instrument
+   * @param {string} [options.unit] - Unit of measurement (e.g., 'ms', 'bytes', '1')
+   * @param {InstrumentationScope} instrumentationScope - Instrumentation scope for this instrument
+   * @param {Object} reader - Metric reader for recording measurements
+   */
+  constructor (name, options, instrumentationScope, reader) {
+    this.name = name
+    this.description = options.description ?? ''
+    this.unit = options.unit ?? ''
+    this.valueType = options.valueType // currently ignored, TODO: add support for ValueType
+    this.advice = options.advice // currently ignored, TODO: add support for MetricAdvice
+    this.instrumentationScope = instrumentationScope
+    this.reader = reader
+  }
+
+  /**
+   * Creates a measurement object for recording metric values.
+   * @param {string} type - Metric type from METRIC_TYPES
+   * @param {number} value - Numeric value to record
+   * @param {Attributes} attributes - Key-value pairs for metric dimensions
+   * @returns {Measurement} Measurement object with metadata and timestamp
+   */
+  createMeasurement (type, value, attributes) {
+    return {
+      name: this.name,
+      description: this.description,
+      unit: this.unit,
+      instrumentationScope: this.instrumentationScope,
+      type,
+      value,
+      attributes: sanitizeAttributes(attributes),
+      timestamp: Number(process.hrtime.bigint())
+    }
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry Counter interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.Counter.html
+ * @class Counter
+ */
+class Counter extends Instrument {
+  add (value, attributes = {}) {
+    if (value < 0) return
+    this.reader?.record(this.createMeasurement(METRIC_TYPES.COUNTER, value, attributes))
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry UpDownCounter interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.UpDownCounter.html
+ * @class UpDownCounter
+ */
+class UpDownCounter extends Instrument {
+  add (value, attributes = {}) {
+    this.reader?.record(this.createMeasurement(METRIC_TYPES.UPDOWNCOUNTER, value, attributes))
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry Histogram interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.Histogram.html
+ * @class Histogram
+ */
+class Histogram extends Instrument {
+  record (value, attributes = {}) {
+    if (value < 0) return
+    this.reader?.record(this.createMeasurement(METRIC_TYPES.HISTOGRAM, value, attributes))
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry Gauge interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.Gauge.html
+ * @class Gauge
+ */
+class Gauge extends Instrument {
+  record (value, attributes = {}) {
+    this.reader?.record(this.createMeasurement(METRIC_TYPES.GAUGE, value, attributes))
+  }
+}
+
+/**
+ * Base class for observable (asynchronous) instruments.
+ * Implementation of the OpenTelemetry Observable interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.Observable.html
+ *
+ */
+class ObservableInstrument extends Instrument {
+  #callbacks = []
+  #type
+
+  constructor (name, options, instrumentationScope, reader, type) {
+    super(name, options, instrumentationScope, reader)
+    this.#type = type
+  }
+
+  /**
+   * Adds a callback to invoke during metric collection.
+   *
+   * @param {Function} callback - Receives an ObservableResult to record observations
+   */
+  addCallback (callback) {
+    if (typeof callback !== 'function') return
+    this.#callbacks.push(callback)
+    this.reader?.observableInstruments.add(this)
+  }
+
+  /**
+   * Removes a callback.
+   *
+   * @param {Function} callback - The callback to remove
+   */
+  removeCallback (callback) {
+    const index = this.#callbacks.indexOf(callback)
+    if (index !== -1) {
+      this.#callbacks.splice(index, 1)
+      if (this.#callbacks.length === 0) {
+        // Remove instrument from collection when no callbacks remain
+        this.reader?.observableInstruments.delete(this)
+      }
+    }
+  }
+
+  /**
+   * Collects observations from all callbacks. Errors are silently ignored.
+   *
+   * @returns {Array<Measurement>} Array of measurements
+   */
+  collect () {
+    const observations = []
+    const observableResult = {
+      observe: (value, attributes = {}) => {
+        observations.push(this.createMeasurement(this.#type, value, attributes))
+      }
+    }
+
+    for (const callback of this.#callbacks) {
+      try {
+        callback(observableResult)
+      } catch {
+        // Ignore callback errors per OpenTelemetry spec to prevent disruption
+        // Errors are swallowed as callbacks should not break metric collection
+      }
+    }
+
+    return observations
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry ObservableGauge interface:
+ * https://open-telemetry.github.io/opentelemetry-js/types/_opentelemetry_api._opentelemetry_api.ObservableGauge.html
+ * @class ObservableGauge
+ */
+class ObservableGauge extends ObservableInstrument {
+  constructor (name, options, instrumentationScope, reader) {
+    super(name, options, instrumentationScope, reader, METRIC_TYPES.GAUGE)
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry ObservableCounter interface:
+ * https://open-telemetry.github.io/opentelemetry-js/types/_opentelemetry_api._opentelemetry_api.ObservableCounter.html
+ * @class ObservableCounter
+ */
+class ObservableCounter extends ObservableInstrument {
+  constructor (name, options, instrumentationScope, reader) {
+    super(name, options, instrumentationScope, reader, METRIC_TYPES.OBSERVABLECOUNTER)
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry ObservableUpDownCounter interface:
+ * https://open-telemetry.github.io/opentelemetry-js/types/_opentelemetry_api._opentelemetry_api.ObservableUpDownCounter.html
+ * @class ObservableUpDownCounter
+ */
+class ObservableUpDownCounter extends ObservableInstrument {
+  constructor (name, options, instrumentationScope, reader) {
+    super(name, options, instrumentationScope, reader, METRIC_TYPES.OBSERVABLEUPDOWNCOUNTER)
+  }
+}
+
+module.exports = {
+  Counter,
+  UpDownCounter,
+  Histogram,
+  Gauge,
+  ObservableGauge,
+  ObservableCounter,
+  ObservableUpDownCounter
+}