dd-trace 5.104.0 → 5.106.0

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

@@ -35,7 +35,6 @@ const b3FlagsKey = 'x-b3-flags'
 const b3HeaderKey = 'b3'
 const sqsdHeaderHey = 'x-aws-sqsd-attr-_datadog'
 const b3HeaderExpr = /^(([0-9a-f]{16}){1,2}-[0-9a-f]{16}(-[01d](-[0-9a-f]{16})?)?|[01d])$/i
-const baggageExpr = new RegExp(`^${baggagePrefix}(.+)$`)
 // W3C Baggage key grammar: key = token (RFC 7230).
 // Spec (up-to-date): "Propagation format for distributed context: Baggage" §3.3.1
 // https://www.w3.org/TR/baggage/#header-content
@@ -56,6 +55,15 @@ const ddKeys = [traceKey, spanKey, samplingKey, originKey]
 const b3Keys = [b3TraceKey, b3SpanKey, b3ParentKey, b3SampledKey, b3FlagsKey, b3HeaderKey]
 const w3cKeys = [traceparentKey, tracestateKey]
 const logKeys = [...ddKeys, ...b3Keys, ...w3cKeys]
+// Dispatch table for `_extractSpanContext`. `'b3'` resolves to the matching
+// single/multi extractor per instance — see `#b3MethodName` — so it is not in
+// this table. `'baggage'` is consumed by `_extractBaggageItems`, not the loop.
+const EXTRACT_STYLE_METHODS = new Map([
+  ['datadog', '_extractDatadogContext'],
+  ['tracecontext', '_extractTraceparentContext'],
+  ['b3 single header', '_extractB3SingleContext'],
+  ['b3multi', '_extractB3MultiContext'],
+])
 // Origin value in tracestate replaces '~', ',' and ';' with '_"
 const tracestateOriginFilter = /[^\x20-\x2B\x2D-\x3A\x3C-\x7D]/g
 // Tag keys in tracestate replace ' ', ',' and '=' with '_'
