dd-trace 5.98.0 → 5.99.0

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,61 +115,15 @@ class OtlpHttpExporterBase {
   }
 
   /**
-   * Parses additional HTTP headers from a comma-separated string or pre-parsed map.
-   * @param {string|Record<string, string>} [headersString=''] - Comma-separated key=value pairs or map
-   * @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 = '') {
-    if (headersString !== null && typeof headersString === 'object') {
-      // The config MAP parser uses tagger.add (which splits on ':'), so OTEL-format
-      // headers ('key=value') arrive with the full 'key=value' string as the map key
-      // and an empty string as the value. Re-split on '=' to get the correct pairs.
-      const result = {}
-      for (const [k, v] of Object.entries(headersString)) {
-        if (v === '' && k.includes('=')) {
-          const idx = k.indexOf('=')
-          result[k.slice(0, idx).trim()] = k.slice(idx + 1).trim()
-        } else {
-          result[k] = v
-        }
-      }
-      return result
-    }
-    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/trace/index.js

@@ -4,7 +4,7 @@ const { VERSION } = require('../../../../../version')
 const OtlpHttpTraceExporter = require('./otlp_http_trace_exporter')
 
 /**
- * @typedef {import('../../config')} Config
+ * @typedef {import('../../config/config-base')} Config
  * @typedef {import('../../opentracing/tracer')} DatadogTracer
  */
 
@@ -33,21 +33,17 @@ const OtlpHttpTraceExporter = require('./otlp_http_trace_exporter')
  */
 function buildResourceAttributes (config) {
   const resourceAttributes = {
-    'service.name': config.service || config.tags.service,
+    'service.name': config.service,
     'telemetry.sdk.name': 'datadog',
     'telemetry.sdk.version': VERSION,
     'telemetry.sdk.language': 'nodejs',
   }
 
-  const env = config.env || config.tags.env
-  if (env) resourceAttributes['deployment.environment'] = env
-  const version = config.version || config.tags.version
-  if (version) resourceAttributes['service.version'] = version
+  if (config.env) resourceAttributes['deployment.environment.name'] = config.env
+  if (config.version) resourceAttributes['service.version'] = config.version
 
-  if (config.tags) {
-    const { service, version, env, ...filteredTags } = config.tags
-    Object.assign(resourceAttributes, filteredTags)
-  }
+  const { service, version, env, ...filteredTags } = config.tags
+  Object.assign(resourceAttributes, filteredTags)
 
   return resourceAttributes
 }
