dd-trace 5.87.0 → 5.89.0

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

@@ -6,7 +6,7 @@ const DatadogTracer = require('./tracer')
 const getConfig = require('./config')
 const runtimeMetrics = require('./runtime_metrics')
 const log = require('./log')
-const { setStartupLogPluginManager } = require('./startup-log')
+const { setStartupLogPluginManager, startupLog } = require('./startup-log')
 const DynamicInstrumentation = require('./debugger')
 const telemetry = require('./telemetry')
 const nomenclature = require('./service-naming')
@@ -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)
       }
@@ -288,6 +292,7 @@ class Tracer extends NoopProxy {
       this._pluginManager.configure(config)
       DynamicInstrumentation.configure(config)
       setStartupLogPluginManager(this._pluginManager)
+      startupLog()
     }
   }
 

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

@@ -11,41 +11,66 @@ let config
 let pluginManager
 /** @type {import('./sampling_rule')[]} */
 let samplingRules = []
-let alreadyRan = false
+let configAlreadyRan = false
+let integrationsAlreadyRan = false
+let agentErrorAlreadyRan = false
 
 /**
- * @param {{ status: number, message: string } } [agentError]
+ * Logs DATADOG TRACER CONFIGURATION immediately at init time.
+ * Excludes integrations_loaded since plugins haven't loaded yet.
  */
-function startupLog (agentError) {
-  if (alreadyRan || !config || !config.startupLogs || !pluginManager) {
+function startupLog () {
+  if (configAlreadyRan || !config || !config.startupLogs) {
     return
   }
 
-  alreadyRan = true
+  configAlreadyRan = true
 
-  const out = tracerInfo()
+  const out = configInfo()
 
-  if (agentError) {
-    out.agent_error = agentError.message
+  warn('DATADOG TRACER CONFIGURATION - ' + out)
+}
+
+/**
+ * Logs loaded integrations. Called from writer.js on first agent payload,
+ * by which time the app has loaded its dependencies.
+ */
+function logIntegrations () {
+  if (integrationsAlreadyRan || !config || !config.startupLogs || !pluginManager) {
+    return
   }
 
-  warn('DATADOG TRACER CONFIGURATION - ' + out)
-  if (agentError) {
-    warn('DATADOG TRACER DIAGNOSTIC - Agent Error: ' + agentError.message)
-    errors.agentError = {
-      code: agentError.status,
-      message: `Agent Error: ${agentError.message}`,
-    }
+  integrationsAlreadyRan = true
+
+  warn('DATADOG TRACER INTEGRATIONS LOADED - ' + JSON.stringify(Object.keys(pluginManager._pluginsByName)))
+}
+
+/**
+ * Logs agent error diagnostic.
+ * @param {{ status: number, message: string }} agentError
+ */
+function logAgentError (agentError) {
+  if (agentErrorAlreadyRan || !config || !config.startupLogs) {
+    return
+  }
+
+  agentErrorAlreadyRan = true
+
+  warn('DATADOG TRACER DIAGNOSTIC - Agent Error: ' + agentError.message)
+  errors.agentError = {
+    code: agentError.status,
+    message: `Agent Error: ${agentError.message}`,
   }
 }
 
 /**
+ * Returns config info without integrations (used by startupLog).
  * @returns {Record<string, unknown>}
  */
-function tracerInfo () {
+function configInfo () {
   const url = getAgentUrl(config)
 
-  const out = {
+  return {
     [inspect.custom] () {
       return String(this)
     },
@@ -73,11 +98,18 @@ function tracerInfo () {
     log_injection_enabled: !!config.logInjection,
     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,
   }
+}
 
+/**
+ * Returns full tracer info including integrations (used by flare module).
+ * @returns {Record<string, unknown>}
+ */
+function tracerInfo () {
+  const out = configInfo()
+  out.integrations_loaded = Object.keys(pluginManager._pluginsByName)
   return out
 }
 
@@ -104,6 +136,8 @@ function setSamplingRules (theRules) {
 
 module.exports = {
   startupLog,
+  logIntegrations,
+  logAgentError,
   setStartupLogConfig,
   setStartupLogPluginManager,
   setSamplingRules,