@@ -68,27 +76,29 @@ const hex16 = /^[0-9A-Fa-f]{16}$/
 const percentByte = /%([0-9A-Fa-f]{2})/g
 
 class TextMapPropagator {
-  #extractB3Context
-
   /** @type {Set<string> | undefined} Cached `Set` view of `_config.baggageTagKeys`. */
   #baggageTagKeysSet
 
   /** @type {string[] | undefined} Source array that `#baggageTagKeysSet` was built from. */
   #baggageTagKeysSetSource
 
+  /** @type {'_extractB3SingleContext' | '_extractB3MultiContext'} */
+  #b3MethodName
+
   constructor (config) {
     this._config = config
 
-    // v6: `'b3'` is always single-header. v5: env-name decides — OTEL_PROPAGATORS callers expect
-    // single, the legacy `DD_TRACE_PROPAGATION_STYLE` callers expect multi.
+    // v6: `'b3'` is always single-header. v5: `OTEL_PROPAGATORS` callers
+    // expect single, legacy `DD_TRACE_PROPAGATION_STYLE` callers expect multi.
+    /* istanbul ignore else: v5 fallback, master ships 6.0.0-pre */
     if (DD_MAJOR >= 6) {
-      this.#extractB3Context = this._extractB3SingleContext
+      this.#b3MethodName = '_extractB3SingleContext'
     } else {
       const envName = getConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
       // eslint-disable-next-line eslint-rules/eslint-env-aliases
-      this.#extractB3Context = envName === 'OTEL_PROPAGATORS'
-        ? this._extractB3SingleContext
-        : this._extractB3MultiContext
+      this.#b3MethodName = envName === 'OTEL_PROPAGATORS'
+        ? '_extractB3SingleContext'
+        : '_extractB3MultiContext'
     }
   }
 
@@ -129,8 +139,7 @@ class TextMapPropagator {
 
   extract (carrier) {
     const spanContext = this._extractSpanContext(carrier)
-
-    if (!spanContext) return spanContext
+    if (spanContext === undefined) return null
 
     if (extractCh.hasSubscribers) {
       extractCh.publish({ spanContext, carrier })
@@ -275,7 +284,7 @@ class TextMapPropagator {
       (DD_MAJOR < 6 && this._hasPropagationStyle('inject', 'b3'))
     if (!hasB3multi) return
 
-    carrier[b3TraceKey] = this._getB3TraceId(spanContext)
+    carrier[b3TraceKey] = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     carrier[b3SpanKey] = spanContext._spanId.toString(16)
     carrier[b3SampledKey] = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
 
@@ -292,9 +301,9 @@ class TextMapPropagator {
     // v6 keeps `'b3 single header'` as a back-compat alias for callers that bypass parser normalisation.
     const hasB3SingleHeader = this._hasPropagationStyle('inject', 'b3 single header') ||
       (DD_MAJOR >= 6 && this._hasPropagationStyle('inject', 'b3'))
-    if (!hasB3SingleHeader) return null
+    if (!hasB3SingleHeader) return
 
-    const traceId = this._getB3TraceId(spanContext)
+    const traceId = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     const spanId = spanContext._spanId.toString(16)
     const sampled = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
 
@@ -361,7 +370,7 @@ class TextMapPropagator {
   }
 
   _hasTraceIdConflict (w3cSpanContext, firstSpanContext) {
-    return w3cSpanContext !== null &&
+    return w3cSpanContext !== undefined &&
            firstSpanContext.toTraceId(true) === w3cSpanContext.toTraceId(true) &&
            firstSpanContext.toSpanId() !== w3cSpanContext.toSpanId()
   }
@@ -372,7 +381,7 @@ class TextMapPropagator {
 
   _updateParentIdFromDdHeaders (carrier, firstSpanContext) {
     const ddCtx = this._extractDatadogContext(carrier)
-    if (ddCtx !== null) {
+    if (ddCtx !== undefined) {
       firstSpanContext._trace.tags[tags.DD_PARENT_ID] = ddCtx._spanId.toString().padStart(16, '0')
     }
   }
@@ -394,35 +403,20 @@ class TextMapPropagator {
   }
 
   _extractSpanContext (carrier) {
-    let context = null
+    let context
     let style = ''
     for (const extractor of this._config.tracePropagationStyle.extract) {
-      let extractedContext = null
-      switch (extractor) {
-        case 'datadog':
-          extractedContext = this._extractDatadogContext(carrier)
-          break
-        case 'tracecontext':
-          extractedContext = this._extractTraceparentContext(carrier)
-          break
-        case 'b3 single header':
-          extractedContext = this._extractB3SingleContext(carrier)
-          break
-        case 'b3':
-          extractedContext = this.#extractB3Context(carrier)
-          break
-        case 'b3multi':
-          extractedContext = this._extractB3MultiContext(carrier)
-          break
-        default:
-          if (extractor !== 'baggage') log.warn('Unknown propagation style:', extractor)
+      const method = extractor === 'b3' ? this.#b3MethodName : EXTRACT_STYLE_METHODS.get(extractor)
+      if (method === undefined) {
+        if (extractor !== 'baggage') log.warn('Unknown propagation style:', extractor)
+        continue
       }
-
-      if (extractedContext === null) { // If the current extractor was invalid, continue to the next extractor
+      const extractedContext = this[method](carrier)
+      if (extractedContext === undefined) {
         continue
       }
 
-      if (context === null) {
+      if (context === undefined) {
         context = extractedContext
         style = extractor
         if (this._config.DD_TRACE_PROPAGATION_EXTRACT_FIRST) {
@@ -446,9 +440,7 @@ class TextMapPropagator {
     }
 
     if (this._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT === 'ignore') {
-      // `context` is null when no extractor matched; the fallback below picks up
-      // the SQSD context if present, otherwise the request runs untraced.
-      if (context) context._links = []
+      if (context !== undefined) context._links = []
     } else {
       if (this._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT === 'restart' && context) {
         context._links = []
@@ -490,14 +482,17 @@ class TextMapPropagator {
 
   _extractB3MultiContext (carrier) {
     const b3 = this._extractB3MultipleHeaders(carrier)
-    if (!b3) return null
+    if (b3 === undefined) return
     return this._extractB3Context(b3)
   }
 
   _extractB3SingleContext (carrier) {
-    if (!b3HeaderExpr.test(carrier[b3HeaderKey])) return null
+    // `typeof === 'string'` first; otherwise the regex coerces `undefined` to
+    // `'undefined'` and runs on every header-less request.
+    const header = carrier[b3HeaderKey]
+    if (typeof header !== 'string' || !b3HeaderExpr.test(header)) return
     const b3 = this._extractB3SingleHeader(carrier)
-    if (!b3) return null
+    if (b3 === undefined) return
     return this._extractB3Context(b3)
   }
 
@@ -527,23 +522,19 @@ class TextMapPropagator {
 
   _extractSqsdContext (carrier) {
     const headerValue = carrier[sqsdHeaderHey]
-    if (!headerValue) {
-      return null
-    }
+    if (!headerValue) return
     let parsed
     try {
       parsed = JSON.parse(headerValue)
     } catch {
-      return null
+      return
     }
     return this._extractDatadogContext(parsed)
   }
 
   _extractTraceparentContext (carrier) {
     const headerValue = carrier[traceparentKey]
-    if (typeof headerValue !== 'string') {
-      return null
-    }
+    if (typeof headerValue !== 'string') return
     const matches = headerValue.trim().match(traceparentExpr)
     if (matches !== null) {
       const [, version, traceId, spanId, flags, tail] = matches
@@ -554,14 +545,14 @@ class TextMapPropagator {
         ? carrier.tracestate.filter(item => typeof item === 'string').join(',')
         : carrier.tracestate
       const tracestate = TraceState.fromString(rawTracestate)
-      if (invalidSegment.test(traceId)) return null
-      if (invalidSegment.test(spanId)) return null
+      if (invalidSegment.test(traceId)) return
+      if (invalidSegment.test(spanId)) return
 
       // Version ff is considered invalid
-      if (version === 'ff') return null
+      if (version === 'ff') return
 
       // Version 00 should have no tail, but future versions may
-      if (tail && version === '00') return null
+      if (tail && version === '00') return
 
       const spanContext = new DatadogSpanContext({
         traceId: id(traceId, 16),
@@ -624,12 +615,11 @@ class TextMapPropagator {
       this._extractLegacyBaggageItems(carrier, spanContext)
       return spanContext
     }
-    return null
   }
 
   _extractGenericContext (carrier, traceKey, spanKey, radix) {
     if (carrier && carrier[traceKey] && carrier[spanKey]) {
-      if (invalidSegment.test(carrier[traceKey])) return null
+      if (invalidSegment.test(carrier[traceKey])) return
 
       return new DatadogSpanContext({
         traceId: id(carrier[traceKey], radix),
@@ -637,11 +627,17 @@ class TextMapPropagator {
         isRemote: true,
       })
     }
-
-    return null
   }
 
   _extractB3MultipleHeaders (carrier) {
+    // `b3ParentKey` is intentionally absent: this method never consults it,
+    // so a parent-id-only carrier should bail with the rest.
+    if (carrier[b3TraceKey] === undefined &&
+      carrier[b3SampledKey] === undefined &&
+      carrier[b3FlagsKey] === undefined) {
+      return
+    }
+
     let empty = true
     const b3 = {}
 
@@ -661,12 +657,12 @@ class TextMapPropagator {
       empty = false
     }
 
-    return empty ? null : b3
+    return empty ? undefined : b3
   }
 
   _extractB3SingleHeader (carrier) {
     const header = carrier[b3HeaderKey]
-    if (!header) return null
+    if (!header) return
 
     const parts = header.split('-')
 
@@ -705,13 +701,12 @@ class TextMapPropagator {
   }
 
   _extractLegacyBaggageItems (carrier, spanContext) {
-    if (this._config.legacyBaggageEnabled) {
-      for (const key of Object.keys(carrier)) {
-        const match = key.match(baggageExpr)
-
-        if (match) {
-          spanContext._baggageItems[match[1]] = carrier[key]
-        }
+    if (!this._config.legacyBaggageEnabled) return
+    for (const key of Object.keys(carrier)) {
+      if (!key.startsWith(baggagePrefix)) continue
+      const baggageKey = key.slice(baggagePrefix.length)
+      if (baggageKey) {
+        spanContext._baggageItems[baggageKey] = carrier[key]
       }
     }
   }
@@ -864,14 +859,6 @@ class TextMapPropagator {
     }
   }
 
-  _getB3TraceId (spanContext) {
-    if (spanContext._traceId.toBuffer().length <= 8 && spanContext._trace.tags['_dd.p.tid']) {
-      return spanContext._trace.tags['_dd.p.tid'] + spanContext._traceId.toString(16)
-    }
-
-    return spanContext._traceId.toString(16)
-  }
-
   /**
    * @param {number} traceparentSampled
    * @param {number|undefined} tracestateSamplingPriority

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

@@ -10,7 +10,10 @@ const tagger = require('../tagger')
 const runtimeMetrics = require('../runtime_metrics')
 const log = require('../log')
 const { storage } = require('../../../datadog-core')
+const { resolveServiceSource } = require('../service-naming/source-resolver')
 const telemetryMetrics = require('../telemetry/metrics')
+const { MANUAL_DROP, MANUAL_KEEP, SAMPLING_PRIORITY } = require('../../../../ext/tags')
+const { DD_MAJOR } = require('../../../../version')
 const SpanContext = require('./span_context')
 
 const dateNow = Date.now
@@ -103,7 +106,7 @@ class DatadogSpan {
 
     this._spanContext = this._createContext(parent, fields)
     this._spanContext._name = operationName
-    this._spanContext._tags = tags
+    Object.assign(this._spanContext.getTags(), tags)
     this._spanContext._hostname = hostname
 
     this._spanContext._trace.started.push(this)
@@ -145,7 +148,7 @@ class DatadogSpan {
 
   toString () {
     const spanContext = this.context()
-    const resourceName = spanContext._tags['resource.name'] || ''
+    const resourceName = spanContext.getTag('resource.name') || ''
     const resource = resourceName.length > 100
       ? `${resourceName.slice(0, 97)}...`
       : resourceName
@@ -153,7 +156,7 @@ class DatadogSpan {
       traceId: spanContext._traceId,
       spanId: spanContext._spanId,
       parentId: spanContext._parentId,
-      service: spanContext._tags['service.name'],
+      service: spanContext.getTag('service.name'),
       name: spanContext._name,
       resource,
     })
@@ -199,12 +202,52 @@ class DatadogSpan {
   }
 
   setTag (key, value) {
-    this._addTags({ [key]: value })
+    this._spanContext.setTag(key, value)
+
+    if (isSamplingPriorityTag(key) && this._spanContext._sampling.priority === undefined) {
+      this._prioritySampler.sample(this, false)
+    }
+
+    if (tagsUpdateCh.hasSubscribers) {
+      tagsUpdateCh.publish(this)
+    }
+
     return this
   }
 
   addTags (keyValueMap) {
-    this._addTags(keyValueMap)
+    // v6 hot path: `Object.assign` straight onto the live tag map. The
+    // string and array shapes never appeared in the public TypeScript
+    // surface, and no internal v6 caller passes one (see MIGRATING.md).
+    // v5 still accepts both via `tagger.add` for `config.tags` /
+    // `options.tags` callers that pass `'key:val,key:val'` strings.
+    const tags = this._spanContext.getTags()
+    let mayChangeSamplingPriority
+
+    if (keyValueMap !== null && typeof keyValueMap === 'object' && !Array.isArray(keyValueMap)) {
+      Object.assign(tags, keyValueMap)
+      mayChangeSamplingPriority =
+        MANUAL_KEEP in keyValueMap ||
+        MANUAL_DROP in keyValueMap ||
+        SAMPLING_PRIORITY in keyValueMap
+    } else {
+      /* istanbul ignore if: v5 fallback, master ships 6.0.0-pre */
+      if (DD_MAJOR < 6 && (typeof keyValueMap === 'string' || Array.isArray(keyValueMap))) {
+        tagger.add(tags, keyValueMap)
+        mayChangeSamplingPriority = true
+      } else {
+        return this
+      }
+    }
+
+    if (mayChangeSamplingPriority && this._spanContext._sampling.priority === undefined) {
+      this._prioritySampler.sample(this, false)
+    }
+
+    if (tagsUpdateCh.hasSubscribers) {
+      tagsUpdateCh.publish(this)
+    }
+
     return this
   }
 
@@ -215,8 +258,9 @@ class DatadogSpan {
   logEvent () {}
 
   addLink (link, attrs) {
-    // TODO: Remove this once we remove addLink(context, attrs) in v6.0.0
-    if (link instanceof SpanContext) {
+    // v5 still accepts the legacy `addLink(spanContext, attrs)` shape; v6 only takes
+    // `addLink({ context, attributes })`.
+    if (DD_MAJOR < 6 && link instanceof SpanContext) {
       link = { context: link, attributes: attrs ?? {} }
     }
 
@@ -267,12 +311,14 @@ class DatadogSpan {
       return
     }
 
-    if (this.#parentTracer._config.DD_TRACE_EXPERIMENTAL_STATE_TRACKING && !this._spanContext._tags['service.name']) {
+    if (this.#parentTracer._config.DD_TRACE_EXPERIMENTAL_STATE_TRACKING && !this._spanContext.getTag('service.name')) {
       log.error('Finishing invalid span: %s', this)
     }
 
     getIntegrationCounter('spans_finished', this._integrationName).inc()
-    this._spanContext._tags['_dd.integration'] = this._integrationName
+    this._spanContext.setTag('_dd.integration', this._integrationName)
+
+    resolveServiceSource(this, this.#parentTracer._service)
 
     if (this.#parentTracer._config.DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.decrement('runtime.node.spans.unfinished')
@@ -404,16 +450,6 @@ class DatadogSpan {
 
     return startTime + now() - ticks
   }
-
-  _addTags (keyValuePairs) {
-    tagger.add(this._spanContext._tags, keyValuePairs)
-
-    this._prioritySampler.sample(this, false)
-
-    if (tagsUpdateCh.hasSubscribers) {
-      tagsUpdateCh.publish(this)
-    }
-  }
 }
 
 function createRegistry (type) {
@@ -423,4 +459,8 @@ function createRegistry (type) {
   })
 }
 
+function isSamplingPriorityTag (key) {
+  return key === MANUAL_KEEP || key === MANUAL_DROP || key === SAMPLING_PRIORITY
+}
+
 module.exports = DatadogSpan

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

@@ -46,9 +46,7 @@ class DatadogSpanContext {
 
   toTraceId (get128bitId = false) {
     if (get128bitId) {
-      return this._traceId.toBuffer().length <= 8 && this._trace.tags[TRACE_ID_128]
-        ? this._trace.tags[TRACE_ID_128] + this._traceId.toString(16).padStart(16, '0')
-        : this._traceId.toString(16).padStart(32, '0')
+      return this._traceId.toTraceIdHex(this._trace.tags[TRACE_ID_128]).padStart(32, '0')
     }
     return this._traceId.toString(10)
   }
@@ -71,6 +69,55 @@ class DatadogSpanContext {
     const version = (this._traceparent && this._traceparent.version) || '00'
     return `${version}-${traceId}-${spanId}-${flags}`
   }
+
+  /**
+   * Set a tag value.
+   * @param {string} key - Tag key
+   * @param {unknown} value - Tag value
+   */
+  setTag (key, value) {
+    this._tags[key] = value
+  }
+
+  /**
+   * Get a tag value.
+   * @param {string} key - Tag key
+   * @returns {unknown} Tag value or undefined
+   */
+  getTag (key) {
+    return this._tags[key]
+  }
+
+  /**
+   * Check if a tag exists.
+   * @param {string} key - Tag key
+   * @returns {boolean}
+   */
+  hasTag (key) { return Object.hasOwn(this._tags, key) }
+
+  /**
+   * Delete a tag.
+   * @param {string} key - Tag key
+   */
+  deleteTag (key) { delete this._tags[key] }
+
+  /**
+   * Get the live internal tags map. The returned reference is mutable;
+   * callers may assign or delete keys directly (e.g.
+   * `Object.assign(getTags(), tags)` in span.js). Subclasses may have
+   * additional sync side effects on the individual `setTag` / `deleteTag`
+   * setters; mutating the returned map bypasses those.
+   *
+   * @returns {object}
+   */
+  getTags () {
+    return this._tags
+  }
+
+  /**
+   * Clear all tags.
+   */
+  clearTags () { this._tags = Object.create(null) }
 }
 
 module.exports = DatadogSpanContext

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

@@ -52,7 +52,6 @@ const {
   TEST_ITR_SKIPPING_ENABLED,
   ITR_CORRELATION_ID,
   TEST_SOURCE_FILE,
-  TEST_LEVEL_EVENT_TYPES,
   TEST_SUITE,
   getFileAndLineNumberFromError,
   DI_ERROR_DEBUG_INFO_CAPTURED,
@@ -128,7 +127,6 @@ function getTestSuiteLevelVisibilityTags (testSuiteSpan, testFramework) {
   const suiteTags = {
     [TEST_SUITE_ID]: testSuiteSpanContext.toSpanId(),
     [TEST_SESSION_ID]: testSuiteSpanContext.toTraceId(),
-    [TEST_COMMAND]: testSuiteSpanContext._tags[TEST_COMMAND],
     [TEST_MODULE]: testFramework,
   }
 
@@ -174,7 +172,7 @@ module.exports = class CiPlugin extends Plugin {
           },
         }
         this.tracer._exporter.addMetadataTags(metadataTags)
-        onDone({ err, libraryConfig, requestErrorTags })
+        onDone({ err, libraryConfig, repositoryRoot: this.repositoryRoot, requestErrorTags })
       })
     })
 
@@ -186,15 +184,22 @@ module.exports = class CiPlugin extends Plugin {
       if (!this.tracer._exporter?.getSkippableSuites) {
         return onDone({ err: new Error('Test optimization was not initialized correctly') })
       }
-      this.tracer._exporter.getSkippableSuites(this.testConfiguration, (err, skippableSuites, itrCorrelationId) => {
-        if (err) {
-          log.error('Skippable suites could not be fetched. %s', err.message)
-          this._addRequestErrorTag(DD_CI_LIBRARY_CONFIGURATION_ERROR_SKIPPABLE_TESTS, err)
-        } else {
-          this.itrCorrelationId = itrCorrelationId
+      this.tracer._exporter.getSkippableSuites(
+        {
+          ...this.testConfiguration,
+          isCoverageReportUploadEnabled: this.libraryConfig?.isCoverageReportUploadEnabled,
+        },
+        (err, skippableSuites, itrCorrelationId, skippableSuitesCoverage) => {
+          if (err) {
+            log.error('Skippable suites could not be fetched. %s', err.message)
+            this._addRequestErrorTag(DD_CI_LIBRARY_CONFIGURATION_ERROR_SKIPPABLE_TESTS, err)
+          } else {
+            this.itrCorrelationId = itrCorrelationId
+            this.skippableSuitesCoverage = skippableSuitesCoverage
+          }
+          onDone({ err, skippableSuites, itrCorrelationId, skippableSuitesCoverage })
         }
-        onDone({ err, skippableSuites, itrCorrelationId })
-      })
+      )
     })
 
     this.addSub(`ci:${this.constructor.id}:session:start`, ({ command, frameworkVersion, rootDir }) => {
@@ -213,12 +218,7 @@ module.exports = class CiPlugin extends Plugin {
         this.testEnvironmentMetadata
       )
 
-      const metadataTags = {}
-      for (const testLevel of TEST_LEVEL_EVENT_TYPES) {
-        metadataTags[testLevel] = {
-          [TEST_SESSION_NAME]: testSessionName,
-        }
-      }
+      const metadataTags = { '*': { [TEST_COMMAND]: command, [TEST_SESSION_NAME]: testSessionName } }
       // tracer might not be initialized correctly
       if (this.tracer._exporter.addMetadataTags) {
         this.tracer._exporter.addMetadataTags(metadataTags)
@@ -255,7 +255,7 @@ module.exports = class CiPlugin extends Plugin {
     })
 
     this.addSub(`ci:${this.constructor.id}:itr:skipped-suites`, ({ skippedSuites, frameworkVersion }) => {
-      const testCommand = this.testSessionSpan.context()._tags[TEST_COMMAND]
+      const testCommand = this.command
       for (const testSuite of skippedSuites) {
         const testSuiteMetadata = {
           ...getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, this.constructor.id),
@@ -615,7 +615,7 @@ module.exports = class CiPlugin extends Plugin {
       const suiteTags = {
         [TEST_SUITE_ID]: testSuiteSpan.context().toSpanId(),
         [TEST_SESSION_ID]: testSuiteSpan.context().toTraceId(),
-        [TEST_COMMAND]: testSuiteSpan.context()._tags[TEST_COMMAND],
+        [TEST_COMMAND]: testSuiteSpan.context().getTag(TEST_COMMAND),
         [TEST_MODULE]: this.constructor.id,
         ...getSessionRequestErrorTags(this.testSessionSpan),
       }
@@ -808,7 +808,7 @@ module.exports = class CiPlugin extends Plugin {
   }
 
   getTestTelemetryTags (testSpan) {
-    const activeSpanTags = testSpan.context()._tags
+    const activeSpanTags = testSpan.context().getTags()
     return {
       hasCodeOwners: !!activeSpanTags[TEST_CODE_OWNERS] || undefined,
       isNew: activeSpanTags[TEST_IS_NEW] === 'true' || undefined,

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

@@ -49,7 +49,7 @@ class DatabasePlugin extends StoragePlugin {
    * @returns {string}
    */
   #createDBMPropagationCommentService (serviceName, span, peerData) {
-    const spanTags = span.context()._tags
+    const spanTags = span.context().getTags()
     const dddb = spanTags['db.name']
     const ddh = spanTags['out.host']
     const cacheKey = `${dddb ?? ''}\0${ddh ?? ''}\0${serviceName ?? ''}`
@@ -91,23 +91,24 @@ class DatabasePlugin extends StoragePlugin {
       return null
     }
 
-    const peerData = this.getPeerService(span.context()._tags)
+    const peerData = this.getPeerService(span.context().getTags())
     const dbmService = this.#getDbmServiceName(serviceName, peerData)
     const servicePropagation = this.#createDBMPropagationCommentService(dbmService, span, peerData)
 
     let dbmComment = servicePropagation
 
-    // Add propagation hash if both process tags and SQL base hash injection are enabled
-    if (propagationHash.isEnabled() && this.config['dbm.injectSqlBaseHash']) {
+    // Add propagation hash if process tags are enabled and either SQL base hash injection is enabled
+    // or dynamic_service mode implicitly enables it
+    if (propagationHash.isEnabled() && (this.config['dbm.injectSqlBaseHash'] || mode === 'dynamic_service')) {
       const hashBase64 = propagationHash.getHashBase64()
       if (hashBase64) {
         dbmComment += `,ddsh='${hashBase64}'`
         // Add hash to span meta as a tag
-        span.setTag('_dd.dbm.propagation_hash', hashBase64)
+        span.setTag('_dd.propagated_hash', hashBase64)
       }
     }
 
-    if (disableFullMode || mode === 'service') {
+    if (disableFullMode || mode === 'service' || mode === 'dynamic_service') {
       return dbmComment
     } else if (mode === 'full') {
       span.setTag('_dd.dbm_trace_injected', 'true')