@@ -56,15 +52,14 @@ function buildResourceAttributes (config) {
  * Creates the OTLP HTTP/JSON trace exporter.
  *
  * @param {Config} config - Tracer configuration instance
- * @param {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
  * @returns {OtlpHttpTraceExporter} The OTLP HTTP/JSON exporter
  */
-function createOtlpTraceExporter (config, resourceAttributes) {
+function createOtlpTraceExporter (config) {
   return new OtlpHttpTraceExporter(
-    config.otelTracesUrl,
-    config.otelTracesHeaders,
-    config.otelTracesTimeout,
-    resourceAttributes
+    config.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
+    config.OTEL_EXPORTER_OTLP_TRACES_HEADERS,
+    config.OTEL_EXPORTER_OTLP_TRACES_TIMEOUT,
+    buildResourceAttributes(config)
   )
 }
 

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

@@ -8,13 +8,20 @@ const OtlpTraceTransformer = require('./otlp_transformer')
 /**
  * OtlpHttpTraceExporter exports DD-formatted spans via OTLP over HTTP/JSON.
  *
- * This implementation follows the OTLP HTTP v1.7.0 specification:
+ * This implementation follows the OTLP HTTP specification:
  * https://opentelemetry.io/docs/specs/otlp/#otlphttp
  *
  * It receives DD-formatted spans (from span_format.js), transforms them
  * to OTLP ExportTraceServiceRequest JSON format, and sends them to the
  * configured OTLP endpoint via HTTP POST.
  *
+ * TODO: Add batch handling similar to the OpenTelemetry SDK Batch Processor
+ * (https://opentelemetry.io/docs/specs/otel/trace/sdk/#batching-processor).
+ * Currently each finished trace is sent as its own HTTP request, which is
+ * unsuitable for high-traffic production environments. The config values
+ * `otelBatchTimeout`, `otelMaxExportBatchSize`, and `otelMaxQueueSize`
+ * (OTEL_BSP_*) are already defined and should drive that implementation.
+ *
  * @class OtlpHttpTraceExporter
  * @augments OtlpHttpExporterBase
  */
@@ -25,12 +32,13 @@ class OtlpHttpTraceExporter extends OtlpHttpExporterBase {
    * Creates a new OtlpHttpTraceExporter 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 {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
    */
   constructor (url, headers, timeout, resourceAttributes) {
-    super(url, headers, timeout, 'http/json', '/v1/traces', 'traces')
+    super(url, headers, timeout, 'http/json', 'traces')
     this.#transformer = new OtlpTraceTransformer(resourceAttributes)
   }
 

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

@@ -3,6 +3,7 @@
 const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
 const { getProtobufTypes } = require('../otlp/protobuf_loader')
 const { VERSION } = require('../../../../../version')
+const id = require('../../id')
 
 const { protoSpanKind } = getProtobufTypes()
 const SPAN_KIND_UNSPECIFIED = protoSpanKind.values.SPAN_KIND_UNSPECIFIED
@@ -12,11 +13,28 @@ const SPAN_KIND_CLIENT = protoSpanKind.values.SPAN_KIND_CLIENT
 const SPAN_KIND_PRODUCER = protoSpanKind.values.SPAN_KIND_PRODUCER
 const SPAN_KIND_CONSUMER = protoSpanKind.values.SPAN_KIND_CONSUMER
 
+// Cached zero Identifier used to detect zero IDs without re-allocating per span.
+const ZERO_ID = id('0')
+
 /**
+ * @typedef {import('../../id').Identifier} Identifier
+ *
+ * @typedef {object} DDSpanLink
+ * @property {string} trace_id - Hex-encoded trace ID
+ * @property {string} span_id - Hex-encoded span ID
+ * @property {Record<string, string | number | boolean>} [attributes] - Link attributes
+ * @property {number} [flags] - Trace flags
+ * @property {string} [tracestate] - W3C trace state
+ *
+ * @typedef {object} DDSpanEvent
+ * @property {string} name - Event name
+ * @property {number} time_unix_nano - Event time in nanoseconds since epoch
+ * @property {Record<string, string | number | boolean>} [attributes] - Event attributes
+ *
  * @typedef {object} DDFormattedSpan
- * @property {import('../../id')} trace_id - DD Identifier for trace ID
- * @property {import('../../id')} span_id - DD Identifier for span ID
- * @property {import('../../id')} parent_id - DD Identifier for parent span ID
+ * @property {Identifier} trace_id - DD Identifier for trace ID
+ * @property {Identifier} span_id - DD Identifier for span ID
+ * @property {Identifier} parent_id - DD Identifier for parent span ID
  * @property {string} name - Span operation name
  * @property {string} resource - Resource name
  * @property {string} [service] - Service name
@@ -24,9 +42,10 @@ const SPAN_KIND_CONSUMER = protoSpanKind.values.SPAN_KIND_CONSUMER
  * @property {number} error - Error flag (0 or 1)
  * @property {{[key: string]: string}} meta - String key-value tags
  * @property {{[key: string]: number}} metrics - Numeric key-value tags
+ * @property {{[key: string]: object}} [meta_struct] - Structured tags (JSON-serialized, bytes in protobuf)
  * @property {number} start - Start time in nanoseconds since epoch
  * @property {number} duration - Duration in nanoseconds
- * @property {object[]} [span_events] - Span events
+ * @property {DDSpanEvent[]} [span_events] - Span events
  */
 
 // Map DD span.kind string values to OTLP SpanKind numeric values
@@ -51,7 +70,7 @@ const EXCLUDED_META_KEYS = new Set([
 /**
  * OtlpTraceTransformer transforms DD-formatted spans to OTLP trace JSON format.
  *
- * This implementation follows the OTLP Trace v1.7.0 Data Model specification:
+ * This implementation follows the OTLP trace data model:
  * https://opentelemetry.io/docs/specs/otlp/#trace-data-model
  *
  * It receives DD-formatted spans (from span_format.js) and produces
@@ -119,7 +138,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
     return {
       traceId: this.#idToBytes(span.trace_id, 16),
       spanId: this.#idToBytes(span.span_id, 8),
-      parentSpanId: (parentId && !this.#isZeroId(parentId)) ? this.#idToBytes(parentId, 8) : undefined,
+      parentSpanId: (parentId && !parentId.equals(ZERO_ID)) ? this.#idToBytes(parentId, 8) : undefined,
       name: span.resource,
       kind: this.#mapSpanKind(span.meta?.['span.kind']),
       startTimeUnixNano: span.start,
@@ -178,7 +197,10 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
       }
     }
 
-    // Add meta_struct as bytesValue attributes (JSON-serialized, base64-encoded per proto JSON mapping)
+    // TODO: meta_struct values are logically raw bytes. The OTLP http/json spec encodes the bytesValue
+    // field as base64, but when http/protobuf or gRPC support is added the payload should be sent as
+    // raw bytes directly (no JSON.stringify + base64). The backend decoding side will need to be
+    // updated in parallel to accept the unencoded bytes.
     if (span.meta_struct) {
       for (const [key, value] of Object.entries(span.meta_struct)) {
         const bytes = Buffer.from(JSON.stringify(value))
@@ -202,33 +224,40 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
 
   /**
    * Maps DD span error state to an OTLP Status object.
+   * Combines error.type and error.message when both are present so error type
+   * information is preserved on the OTel side.
    *
    * @param {DDFormattedSpan} span - DD-formatted span
    * @returns {object} OTLP Status object with code and message
    */
   #mapStatus (span) {
-    if (span.error === 1) {
-      return {
-        code: STATUS_CODE_ERROR,
-        message: span.meta?.['error.message'] || '',
-      }
+    if (span.error !== 1) {
+      return { code: STATUS_CODE_UNSET, message: '' }
+    }
+    const errorType = span.meta?.['error.type']
+    const errorMessage = span.meta?.['error.message']
+    let message = ''
+    if (errorType && errorMessage) {
+      message = `${errorType}: ${errorMessage}`
+    } else if (errorType) {
+      message = errorType
+    } else if (errorMessage) {
+      message = errorMessage
     }
-    return { code: STATUS_CODE_UNSET, message: '' }
+    return { code: STATUS_CODE_ERROR, message }
   }
 
   /**
    * Transforms a DD span event to an OTLP Event object.
    *
-   * @param {object} event - DD span event with name, time_unix_nano, and attributes
+   * @param {DDSpanEvent} event - DD span event
    * @returns {object} OTLP Event object
    */
   #transformEvent (event) {
     return {
       timeUnixNano: event.time_unix_nano,
       name: event.name || '',
-      attributes: event.attributes && Object.keys(event.attributes).length > 0
-        ? this.transformAttributes(event.attributes)
-        : [],
+      attributes: this.transformAttributes(event.attributes ?? {}),
       droppedAttributesCount: 0,
     }
   }
@@ -257,7 +286,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
   /**
    * Transforms a single DD span link to an OTLP Link object.
    *
-   * @param {object} link - DD span link with trace_id, span_id, attributes, flags, tracestate
+   * @param {DDSpanLink} link - DD span link
    * @returns {object} OTLP Link object
    */
   #transformLink (link) {
@@ -265,9 +294,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
       traceId: this.#hexToBytes(link.trace_id, 16),
       spanId: this.#hexToBytes(link.span_id, 8),
       traceState: link.tracestate || '',
-      attributes: link.attributes && Object.keys(link.attributes).length > 0
-        ? this.transformAttributes(link.attributes)
-        : [],
+      attributes: this.transformAttributes(link.attributes ?? {}),
       droppedAttributesCount: 0,
       flags: link.flags,
     }
@@ -278,7 +305,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
    * Pads with leading zeros if the identifier buffer is shorter than the target.
    * Per the OTLP http/json spec, trace-ids and span-ids must be hex-encoded strings.
    *
-   * @param {object} identifier - DD Identifier object with toBuffer() method
+   * @param {Identifier} identifier - DD Identifier
    * @param {number} targetLength - Target byte length (16 for trace ID, 8 for span ID)
    * @returns {string} Hex-encoded string of the specified length
    */
@@ -290,29 +317,12 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
     if (buffer.length > targetLength) {
       return Buffer.from(buffer.slice(buffer.length - targetLength)).toString('hex')
     }
-    // Pad with leading zeros to reach target length
+    // Pad with leading zeros to reach target length.
     const result = Buffer.alloc(targetLength)
-    const offset = targetLength - buffer.length
-    for (let i = 0; i < buffer.length; i++) {
-      result[offset + i] = buffer[i]
-    }
+    Buffer.from(buffer).copy(result, targetLength - buffer.length)
     return result.toString('hex')
   }
 
-  /**
-   * Checks if a DD Identifier represents a zero ID (all bytes are 0).
-   *
-   * @param {object} identifier - DD Identifier object with toBuffer() method
-   * @returns {boolean} True if the identifier is all zeros
-   */
-  #isZeroId (identifier) {
-    const buffer = identifier.toBuffer()
-    for (let i = 0; i < buffer.length; i++) {
-      if (buffer[i] !== 0) return false
-    }
-    return true
-  }
-
   /**
    * Normalizes a hex string to the specified byte length.
    * Pads with leading zeros if the hex string is shorter than expected.

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

@@ -81,10 +81,10 @@ class Tracer {
   }
 
   _convertOtelContextToDatadog (traceId, spanId, traceFlag, ts, meta = {}) {
-    const origin = null
+    let origin = null
     let samplingPriority = traceFlag
 
-    ts = ts?.traceparent || null
+    ts = ts?.traceparent
 
     if (ts) {
       // Use TraceState.fromString to parse the tracestate header
@@ -101,19 +101,17 @@ class Tracer {
         // Assuming ddTraceStateData is now a Map or similar structure containing Datadog trace state data
         // Extract values as needed, similar to the original logic
         const samplingPriorityTs = ddTraceStateData.get('s')
-        const origin = ddTraceStateData.get('o')
+        origin = ddTraceStateData.get('o') ?? null
         // Convert Map to object for meta
         const otherPropagatedTags = Object.fromEntries(ddTraceStateData.entries())
 
         // Update meta and samplingPriority based on extracted values
         Object.assign(meta, otherPropagatedTags)
-        samplingPriority = TextMapPropagator._getSamplingPriority(
-          traceFlag,
-          Number.parseInt(samplingPriorityTs, 10),
-          origin
-        )
+        // Guard against an undefined/empty `s:` field that would result in NaN.
+        const tracestateSamplingPriority = samplingPriorityTs ? Math.trunc(samplingPriorityTs) : undefined
+        samplingPriority = TextMapPropagator._getSamplingPriority(traceFlag, tracestateSamplingPriority, origin)
       } else {
-        log.debug('no dd list member in tracestate from incoming request:', ts)
+        log.debug('No dd list member in tracestate from incoming request:', ts)
       }
     }
 
@@ -121,8 +119,8 @@ class Tracer {
       traceId: id(traceId, 16), spanId: id(), tags: meta, parentId: id(spanId, 16),
     })
 
-    spanContext._sampling = { priority: samplingPriority }
-    spanContext._trace = { origin }
+    spanContext._ddContext._sampling = { priority: samplingPriority }
+    spanContext._ddContext._trace = { ...spanContext._ddContext._trace, origin }
     return spanContext
   }
 

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -802,18 +802,25 @@ class TextMapPropagator {
     return spanContext._traceId.toString(16)
   }
 
-  static _getSamplingPriority (traceparentSampled, tracestateSamplingPriority, origin = null) {
+  /**
+   * @param {number} traceparentSampled
+   * @param {number|undefined} tracestateSamplingPriority
+   * @param {string|null} origin
+   * @returns {import('../../priority_sampler').SamplingPriority}
+   */
+  static _getSamplingPriority (traceparentSampled, tracestateSamplingPriority, origin) {
     const fromRumWithoutPriority = !tracestateSamplingPriority && origin === 'rum'
 
-    let samplingPriority
-    if (!fromRumWithoutPriority && traceparentSampled === 0 &&
-    (!tracestateSamplingPriority || tracestateSamplingPriority >= 0)) {
-      samplingPriority = 0
-    } else if (!fromRumWithoutPriority && traceparentSampled === 1 &&
-    (!tracestateSamplingPriority || tracestateSamplingPriority < 0)) {
-      samplingPriority = 1
-    } else {
-      samplingPriority = tracestateSamplingPriority
+    let samplingPriority =
+      /** @type {import('../../priority_sampler').SamplingPriority} */ (tracestateSamplingPriority ?? AUTO_KEEP)
+    if (!fromRumWithoutPriority) {
+      if (traceparentSampled === 0 &&
+          (!tracestateSamplingPriority || tracestateSamplingPriority >= 0)) {
+        samplingPriority = AUTO_REJECT
+      } else if (traceparentSampled === 1 &&
+                 (!tracestateSamplingPriority || tracestateSamplingPriority < 0)) {
+        samplingPriority = AUTO_KEEP
+      }
     }
 
     return samplingPriority

package/packages/dd-trace/src/opentracing/span.js

@@ -149,7 +149,7 @@ class DatadogSpan {
   }
 
   /**
-   * @returns {import('../priority_sampler').DatadogSpanContext}
+   * @returns {import('./span_context')}
    */
   context () {
     return this._spanContext

package/packages/dd-trace/src/opentracing/tracer.js

@@ -20,7 +20,7 @@ const REFERENCE_CHILD_OF = 'child_of'
 const REFERENCE_FOLLOWS_FROM = 'follows_from'
 
 class DatadogTracer {
-  constructor (config, prioritySampler, exporter) {
+  constructor (config, prioritySampler) {
     this._config = config
     this._service = config.service
     this._version = config.version
@@ -29,8 +29,15 @@ class DatadogTracer {
     this._debug = config.debug
     this._prioritySampler = prioritySampler ?? new PrioritySampler(config.env, config.sampler)
 
-    if (exporter) {
-      this._exporter = exporter
+    // OTEL_TRACES_EXPORTER=otlp should not replace the Test Optimization
+    // exporter when the tracer is running in Test Optimization mode. Test spans
+    // (test_session/test_module/ test_suite/test) belong on the citestcycle
+    // endpoint, not on an OTLP traces endpoint — otherwise users with OTEL_*
+    // vars set in their environment (e.g. for a separate telemetry integration)
+    // silently lose all test spans.
+    if (config.OTEL_TRACES_EXPORTER === 'otlp' && !config.isCiVisibility) {
+      const { createOtlpTraceExporter } = require('../opentelemetry/trace')
+      this._exporter = createOtlpTraceExporter(config)
     } else {
       const Exporter = getExporter(config.experimental.exporter)
       this._exporter = new Exporter(config, this._prioritySampler)
@@ -43,7 +50,7 @@ class DatadogTracer {
     this._propagators = {
       [formats.TEXT_MAP]: new TextMapPropagator(config),
       [formats.HTTP_HEADERS]: new HttpPropagator(config),
-      [formats.BINARY]: new BinaryPropagator(config),
+      [formats.BINARY]: new BinaryPropagator(),
       [formats.LOG]: new LogPropagator(config),
       [formats.TEXT_MAP_DSM]: new DSMTextMapPropagator(config),
     }
@@ -116,7 +123,7 @@ class DatadogTracer {
  * Get the span context from a span or a span context.
  *
  * @param {Span|SpanContext} spanContext
- * @returns {SpanContext}
+ * @returns {SpanContext|null}
  */
 function getContext (spanContext) {
   if (spanContext instanceof Span) {

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

@@ -6,6 +6,7 @@ const plugins = {
   get '@aws-sdk/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
   get '@azure/event-hubs' () { return require('../../../datadog-plugin-azure-event-hubs/src') },
   get '@azure/functions' () { return require('../../../datadog-plugin-azure-functions/src') },
+  get '@modelcontextprotocol/sdk' () { return require('../../../datadog-plugin-modelcontextprotocol-sdk/src') },
   get 'durable-functions' () { return require('../../../datadog-plugin-azure-durable-functions/src') },
   get '@azure/service-bus' () { return require('../../../datadog-plugin-azure-service-bus/src') },
   get '@cucumber/cucumber' () { return require('../../../datadog-plugin-cucumber/src') },