dd-trace 5.99.1 → 5.101.0

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

@@ -217,6 +217,8 @@ const TEST_MANAGEMENT_IS_QUARANTINED = 'test.test_management.is_quarantined'
 const TEST_MANAGEMENT_ENABLED = 'test.test_management.enabled'
 const TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED = 'test.test_management.attempt_to_fix_passed'
 
+const MAX_TEST_OPTIMIZATION_SUMMARY_ITEMS = 10
+
 // Impacted tests
 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\/.*)$/
@@ -358,7 +360,14 @@ module.exports = {
   GIT_REPOSITORY_URL,
   DYNAMIC_NAME_RE,
   collectDynamicNamesFromTraces,
+  collectTestOptimizationSummariesFromTraces,
   logDynamicNamesWarning,
+  recordAttemptToFixExecution,
+  collectAttemptToFixExecutionsFromTraces,
+  formatAttemptToFixSummary,
+  logAttemptToFixTestExecution,
+  formatDynamicNamesSummary,
+  logTestOptimizationSummary,
 }
 
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
@@ -1327,23 +1336,149 @@ function getModifiedFilesFromDiff (diff) {
 }
 
 /**
- * Scans serialized worker trace payloads for tests tagged with TEST_HAS_DYNAMIC_NAME
- * and populates the provided Set. Silently ignores parse errors.
+ * @typedef {object} AttemptToFixExecutionResult
+ * @property {string} name
+ * @property {number} executions
+ * @property {number} failedCount
+ * @property {boolean} isDisabled
+ * @property {boolean} isQuarantined
+ */
+
+/**
+ * @typedef {Map<string, AttemptToFixExecutionResult>} AttemptToFixExecutions
+ */
+
+/**
+ * Formats a test name for user-facing Test Optimization summaries.
+ *
+ * @param {string | undefined} testSuite
+ * @param {string} testName
+ * @returns {string}
+ */
+function formatTestOptimizationName (testSuite, testName) {
+  return testSuite ? `${testSuite} › ${testName}` : testName
+}
+
+/**
+ * Renders a bounded bullet list for Test Optimization summaries.
+ *
+ * @param {Array<{ text: string, suffix?: string }>} items
+ * @returns {string}
+ */
+function formatTestOptimizationList (items) {
+  const shown = items.slice(0, MAX_TEST_OPTIMIZATION_SUMMARY_ITEMS)
+  const more = items.length - shown.length
+  const moreSuffix = more > 0 ? `\n  ... and ${more} more` : ''
+
+  return shown.map(({ text, suffix }) => `  • ${text}${suffix ? ` (${suffix})` : ''}`).join('\n') + moreSuffix
+}
+
+/**
+ * Logs a compact message when an attempt-to-fix test execution starts.
+ *
+ * @param {string | undefined} testSuite
+ * @param {string} testName
+ * @param {Set<string>} [loggedAttemptToFixTests]
+ */
+function logAttemptToFixTestExecution (testSuite, testName, loggedAttemptToFixTests) {
+  if (!testName) return
+
+  const name = formatTestOptimizationName(testSuite, testName)
+  if (loggedAttemptToFixTests) {
+    if (loggedAttemptToFixTests.has(name)) return
+
+    loggedAttemptToFixTests.add(name)
+  }
+
+  // eslint-disable-next-line no-console -- Intentional user-facing attempt-to-fix progress report
+  console.warn(`Datadog Test Optimization: attempting to fix ${name}`)
+}
+
+/**
+ * Records a single attempt-to-fix execution for the end-of-session user summary.
+ *
+ * @param {AttemptToFixExecutions} attemptToFixExecutions
+ * @param {{
+ *   testSuite?: string,
+ *   testName: string,
+ *   status: string,
+ *   isDisabled?: boolean,
+ *   isQuarantined?: boolean
+ * }} execution
+ */
+function recordAttemptToFixExecution (attemptToFixExecutions, execution) {
+  if (!execution?.testName) return
+
+  const { testSuite, testName, status, isDisabled, isQuarantined } = execution
+  const name = formatTestOptimizationName(testSuite, testName)
+  let result = attemptToFixExecutions.get(name)
+
+  if (!result) {
+    result = {
+      name,
+      executions: 0,
+      failedCount: 0,
+      isDisabled: false,
+      isQuarantined: false,
+    }
+    attemptToFixExecutions.set(name, result)
+  }
+
+  result.executions++
+  result.isDisabled = result.isDisabled || !!isDisabled
+  result.isQuarantined = result.isQuarantined || !!isQuarantined
+
+  if (status === 'fail') {
+    result.failedCount++
+  }
+}
+
+function collectDynamicNameFromTraceSpan (span, newTestsWithDynamicNames) {
+  const meta = span.meta
+  if (meta?.[TEST_HAS_DYNAMIC_NAME] !== 'true') return
+
+  const suite = meta[TEST_SUITE]
+  const name = meta[TEST_NAME]
+  if (suite && name) {
+    newTestsWithDynamicNames.add(`${suite} › ${name}`)
+  }
+}
+
+function collectAttemptToFixExecutionFromTraceSpan (span, attemptToFixExecutions) {
+  const meta = span.meta
+  if (meta?.[TEST_MANAGEMENT_IS_ATTEMPT_TO_FIX] !== 'true') return
+
+  recordAttemptToFixExecution(attemptToFixExecutions, {
+    testSuite: meta[TEST_SUITE],
+    testName: meta[TEST_NAME],
+    status: meta[TEST_STATUS],
+    isDisabled: meta[TEST_MANAGEMENT_IS_DISABLED] === 'true',
+    isQuarantined: meta[TEST_MANAGEMENT_IS_QUARANTINED] === 'true',
+  })
+}
+
+/**
+ * Scans serialized worker trace payloads and populates Test Optimization summary data.
+ * Silently ignores parse errors.
  *
  * @param {string} data - JSON-serialized traces from a worker
- * @param {Set<string>} newTestsWithDynamicNames - Set to populate with "suite › name" strings
+ * @param {{
+ *   newTestsWithDynamicNames?: Set<string>,
+ *   attemptToFixExecutions?: AttemptToFixExecutions
+ * }} summaries
  */
