dd-trace 5.109.0 → 5.111.0

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

@@ -1,11 +1,14 @@
 '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 { storage } = require('../../../../datadog-core')
 const log = require('../../log')
 const telemetryMetrics = require('../../telemetry/metrics')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
+const legacyStorage = storage('legacy')
 
 /**
  * Base class for OTLP HTTP exporters.
@@ -16,6 +19,8 @@ const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
  * @class OtlpHttpExporterBase
  */
 class OtlpHttpExporterBase {
+  #transport = https
+
   /**
    * Creates a new OtlpHttpExporterBase instance.
    *
@@ -32,20 +37,22 @@ class OtlpHttpExporterBase {
 
     const isJson = protocol === 'http/json'
 
-    // Initialize fields setUrl doesn't touch; it fills in hostname/port/path below.
+    const parsedUrl = new URL(url)
+    this.#transport = parsedUrl.protocol === 'http:' ? http : https
     this.options = {
       method: 'POST',
       timeout,
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port,
+      path: parsedUrl.pathname + parsedUrl.search,
       headers: {
         'Content-Type': isJson ? 'application/json' : 'application/x-protobuf',
         ...headers,
       },
     }
 
-    this.setUrl(url)
-
     this.telemetryTags = [
-      'protocol:http',
+      `protocol:${this.#transport === https ? 'https' : 'http'}`,
       `encoding:${isJson ? 'json' : 'protobuf'}`,
     ]
   }
@@ -81,55 +88,54 @@ class OtlpHttpExporterBase {
       },
     }
 
-    const req = http.request(options, (res) => {
-      let data = ''
-
-      res.on('data', (chunk) => {
-        data += chunk
+    legacyStorage.run({ noop: true }, () => {
+      const req = this.#transport.request(options, (res) => {
+        let data = ''
+
+        res.on('data', (chunk) => {
+          data += chunk
+        })
+
+        res.once('end', () => {
+          // @ts-expect-error - res.statusCode can be undefined
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resultCallback({ code: 0 })
+          } else {
+            const error = new Error(`HTTP ${res.statusCode}: ${data}`)
+            resultCallback({ code: 1, error })
+          }
+        })
       })
 
-      res.once('end', () => {
-        // @ts-expect-error - res.statusCode can be undefined
-        if (res.statusCode >= 200 && res.statusCode < 300) {
-          resultCallback({ code: 0 })
-        } else {
-          const error = new Error(`HTTP ${res.statusCode}: ${data}`)
-          resultCallback({ code: 1, error })
-        }
+      req.on('error', (error) => {
+        log.error('Error sending OTLP %s:', this.signalType, error)
+        resultCallback({ code: 1, error })
       })
-    })
 
-    req.on('error', (error) => {
-      log.error('Error sending OTLP %s:', this.signalType, error)
-      resultCallback({ code: 1, error })
-    })
+      req.once('timeout', () => {
+        req.destroy()
+        const error = new Error('Request timeout')
+        resultCallback({ code: 1, error })
+      })
 
-    req.once('timeout', () => {
-      req.destroy()
-      const error = new Error('Request timeout')
-      resultCallback({ code: 1, error })
+      req.write(payload)
+      req.end()
     })
-
-    req.write(payload)
-    req.end()
   }
 
   /**
-   * 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
+   * Re-targets the exporter to a different URL, updating transport, hostname, port, and path.
+   * @param {string} url
    */
   setUrl (url) {
     const parsedUrl = new URL(url)
+    this.#transport = parsedUrl.protocol === 'http:' ? http : https
     this.options.hostname = parsedUrl.hostname
     this.options.port = parsedUrl.port
     this.options.path = parsedUrl.pathname + parsedUrl.search
+    this.telemetryTags[0] = `protocol:${this.#transport === https ? 'https' : 'http'}`
   }
 
-  /**
-   * Shuts down the exporter.
-   * Subclasses can override to add cleanup logic.
-   */
   shutdown () {}
 }
 

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

@@ -45,6 +45,10 @@ function buildResourceAttributes (config) {
   const { service, version, env, ...filteredTags } = config.tags
   Object.assign(resourceAttributes, filteredTags)
 
+  if (config.OTEL_TRACES_SPAN_METRICS_ENABLED) {
+    resourceAttributes['_dd.stats_computed'] = 'true'
+  }
+
   return resourceAttributes
 }
 
