dd-trace 5.109.0 → 5.110.0

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

@@ -2,7 +2,7 @@
 
 const { channel } = require('dc-polyfill')
 
-const { isError, isTrue } = require('../util')
+const { isError } = require('../util')
 const tracerVersion = require('../../../../package.json').version
 const logger = require('../log')
 const { getValueFromEnvSources } = require('../config/helper')
@@ -65,9 +65,11 @@ class LLMObs extends NoopLLMObs {
 
     logger.debug('Enabling LLMObs')
 
-    const DD_LLMOBS_ENABLED = getValueFromEnvSources('DD_LLMOBS_ENABLED')
+    // skipDefault: only an explicit DD_LLMOBS_ENABLED=false blocks enable(); an unset value
+    // (its default is false) must still allow this programmatic opt-in.
+    const DD_LLMOBS_ENABLED = getValueFromEnvSources('DD_LLMOBS_ENABLED', true)
 
-    if (DD_LLMOBS_ENABLED != null && !isTrue(DD_LLMOBS_ENABLED)) {
+    if (DD_LLMOBS_ENABLED === false) {
       logger.debug('LLMObs.enable() called when DD_LLMOBS_ENABLED is false. No action taken.')
       return
     }

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

@@ -33,6 +33,8 @@ const {
   ROUTING_API_KEY,
   ROUTING_SITE,
   LLMOBS_SUBMITTED_TAG_KEY,
+  SAMPLE_RATE,
+  SAMPLING_DECISION,
 } = require('./constants/tags')
 const { UNSERIALIZABLE_VALUE_TEXT } = require('./constants/text')
 const telemetry = require('./telemetry')
@@ -248,6 +250,8 @@ class LLMObsSpanProcessor {
       _dd: {
         span_id: span.context().toSpanId(),
         trace_id: span.context().toTraceId(true),
+        sample_rate: mlObsTags[SAMPLE_RATE],
+        sampling_decision: mlObsTags[SAMPLING_DECISION],
       },
     }
 

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

@@ -1,6 +1,8 @@
 'use strict'
 
 const log = require('../log')
+const Sampler = require('../sampler')
+const { formatKnuthRate } = require('../util')
 const {
   MODEL_NAME,
   MODEL_PROVIDER,
@@ -41,6 +43,12 @@ const {
   ROUTING_SITE,
   PROMPT_TRACKING_INSTRUMENTATION_METHOD,
   INSTRUMENTATION_METHOD_ANNOTATED,
+  SAMPLE_RATE,
+  SAMPLING_DECISION,
+  SAMPLING_DECISION_SAMPLED,
+  SAMPLING_DECISION_DROPPED,
+  PROPAGATED_SAMPLE_RATE_KEY,
+  PROPAGATED_SAMPLING_DECISION_KEY,
 } = require('./constants/tags')
 const { storage } = require('./storage')
 const { findGenAIAncestorSpanId, validateCostTags, writeBridgeTags, validateToolDefinitions } = require('./util')
@@ -53,12 +61,31 @@ class LLMObsTagger {
   /** @type {import('../config/config-base')} */
   #config
 
+  /** @type {import('../sampler') | null} */
+  #sampler = null
+
   constructor (config, softFail = false) {
     this.#config = config
 
     this.softFail = softFail
   }
 
+  /**
+   * The sampler reads its rate from `config.llmobs.sampleRate`, which can change
+   * at runtime (e.g. via remote config). Rebuild the sampler whenever the rate
+   * changes so decisions reflect the current config, while reusing the existing
+   * sampler when it hasn't.
+   *
+   * @returns {import('../sampler')}
+   */
+  #getSampler () {
+    const rate = this.#config.llmobs?.sampleRate ?? 1
+    if (this.#sampler === null || rate !== this.#sampler.rate()) {
+      this.#sampler = new Sampler(rate)
+    }
+    return this.#sampler
+  }
+
   static get tagMap () {
     return registry
   }
@@ -124,6 +151,8 @@ class LLMObsTagger {
       ROOT_PARENT_ID
     this._setTag(span, PARENT_ID_KEY, parentId)
 
+    this.#tagSamplingDecision(span, parent)
+
     // apply annotation context
     const annotationContext = storage.getStore()?.annotationContext
 
@@ -153,6 +182,32 @@ class LLMObsTagger {
     }
   }
 
+  #tagSamplingDecision (span, parent) {
+    const traceTags = span.context()._trace.tags
+    const parentTags = registry.get(parent)
+
+    let sampleRate, samplingDecision
+    if (parentTags) {
+      // Local LLMObs parent: inherit its decision.
+      sampleRate = parentTags[SAMPLE_RATE]
+      samplingDecision = parentTags[SAMPLING_DECISION]
+    } else if (traceTags[PROPAGATED_PARENT_ID_KEY]) {
+      // Distributed LLMObs parent: inherit whatever was propagated. This may be
+      // absent if the upstream service predates sampling propagation, in which
+      // case we make no decision here rather than starting a divergent one.
+      sampleRate = traceTags[PROPAGATED_SAMPLE_RATE_KEY]
+      samplingDecision = traceTags[PROPAGATED_SAMPLING_DECISION_KEY]
+    } else {
+      // Root span: make the trace's one sampling decision.
+      const sampler = this.#getSampler()
+      sampleRate = formatKnuthRate(sampler.rate())
+      samplingDecision = sampler.isSampled(span) ? SAMPLING_DECISION_SAMPLED : SAMPLING_DECISION_DROPPED
+    }
+
+    if (sampleRate != null) this._setTag(span, SAMPLE_RATE, sampleRate)
+    if (samplingDecision != null) this._setTag(span, SAMPLING_DECISION, samplingDecision)
+  }
+
   // TODO: similarly for the following `tag` methods,
   // how can we transition from a span weakmap to core API functionality
   tagLLMIO (span, inputData, outputData) {

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

@@ -87,6 +87,7 @@ function recordLLMObsEnabled (startTime, config, value = 1) {
     site: config.site,
     auto: Number(autoEnabled),
     ml_app: config.llmobs.mlApp,
+    sample_rate: config.llmobs.sampleRate,
   }
   llmobsMetrics.count('product_enabled', tags).inc(value)
   llmobsMetrics.distribution('init_time', tags).track(initTimeMs)

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

@@ -2,19 +2,16 @@
 
 const { inspect } = require('util')
 
-const { defaults } = require('../config/defaults')
-const { isTrue } = require('../util')
 const { getValueFromEnvSources } = require('../config/helper')
+// Eager require restores the original startup module-load order: pulling `config/defaults` here
+// also installs the instrumented `dns` it transitively loads before the tracer/agent connects.
+// `config/defaults` defers its own `dns` require until after it exports, so this no longer hits
+// the `config/defaults` <-> log parse cycle that motivated the lazy require below.
+const { defaults } = require('../config/defaults')
 const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
 const { Log, LogConfig, NoTransmitError } = require('./log')
 
-const config = {
-  enabled: defaults.DD_TRACE_DEBUG,
-  logger: undefined,
-  logLevel: defaults.logLevel,
-}
-
 // In most places where we know we want to mute a log we use log.error() directly
 const NO_TRANSMIT = new LogConfig(false)
 
@@ -77,19 +74,17 @@ const log = {
   },
 
   configure (options) {
-    config.logger = options.logger
-    config.logLevel = options.logLevel ??
-        getValueFromEnvSources('DD_TRACE_LOG_LEVEL') ??
-        config.logLevel
-    config.enabled = isTrue(
-      getValueFromEnvSources('DD_TRACE_DEBUG') ??
+    const logger = options.logger
+    const logLevel = options.logLevel ??
+        getValueFromEnvSources('DD_TRACE_LOG_LEVEL', true) ??
+        defaults?.logLevel
+    const enabled = getValueFromEnvSources('DD_TRACE_DEBUG', true) ??
       // TODO: Handle this by adding a log buffer so that configure may be called with the actual configurations.
       // eslint-disable-next-line eslint-rules/eslint-process-env
-      (process.env.OTEL_LOG_LEVEL === 'debug' || config.enabled)
-    )
-    logWriter.configure(config.enabled, config.logLevel, options.logger)
+      (process.env.OTEL_LOG_LEVEL === 'debug' || defaults?.DD_TRACE_DEBUG)
+    logWriter.configure(enabled, logLevel, logger)
 
-    return config.enabled
+    return enabled
   },
 }
 
@@ -113,6 +108,9 @@ function getErrorLog (err) {
   return err
 }
 
-log.configure({})
-
+// Assign before the bootstrap configure() call: an invalid DD_TRACE_LOG_LEVEL
+// makes config/defaults re-require this module to warn, which must observe the
+// fully built log object rather than a half-initialized one.
 module.exports = log
+
+log.configure({})

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

@@ -1,18 +1,13 @@
 'use strict'
 
 const { channel } = require('dc-polyfill')
+const requireOptionalPeer = require('../../../datadog-instrumentations/src/helpers/require-optional-peer')
 const log = require('../log')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
 const EvalMetricsHook = require('./eval-metrics-hook')
 const SpanEnrichmentHook = require('./span-enrichment-hook')
 
-// Bundler-opaque require for the optional peer chain
-// `@datadog/openfeature-node-server` -> `@openfeature/server-sdk` ->
-// `@openfeature/core`. Same shape as `helpers/rewriter/compiler.js`.
-// Refs: https://github.com/DataDog/dd-trace-js/issues/8635
-// eslint-disable-next-line camelcase, no-undef
-const runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require
-const { DatadogNodeServerProvider } = runtimeRequire(['@datadog/openfeature', 'node', 'server'].join('-'))
+const { DatadogNodeServerProvider } = requireOptionalPeer('@datadog/openfeature-node-server')
 
 /**
  * OpenFeature provider that integrates with Datadog's feature flagging system.

package/packages/dd-trace/src/opentelemetry/bridge-span-base.js

@@ -30,6 +30,7 @@ class BridgeSpanBase {
    */
   constructor (ddSpan) {
     this._ddSpan = ddSpan
+    this._otelTraceSemanticsEnabled = false
   }
 
   get ended () {
@@ -45,7 +46,7 @@ class BridgeSpanBase {
    * @param {import('@opentelemetry/api').AttributeValue} value
    */
   setAttribute (key, value) {
-    setOtelAttribute(this._ddSpan, key, value)
+    setOtelAttribute(this._ddSpan, key, value, this._otelTraceSemanticsEnabled)
     return this
   }
 
@@ -53,7 +54,7 @@ class BridgeSpanBase {
    * @param {import('@opentelemetry/api').Attributes} attributes
    */
   setAttributes (attributes) {
-    setOtelAttributes(this._ddSpan, attributes)
+    setOtelAttributes(this._ddSpan, attributes, this._otelTraceSemanticsEnabled)
     return this
   }
 
@@ -91,14 +92,14 @@ class BridgeSpanBase {
    * @param {import('@opentelemetry/api').TimeInput} [timeInput]
    */
   recordException (exception, timeInput) {
-    recordException(this._ddSpan, exception, timeInput)
+    recordException(this._ddSpan, exception, timeInput, this._otelTraceSemanticsEnabled)
   }
 
   /**
    * @param {import('@opentelemetry/api').SpanStatus} status
    */
   setStatus (status) {
-    this.#statusCode = applyOtelStatus(this._ddSpan, this.#statusCode, status)
+    this.#statusCode = applyOtelStatus(this._ddSpan, this.#statusCode, status, this._otelTraceSemanticsEnabled)
     return this
   }
 }

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

@@ -2,6 +2,7 @@
 
 const { sanitizeAttributes } = require('../../../../../vendor/dist/@opentelemetry/core')
 const { METRIC_TYPES } = require('./constants')
+const { nowUnixNano } = require('./time')
 
 /**
  * @typedef {import('@opentelemetry/api').Attributes} Attributes
@@ -62,7 +63,7 @@ class Instrument {
       type,
       value,
       attributes: sanitizeAttributes(attributes),
-      timestamp: Number(process.hrtime.bigint()),
+      timestamp: nowUnixNano(),
     }
   }
 }

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

@@ -6,6 +6,7 @@ const {
   METRIC_TYPES, TEMPORALITY, DEFAULT_HISTOGRAM_BUCKETS, DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE,
 } = require('./constants')
 const { ObservableInstrument } = require('./instruments')
+const { nowUnixNano } = require('./time')
 
 /**
  * @typedef {import('@opentelemetry/api').Attributes} Attributes
@@ -309,7 +310,7 @@ class PeriodicMetricReader {
  *
  */
 class MetricAggregator {
-  #startTime = Number(process.hrtime.bigint())
+  #startTime = nowUnixNano()
   #temporalityPreference
   #maxBatchedQueueSize
 
@@ -444,8 +445,8 @@ class MetricAggregator {
    */
   #isDeltaType (type) {
     return type === METRIC_TYPES.COUNTER ||
-           type === METRIC_TYPES.OBSERVABLECOUNTER ||
-           type === METRIC_TYPES.HISTOGRAM
+          type === METRIC_TYPES.OBSERVABLECOUNTER ||
+          type === METRIC_TYPES.HISTOGRAM
   }
 
   /**

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

@@ -0,0 +1,19 @@
+'use strict'
+
+const { timeOrigin } = performance
+
+/**
+ * Current wall-clock time as UNIX epoch nanoseconds, the unit OTLP requires for
+ * `timeUnixNano` / `startTimeUnixNano`. `process.hrtime.bigint()` is a monotonic
+ * clock with an arbitrary origin, so its values decode as 1970 timestamps that
+ * the Datadog Agent silently drops. Anchoring on `performance.timeOrigin` puts
+ * the value on the epoch while `performance.now()` keeps it monotonic, so a
+ * backward wall-clock jump can't make `timeUnixNano` precede `startTimeUnixNano`.
+ *
+ * @returns {number} Nanoseconds since the UNIX epoch
+ */
+function nowUnixNano () {
+  return Math.round((timeOrigin + performance.now()) * 1e6)
+}
+
+module.exports = { nowUnixNano }

package/packages/dd-trace/src/opentelemetry/otlp/common.proto

@@ -68,7 +68,7 @@ message KeyValue {
 }
 
 // InstrumentationScope is a message representing the instrumentation scope information
-// such as the fully qualified name and version. 
+// such as the fully qualified name and version.
 message InstrumentationScope {
   // An empty instrumentation scope name means the name is unknown.
   string name = 1;
@@ -113,4 +113,4 @@ message EntityRef {
   // These attribute keys are not part of entity's identity.
   // These keys MUST exist in the containing {message}.attributes.
   repeated string description_keys = 4;
-}
+}

package/packages/dd-trace/src/opentelemetry/otlp/logs.proto

@@ -223,4 +223,4 @@ message LogRecord {
   //
   // [Optional].
   string event_name = 12;
-}
+}

package/packages/dd-trace/src/opentelemetry/otlp/logs_service.proto

@@ -75,4 +75,4 @@ message ExportLogsPartialSuccess {
   // error_message is an optional field. An error_message with an empty value
   // is equivalent to it not being set.
   string error_message = 2;
-}
+}

package/packages/dd-trace/src/opentelemetry/otlp/metrics.proto

@@ -717,4 +717,4 @@ message Exemplar {
   // trace_id may be missing if the measurement is not recorded inside a trace
   // or if the trace is not sampled.
   bytes trace_id = 5;
-}
+}

package/packages/dd-trace/src/opentelemetry/otlp/metrics_service.proto

@@ -75,4 +75,4 @@ message ExportMetricsPartialSuccess {
   // error_message is an optional field. An error_message with an empty value
   // is equivalent to it not being set.
   string error_message = 2;
-}
+}

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

@@ -1,7 +1,8 @@
 'use strict'
 
-const http = require('http')
-const { URL } = require('url')
+const http = require('node:http')
+const https = require('node:https')
+const { URL } = require('node:url')
 const log = require('../../log')
 const telemetryMetrics = require('../../telemetry/metrics')
 
@@ -16,6 +17,8 @@ const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
  * @class OtlpHttpExporterBase
  */
 class OtlpHttpExporterBase {
+  #transport = https
+
   /**
    * Creates a new OtlpHttpExporterBase instance.
    *
@@ -45,7 +48,7 @@ class OtlpHttpExporterBase {
     this.setUrl(url)
 
     this.telemetryTags = [
-      'protocol:http',
+      `protocol:${this.#transport === https ? 'https' : 'http'}`,
       `encoding:${isJson ? 'json' : 'protobuf'}`,
     ]
   }
@@ -81,7 +84,7 @@ class OtlpHttpExporterBase {
       },
     }
 
-    const req = http.request(options, (res) => {
+    const req = this.#transport.request(options, (res) => {
       let data = ''
 
       res.on('data', (chunk) => {
@@ -124,6 +127,10 @@ class OtlpHttpExporterBase {
     this.options.hostname = parsedUrl.hostname
     this.options.port = parsedUrl.port
     this.options.path = parsedUrl.pathname + parsedUrl.search
+    this.#transport = parsedUrl.protocol === 'http:' ? http : https
+    if (this.telemetryTags !== undefined) {
+      this.telemetryTags[0] = `protocol:${this.#transport === https ? 'https' : 'http'}`
+    }
   }
 
   /**

package/packages/dd-trace/src/opentelemetry/span-helpers.js

@@ -137,14 +137,17 @@ function normalizeLinkContext (context) {
  * Mirrors `http.response.status_code` onto `http.status_code` (DD's special tag used by APM
  * trace metrics and client-side stats); both names end up on the span.
  *
+ * When OTel trace semantics are enabled, the behavior is disabled.
+ *
  * @param {import('../opentracing/span')} ddSpan
  * @param {string} key
  * @param {unknown} value
+ * @param {boolean} [otelTraceSemanticsEnabled]
  */
-function setOtelAttribute (ddSpan, key, value) {
+function setOtelAttribute (ddSpan, key, value, otelTraceSemanticsEnabled) {
   if (!isWritable(ddSpan)) return
 
-  if (key === 'http.response.status_code') {
+  if (!otelTraceSemanticsEnabled && key === 'http.response.status_code') {
     ddSpan.setTag('http.status_code', String(value))
   }
 
@@ -155,14 +158,17 @@ function setOtelAttribute (ddSpan, key, value) {
  * Same `http.status_code` mirror as `setOtelAttribute`; does not mutate the caller's
  * `attributes` object.
  *
+ * When OTel trace semantics are enabled, the behavior is disabled.
+ *
  * @param {import('../opentracing/span')} ddSpan
  * @param {Record<string, unknown>} attributes
+ * @param {boolean} [otelTraceSemanticsEnabled]
  */
-function setOtelAttributes (ddSpan, attributes) {
+function setOtelAttributes (ddSpan, attributes, otelTraceSemanticsEnabled) {
   if (!isWritable(ddSpan)) return
 
   ddSpan.addTags(attributes)
-  if ('http.response.status_code' in attributes) {
+  if (!otelTraceSemanticsEnabled && 'http.response.status_code' in attributes) {
     ddSpan.setTag('http.status_code', String(attributes['http.response.status_code']))
   }
 }
@@ -223,16 +229,19 @@ function addOtelEvent (ddSpan, name, attributesOrStartTime, startTime) {
  * @param {import('../opentracing/span')} ddSpan
  * @param {ExceptionLike} exception
  * @param {TimeInput} [timeInput]
+ * @param {boolean} [otelTraceSemanticsEnabled]
  */
-function recordException (ddSpan, exception, timeInput) {
+function recordException (ddSpan, exception, timeInput, otelTraceSemanticsEnabled) {
   if (!isWritable(ddSpan)) return
 
-  ddSpan.addTags({
-    [ERROR_TYPE]: exception.name,
-    [ERROR_MESSAGE]: exception.message,
-    [ERROR_STACK]: exception.stack,
-    [IGNORE_OTEL_ERROR]: ddSpan.context().getTag(IGNORE_OTEL_ERROR) ?? true,
-  })
+  if (!otelTraceSemanticsEnabled) {
+    ddSpan.addTags({
+      [ERROR_TYPE]: exception.name,
+      [ERROR_MESSAGE]: exception.message,
+      [ERROR_STACK]: exception.stack,
+      [IGNORE_OTEL_ERROR]: ddSpan.context().getTag(IGNORE_OTEL_ERROR) ?? true,
+    })
+  }
 
   const attributes = {}
   if (exception.message) attributes['exception.message'] = exception.message
@@ -251,13 +260,20 @@ function recordException (ddSpan, exception, timeInput) {
  * @param {import('../opentracing/span')} ddSpan
  * @param {number} currentCode 0 = UNSET, 1 = OK, 2 = ERROR.
  * @param {{ code?: number, message?: string }} [status]
+ * @param {boolean} [otelTraceSemanticsEnabled]
  * @returns {number} The new status code to track on the caller.
  */
-function applyOtelStatus (ddSpan, currentCode, status) {
+function applyOtelStatus (ddSpan, currentCode, status, otelTraceSemanticsEnabled) {
   if (!isWritable(ddSpan)) return currentCode
 
   const code = status?.code
-  if (!code || currentCode === 1) return currentCode
+  if (!code || currentCode === 1) {
+    if (otelTraceSemanticsEnabled) {
+      ddSpan.context().deleteTag(ERROR_MESSAGE)
+      ddSpan.context().deleteTag(IGNORE_OTEL_ERROR)
+    }
+    return currentCode
+  }
 
   if (code === 2) {
     ddSpan.addTags({

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

@@ -15,7 +15,7 @@ const kinds = require('../../../../ext/kinds')
 const id = require('../id')
 const BridgeSpanBase = require('./bridge-span-base')
 const SpanContext = require('./span_context')
-const { setOtelOperationName } = require('./span-helpers')
+const { setOtelOperationName, setOtelResource } = require('./span-helpers')
 
 const spanKindNames = {
   [api.SpanKind.INTERNAL]: kinds.INTERNAL,
@@ -118,6 +118,8 @@ function spanNameMapper (spanName, kind, attributes) {
  * surface; the underlying DD span carries the lifecycle.
  */
 class Span extends BridgeSpanBase {
+  #otelName
+
   /**
    * @param {import('./tracer')} parentTracer
    * @param {import('@opentelemetry/api').Context} context
@@ -159,12 +161,15 @@ class Span extends BridgeSpanBase {
 
     super(ddSpan)
 
+    this._otelTraceSemanticsEnabled = _tracer._config.DD_TRACE_OTEL_SEMANTICS_ENABLED
+
     if (attributes) {
       this.setAttributes(attributes)
     }
 
     this._parentTracer = parentTracer
     this._context = context
+    this.#otelName = spanName || this._ddSpan.context()._name
 
     // NOTE: Need to grab the value before setting it on the span because the
     // math for computing opentracing timestamps is apparently lossy...
@@ -192,7 +197,7 @@ class Span extends BridgeSpanBase {
   }
 
   get name () {
-    return this._ddSpan.context()._name
+    return this.#otelName
   }
 
   spanContext () {
@@ -223,7 +228,13 @@ class Span extends BridgeSpanBase {
    * @param {string} name
    */
   updateName (name) {
-    setOtelOperationName(this._ddSpan, name)
+    if (this.ended) return this
+    this.#otelName = name
+    if (this._otelTraceSemanticsEnabled) {
+      setOtelResource(this._ddSpan, name)
+    } else {
+      setOtelOperationName(this._ddSpan, name)
+    }
     return this
   }
 

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

@@ -32,6 +32,7 @@ class SpanContext {
   }
 
   get traceFlags () {
+    this._ddContext._ensureSamplingPriority()
     return this._ddContext._sampling.priority >= AUTO_KEEP ? 1 : 0
   }
 

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

@@ -59,7 +59,8 @@ function createOtlpTraceExporter (config) {
     config.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
     config.OTEL_EXPORTER_OTLP_TRACES_HEADERS,
     config.OTEL_EXPORTER_OTLP_TRACES_TIMEOUT,
-    buildResourceAttributes(config)
+    buildResourceAttributes(config),
+    config.DD_TRACE_OTEL_SEMANTICS_ENABLED
   )
 }
 

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

@@ -36,10 +36,11 @@ class OtlpHttpTraceExporter extends OtlpHttpExporterBase {
    *   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
+   * @param {boolean} otelTraceSemanticsEnabled - When true, do not emit Datadog-only attributes as span attributes
    */
-  constructor (url, headers, timeout, resourceAttributes) {
+  constructor (url, headers, timeout, resourceAttributes, otelTraceSemanticsEnabled) {
     super(url, headers, timeout, 'http/json', 'traces')
-    this.#transformer = new OtlpTraceTransformer(resourceAttributes)
+    this.#transformer = new OtlpTraceTransformer(resourceAttributes, otelTraceSemanticsEnabled)
   }
 
   /**