dd-trace 5.87.0 → 5.88.0

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

@@ -2,6 +2,7 @@
 
 const { trace, ROOT_CONTEXT, propagation } = require('@opentelemetry/api')
 const { storage } = require('../../../datadog-core')
+const { getAllBaggageItems, setBaggageItem, removeAllBaggageItems } = require('../baggage')
 
 const tracer = require('../../')
 const SpanContext = require('./span_context')
@@ -19,31 +20,26 @@ 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 otelBaggages
+    if (hasBaggage) {
+      const entries = {}
+      for (const [key, value] of Object.entries(baggages)) {
+        entries[key] = { value }
+      }
+      otelBaggages = propagation.createBaggage(entries)
+    }
+
     // If stored span wraps the active DD span, prefer the stored context
     if (storedSpan && storedSpan._ddSpan === activeSpan) {
-      const baggages = JSON.parse(activeSpan.getAllBaggageItems())
-      if (Object.keys(baggages).length > 0) {
-        const entries = {}
-        for (const [key, value] of Object.entries(baggages)) {
-          entries[key] = { value }
-        }
-        const otelBaggages = propagation.createBaggage(entries)
-        return propagation.setBaggage(store, otelBaggages)
-      }
+      if (otelBaggages) return propagation.setBaggage(store, otelBaggages)
       return store
     }
 
     if (!activeSpan) {
-      const storedBaggageItems = storedSpan?._spanContext?._ddContext?._baggageItems
-      if (storedBaggageItems) {
-        const baggages = storedBaggageItems
-        const entries = {}
-        for (const [key, value] of Object.entries(baggages)) {
-          entries[key] = { value }
-        }
-        const otelBaggages = propagation.createBaggage(entries)
-        return propagation.setBaggage(baseContext, otelBaggages)
-      }
+      if (otelBaggages) return propagation.setBaggage(baseContext, otelBaggages)
       return baseContext
     }
 
@@ -53,18 +49,6 @@ class ContextManager {
       ddContext._otelSpanContext = new SpanContext(ddContext)
     }
 
-    // Convert DD baggage to OTel format
-    const baggages = JSON.parse(activeSpan.getAllBaggageItems())
-    const hasBaggage = Object.keys(baggages).length > 0
-    let otelBaggages
-    if (hasBaggage) {
-      const entries = {}
-      for (const [key, value] of Object.entries(baggages)) {
-        entries[key] = { value }
-      }
-      otelBaggages = propagation.createBaggage(entries)
-    }
-
     if (store && trace.getSpanContext(store) === ddContext._otelSpanContext) {
       return otelBaggages ? propagation.setBaggage(store, otelBaggages) : store
     }
