dd-trace 6.10.0 → 6.11.0

package/packages/dd-trace/src/llmobs/experiments/noop.js

@@ -1,13 +1,20 @@
 'use strict'
 
 const log = require('../../log')
+const { ExternalExperiment } = require('./experiment')
+
+const NOOP_EXPERIMENT_ID = '00000000-0000-0000-0000-000000000000'
+const NOOP_SPAN_ID = '0000000000000000'
+const NOOP_TRACE_ID = '00000000000000000000000000000000'
 
 class NoopDataset {
   #name
+  #description
   #records
 
   constructor (name = '', options = {}) {
     this.#name = name
+    this.#description = typeof options === 'string' ? options : (options.description ?? '')
     this.#records = (typeof options === 'string' ? [] : (options.records ?? [])).map(record => ({
       id: record.id ?? null,
       input: record.inputData,
@@ -21,6 +28,20 @@ class NoopDataset {
     return this
   }
 
+  update (index, fields) {
+    const record = this.#records[index]
+    if (record == null) return this
+    if (Object.hasOwn(fields, 'input')) record.input = fields.input
+    if (Object.hasOwn(fields, 'expectedOutput')) record.expectedOutput = fields.expectedOutput ?? null
+    if (Object.hasOwn(fields, 'metadata')) record.metadata = fields.metadata ?? {}
+    return this
+  }
+
+  delete (index) {
+    this.#records.splice(index, 1)
+    return this
+  }
+
   push () {
     return Promise.resolve({ pushedCount: 0, totalCount: 0 })
   }
@@ -29,6 +50,10 @@ class NoopDataset {
     return this.#name
   }
 
+  description () {
+    return this.#description
+  }
+
   id () {
     return null
   }
@@ -60,9 +85,11 @@ class NoopDataset {
 
 class NoopExperiment {
   #name
+  #external
 
-  constructor (name = '') {
+  constructor (name = '', external = false) {
     this.#name = name
+    this.#external = external
   }
 
   name () {
@@ -70,7 +97,7 @@ class NoopExperiment {
   }
 
   experimentId () {
-    return null
+    return this.#external ? NOOP_EXPERIMENT_ID : null
   }
 
   url () {
@@ -80,6 +107,32 @@ class NoopExperiment {
   run () {
     return Promise.resolve({ experimentId: null, rows: [], url: null })
   }
+
+  /**
+   * @returns {Promise<{experimentId: string, spanId: string, traceId: string, url: null}>}
+   */
+  submitSpan () {
+    return Promise.resolve({
+      experimentId: NOOP_EXPERIMENT_ID,
+      spanId: NOOP_SPAN_ID,
+      traceId: NOOP_TRACE_ID,
+      url: null,
+    })
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  submitEvaluationMetrics () {
+    return Promise.resolve()
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  close () {
+    return Promise.resolve()
+  }
 }
 
 // No-op Experiments used when LLM Observability is disabled or the API/APP keys
@@ -87,9 +140,11 @@ class NoopExperiment {
 // throwing, so intentionally disabled experiments remain graceful.
 class NoopExperiments {
   #reason
+  #startExperiment
 
-  constructor (reason) {
+  constructor (reason, options = {}) {
     this.#reason = reason || 'LLMObs experiments are not available'
+    this.#startExperiment = options.startExperiment
   }
 
   #warn () {
@@ -110,6 +165,19 @@ class NoopExperiments {
     this.#warn()
     return new NoopExperiment(options.name)
   }
+
+  /**
+   * @param {object} options
+   * @returns {Promise<ExternalExperiment>}
+   */
+  startExperiment (options = {}) {
+    if (this.#startExperiment !== undefined && options.projectName) {
+      return this.#startExperiment(options)
+    }
+
+    this.#warn()
+    return Promise.resolve(new ExternalExperiment(new NoopExperiment(options.name, true)))
+  }
 }
 
 module.exports = NoopExperiments

package/packages/dd-trace/src/llmobs/experiments/result.js

@@ -13,6 +13,7 @@ class Row {
     this.expectedOutput = fields.expectedOutput
     this.errorType = fields.errorType
     this.errorMessage = fields.errorMessage
+    this.errorStack = fields.errorStack
     this.evaluations = fields.evaluations
     this.evaluationErrors = fields.evaluationErrors
   }

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

@@ -178,12 +178,12 @@ function buildTags (userTags, autoTags) {
 }
 
 /**
- * @param {Record<string, unknown> | undefined} userTags
- * @param {Record<string, unknown>} autoTags
+ * @param {Record<string, unknown> | undefined} baseTags
+ * @param {Record<string, unknown> | undefined} overrideTags
  * @returns {Record<string, unknown>}
  */
-function buildExperimentTagObject (userTags, autoTags) {
-  return userTags ? { ...userTags, ...autoTags } : { ...autoTags }
+function mergeTags (baseTags, overrideTags) {
+  return { ...baseTags, ...overrideTags }
 }
 
 /**
@@ -195,6 +195,40 @@ function sleep (ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
+/**
+ * @param {unknown} value
+ * @param {number} fallback
+ * @returns {number}
+ */
+function timestampMs (value, fallback = Date.now()) {
+  if (value === null || value === undefined) return fallback
+  if (value instanceof Date) {
+    const timestamp = value.getTime()
+    return Number.isFinite(timestamp) ? timestamp : fallback
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  const parsed = Date.parse(String(value))
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+/**
+ * @param {{ durationMs?: unknown, completedAt?: unknown }} row
+ * @param {number} startMs
+ * @returns {number}
+ */
+function durationNs (row, startMs) {
+  if (typeof row.durationMs === 'number' && Number.isFinite(row.durationMs)) {
+    return Math.max(0, Math.round(row.durationMs * 1e6))
+  }
+
+  if (row.completedAt !== undefined) {
+    const completedMs = timestampMs(row.completedAt, startMs)
+    return Math.max(0, Math.round((completedMs - startMs) * 1e6))
+  }
+
+  return 0
+}
+
 /**
  * @param {Record<string, unknown> | undefined} recordMetadata
  * @param {Record<string, unknown>} config
@@ -207,14 +241,16 @@ function buildSpanMetadata (recordMetadata, config) {
 }
 
 module.exports = {
-  buildExperimentTagObject,
   buildSpanMetadata,
   buildTags,
+  durationNs,
   hasEntries,
   inferMetricType,
+  mergeTags,
   normalizeEvaluators,
   normalizeJsonMetricValue,
   sleep,
   stringify,
+  timestampMs,
   validateEvaluatorName,
 }

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

@@ -228,6 +228,7 @@ function getJsonStringValue (str, defaultValue) {
 function getModelMetadata (tags) {
   /** @type {Record<string, unknown>} */
   const modelMetadata = {}
+  let hasModelMetadata = false
   for (const tag of Object.keys(tags)) {
     const isModelMetadata = tag.startsWith(VERCEL_AI_MODEL_METADATA_PREFIX)
     if (isModelMetadata) {
@@ -235,6 +236,7 @@ function getModelMetadata (tags) {
       const metadataKey = lastCommaPosition === -1 ? tag : tag.slice(lastCommaPosition + 1)
       if (metadataKey && MODEL_METADATA_KEYS.has(metadataKey)) {
         modelMetadata[metadataKey] = tags[tag]
+        hasModelMetadata = true
       }
     } else {
       const isTelemetryMetadata = tag.startsWith(VERCEL_AI_TELEMETRY_METADATA_PREFIX)
@@ -242,12 +244,13 @@ function getModelMetadata (tags) {
         const metadataKey = tag.slice(VERCEL_AI_TELEMETRY_METADATA_PREFIX.length)
         if (metadataKey) {
           modelMetadata[metadataKey] = tags[tag]
+          hasModelMetadata = true
         }
       }
     }
   }
 
-  return Object.keys(modelMetadata).length ? modelMetadata : null
+  return hasModelMetadata ? modelMetadata : null
 }
 
 /**
@@ -259,6 +262,7 @@ function getModelMetadata (tags) {
 function getGenerationMetadata (tags) {
   /** @type {Record<string, unknown>} */
   const metadata = {}
+  let hasMetadata = false
 
   for (const tag of Object.keys(tags)) {
     const isGenerationMetadata = tag.startsWith(VERCEL_AI_GENERATION_METADATA_PREFIX)
@@ -270,18 +274,20 @@ function getGenerationMetadata (tags) {
 
       const settingValue = tags[tag]
       metadata[settingKey] = settingValue
+      hasMetadata = true
     } else {
       const isTelemetryMetadata = tag.startsWith(VERCEL_AI_TELEMETRY_METADATA_PREFIX)
       if (isTelemetryMetadata) {
         const metadataKey = tag.slice(VERCEL_AI_TELEMETRY_METADATA_PREFIX.length)
         if (metadataKey) {
           metadata[metadataKey] = tags[tag]
+          hasMetadata = true
         }
       }
     }
   }
 
-  return Object.keys(metadata).length ? metadata : null
+  return hasMetadata ? metadata : null
 }
 
 /**
@@ -307,6 +313,7 @@ function getGenerationMetadataFromEvent (event) {
     metadata[transformedKey] = value
   }
 
+  // eslint-disable-next-line no-restricted-syntax -- manual tracking would duplicate Object.assign semantics
   return Object.keys(metadata).length ? metadata : null
 }
 
@@ -432,6 +439,7 @@ function getLlmObsSpanName (operation, functionId) {
  */
 function getTelemetryMetadata (tags) {
   const metadata = {}
+  let hasMetadata = false
 
   for (const tag of Object.keys(tags)) {
     if (!tag.startsWith(VERCEL_AI_TELEMETRY_METADATA_PREFIX)) continue
@@ -439,10 +447,11 @@ function getTelemetryMetadata (tags) {
     const metadataKey = tag.slice(VERCEL_AI_TELEMETRY_METADATA_PREFIX.length)
     if (metadataKey) {
       metadata[metadataKey] = tags[tag]
+      hasMetadata = true
     }
   }
 
-  return Object.keys(metadata).length ? metadata : null
+  return hasMetadata ? metadata : null
 }
 
 module.exports = {

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

@@ -84,9 +84,11 @@ class LLMObsPlugin extends TracingPlugin {
   }
 
   configure (config) {
-    // we do not want to enable any LLMObs plugins if it is disabled on the tracer
+    // we do not want to enable any LLMObs plugins if it is disabled on the tracer, or if the
+    // integration opted out via `tracer.use(<name>, { llmobs: false })`. Opting out only disables
+    // the LLMObs layer: the integration keeps emitting APM spans and propagating trace context.
     const llmobsEnabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
-    if (llmobsEnabled === false) {
+    if (llmobsEnabled === false || config?.llmobs === false) {
       config = typeof config === 'boolean' ? false : { ...config, enabled: false } // override to false
     }
     super.configure(config)

package/packages/dd-trace/src/noop/proxy.js

@@ -1,9 +1,9 @@
 'use strict'
 
-const { features } = require('../feature-registry')
 const NoopAppsecSdk = require('../appsec/sdk/noop')
 const NoopLLMObsSDK = require('../llmobs/noop')
 const NoopAIGuardSDK = require('../aiguard/noop')
+const NoopFlaggingProvider = require('../openfeature/noop')
 const NoopDogStatsDClient = require('./dogstatsd')
 const NoopTracer = require('./tracer')
 
@@ -12,6 +12,7 @@ const noopAppsec = new NoopAppsecSdk()
 const noopDogStatsDClient = new NoopDogStatsDClient()
 const noopLLMObs = new NoopLLMObsSDK(noop)
 const noopAIGuard = new NoopAIGuardSDK()
+const noopFlaggingProviderInstance = new NoopFlaggingProvider()
 const noopProfiling = {
   setCustomLabelKeys () {},
   runWithLabels (labels, fn) { return fn() },
@@ -25,9 +26,7 @@ class NoopProxy {
     this.dogstatsd = noopDogStatsDClient
     this.llmobs = noopLLMObs
     this.aiguard = noopAIGuard
-    for (const { name, noop } of Object.values(features)) {
-      this[name] = noop
-    }
+    this.openfeature = noopFlaggingProviderInstance
     this.setBaggageItem = (key, value) => {}
     this.getBaggageItem = (key) => {}
     this.getAllBaggageItems = () => {}

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

@@ -1,14 +1,14 @@
 'use strict'
 
 const { channel } = require('dc-polyfill')
+
+const { DatadogNodeServerProvider } = require('../../../../vendor/dist/@datadog/openfeature-node-server')
 const log = require('../log')
 const configurationSource = require('./configuration_source')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
 const EvalMetricsHook = require('./eval-metrics-hook')
 const SpanEnrichmentHook = require('./span-enrichment-hook')
 
-const { DatadogNodeServerProvider } = require('./require-provider')
-
 /**
  * OpenFeature provider that integrates with Datadog's feature flagging system.
  * Extends DatadogNodeServerProvider to add tracer integration and configuration management.
@@ -48,6 +48,22 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     this.#configurationSource?.start()
   }
 
+  /**
+   * @param {import('@openfeature/core').EvaluationContext} [context]
+   * @returns {Promise<void>}
+   */
+  initialize (context) {
+    const promise = super.initialize(context)
+
+    // `DatadogNodeServerProvider#initialize` starts a timer that is never unref'd, which would
+    // otherwise keep an idle process (a short script, a serverless handler) alive for up to
+    // `initializationTimeoutMs` while waiting for configuration to arrive.
+    // TODO: remove once `@datadog/openfeature-node-server` unrefs this timer itself.
+    this.initController?.timeoutId?.unref?.()
+
+    return promise
+  }
+
   /**
    * Called when the provider is shut down.
    * Cleans up resources including channel subscriptions.

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

@@ -6,7 +6,7 @@ const RemoteConfigCapabilities = require('../remote_config/capabilities')
  * Configures remote config handlers for openfeature feature flagging
  *
  * @param {import('../remote_config')} rc - RemoteConfig instance
- * @param {() => import('./flagging_provider')} getOpenfeatureProxy
+ * @param {() => InstanceType<ReturnType<typeof import('./flagging_provider')>>} getOpenfeatureProxy
  * @param {boolean} subscribe - Whether Agent Remote Config owns UFC delivery
  */
 function enable (rc, getOpenfeatureProxy, subscribe) {

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

@@ -21,14 +21,14 @@ class ContextManager {
     const storedSpan = store ? trace.getSpan(store) : null
 
     // Convert DD baggage to OTel format
-    const baggages = getAllBaggageItems()
-    const hasBaggage = Object.keys(baggages).length > 0
+    let entries
+    for (const [key, value] of Object.entries(getAllBaggageItems())) {
+      entries ??= {}
+      entries[key] = { value }
+    }
+
     let otelBaggages
-    if (hasBaggage) {
-      const entries = {}
-      for (const [key, value] of Object.entries(baggages)) {
-        entries[key] = { value }
-      }
+    if (entries !== undefined) {
       otelBaggages = propagation.createBaggage(entries)
     }
 

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

@@ -42,7 +42,8 @@ class BatchLogRecordProcessor {
    */
   onEmit (logRecord, instrumentationScope) {
     // Store the log record (already enriched by Logger.emit)
-    this.#logRecords.push({ ...logRecord, instrumentationScope })
+    logRecord.instrumentationScope = instrumentationScope
+    this.#logRecords.push(logRecord)
 
     if (this.#logRecords.length >= this.#maxExportBatchSize) {
       this.#export()

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

@@ -1,8 +1,65 @@
 'use strict'
 
 const { context } = require('@opentelemetry/api')
-const { sanitizeAttributes } = require('../../../../../vendor/dist/@opentelemetry/core')
+const {
+  millisToHrTime,
+  sanitizeAttributes,
+  timeInputToHrTime,
+} = require('../../../../../vendor/dist/@opentelemetry/core')
 const { VERSION: packageVersion } = require('../../../../../version')
+const log = require('../../log')
+
+const MAX_DATE_MILLISECONDS = 8.64e15
+const NANOSECONDS_PER_SECOND = 1e9
+const MAX_UINT64_SECONDS = 18_446_744_073
+const MAX_UINT64_NANOSECONDS = 709_551_615
+let invalidTimestampWarningLogged = false
+
+function isValidHrTime (hrTime) {
+  return Array.isArray(hrTime) &&
+    hrTime.length === 2 &&
+    Number.isInteger(hrTime[0]) &&
+    Number.isInteger(hrTime[1]) &&
+    hrTime[0] >= 0 &&
+    hrTime[1] >= 0 &&
+    hrTime[1] < NANOSECONDS_PER_SECOND &&
+    (hrTime[0] < MAX_UINT64_SECONDS ||
+      (hrTime[0] === MAX_UINT64_SECONDS && hrTime[1] <= MAX_UINT64_NANOSECONDS))
+}
+
+function toHrTime (timestamp) {
+  if (typeof timestamp === 'number') {
+    if (!Number.isFinite(timestamp)) return
+
+    // Older versions documented numeric timestamps as Unix nanoseconds.
+    if (Math.abs(timestamp) > MAX_DATE_MILLISECONDS) {
+      const seconds = Math.trunc(timestamp / NANOSECONDS_PER_SECOND)
+      const hrTime = [seconds, timestamp - seconds * NANOSECONDS_PER_SECOND]
+      return isValidHrTime(hrTime) ? hrTime : undefined
+    }
+  }
+
+  try {
+    const hrTime = timeInputToHrTime(timestamp)
+    return isValidHrTime(hrTime) ? hrTime : undefined
+  } catch {
+    // Invalid timestamps fall back to the current time in normalizeTimestamp.
+  }
+}
+
+function normalizeTimestamp (timestamp) {
+  if (timestamp !== undefined) {
+    const hrTime = toHrTime(timestamp)
+    if (hrTime) return hrTime
+
+    if (!invalidTimestampWarningLogged) {
+      invalidTimestampWarningLogged = true
+      log.warn('Invalid OpenTelemetry log timestamp; using the current time instead')
+    }
+  }
+
+  return millisToHrTime(Date.now())
+}
 
 /**
  * @typedef {import('@opentelemetry/api-logs').LogRecord} LogRecord
@@ -62,21 +119,20 @@ class Logger {
       return
     }
 
-    if (logRecord.attributes) {
-      logRecord.attributes = sanitizeAttributes(logRecord.attributes)
+    const record = {
+      ...logRecord,
+      timestamp: normalizeTimestamp(logRecord.timestamp),
+      context: logRecord.context || context.active(),
     }
 
-    // Note: timestamp is in nanoseconds (as defined by OpenTelemetry LogRecord API)
-    if (!logRecord.timestamp) {
-      logRecord.timestamp = Number(process.hrtime.bigint())
+    if (logRecord.observedTimestamp !== undefined) {
+      record.observedTimestamp = normalizeTimestamp(logRecord.observedTimestamp)
     }
-
-    if (!logRecord.context) {
-      // Store span context in the log record context for trace correlation
-      logRecord.context = context.active()
+    if (logRecord.attributes) {
+      record.attributes = sanitizeAttributes(logRecord.attributes)
     }
 
-    this.loggerProvider.processor.onEmit(logRecord, this.#instrumentationScope)
+    this.loggerProvider.processor.onEmit(record, this.#instrumentationScope)
   }
 }
 

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

@@ -38,6 +38,17 @@ const SEVERITY_MAP = {
   [SeverityNumber.FATAL4]: 'SEVERITY_NUMBER_FATAL4',
 }
 
+const NANOSECONDS_PER_SECOND = 1_000_000_000n
+
+/**
+ * Converts an OpenTelemetry HrTime to an exact OTLP uint64 decimal string.
+ * @param {import('@opentelemetry/api').HrTime} hrTime
+ * @returns {string}
+ */
+function encodeHrTime (hrTime) {
+  return (BigInt(hrTime[0]) * NANOSECONDS_PER_SECOND + BigInt(hrTime[1])).toString()
+}
+
 /**
  * OtlpTransformer transforms log records to OTLP format.
  *
@@ -138,13 +149,13 @@ class OtlpTransformer extends OtlpTransformerBase {
     const spanContext = this.#extractSpanContext(logRecord.context)
 
     const result = {
-      timeUnixNano: logRecord.timestamp,
+      timeUnixNano: encodeHrTime(logRecord.timestamp),
       body: this.#transformBody(logRecord.body),
     }
 
     // Add optional fields only if they are set
-    if (logRecord.observedTimestamp) {
-      result.observedTimeUnixNano = logRecord.observedTimestamp
+    if (logRecord.observedTimestamp !== undefined) {
+      result.observedTimeUnixNano = encodeHrTime(logRecord.observedTimestamp)
     }
 
     if (logRecord.severityNumber !== undefined) {

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

@@ -10,6 +10,8 @@ const MeterProvider = require('./meter_provider')
 const PeriodicMetricReader = require('./periodic_metric_reader')
 const OtlpHttpMetricExporter = require('./otlp_http_metric_exporter')
 
+const RESERVED_TRACER_TAGS = new Set(['service', 'env', 'version', 'runtime_id', 'runtime-id'])
+
 /**
  * @typedef {import('../../config')} Config
  */
@@ -78,7 +80,16 @@ function initializeOpenTelemetryMetrics (config) {
   metrics.setGlobalMeterProvider(meterProvider)
 }
 
-function buildResourceAttributes (tags, { reportHostname, otelSemanticsEnabled, service, env, serviceVersion } = {}) {
+/**
+ * @param {Record<string, unknown>} tags
+ * @param {object} [options]
+ * @param {boolean} [options.reportHostname]
+ * @param {string} [options.service]
+ * @param {string} [options.env]
+ * @param {string} [options.serviceVersion]
+ * @returns {import('@opentelemetry/api').Attributes}
+ */
+function buildResourceAttributes (tags, { reportHostname, service, env, serviceVersion } = {}) {
   const attrs = {
     'telemetry.sdk.name': 'datadog',
     'telemetry.sdk.language': 'nodejs',
@@ -89,14 +100,19 @@ function buildResourceAttributes (tags, { reportHostname, otelSemanticsEnabled,
   if (env) attrs['deployment.environment.name'] = env
   if (reportHostname) attrs['host.name'] = os.hostname()
 
-  if (!otelSemanticsEnabled) {
-    if (tags?.['runtime-id']) attrs['datadog.runtime_id'] = tags['runtime-id']
-    const processTagsObject = processTags.tagsObject
-    if (processTagsObject) {
-      for (const key of Object.keys(processTagsObject)) {
-        attrs[`datadog.${key}`] = processTagsObject[key]
-      }
-    }
+  if (tags['runtime-id']) attrs['datadog.runtime_id'] = tags['runtime-id']
+  const tracerTags = []
+  for (const [key, value] of Object.entries(tags)) {
+    const valueType = typeof value
+    const supported = valueType === 'string' || valueType === 'boolean' ||
+      (valueType === 'number' && Number.isFinite(value))
+    if (!RESERVED_TRACER_TAGS.has(key) && supported) tracerTags.push(`${key}:${value}`)
+  }
+  if (tracerTags.length) attrs['datadog.tracer_tags'] = tracerTags
+  // Mirrors the legacy v0.6/stats ProcessTags shape (buildProcessTags().tagsArray); keep both in sync.
+  const processTagsArray = processTags.tagsArray
+  if (processTagsArray.length) {
+    attrs['datadog.process_tags'] = processTagsArray
   }
   return attrs
 }
@@ -106,7 +122,6 @@ function createOtlpSpanStatsExporter (config) {
   const protocol = config.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL || 'http/json'
   const resourceAttributes = buildResourceAttributes(config.tags, {
     reportHostname: config.reportHostname,
-    otelSemanticsEnabled: config.DD_TRACE_OTEL_SEMANTICS_ENABLED,
     service: config.service,
     env: config.env,
     serviceVersion: config.version,
@@ -115,8 +130,6 @@ function createOtlpSpanStatsExporter (config) {
     config.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
     protocol,
     resourceAttributes,
-    config.DD_TRACE_OTEL_SEMANTICS_ENABLED,
-    config.service,
     config.OTEL_EXPORTER_OTLP_METRICS_HEADERS,
     config.OTEL_EXPORTER_OTLP_METRICS_TIMEOUT
   )

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

@@ -11,15 +11,12 @@ class OtlpStatsExporter extends OtlpHttpExporterBase {
    * @param {string} url
    * @param {string} protocol
    * @param {import('@opentelemetry/api').Attributes} resourceAttributes
-   * @param {boolean} [otelSemanticsEnabled]
-   * @param {string} [defaultService]
    * @param {Record<string, string>} [headers]
    * @param {number} [timeout]
    */
-  constructor (url, protocol, resourceAttributes, otelSemanticsEnabled = false, defaultService = '',
-    headers, timeout = 10_000) {
+  constructor (url, protocol, resourceAttributes, headers, timeout = 10_000) {
     super(url, headers, timeout, protocol, 'span-stats')
-    this.#transformer = new OtlpStatsTransformer(resourceAttributes, protocol, otelSemanticsEnabled, defaultService)
+    this.#transformer = new OtlpStatsTransformer(resourceAttributes, protocol)
   }
 
   /**