-function collectDynamicNamesFromTraces (data, newTestsWithDynamicNames) {
+function collectTestOptimizationSummariesFromTraces (data, summaries) {
+  const { newTestsWithDynamicNames, attemptToFixExecutions } = summaries
+
   try {
     const traces = JSON.parse(data)
     for (const trace of traces) {
       for (const span of trace) {
-        if (span.meta?.[TEST_HAS_DYNAMIC_NAME] === 'true') {
-          const suite = span.meta[TEST_SUITE]
-          const name = span.meta[TEST_NAME]
-          if (suite && name) {
-            newTestsWithDynamicNames.add(`${suite} › ${name}`)
-          }
+        if (newTestsWithDynamicNames) {
+          collectDynamicNameFromTraceSpan(span, newTestsWithDynamicNames)
+        }
+        if (attemptToFixExecutions) {
+          collectAttemptToFixExecutionFromTraceSpan(span, attemptToFixExecutions)
         }
       }
     }
@@ -1353,33 +1488,164 @@ function collectDynamicNamesFromTraces (data, newTestsWithDynamicNames) {
 }
 
 /**
- * Logs a "Datadog Test Optimization" warning about new tests with dynamic names.
- * Clears the Set after logging. No-op if the Set is empty.
+ * Scans serialized worker trace payloads for tests tagged with TEST_HAS_DYNAMIC_NAME
+ * and populates the provided Set. Silently ignores parse errors.
  *
- * @param {Set<string>} newTestsWithDynamicNames
+ * @param {string} data - JSON-serialized traces from a worker
+ * @param {Set<string>} newTestsWithDynamicNames - Set to populate with "suite › name" strings
  */
-function logDynamicNamesWarning (newTestsWithDynamicNames) {
-  if (newTestsWithDynamicNames.size === 0) return
+function collectDynamicNamesFromTraces (data, newTestsWithDynamicNames) {
+  collectTestOptimizationSummariesFromTraces(data, { newTestsWithDynamicNames })
+}
 
-  const MAX_SHOWN = 10
-  const names = [...newTestsWithDynamicNames]
-  const shown = names.slice(0, MAX_SHOWN)
-  const more = names.length - shown.length
-  const moreSuffix = more > 0 ? `\n  ... and ${more} more` : ''
-  const nameList = shown.map(n => `  • ${n}`).join('\n') + moreSuffix
+/**
+ * Scans serialized worker trace payloads for attempt-to-fix test spans.
+ *
+ * @param {string} data - JSON-serialized traces from a worker
+ * @param {AttemptToFixExecutions} attemptToFixExecutions
+ */
+function collectAttemptToFixExecutionsFromTraces (data, attemptToFixExecutions) {
+  collectTestOptimizationSummariesFromTraces(data, { attemptToFixExecutions })
+}
 
-  const line = '-'.repeat(50)
-  // eslint-disable-next-line no-console -- Intentional user-facing session summary
-  console.warn(
-    `\n${line}\nDatadog Test Optimization\n${line}\n` +
+function getAttemptToFixManagementNotes (result) {
+  const notes = []
+
+  if (result.isDisabled) {
+    notes.push('Test was marked as disabled but was run because it is attempt to fix.')
+  }
+  if (result.isQuarantined) {
+    notes.push('Test was marked as quarantined but was not quarantined because it is attempt to fix.')
+  }
+
+  return notes
+}
+
+function hasAttemptToFixManagementNotes (result) {
+  return result.isDisabled || result.isQuarantined
+}
+
+function addAttemptToFixResultLine (lines, result) {
+  lines.push(`  • ${result.name}`)
+
+  for (const note of getAttemptToFixManagementNotes(result)) {
+    lines.push(`    ${note}`)
+  }
+}
+
+/**
+ * Formats the attempt-to-fix end-of-session summary.
+ *
+ * @param {AttemptToFixExecutions} attemptToFixExecutions
+ * @returns {string}
+ */
+function formatAttemptToFixSummary (attemptToFixExecutions) {
+  if (attemptToFixExecutions.size === 0) return ''
+
+  const results = [...attemptToFixExecutions.values()]
+  const failedResults = results.filter(result => result.failedCount > 0)
+  const totalExecutions = results.reduce((total, result) => total + result.executions, 0)
+
+  if (failedResults.length === 0) {
+    const lines = [
+      `Attempt to fix passed: all ${totalExecutions} execution(s) passed for ${results.length} test(s).`,
+    ]
+
+    for (const result of results) {
+      if (hasAttemptToFixManagementNotes(result)) {
+        addAttemptToFixResultLine(lines, result)
+      }
+    }
+
+    return lines.join('\n')
+  }
+
+  const totalFailedExecutions = failedResults.reduce(
+    (total, result) => total + result.failedCount,
+    0
+  )
+  const lines = [
+    `Attempt to fix failed: ${totalFailedExecutions} of ${totalExecutions} execution(s) failed ` +
+      `across ${failedResults.length} of ${results.length} test(s).`,
+  ]
+
+  for (const result of failedResults) {
+    addAttemptToFixResultLine(lines, result)
+  }
+  for (const result of results) {
+    if (result.failedCount === 0 && hasAttemptToFixManagementNotes(result)) {
+      addAttemptToFixResultLine(lines, result)
+    }
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Formats the dynamic-name warning section of the Test Optimization summary.
+ *
+ * @param {Set<string>} newTestsWithDynamicNames
+ * @returns {string}
+ */
+function formatDynamicNamesSummary (newTestsWithDynamicNames) {
+  if (newTestsWithDynamicNames.size === 0) return ''
+
+  const items = [...newTestsWithDynamicNames].map(name => ({ text: name }))
+  return (
     `${newTestsWithDynamicNames.size} test(s) detected as new but their names contain ` +
     'dynamic data (timestamps, UUIDs, etc.).\n' +
     'Tests with changing names are always treated as new on every run, ' +
     'causing unnecessary Early Flake Detection retries and preventing correct new test detection.\n' +
     'Consider using stable, deterministic test names.\n\n' +
-    `${nameList}\n`
+    formatTestOptimizationList(items)
   )
-  newTestsWithDynamicNames.clear()
+}
+
+/**
+ * Logs a single Test Optimization session summary.
+ *
+ * @param {{
+ *   attemptToFixExecutions?: AttemptToFixExecutions,
+ *   newTestsWithDynamicNames?: Set<string>,
+ *   extraSections?: string[]
+ * }} summary
+ */
+function logTestOptimizationSummary (summary) {
+  const { attemptToFixExecutions, newTestsWithDynamicNames, extraSections = [] } = summary
+  const sections = []
+  const attemptToFixSummary = attemptToFixExecutions
+    ? formatAttemptToFixSummary(attemptToFixExecutions)
+    : ''
+  const dynamicNamesSummary = newTestsWithDynamicNames
+    ? formatDynamicNamesSummary(newTestsWithDynamicNames)
+    : ''
+
+  if (attemptToFixSummary) sections.push(attemptToFixSummary)
+  sections.push(...extraSections.filter(Boolean))
+  if (dynamicNamesSummary) sections.push(dynamicNamesSummary)
+
+  if (sections.length === 0) return
+
+  const line = '-'.repeat(50)
+  // eslint-disable-next-line no-console -- Intentional user-facing session summary
+  console.warn(`\n${line}\nDatadog Test Optimization\n${line}\n${sections.join('\n\n')}\n`)
+
+  if (attemptToFixExecutions) {
+    attemptToFixExecutions.clear()
+  }
+  if (newTestsWithDynamicNames) {
+    newTestsWithDynamicNames.clear()
+  }
+}
+
+/**
+ * Logs a "Datadog Test Optimization" warning about new tests with dynamic names.
+ * Clears the Set after logging. No-op if the Set is empty.
+ *
+ * @param {Set<string>} newTestsWithDynamicNames
+ */
+function logDynamicNamesWarning (newTestsWithDynamicNames) {
+  logTestOptimizationSummary({ newTestsWithDynamicNames })
 }
 
 function isModifiedTest (testPath, testStartLine, testEndLine, modifiedFiles, testFramework) {

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

@@ -148,9 +148,8 @@ class PrioritySampler {
   update (rates) {
     const samplers = {}
 
-    for (const key in rates) {
-      const rate = rates[key]
-      samplers[key] = new Sampler(rate)
+    for (const key of Object.keys(rates)) {
+      samplers[key] = new Sampler(rates[key])
     }
 
     samplers[DEFAULT_KEY] = samplers[DEFAULT_KEY] || defaultSampler
@@ -334,7 +333,10 @@ class PrioritySampler {
       if (!trace.tags[DECISION_MAKER_KEY]) {
         trace.tags[DECISION_MAKER_KEY] = `-${mechanism}`
       }
-    } else {
+    } else if (DECISION_MAKER_KEY in trace.tags) {
+      // Guard the `delete` so the common drop path doesn't pay the V8
+      // dictionary-mode transition unless a prior keep decision actually
+      // set the tag.
       delete trace.tags[DECISION_MAKER_KEY]
     }
   }

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

@@ -4,6 +4,7 @@ const path = require('path')
 const { pathToFileURL } = require('url')
 
 const satisfies = require('../../../../vendor/dist/semifies')
+const getGitMetadata = require('../git_metadata')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { getIsAzureFunction } = require('../serverless')
 const { getAzureTagsFromMetadata, getAzureAppMetadata, getAzureFunctionMetadata } = require('../azure_metadata')
@@ -38,10 +39,10 @@ class Config {
       ...getAzureTagsFromMetadata(getIsAzureFunction() ? getAzureFunctionMetadata() : getAzureAppMetadata()),
     }
 
-    // Add source code integration tags if available
-    if (options.repositoryUrl && options.commitSHA) {
-      this.tags[GIT_REPOSITORY_URL] = options.repositoryUrl
-      this.tags[GIT_COMMIT_SHA] = options.commitSHA
+    const { commitSHA, repositoryUrl } = getGitMetadata(options)
+    if (repositoryUrl && commitSHA) {
+      this.tags[GIT_REPOSITORY_URL] = repositoryUrl
+      this.tags[GIT_COMMIT_SHA] = commitSHA
     }
 
     // Normalize from seconds to milliseconds. Default must be longer than a minute.

package/packages/dd-trace/src/profiling/ssi-heuristics.js

@@ -14,12 +14,12 @@ class SSIHeuristics {
    * @param {import('../config/config-base')} config - Tracer configuration
    */
   constructor (config) {
-    const longLivedThreshold = config.profiling.longLivedThreshold || DEFAULT_LONG_LIVED_THRESHOLD
+    const longLivedThreshold = config.DD_INTERNAL_PROFILING_LONG_LIVED_THRESHOLD || DEFAULT_LONG_LIVED_THRESHOLD
     if (typeof longLivedThreshold !== 'number' || longLivedThreshold <= 0) {
       this.longLivedThreshold = DEFAULT_LONG_LIVED_THRESHOLD
       log.warn(
         'Invalid SSIHeuristics.longLivedThreshold value: %s. Using default value:',
-        config.profiling.longLivedThreshold,
+        config.DD_INTERNAL_PROFILING_LONG_LIVED_THRESHOLD,
         DEFAULT_LONG_LIVED_THRESHOLD
       )
     } else {

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

@@ -33,7 +33,7 @@ class PropagationHashManager {
    * @returns {boolean}
    */
   isEnabled () {
-    return this._config?.propagateProcessTags?.enabled === true
+    return this._config?.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED === true
   }
 
   /**

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

@@ -113,11 +113,11 @@ class Tracer extends NoopProxy {
       const propagationHash = require('./propagation-hash')
       propagationHash.configure(config)
 
-      if (config.crashtracking.enabled) {
+      if (config.DD_CRASHTRACKING_ENABLED) {
         require('./crashtracking').start(config)
       }
 
-      if (config.heapSnapshot.count > 0) {
+      if (config.DD_HEAP_SNAPSHOT_COUNT > 0) {
         require('./heap_snapshots').start(config)
       }
 
@@ -229,7 +229,7 @@ class Tracer extends NoopProxy {
         initializeOpenTelemetryLogs(config)
       }
 
-      if (config.otelMetricsEnabled) {
+      if (config.DD_METRICS_OTEL_ENABLED) {
         const { initializeOpenTelemetryMetrics } = require('./opentelemetry/metrics')
         initializeOpenTelemetryMetrics(config)
       }

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

@@ -5,6 +5,7 @@ const tracerVersion = require('../../../../package.json').version
 const request = require('../exporters/common/request')
 const log = require('../log')
 const { getExtraServices } = require('../service-naming/extra-services')
+const getGitMetadata = require('../git_metadata')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const tagger = require('../tagger')
 const { getAgentUrl } = require('../agent/url')
@@ -37,11 +38,12 @@ class RemoteConfig {
       '_dd.rc.client_id': clientId,
     })
 
-    const tags = config.repositoryUrl
+    const { commitSHA, repositoryUrl } = getGitMetadata(config)
+    const tags = repositoryUrl
       ? {
           ...config.tags,
-          [GIT_REPOSITORY_URL]: config.repositoryUrl,
-          [GIT_COMMIT_SHA]: config.commitSHA,
+          [GIT_REPOSITORY_URL]: repositoryUrl,
+          [GIT_COMMIT_SHA]: commitSHA,
         }
       : config.tags
 

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

@@ -42,7 +42,7 @@ module.exports = {
     this.stop()
     const clientConfig = DogStatsDClient.generateClientConfig(config)
 
-    if (config.propagateProcessTags?.enabled) {
+    if (config.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED) {
       for (const tag of processTags.tagsArray) {
         clientConfig.tags.push(tag)
       }

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

@@ -2,6 +2,11 @@
 
 const tags = require('../../../ext/tags')
 const constants = require('./constants')
+const {
+  MAX_META_KEY_LENGTH,
+  MAX_META_VALUE_LENGTH,
+  MAX_METRIC_KEY_LENGTH,
+} = require('./encode/tags-processors')
 const id = require('./id')
 const { isError } = require('./util')
 const { registerExtraService } = require('./service-naming/extra-services')
@@ -33,6 +38,23 @@ const map = {
   'resource.name': 'resource',
 }
 
+/**
+ * @typedef {object} FormattedSpan
+ * @property {import('./id').Identifier} trace_id
+ * @property {import('./id').Identifier} span_id
+ * @property {import('./id').Identifier} parent_id
+ * @property {string} name
+ * @property {string} resource
+ * @property {number} error
+ * @property {Record<string, string>} meta
+ * @property {Record<string, number>} metrics
+ * @property {Record<string, unknown> | undefined} meta_struct
+ * @property {number} start
+ * @property {number} duration
+ * @property {Array} links
+ * @property {Array<{ name: string, time_unix_nano: number, attributes?: Record<string, string> }>} [span_events]
+ */
+
 function format (span, isFirstSpanInChunk = false, tagForFirstSpanInChunk = false) {
   const formatted = formatSpan(span)
 
@@ -71,12 +93,15 @@ function setSingleSpanIngestionTags (span, options) {
   addTag({}, span.metrics, SPAN_SAMPLING_MAX_PER_SECOND, options.maxPerSecond)
 }
 
+/**
+ * @param {FormattedSpan} formattedSpan
+ * @param {import('./opentracing/span')} span
+ */
 function extractSpanLinks (formattedSpan, span) {
   if (!span._links?.length) {
     return
   }
-  const links = span._links.map(link => {
-    const { context, attributes } = link
+  const links = span._links.map(({ context, attributes }) => {
     const formattedLink = {
       trace_id: context.toTraceId(true),
       span_id: context.toSpanId(true),
@@ -90,21 +115,28 @@ function extractSpanLinks (formattedSpan, span) {
 
     return formattedLink
   })
-  formattedSpan.meta['_dd.span_links'] = JSON.stringify(links)
+  let serialized = JSON.stringify(links)
+  if (serialized.length > MAX_META_VALUE_LENGTH) {
+    serialized = `${serialized.slice(0, MAX_META_VALUE_LENGTH)}...`
+  }
+  formattedSpan.meta['_dd.span_links'] = serialized
 }
 
+/**
+ * @param {FormattedSpan} formattedSpan
+ * @param {import('./opentracing/span')} span
+ */
 function extractSpanEvents (formattedSpan, span) {
   if (!span._events?.length) {
     return
   }
-  const events = span._events.map(event => {
+  formattedSpan.span_events = span._events.map(event => {
     return {
       name: event.name,
       time_unix_nano: Math.round(event.startTime * 1e6),
       attributes: event.attributes && Object.keys(event.attributes).length > 0 ? event.attributes : undefined,
     }
   })
-  formattedSpan.span_events = events
 }
 
 function extractTags (formattedSpan, span) {
@@ -225,13 +257,25 @@ function extractError (formattedSpan, error) {
 function addTag (meta, metrics, key, value, nested) {
   switch (typeof value) {
     case 'string':
+      if (key.length > MAX_META_KEY_LENGTH) {
+        key = `${key.slice(0, MAX_META_KEY_LENGTH)}...`
+      }
+      if (value.length > MAX_META_VALUE_LENGTH) {
+        value = `${value.slice(0, MAX_META_VALUE_LENGTH)}...`
+      }
       meta[key] = value
       break
     case 'number':
       if (Number.isNaN(value)) break
+      if (key.length > MAX_METRIC_KEY_LENGTH) {
+        key = `${key.slice(0, MAX_METRIC_KEY_LENGTH)}...`
+      }
       metrics[key] = value
       break
     case 'boolean':
+      if (key.length > MAX_METRIC_KEY_LENGTH) {
+        key = `${key.slice(0, MAX_METRIC_KEY_LENGTH)}...`
+      }
       metrics[key] = value ? 1 : 0
       break
     default:
@@ -240,6 +284,9 @@ function addTag (meta, metrics, key, value, nested) {
       // Special case for Node.js Buffer and URL
       // TODO(BridgeAR)[31.03.2025]: Figure out if all typed arrays should be treated as buffers.
       if (isNodeBuffer(value) || isUrl(value)) {
+        if (key.length > MAX_METRIC_KEY_LENGTH) {
+          key = `${key.slice(0, MAX_METRIC_KEY_LENGTH)}...`
+        }
         metrics[key] = value.toString()
       } else if (!Array.isArray(value) && !nested) {
         for (const [prop, val] of Object.entries(value)) {

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

@@ -25,7 +25,7 @@ class SpanProcessor {
     this._spanSampler = new SpanSampler(config.sampler)
     this._gitMetadataTagger = new GitMetadataTagger(config)
 
-    this._processTags = config.propagateProcessTags?.enabled
+    this._processTags = config.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED
       ? processTags.serialized
       : false
   }
@@ -158,10 +158,6 @@ class SpanProcessor {
       }
     }
 
-    for (const span of trace.finished) {
-      span.context()._tags = {}
-    }
-
     trace.started = active
     trace.finished = []
   }

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

@@ -85,7 +85,6 @@ module.exports.addSpan = function (span) {
   const expiration = now + LIFETIME
   const wrapped = new WeakRef(span)
   spans.add(wrapped, expiration)
-  // registry.register(span, span._name)
 }
 
 function isEnabled () {

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

@@ -163,12 +163,14 @@ function getProducts (config) {
  * @param {import('../config/config-base')} config
  */
 function getInstallSignature (config) {
-  const { installSignature: sig } = config
-  if (sig && (sig.id || sig.time || sig.type)) {
+  const id = config.DD_INSTRUMENTATION_INSTALL_ID
+  const time = config.DD_INSTRUMENTATION_INSTALL_TIME
+  const type = config.DD_INSTRUMENTATION_INSTALL_TYPE
+  if (id || time || type) {
     return {
-      install_id: sig.id,
-      install_time: sig.time,
-      install_type: sig.type,
+      install_id: id,
+      install_time: time,
+      install_type: type,
     }
   }
 }

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

@@ -14,7 +14,7 @@ function storeConfig (config) {
     const { containerId } = require('./exporters/common/docker')
     const processTags = require('./process-tags')
 
-    const processTagsSerialized = config.propagateProcessTags?.enabled
+    const processTagsSerialized = config.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED
       ? (processTags.serialized || null)
       : null