@@ -86,22 +70,11 @@ class ContextManager {
     if (baggages) {
       baggageItems = baggages.getAllEntries()
     }
-    if (span && span._ddSpan) {
-      // does otel always override datadog?
-      span._ddSpan.removeAllBaggageItems()
-      for (const baggage of baggageItems) {
-        span._ddSpan.setBaggageItem(baggage[0], baggage[1].value)
-      }
-      return ddScope.activate(span._ddSpan, run)
-    }
-    // span instanceof NonRecordingSpan
-    const ddContext = span?._spanContext?._ddContext
-    if (ddContext && ddContext._baggageItems) {
-      ddContext._baggageItems = {}
-      for (const baggage of baggageItems) {
-        ddContext._baggageItems[baggage[0]] = baggage[1].value
-      }
+    removeAllBaggageItems()
+    for (const baggage of baggageItems) {
+      setBaggageItem(baggage[0], baggage[1].value)
     }
+    if (span && span._ddSpan) return ddScope.activate(span._ddSpan, run)
     return run()
   }
 

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

@@ -20,7 +20,7 @@ class OtlpHttpExporterBase {
    * Creates a new OtlpHttpExporterBase instance.
    *
    * @param {string} url - OTLP endpoint URL
-   * @param {string} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {string|undefined} headers - Additional HTTP headers as comma-separated key=value string
    * @param {number} timeout - Request timeout in milliseconds
    * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
    * @param {string} defaultPath - Default path to use if URL has no path
@@ -117,11 +117,10 @@ class OtlpHttpExporterBase {
 
   /**
    * Parses additional HTTP headers from a comma-separated string.
-   * @param {string} headersString - Comma-separated key=value pairs
+   * @param {string} [headersString=''] - Comma-separated key=value pairs
    * @returns {Record<string, string>} Parsed headers object
-   * @private
    */
-  #parseAdditionalHeaders (headersString) {
+  #parseAdditionalHeaders (headersString = '') {
     const headers = {}
     let key = ''
     let value = ''

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

@@ -670,10 +670,8 @@ class TextMapPropagator {
     if (!this._hasPropagationStyle('extract', 'baggage')) return
     if (!carrier?.baggage) return
     const baggages = carrier.baggage.split(',')
-    const tagAllKeys = this._config.baggageTagKeys === '*'
-    const keysToSpanTag = tagAllKeys
-      ? undefined
-      : new Set(this._config.baggageTagKeys.split(','))
+    const baggageTagKeys = new Set(this._config.baggageTagKeys)
+    const tagAllKeys = baggageTagKeys.has('*')
     for (const keyValue of baggages) {
       if (!keyValue) continue
 
@@ -707,7 +705,7 @@ class TextMapPropagator {
         return
       }
 
-      if (spanContext && (tagAllKeys || keysToSpanTag?.has(key))) {
+      if (spanContext && (tagAllKeys || baggageTagKeys.has(key))) {
         spanContext._trace.tags['baggage.' + key] = value
       }
       setBaggageItem(key, value)

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

@@ -3,7 +3,6 @@
 // TODO (new internal tracer): use DC events for lifecycle metrics and test them
 const { performance } = require('perf_hooks')
 const now = performance.now.bind(performance)
-const dateNow = Date.now
 const util = require('util')
 const { channel } = require('dc-polyfill')
 const id = require('../id')
@@ -13,12 +12,15 @@ const log = require('../log')
 const { storage } = require('../../../datadog-core')
 const telemetryMetrics = require('../telemetry/metrics')
 const { getValueFromEnvSources } = require('../config/helper')
+const { isTrue } = require('../util')
 const SpanContext = require('./span_context')
 
+const dateNow = Date.now
+
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
-const DD_TRACE_EXPERIMENTAL_STATE_TRACKING = getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_STATE_TRACKING')
-const DD_TRACE_EXPERIMENTAL_SPAN_COUNTS = getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_SPAN_COUNTS')
+const DD_TRACE_EXPERIMENTAL_STATE_TRACKING = isTrue(getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_STATE_TRACKING'))
+const DD_TRACE_EXPERIMENTAL_SPAN_COUNTS = isTrue(getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_SPAN_COUNTS'))
 
 const unfinishedRegistry = createRegistry('unfinished')
 const finishedRegistry = createRegistry('finished')
@@ -251,7 +253,7 @@ class DatadogSpan {
       return
     }
 
-    if (DD_TRACE_EXPERIMENTAL_STATE_TRACKING === 'true' && !this._spanContext._tags['service.name']) {
+    if (DD_TRACE_EXPERIMENTAL_STATE_TRACKING && !this._spanContext._tags['service.name']) {
       log.error('Finishing invalid span: %s', this)
     }
 

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

@@ -63,6 +63,8 @@ const {
   getPullRequestDiff,
   getModifiedFilesFromDiff,
   getPullRequestBaseBranch,
+  getSessionRequestErrorTags,
+  DD_CI_LIBRARY_CONFIGURATION_ERROR,
   TEST_IS_TEST_FRAMEWORK_WORKER,
   TEST_IS_NEW,
   TEST_IS_RUM_ACTIVE,
@@ -120,6 +122,7 @@ module.exports = class CiPlugin extends Plugin {
     this.fileLineToProbeId = new Map()
     this.rootDir = process.cwd() // fallback in case :session:start events are not emitted
     this._testSuiteSpansByTestSuite = new Map()
+    this._pendingRequestErrorTags = []
 
     this.addSub(`ci:${this.constructor.id}:library-configuration`, (ctx) => {
       const { onDone, isParallel, frameworkVersion } = ctx
@@ -131,10 +134,15 @@ module.exports = class CiPlugin extends Plugin {
       this.tracer._exporter.getLibraryConfiguration(this.testConfiguration, (err, libraryConfig) => {
         if (err) {
           log.error('Library configuration could not be fetched. %s', err.message)
+          this._addRequestErrorTag(DD_CI_LIBRARY_CONFIGURATION_ERROR, err)
         } else {
           this.libraryConfig = libraryConfig
         }
 
+        const requestErrorTags = this.testSessionSpan
+          ? getSessionRequestErrorTags(this.testSessionSpan)
+          : Object.fromEntries(this._pendingRequestErrorTags.map(({ tag, value }) => [tag, value]))
+
         const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, isParallel, frameworkVersion)
         const metadataTags = {
           test: {
@@ -142,7 +150,7 @@ module.exports = class CiPlugin extends Plugin {
           },
         }
         this.tracer._exporter.addMetadataTags(metadataTags)
-        onDone({ err, libraryConfig })
+        onDone({ err, libraryConfig, requestErrorTags })
       })
     })
 
@@ -200,6 +208,10 @@ module.exports = class CiPlugin extends Plugin {
         },
         integrationName: this.constructor.id,
       })
+      for (const { tag, value } of this._pendingRequestErrorTags) {
+        this.testSessionSpan.setTag(tag, value)
+      }
+      this._pendingRequestErrorTags = []
       // TODO: add telemetry tag when we can add `is_agentless_log_submission_enabled` for agentless log submission
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'session')
 
@@ -209,6 +221,7 @@ module.exports = class CiPlugin extends Plugin {
           [COMPONENT]: this.constructor.id,
           ...this.testEnvironmentMetadata,
           ...testModuleSpanMetadata,
+          ...getSessionRequestErrorTags(this.testSessionSpan),
         },
         integrationName: this.constructor.id,
       })
@@ -230,7 +243,10 @@ 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]
       for (const testSuite of skippedSuites) {
-        const testSuiteMetadata = getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, this.constructor.id)
+        const testSuiteMetadata = {
+          ...getTestSuiteCommonTags(testCommand, frameworkVersion, testSuite, this.constructor.id),
+          ...getSessionRequestErrorTags(this.testSessionSpan),
+        }
         if (this.itrCorrelationId) {
           testSuiteMetadata[ITR_CORRELATION_ID] = this.itrCorrelationId
         }
@@ -261,8 +277,10 @@ module.exports = class CiPlugin extends Plugin {
       this.tracer._exporter.getKnownTests(this.testConfiguration, (err, knownTests) => {
         if (err) {
           log.error('Known tests could not be fetched. %s', err.message)
-          this.libraryConfig.isEarlyFlakeDetectionEnabled = false
-          this.libraryConfig.isKnownTestsEnabled = false
+          if (this.libraryConfig) {
+            this.libraryConfig.isEarlyFlakeDetectionEnabled = false
+            this.libraryConfig.isKnownTestsEnabled = false
+          }
         }
         onDone({ err, knownTests })
       })
@@ -279,7 +297,9 @@ module.exports = class CiPlugin extends Plugin {
       this.tracer._exporter.getTestManagementTests(this.testConfiguration, (err, testManagementTests) => {
         if (err) {
           log.error('Test management tests could not be fetched. %s', err.message)
-          this.libraryConfig.isTestManagementEnabled = false
+          if (this.libraryConfig) {
+            this.libraryConfig.isTestManagementEnabled = false
+          }
         }
         onDone({ err, testManagementTests })
       })
@@ -346,8 +366,15 @@ module.exports = class CiPlugin extends Plugin {
             span.meta = {
               ...span.meta,
               ...testSuiteTags,
+              ...getSessionRequestErrorTags(this.testSessionSpan),
             }
           }
+
+          // Jest and Vitest worker test spans are serialized in the worker and may not include
+          // request error tags; add them from the session span in the main process.
+          if ((span.name === 'jest.test' || span.name === 'vitest.test') && this.testSessionSpan) {
+            Object.assign(span.meta, getSessionRequestErrorTags(this.testSessionSpan))
+          }
         }
         this.tracer._exporter.export(trace)
       }
@@ -418,6 +445,30 @@ module.exports = class CiPlugin extends Plugin {
     }
   }
 
+  /**
+   * 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),
+   * the tag is queued and applied when the span is created.
+   * @param {string} tag - Tag name (e.g. DD_CI_LIBRARY_CONFIGURATION_ERROR)
+   * @param {Error} err - Request error
+   */
+  _addRequestErrorTag (tag, err) {
+    const value = 'true'
+    if (this.testSessionSpan) {
+      this.testSessionSpan.setTag(tag, value)
+    } else {
+      this._pendingRequestErrorTags.push({ tag, value })
+    }
+  }
+
+  /**
+   * Returns request error tags from the test session span for propagation to module, suite and test spans.
+   * @returns {Record<string, string>}
+   */
+  getSessionRequestErrorTags () {
+    return getSessionRequestErrorTags(this.testSessionSpan)
+  }
+
   configure (config, shouldGetEnvironmentData = true) {
     super.configure(config)
 
@@ -529,6 +580,7 @@ module.exports = class CiPlugin extends Plugin {
         [TEST_SESSION_ID]: testSuiteSpan.context().toTraceId(),
         [TEST_COMMAND]: testSuiteSpan.context()._tags[TEST_COMMAND],
         [TEST_MODULE]: this.constructor.id,
+        ...getSessionRequestErrorTags(this.testSessionSpan),
       }
       if (testSuiteSpan.context()._parentId) {
         suiteTags[TEST_MODULE_ID] = testSuiteSpan.context()._parentId.toString(10)

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const { PEER_SERVICE_KEY, PEER_SERVICE_SOURCE_KEY } = require('../constants')
+const propagationHash = require('../propagation-hash')
 const StoragePlugin = require('./storage')
 
 class DatabasePlugin extends StoragePlugin {
@@ -59,13 +60,25 @@ class DatabasePlugin extends StoragePlugin {
     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']) {
+      const hashBase64 = propagationHash.getHashBase64()
+      if (hashBase64) {
+        dbmComment += `,ddsh='${hashBase64}'`
+        // Add hash to span meta as a tag
+        span.setTag('_dd.dbm.propagation_hash', hashBase64)
+      }
+    }
+
     if (disableFullMode || mode === 'service') {
-      return servicePropagation
+      return dbmComment
     } else if (mode === 'full') {
       span.setTag('_dd.dbm_trace_injected', 'true')
       span._processor.sample(span)
       const traceparent = span._spanContext.toTraceparent()
-      return `${servicePropagation},traceparent='${traceparent}'`
+      return `${dbmComment},traceparent='${traceparent}'`
     }
   }
 

package/packages/dd-trace/src/plugins/util/test.js

@@ -145,6 +145,10 @@ const DD_CAPABILITIES_TEST_MANAGEMENT_QUARANTINE = '_dd.library_capabilities.tes
 const DD_CAPABILITIES_TEST_MANAGEMENT_DISABLE = '_dd.library_capabilities.test_management.disable'
 const DD_CAPABILITIES_TEST_MANAGEMENT_ATTEMPT_TO_FIX = '_dd.library_capabilities.test_management.attempt_to_fix'
 const DD_CAPABILITIES_FAILED_TEST_REPLAY = '_dd.library_capabilities.failed_test_replay'
+
+// Library configuration request error tag
+const DD_CI_LIBRARY_CONFIGURATION_ERROR = '_dd.ci.library_configuration_error'
+
 const UNSUPPORTED_TIA_FRAMEWORKS = new Set(['playwright', 'vitest'])
 const UNSUPPORTED_TIA_FRAMEWORKS_PARALLEL_MODE = new Set(['cucumber', 'mocha'])
 const MINIMUM_FRAMEWORK_VERSION_FOR_EFD = {
@@ -202,6 +206,22 @@ const TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED = 'test.test_management.attempt_to_f
 const POSSIBLE_BASE_BRANCHES = ['main', 'master', 'preprod', 'prod', 'dev', 'development', 'trunk']
 const BASE_LIKE_BRANCH_FILTER = /^(main|master|preprod|prod|dev|development|trunk|release\/.*|hotfix\/.*)$/
 
+/**
+ * Returns request error tags from a test session span for propagation to child events.
+ * @param {{ context: () => { _tags?: Record<string, string> } } | undefined} sessionSpan
+ * @returns {Record<string, string>}
+ */
+function getSessionRequestErrorTags (sessionSpan) {
+  const tags = sessionSpan?.context()._tags
+  if (!tags || typeof tags !== 'object') return {}
+  if (tags[DD_CI_LIBRARY_CONFIGURATION_ERROR] === 'true') {
+    return {
+      [DD_CI_LIBRARY_CONFIGURATION_ERROR]: 'true',
+    }
+  }
+  return {}
+}
+
 module.exports = {
   TEST_CODE_OWNERS,
   TEST_SESSION_NAME,
@@ -278,6 +298,7 @@ module.exports = {
   removeInvalidMetadata,
   parseAnnotations,
   getIsFaultyEarlyFlakeDetection,
+  getEfdRetryCount,
   TEST_BROWSER_DRIVER,
   TEST_BROWSER_DRIVER_VERSION,
   TEST_BROWSER_NAME,
@@ -308,6 +329,8 @@ module.exports = {
   TEST_MANAGEMENT_ENABLED,
   TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED,
   getLibraryCapabilitiesTags,
+  getSessionRequestErrorTags,
+  DD_CI_LIBRARY_CONFIGURATION_ERROR,
   checkShaDiscrepancies,
   getPullRequestDiff,
   getPullRequestBaseBranch,
@@ -846,6 +869,31 @@ function parseAnnotations (annotations) {
   }, {})
 }
 
+/**
+ * Given a test's first-execution duration (ms) and the slow_test_retries map
+ * from the backend, return how many EFD retries to run.
+ *
+ * Returns 0 when the test is too slow to retry (≥ 5 min).
+ *
+ * @param {number} durationMs
+ * @param {Record<string, number>} slowTestRetries  e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
+ * @returns {number}
+ */
+function getEfdRetryCount (durationMs, slowTestRetries) {
+  const thresholds = [
+    { limitMs: 5 * 1000, key: '5s' },
+    { limitMs: 10 * 1000, key: '10s' },
+    { limitMs: 30 * 1000, key: '30s' },
+    { limitMs: 5 * 60 * 1000, key: '5m' },
+  ]
+  for (const { limitMs, key } of thresholds) {
+    if (durationMs < limitMs) {
+      return slowTestRetries[key] ?? 0
+    }
+  }
+  return 0 // ≥ 5 min — abort
+}
+
 function getIsFaultyEarlyFlakeDetection (projectSuites, testsBySuiteName, faultyThresholdPercentage) {
   let newSuites = 0
   for (const suite of projectSuites) {

package/packages/dd-trace/src/profiling/exporter_cli.js

@@ -17,6 +17,7 @@ function exporterFromURL (url) {
   if (url.protocol === 'file:') {
     return new FileExporter({ pprofPrefix: fileURLToPath(url) })
   }
+  // TODO: Why is DD_INJECTION_ENABLED a comma separated list?
   const injectionEnabled = (getValueFromEnvSources('DD_INJECTION_ENABLED') ?? '').split(',')
   const libraryInjected = injectionEnabled.length > 0
   const profilingEnabled = (getValueFromEnvSources('DD_PROFILING_ENABLED') ?? '').toLowerCase()

package/packages/dd-trace/src/propagation-hash/index.js

@@ -0,0 +1,145 @@
+'use strict'
+
+const { fnv64 } = require('../datastreams/fnv')
+const log = require('../log')
+
+/**
+ * PropagationHashManager is a singleton that manages the propagation hash computation.
+ * The propagation hash is an FNV-1a 64-bit hash combining:
+ * - Process tags (entrypoint info, package.json name, etc.)
+ * - Container tags hash (received from the Datadog agent)
+ *
+ * This hash is used to correlate traces with database operations (DBM) and
+ * data stream pathways (DSM) for enhanced observability.
+ */
+class PropagationHashManager {
+  _containerTagsHash = null
+  _cachedHash = null
+  _cachedHashString = null
+  _cachedHashBase64 = null
+  _config = null
+
+  /**
+   * Configure the propagation hash manager with tracer config
+   * @param {object} config - Tracer configuration
+   */
+  configure (config) {
+    this._config = config
+  }
+
+  /**
+   * Check if process tags propagation is enabled
+   * @returns {boolean}
+   */
+  isEnabled () {
+    return this._config?.propagateProcessTags?.enabled === true
+  }
+
+  /**
+   * Update the container tags hash received from the agent
+   * @param {string} hash - Container tags hash from agent response
+   */
+  updateContainerTagsHash (hash) {
+    if (hash !== this._containerTagsHash) {
+      log.debug('Updating container tags hash: %s', hash)
+      this._containerTagsHash = hash
+      this._invalidateCache()
+    }
+  }
+
+  /**
+   * Get the propagation hash as a BigInt
+   * @returns {bigint | null} The propagation hash or null if disabled/unavailable
+   */
+  getHash () {
+    if (!this.isEnabled()) {
+      return null
+    }
+    if (this._cachedHash) {
+      return this._cachedHash
+    }
+    this._computeHash()
+    return this._cachedHash
+  }
+
+  /**
+   * Get the propagation hash as a hexadecimal string
+   * @returns {string|null} The propagation hash in hex format or null if disabled/unavailable
+   */
+  getHashString () {
+    const hash = this.getHash()
+    if (!hash) {
+      return null
+    }
+    if (!this._cachedHashString) {
+      this._cachedHashString = hash.toString(16)
+    }
+    return this._cachedHashString
+  }
+
+  /**
+   * Get the propagation hash as a base64 string
+   * @returns {string|null} The propagation hash in base64 format or null if disabled/unavailable
+   */
+  getHashBase64 () {
+    const hash = this.getHash()
+    if (!hash) {
+      return null
+    }
+    if (!this._cachedHashBase64) {
+      // Convert BigInt to 8-byte buffer (64-bit hash)
+      const buffer = Buffer.allocUnsafe(8)
+      // Write as big-endian 64-bit unsigned integer
+      buffer.writeBigUInt64BE(hash, 0)
+      this._cachedHashBase64 = buffer.toString('base64')
+    }
+    return this._cachedHashBase64
+  }
+
+  /**
+   * Compute the propagation hash using FNV-1a algorithm
+   * @private
+   */
+  _computeHash () {
+    try {
+      const processTags = require('../process-tags')
+
+      // Combine process tags and container tags hash
+      // Process tags are already serialized as a comma-separated string
+      const input = processTags.serialized + (this._containerTagsHash || '')
+
+      if (!input) {
+        // If both are empty, don't compute a hash
+        this._cachedHash = null
+        this._cachedHashString = null
+        this._cachedHashBase64 = null
+        return
+      }
+
+      // Compute FNV-1a 64-bit hash
+      this._cachedHash = fnv64(input)
+      this._cachedHashString = null // Will be computed on demand
+      this._cachedHashBase64 = null // Will be computed on demand
+
+      log.debug('Computed propagation hash from input (length=%s): "%s"', input.length, this._cachedHash.toString(16))
+    } catch (e) {
+      log.error('Error computing propagation hash', e)
+      this._cachedHash = null
+      this._cachedHashString = null
+      this._cachedHashBase64 = null
+    }
+  }
+
+  /**
+   * Invalidate the cached hash
+   * @private
+   */
+  _invalidateCache () {
+    this._cachedHash = null
+    this._cachedHashString = null
+    this._cachedHashBase64 = null
+  }
+}
+
+// Export singleton instance
+module.exports = new PropagationHashManager()

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

@@ -102,6 +102,10 @@ class Tracer extends NoopProxy {
     try {
       const config = getConfig(options) // TODO: support dynamic code config
 
+      // Configure propagation hash manager for process tags + container tags
+      const propagationHash = require('./propagation-hash')
+      propagationHash.configure(config)
+
       if (config.crashtracking.enabled) {
         require('./crashtracking').start(config)
       }

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

@@ -238,7 +238,7 @@ function captureHeapSpace () {
   const stats = v8.getHeapSpaceStatistics()
 
   for (let i = 0, l = stats.length; i < l; i++) {
-    const tags = [`space:${stats[i].space_name}`]
+    const tags = [`heap_space:${stats[i].space_name}`]
 
     client.gauge('runtime.node.heap.size.by.space', stats[i].space_size, tags)
     client.gauge('runtime.node.heap.used_size.by.space', stats[i].space_used_size, tags)

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

@@ -74,7 +74,7 @@ function tracerInfo () {
     runtime_metrics_enabled: !!config.runtimeMetrics,
     profiling_enabled: config.profiling?.enabled === 'true' || config.profiling?.enabled === 'auto',
     integrations_loaded: Object.keys(pluginManager._pluginsByName),
-    appsec_enabled: !!config.appsec.enabled,
+    appsec_enabled: config.appsec.enabled,
     data_streams_enabled: !!config.dsmEnabled,
   }