dd-trace 5.97.0 → 5.99.0

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

@@ -0,0 +1,57 @@
+'use strict'
+
+/**
+ * Formats tool call input as a JSON string.
+ * @param {string} toolName - The name of the tool being called
+ * @param {object} toolArguments - The arguments passed to the tool
+ * @returns {string} Formatted input string
+ */
+function formatInput (toolName, toolArguments) {
+  if (!toolName && !toolArguments) return ''
+
+  if (toolArguments === undefined || toolArguments === null) {
+    return toolName || ''
+  }
+
+  try {
+    return JSON.stringify({ name: toolName, arguments: toolArguments })
+  } catch {
+    return toolName || ''
+  }
+}
+
+/**
+ * Formats MCP tool call result as a structured object matching Python's output format.
+ * MCP tool results contain a `content` array with items like:
+ * `[{ type: 'text', text: '...' }, { type: 'image', data: '...', mimeType: '...' }]`
+ * @param {object} result - The MCP CallToolResult
+ * @returns {string} JSON string of `{ content: Array<{type, text, annotations, meta}>, isError: boolean }`
+ */
+function formatOutput (result) {
+  if (!result) return ''
+
+  const content = result.content
+  const isError = result.isError || false
+
+  const processed = []
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item.type !== 'text') continue
+      const contentBlock = {
+        type: item.type,
+        text: item.text || '',
+        annotations: item.annotations || {},
+        meta: item._meta || {},
+      }
+      processed.push(contentBlock)
+    }
+  }
+
+  try {
+    return JSON.stringify({ content: processed, isError })
+  } catch {
+    return ''
+  }
+}
+
+module.exports = { formatInput, formatOutput }

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

@@ -2,7 +2,7 @@
 
 const { channel } = require('dc-polyfill')
 
-const { isTrue, isError } = require('../util')
+const { isError, isTrue } = require('../util')
 const tracerVersion = require('../../../../package.json').version
 const logger = require('../log')
 const { getValueFromEnvSources } = require('../config/helper')
@@ -427,7 +427,7 @@ class LLMObs extends NoopLLMObs {
       }
 
       // When OTel tracing is enabled, add source:otel tag to allow backend to wait for OTel span conversion