@@ -59,7 +63,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)
   }
 
   /**

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

@@ -74,6 +74,9 @@ const EXCLUDED_META_KEYS = new Set([
   TRACE_ID_128,
 ])
 
+// DD-only error tags that should not appear as attributes when OTel trace semantics are enabled.
+const DD_ERROR_META_KEYS = new Set(['error.message'])
+
 /**
  * OtlpTraceTransformer transforms DD-formatted spans to OTLP trace JSON format.
  *
@@ -87,13 +90,17 @@ const EXCLUDED_META_KEYS = new Set([
  * @augments OtlpTransformerBase
  */
 class OtlpTraceTransformer extends OtlpTransformerBase {
+  #otelTraceSemanticsEnabled
+
   /**
    * Creates a new OtlpTraceTransformer instance.
    *
    * @param {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
+   * @param {boolean} [otelTraceSemanticsEnabled] - When true, do not emit Datadog-only attributes as span attributes
    */
-  constructor (resourceAttributes) {
+  constructor (resourceAttributes, otelTraceSemanticsEnabled) {
     super(resourceAttributes, 'http/json', 'traces')
+    this.#otelTraceSemanticsEnabled = otelTraceSemanticsEnabled
   }
 
   /**
@@ -184,24 +191,30 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
   #buildAttributes (span) {
     const attributes = []
 
-    // Add top-level DD span fields as OTLP attributes
-    if (span.service) {
-      attributes.push({ key: 'service.name', value: { stringValue: span.service } })
-    }
-    if (span.name) {
-      attributes.push({ key: 'operation.name', value: { stringValue: span.name } })
-    }
-    if (span.resource) {
-      attributes.push({ key: 'resource.name', value: { stringValue: span.resource } })
-    }
-    if (span.type) {
-      attributes.push({ key: 'span.type', value: { stringValue: span.type } })
+    // Add top-level DD span fields as OTLP attributes.
+    // When OTel trace semantics are enabled, these Datadog-only concepts
+    // are not added to the span attributes so the output conforms to pure
+    // OpenTelemetry semantics.
+    if (!this.#otelTraceSemanticsEnabled) {
+      if (span.service) {
+        attributes.push({ key: 'service.name', value: { stringValue: span.service } })
+      }
+      if (span.name) {
+        attributes.push({ key: 'operation.name', value: { stringValue: span.name } })
+      }
+      if (span.resource) {
+        attributes.push({ key: 'resource.name', value: { stringValue: span.resource } })
+      }
+      if (span.type) {
+        attributes.push({ key: 'span.type', value: { stringValue: span.type } })
+      }
     }
 
     // Add meta string tags, skipping keys that map to dedicated OTLP fields
     if (span.meta) {
       for (const [key, value] of Object.entries(span.meta)) {
         if (EXCLUDED_META_KEYS.has(key)) continue
+        if (this.#otelTraceSemanticsEnabled && DD_ERROR_META_KEYS.has(key)) continue
         attributes.push({ key, value: { stringValue: value } })
       }
     }

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

@@ -68,7 +68,7 @@ class TracerProvider {
       return Promise.reject(new Error('Not started'))
     }
 
-    exporter._writer.flush()
+    exporter._writer?.flush()
     return this._activeProcessor.forceFlush()
   }
 

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

@@ -371,8 +371,8 @@ class TextMapPropagator {
 
   _hasTraceIdConflict (w3cSpanContext, firstSpanContext) {
     return w3cSpanContext !== undefined &&
-           firstSpanContext.toTraceId(true) === w3cSpanContext.toTraceId(true) &&
-           firstSpanContext.toSpanId() !== w3cSpanContext.toSpanId()
+          firstSpanContext.toTraceId(true) === w3cSpanContext.toTraceId(true) &&
+          firstSpanContext.toSpanId() !== w3cSpanContext.toSpanId()
   }
 
   _hasParentIdInTags (spanContext) {
@@ -875,7 +875,7 @@ class TextMapPropagator {
           (!tracestateSamplingPriority || tracestateSamplingPriority >= 0)) {
         samplingPriority = AUTO_REJECT
       } else if (traceparentSampled === 1 &&
-                 (!tracestateSamplingPriority || tracestateSamplingPriority < 0)) {
+                (!tracestateSamplingPriority || tracestateSamplingPriority < 0)) {
         samplingPriority = AUTO_KEEP
       }
     }

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

@@ -63,6 +63,7 @@ class DatadogSpanContext {
   }
 
   toTraceparent () {
+    this._ensureSamplingPriority()
     const flags = this._sampling.priority >= AUTO_KEEP ? '01' : '00'
     const traceId = this.toTraceId(true)
     const spanId = this.toSpanId(true)
@@ -70,6 +71,22 @@ class DatadogSpanContext {
     return `${version}-${traceId}-${spanId}-${flags}`
   }
 
+  /**
+   * Materialize the lazy priority-sampling decision for this trace, the same
+   * way {@link DatadogTracer#inject} does before propagation. The auto priority
+   * is otherwise computed at flush time, so the W3C sampled flag reads "drop"
+   * for a freshly started, not-yet-flushed span — see
+   * https://github.com/DataDog/dd-trace-js/issues/2547.
+   *
+   * The root span is only used to reach the priority sampler; `this` is passed
+   * to `sample()` so a manual sampling tag set directly on this context is
+   * honored, matching what `inject(this)` would decide.
+   */
+  _ensureSamplingPriority () {
+    if (this._sampling.priority !== undefined) return
+    this._trace.started[0]?._prioritySampler?.sample(this)
+  }
+
   /**
    * Set a tag value.
    * @param {string} key - Tag key

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

@@ -45,7 +45,12 @@ class DatadogTracer {
       this._exporter = new Exporter(config, this._prioritySampler)
     }
 
-    this._processor = new SpanProcessor(this._exporter, this._prioritySampler, config)
+    let otlpStatsExporter
+    if (config.OTEL_TRACES_SPAN_METRICS_ENABLED) {
+      const { createOtlpSpanStatsExporter } = require('../opentelemetry/metrics')
+      otlpStatsExporter = createOtlpSpanStatsExporter(config)
+    }
+    this._processor = new SpanProcessor(this._exporter, this._prioritySampler, config, otlpStatsExporter)
     this._url = this._exporter._url
     this._enableGetRumData = config.experimental.enableGetRumData
     this._traceId128BitGenerationEnabled = config.traceId128BitGenerationEnabled

package/packages/dd-trace/src/plugin_manager.js

@@ -60,7 +60,11 @@ function maybeEnable (Plugin) {
 
 function getEnabled (Plugin) {
   const envName = `DD_TRACE_${Plugin.id.toUpperCase()}_ENABLED`
-  return getValueFromEnvSources(normalizePluginEnvName(envName))
+  // skipDefault: only an explicitly configured value should drive enablement here. A registered
+  // default of `false` (e.g. an experimental plugin like `nats`) must not be read as an explicit
+  // "disabled via configuration option" — that path both logs a misleading line and nulls the
+  // plugin class, bypassing the experimental opt-in handled by `loadPlugin`.
+  return getValueFromEnvSources(normalizePluginEnvName(envName), true)
 }
 
 // TODO this must always be a singleton.
@@ -154,7 +158,7 @@ module.exports = class PluginManager {
     const {
       logInjection,
       serviceMapping,
-      queryStringObfuscation,
+      DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP,
       site,
       url,
       headerTags,
@@ -164,16 +168,17 @@ module.exports = class PluginManager {
       clientIpEnabled,
       clientIpHeader,
       DD_TRACE_MEMCACHED_COMMAND_ENABLED,
+      DD_TRACE_OTEL_SEMANTICS_ENABLED,
       DD_TEST_SESSION_NAME,
       DD_AGENTLESS_LOG_SUBMISSION_ENABLED,
-      isTestDynamicInstrumentationEnabled,
+      testOptimization,
       isServiceUserProvided,
       middlewareTracingEnabled,
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
       traceWebsocketMessagesSeparateTraces,
       experimental,
-      resourceRenamingEnabled,
+      DD_TRACE_RESOURCE_RENAMING_ENABLED,
     } = /** @type {import('./config/config-base')} */ (this._tracerConfig)
 
     const sharedConfig = {
@@ -181,27 +186,28 @@ module.exports = class PluginManager {
       dbmPropagationMode,
       dsmEnabled,
       DD_TRACE_MEMCACHED_COMMAND_ENABLED,
+      DD_TRACE_OTEL_SEMANTICS_ENABLED,
       site,
       url,
       headers: headerTags || [],
       clientIpHeader,
       DD_TEST_SESSION_NAME,
       DD_AGENTLESS_LOG_SUBMISSION_ENABLED,
-      isTestDynamicInstrumentationEnabled,
+      isTestDynamicInstrumentationEnabled: testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED,
       isServiceUserProvided,
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
       traceWebsocketMessagesSeparateTraces,
       experimental,
-      resourceRenamingEnabled,
+      resourceRenamingEnabled: DD_TRACE_RESOURCE_RENAMING_ENABLED,
     }
 
     if (logInjection !== undefined) {
       sharedConfig.logInjection = logInjection
     }
 
-    if (queryStringObfuscation !== undefined) {
-      sharedConfig.queryStringObfuscation = queryStringObfuscation
+    if (DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP !== undefined) {
+      sharedConfig.queryStringObfuscation = DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP
     }
 
     if (serviceMapping && serviceMapping[name]) {

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

@@ -31,6 +31,7 @@ const Plugin = require('./plugin')
 const { getRepositoryRoot } = require('./util/git')
 const {
   getTestEnvironmentMetadata,
+  getTestLevelsMetadataTags,
   getTestSessionName,
   getCodeOwnersFileEntries,
   getTestParentSpan,
@@ -44,6 +45,7 @@ const {
   TEST_MODULE_ID,
   TEST_SESSION_ID,
   TEST_COMMAND,
+  TEST_LEVELS_METADATA,
   TEST_MODULE,
   TEST_SESSION_NAME,
   getTestSuiteCommonTags,
@@ -59,7 +61,7 @@ const {
   DI_DEBUG_ERROR_SNAPSHOT_ID_SUFFIX,
   DI_DEBUG_ERROR_FILE_SUFFIX,
   DI_DEBUG_ERROR_LINE_SUFFIX,
-  getLibraryCapabilitiesTags,
+  getLibraryCapabilitiesTags: getDefaultLibraryCapabilitiesTags,
   getPullRequestDiff,
   getModifiedFilesFromDiff,
   getPullRequestBaseBranch,
@@ -107,7 +109,7 @@ const TEST_FRAMEWORKS_TO_SKIP_GIT_METADATA_EXTRACTION = new Set([
 ])
 
 function setItrSkippingEnabledTagFromLibraryConfig (plugin, frameworkVersion) {
-  const libraryCapabilitiesTags = getLibraryCapabilitiesTags(plugin.constructor.id, frameworkVersion)
+  const libraryCapabilitiesTags = getDefaultLibraryCapabilitiesTags(plugin.constructor.id, frameworkVersion)
 
   if (!libraryCapabilitiesTags[DD_CAPABILITIES_TEST_IMPACT_ANALYSIS] ||
     !plugin.libraryConfig ||
@@ -166,7 +168,7 @@ module.exports = class CiPlugin extends Plugin {
           ? getSessionRequestErrorTags(this.testSessionSpan)
           : Object.fromEntries(this._pendingRequestErrorTags.map(({ tag, value }) => [tag, value]))
 
-        const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, frameworkVersion)
+        const libraryCapabilitiesTags = this.getLibraryCapabilitiesTags(frameworkVersion, ctx)
         const metadataTags = {
           test: {
             ...libraryCapabilitiesTags,
@@ -219,7 +221,13 @@ module.exports = class CiPlugin extends Plugin {
         this.testEnvironmentMetadata
       )
 
-      const metadataTags = { '*': { [TEST_COMMAND]: command, [TEST_SESSION_NAME]: testSessionName } }
+      const metadataTags = {
+        [TEST_LEVELS_METADATA]: {
+          [TEST_COMMAND]: command,
+          [TEST_SESSION_NAME]: testSessionName,
+          ...getTestLevelsMetadataTags(this.testEnvironmentMetadata),
+        },
+      }
       // tracer might not be initialized correctly
       if (this.tracer._exporter.addMetadataTags) {
         this.tracer._exporter.addMetadataTags(metadataTags)
@@ -423,6 +431,15 @@ module.exports = class CiPlugin extends Plugin {
     }
   }
 
+  /**
+   * Returns library capability metadata tags for this test framework.
+   * @param {string} frameworkVersion - The test framework version.
+   * @returns {Record<string, string|undefined>}
+   */
+  getLibraryCapabilitiesTags (frameworkVersion) {
+    return getDefaultLibraryCapabilitiesTags(this.constructor.id, frameworkVersion)
+  }
+
   /**
    * Adds a hidden _dd tag to the test session span when a test-optimization request fails.
    * If the session span does not exist yet (e.g. library-configuration failed before session:start),