-      if (isTrue(getValueFromEnvSources('DD_TRACE_OTEL_ENABLED'))) {
+      if (this._config.DD_TRACE_OTEL_ENABLED) {
         evaluationTags.source = 'otel'
       }
 

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

@@ -8,7 +8,6 @@ const { getValueFromEnvSources } = require('../config/helper')
 const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
 const { Log, LogConfig, NoTransmitError } = require('./log')
-const { memoize } = require('./utils')
 
 const config = {
   enabled: defaults.DD_TRACE_DEBUG,
@@ -16,11 +15,6 @@ const config = {
   logLevel: defaults.logLevel,
 }
 
-const deprecate = memoize((code, message) => {
-  publishFormatted(errorChannel, null, message)
-  return true
-})
-
 // In most places where we know we want to mute a log we use log.error() directly
 const NO_TRANSMIT = new LogConfig(false)
 
@@ -82,10 +76,6 @@ const log = {
     return log
   },
 
-  deprecate (code, message) {
-    return deprecate(code, message)
-  },
-
   configure (options) {
     config.logger = options.logger
     config.logLevel = options.logLevel ??

package/packages/dd-trace/src/openfeature/eval-metrics-hook.js

@@ -0,0 +1,103 @@
+'use strict'
+
+const log = require('../log')
+
+const METER_NAME = 'dd-trace-js/openfeature'
+const COUNTER_NAME = 'feature_flag.evaluations'
+const COUNTER_DESCRIPTION = 'Number of feature flag evaluations'
+const COUNTER_UNIT = '{evaluation}'
+
+/**
+ * OpenFeature hook that tracks feature flag evaluation metrics using an
+ * OpenTelemetry counter.
+ *
+ * Implements the OpenFeature `finally` hook interface so it can be pushed
+ * directly onto a provider's `hooks` array. We use the `finally` stage
+ * (not diagnostic channels inside the provider's `resolve*` methods) because
+ * the OpenFeature SDK short-circuits before calling the provider when it is in
+ * NOT_READY state; the `finally` hook still fires, ensuring all evaluations are
+ * captured. It also catches type-mismatch errors detected by the SDK client
+ * after the provider returns.
+ *
+ * The counter is created lazily on the first successful `finally()` call rather
+ * than in the constructor. This is necessary because `FlaggingProvider` is
+ * constructed eagerly by `proxy.js#updateTracing()`, which runs *before*
+ * `initializeOpenTelemetryMetrics()` sets the global OTel meter provider.
+ * Calling `getMeter()` in the constructor would return the noop meter and
+ * produce a noop counter that silently discards all measurements. By deferring
+ * to `finally()` time we give the meter provider a chance to be set up first.
+ *
+ * If counter creation fails (e.g. the OTel API is not yet available), the call
+ * is silently skipped and retried on the next `finally()` invocation.
+ *
+ * When `config.otelMetricsEnabled` is false, `finally()` is always a no-op.
+ */
+class EvalMetricsHook {
+  #enabled = false
+  #counter = null
+
+  /**
+   * @param {import('../config')} config - Tracer configuration object
+   */
+  constructor (config) {
+    this.#enabled = config.otelMetricsEnabled === true
+  }
+
+  /**
+   * Returns the OTel counter, creating it on first successful call.
+   * Returns `null` if counter creation fails; will retry on next call.
+   *
+   * @returns {import('@opentelemetry/api').Counter | null}
+   */
+  #getCounter () {
+    if (this.#counter) return this.#counter
+
+    try {
+      const { metrics } = require('@opentelemetry/api')
+      const meter = metrics.getMeter(METER_NAME)
+      this.#counter = meter.createCounter(COUNTER_NAME, {
+        description: COUNTER_DESCRIPTION,
+        unit: COUNTER_UNIT,
+      })
+    } catch (e) {
+      log.warn('EvalMetricsHook: failed to create counter: %s', e.message)
+    }
+
+    return this.#counter
+  }
+
+  /**
+   * Called by the OpenFeature SDK after every flag evaluation (success or error).
+   *
+   * @param {{ flagKey: string }} hookContext - Hook context containing the flag key
+   * @param {{ variant?: string, reason?: string, errorCode?: string, flagMetadata?: object }} evaluationDetails
+   *   - Full evaluation details
+   * @returns {void}
+   */
+  finally (hookContext, evaluationDetails) {
+    if (!this.#enabled) return
+
+    const counter = this.#getCounter()
+    if (!counter) return
+
+    const attributes = {
+      'feature_flag.key': hookContext?.flagKey ?? '',
+      'feature_flag.result.variant': evaluationDetails?.variant ?? '',
+      'feature_flag.result.reason': evaluationDetails?.reason?.toLowerCase() ?? 'unknown',
+    }
+
+    const errorCode = evaluationDetails?.errorCode
+    if (errorCode) {
+      attributes['error.type'] = errorCode.toLowerCase()
+    }
+
+    const allocationKey = evaluationDetails?.flagMetadata?.allocationKey
+    if (allocationKey) {
+      attributes['feature_flag.result.allocation_key'] = allocationKey
+    }
+
+    counter.add(1, attributes)
+  }
+}
+
+module.exports = EvalMetricsHook

package/packages/dd-trace/src/openfeature/flagging_provider.js

@@ -4,6 +4,7 @@ const { DatadogNodeServerProvider } = require('@datadog/openfeature-node-server'
 const { channel } = require('dc-polyfill')
 const log = require('../log')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
+const EvalMetricsHook = require('./eval-metrics-hook')
 
 /**
  * OpenFeature provider that integrates with Datadog's feature flagging system.
@@ -24,6 +25,8 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     this._tracer = tracer
     this._config = config
 
+    this.hooks.push(new EvalMetricsHook(config))
+
     log.debug('%s created with timeout: %dms', this.constructor.name,
       config.experimental.flaggingProvider.initializationTimeoutMs)
   }

package/packages/dd-trace/src/openfeature/remote_config.js

@@ -19,9 +19,14 @@ function enable (rc, config, getOpenfeatureProxy) {
 
   // Set product handler for FFE_FLAGS
   rc.setProductHandler('FFE_FLAGS', (action, conf) => {
-    // Feed UFC config directly to OpenFeature provider
     if (action === 'apply' || action === 'modify') {
+      // Feed UFC config directly to OpenFeature provider
       getOpenfeatureProxy()._setConfiguration(conf)
+    } else if (action === 'unapply') {
+      // Clear the configuration so evaluations return PROVIDER_NOT_READY,
+      // consistent with Go and Python which also set config to null on RC deletion.
+      // The evaluator returns PROVIDER_NOT_READY when config is null/undefined.
+      getOpenfeatureProxy()._setConfiguration(null)
     }
   })
 }

package/packages/dd-trace/src/opentelemetry/context_manager.js

@@ -4,7 +4,6 @@ const { trace, ROOT_CONTEXT, propagation } = require('@opentelemetry/api')
 const { storage } = require('../../../datadog-core')
 const { getAllBaggageItems, setBaggageItem, removeAllBaggageItems } = require('../baggage')
 
-const tracer = require('../../')
 const SpanContext = require('./span_context')
 
 class ContextManager {
@@ -16,7 +15,7 @@ class ContextManager {
   active () {
     const store = this._store.getStore()
     const baseContext = store || ROOT_CONTEXT
-    const activeSpan = tracer.scope().active()
+    const activeSpan = storage('legacy').getStore()?.span
 
     const storedSpan = store ? trace.getSpan(store) : null
 
@@ -60,7 +59,6 @@ class ContextManager {
   // converts otel to dd
   with (context, fn, thisArg, ...args) {
     const span = trace.getSpan(context)
-    const ddScope = tracer.scope()
     const run = () => {
       const cb = thisArg == null ? fn : fn.bind(thisArg)
       return this._store.run(context, cb, ...args)
@@ -74,7 +72,11 @@ class ContextManager {
     for (const baggage of baggageItems) {
       setBaggageItem(baggage[0], baggage[1].value)
     }
-    if (span && span._ddSpan) return ddScope.activate(span._ddSpan, run)
+    if (span && span._ddSpan) {
+      const ddSpan = span._ddSpan
+      const parentStore = storage('legacy').getStore(ddSpan._store) ?? storage('legacy').getStore()
+      return storage('legacy').run({ ...parentStore, span: ddSpan }, run)
+    }
     return run()
   }
 

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

@@ -61,7 +61,7 @@ function initializeOpenTelemetryLogs (config) {
   // Create OTLP exporter using resolved config values
   const exporter = new OtlpHttpLogExporter(
     config.otelLogsUrl,
-    config.otelLogsHeaders,
+    config.OTEL_EXPORTER_OTLP_LOGS_HEADERS,
     config.otelLogsTimeout,
     config.otelLogsProtocol,
     resourceAttributes

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

@@ -22,13 +22,14 @@ class OtlpHttpLogExporter extends OtlpHttpExporterBase {
    * Creates a new OtlpHttpLogExporter instance.
    *
    * @param {string} url - OTLP endpoint URL
-   * @param {string} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {Record<string, string>|undefined} headers - Additional HTTP headers parsed from the
+   *   corresponding `OTEL_EXPORTER_OTLP_*_HEADERS` env by the MAP parser.
    * @param {number} timeout - Request timeout in milliseconds
    * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
    * @param {Resource} resource - Resource attributes
    */
   constructor (url, headers, timeout, protocol, resource) {
-    super(url, headers, timeout, protocol, '/v1/logs', 'logs')
+    super(url, headers, timeout, protocol, 'logs')
     this.transformer = new OtlpTransformer(resource, protocol)
   }
 

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

@@ -58,7 +58,7 @@ function initializeOpenTelemetryMetrics (config) {
 
   const exporter = new OtlpHttpMetricExporter(
     config.otelMetricsUrl,
-    config.otelMetricsHeaders,
+    config.OTEL_EXPORTER_OTLP_METRICS_HEADERS,
     config.otelMetricsTimeout,
     config.otelMetricsProtocol,
     resourceAttributes

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

@@ -18,13 +18,14 @@ class OtlpHttpMetricExporter extends OtlpHttpExporterBase {
    * Creates a new OtlpHttpMetricExporter instance.
    *
    * @param {string} url - OTLP endpoint URL
-   * @param {string} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {Record<string, string>|undefined} headers - Additional HTTP headers parsed from the
+   *   corresponding `OTEL_EXPORTER_OTLP_*_HEADERS` env by the MAP parser.
    * @param {number} timeout - Request timeout in milliseconds
    * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
    * @param {Resource} resource - Resource attributes
    */
   constructor (url, headers, timeout, protocol, resource) {
-    super(url, headers, timeout, protocol, '/v1/metrics', 'metrics')
+    super(url, headers, timeout, protocol, 'metrics')
     this.transformer = new OtlpTransformer(resource, protocol)
   }
 

package/packages/dd-trace/src/opentelemetry/otlp/otlp_http_exporter_base.js

@@ -19,34 +19,31 @@ class OtlpHttpExporterBase {
   /**
    * Creates a new OtlpHttpExporterBase instance.
    *
-   * @param {string} url - OTLP endpoint URL
-   * @param {string|undefined} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {string} url - OTLP endpoint URL (callers are expected to supply the full signal URL)
+   * @param {Record<string, string>|undefined} headers - Additional HTTP headers parsed from the
+   *   corresponding `OTEL_EXPORTER_OTLP_*_HEADERS` env by the MAP parser.
    * @param {number} timeout - Request timeout in milliseconds
    * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
-   * @param {string} defaultPath - Default path to use if URL has no path
    * @param {string} signalType - Signal type for error messages (e.g., 'logs', 'metrics')
    */
-  constructor (url, headers, timeout, protocol, defaultPath, signalType) {
-    const parsedUrl = new URL(url)
-
+  constructor (url, headers, timeout, protocol, signalType) {
     this.protocol = protocol
     this.signalType = signalType
 
-    // If no path is provided, use default path
-    const path = parsedUrl.pathname === '/' ? defaultPath : parsedUrl.pathname
     const isJson = protocol === 'http/json'
 
+    // Initialize fields setUrl doesn't touch; it fills in hostname/port/path below.
     this.options = {
-      hostname: parsedUrl.hostname,
-      port: parsedUrl.port,
-      path: path + parsedUrl.search,
       method: 'POST',
       timeout,
       headers: {
         'Content-Type': isJson ? 'application/json' : 'application/x-protobuf',
-        ...this.#parseAdditionalHeaders(headers),
+        ...headers,
       },
     }
+
+    this.setUrl(url)
+
     this.telemetryTags = [
       'protocol:http',
       `encoding:${isJson ? 'json' : 'protobuf'}`,
@@ -61,6 +58,7 @@ class OtlpHttpExporterBase {
    * @protected
    */
   recordTelemetry (metricName, count, additionalTags) {
+    // @ts-expect-error - additionalTags is optional and can be undefined
     if (additionalTags?.length > 0) {
       tracerMetrics.count(metricName, [...this.telemetryTags, ...additionalTags || []]).inc(count)
     } else {
@@ -91,6 +89,7 @@ class OtlpHttpExporterBase {
       })
 
       res.once('end', () => {
+        // @ts-expect-error - res.statusCode can be undefined
         if (res.statusCode >= 200 && res.statusCode < 300) {
           resultCallback({ code: 0 })
         } else {
@@ -116,46 +115,15 @@ class OtlpHttpExporterBase {
   }
 
   /**
-   * Parses additional HTTP headers from a comma-separated string.
-   * @param {string} [headersString=''] - Comma-separated key=value pairs
-   * @returns {Record<string, string>} Parsed headers object
+   * Updates the target URL used by this exporter. The URL is used as-is per the OTel spec: the
+   * caller is responsible for including the signal-specific path (`/v1/traces` etc.).
+   * @param {string} url - New OTLP endpoint URL
    */
-  #parseAdditionalHeaders (headersString = '') {
-    const headers = {}
-    let key = ''
-    let value = ''
-    let readingKey = true
-
-    for (const char of headersString) {
-      if (readingKey) {
-        if (char === '=') {
-          readingKey = false
-          key = key.trim()
-        } else {
-          key += char
-        }
-      } else if (char === ',') {
-        value = value.trim()
-        if (key && value) {
-          headers[key] = value
-        }
-        key = ''
-        value = ''
-        readingKey = true
-      } else {
-        value += char
-      }
-    }
-
-    // Add the last pair if present
-    if (!readingKey) {
-      value = value.trim()
-      if (value) {
-        headers[key] = value
-      }
-    }
-
-    return headers
+  setUrl (url) {
+    const parsedUrl = new URL(url)
+    this.options.hostname = parsedUrl.hostname
+    this.options.port = parsedUrl.port
+    this.options.path = parsedUrl.pathname + parsedUrl.search
   }
 
   /**

package/packages/dd-trace/src/opentelemetry/otlp/protobuf_loader.js

@@ -1,9 +1,9 @@
 'use strict'
 
 /**
- * Protobuf Loader for OpenTelemetry Logs and Metrics
+ * Protobuf Loader for OpenTelemetry Logs, Traces, and Metrics
  *
- * This module loads protobuf definitions for OpenTelemetry logs and metrics.
+ * This module loads protobuf definitions for OpenTelemetry logs, traces, and metrics.
  *
  * VERSION SUPPORT:
  * - OTLP Protocol: v1.7.0
@@ -20,6 +20,8 @@ const protobuf = require('../../../../../vendor/dist/protobufjs')
 let _root = null
 let protoLogsService = null
 let protoSeverityNumber = null
+let protoTraceService = null
+let protoSpanKind = null
 let protoMetricsService = null
 let protoAggregationTemporality = null
 
@@ -28,6 +30,8 @@ function getProtobufTypes () {
     return {
       protoLogsService,
       protoSeverityNumber,
+      protoTraceService,
+      protoSpanKind,
       protoMetricsService,
       protoAggregationTemporality,
     }
@@ -39,6 +43,8 @@ function getProtobufTypes () {
     'resource.proto',
     'logs.proto',
     'logs_service.proto',
+    'trace.proto',
+    'trace_service.proto',
     'metrics.proto',
     'metrics_service.proto',
   ].map(file => path.join(protoDir, file))
@@ -49,6 +55,10 @@ function getProtobufTypes () {
   protoLogsService = _root.lookupType('opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest')
   protoSeverityNumber = _root.lookupEnum('opentelemetry.proto.logs.v1.SeverityNumber')
 
+  // Get the message types for traces
+  protoTraceService = _root.lookupType('opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest')
+  protoSpanKind = _root.lookupEnum('opentelemetry.proto.trace.v1.SpanKind')
+
   // Get the message types for metrics
   protoMetricsService = _root.lookupType('opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest')
   protoAggregationTemporality = _root.lookupEnum('opentelemetry.proto.metrics.v1.AggregationTemporality')
@@ -56,6 +66,8 @@ function getProtobufTypes () {
   return {
     protoLogsService,
     protoSeverityNumber,
+    protoTraceService,
+    protoSpanKind,
     protoMetricsService,
     protoAggregationTemporality,
   }