dd-trace 6.4.0 → 6.6.0

package/packages/dd-trace/src/openfeature/configuration_source.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const { isLoopbackHost } = require('../exporters/common/url')
+const log = require('../log')
+
+const DEFAULT_AGENTLESS_PATH = '/api/v2/feature-flagging/config/rules-based/server'
+const MAX_POLL_INTERVAL_SECONDS = 60 * 60
+
+/**
+ * @typedef {import('@datadog/openfeature-node-server').UniversalFlagConfigurationV1} UniversalFlagConfiguration
+ */
+
+/**
+ * @param {import('../config/config-base')} config
+ * @param {(configuration: UniversalFlagConfiguration) => void} applyConfiguration
+ */
+function create (config, applyConfiguration) {
+  const {
+    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE: source,
+    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_BASE_URL: baseUrl,
+    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_POLL_INTERVAL_SECONDS: pollIntervalSeconds,
+    DD_FEATURE_FLAGS_CONFIGURATION_SOURCE_AGENTLESS_REQUEST_TIMEOUT_SECONDS: requestTimeoutSeconds,
+    DD_FEATURE_FLAGS_ENABLED: enabled,
+  } = config.featureFlags
+
+  if (!enabled || source !== 'agentless') {
+    return
+  }
+
+  try {
+    if (!config.DD_API_KEY) {
+      throw new Error('DD_API_KEY is required for Feature Flagging agentless delivery')
+    }
+
+    const AgentlessConfigurationSource = require('./agentless_configuration_source')
+    return new AgentlessConfigurationSource({
+      endpoint: endpoint(config, baseUrl),
+      pollIntervalMs: Math.min(pollIntervalSeconds, MAX_POLL_INTERVAL_SECONDS) * 1000,
+      requestTimeoutMs: requestTimeoutSeconds * 1000,
+      apiKey: config.DD_API_KEY,
+    }, applyConfiguration)
+  } catch (error) {
+    log.error('Unable to configure Feature Flagging configuration source', error)
+  }
+}
+
+/**
+ * Builds the agentless rules-based server endpoint.
+ *
+ * A configured URL with a non-root path is treated as the exact endpoint. A
+ * configured origin (or root URL) receives the standard rules-based server
+ * path.
+ *
+ * @param {import('../config/config-base')} config - Tracer configuration.
+ * @param {string | undefined} configuredBaseUrl - Optional endpoint or origin override.
+ * @returns {URL} Agentless endpoint.
+ */
+function endpoint (config, configuredBaseUrl) {
+  const configured = configuredBaseUrl?.trim()
+
+  if (!configured) {
+    const url = new URL(`https://ufc-server.ff-cdn.${config.site.toLowerCase()}${DEFAULT_AGENTLESS_PATH}`)
+    if (config.env) url.searchParams.set('dd_env', config.env)
+    return url
+  }
+
+  let url
+  try {
+    url = new URL(configured)
+  } catch {
+    throw new Error('Invalid Feature Flagging agentless URL')
+  }
+
+  if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+    throw new Error('Feature Flagging agentless URL must use HTTP or HTTPS')
+  }
+  if (url.protocol === 'http:' && !isLoopbackHost(url.hostname)) {
+    throw new Error('Feature Flagging agentless URL must use HTTPS unless it targets loopback')
+  }
+
+  if (url.pathname === '' || url.pathname === '/') {
+    url.pathname = DEFAULT_AGENTLESS_PATH
+  }
+
+  return url
+}
+
+module.exports = {
+  create,
+}

package/packages/dd-trace/src/openfeature/flagging_provider.js

@@ -1,40 +1,40 @@
 'use strict'
 
 const { channel } = require('dc-polyfill')
-const requireOptionalPeer = require('../../../datadog-instrumentations/src/helpers/require-optional-peer')
 const log = require('../log')
+const configurationSource = require('./configuration_source')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
 const EvalMetricsHook = require('./eval-metrics-hook')
 const SpanEnrichmentHook = require('./span-enrichment-hook')
 
-const { DatadogNodeServerProvider } = requireOptionalPeer('@datadog/openfeature-node-server')
+const { DatadogNodeServerProvider } = require('./require-provider')
 
 /**
  * OpenFeature provider that integrates with Datadog's feature flagging system.
  * Extends DatadogNodeServerProvider to add tracer integration and configuration management.
  */
 class FlaggingProvider extends DatadogNodeServerProvider {
-  /** @type {SpanEnrichmentHook?} */
+  /** @type {SpanEnrichmentHook | undefined} */
   #spanEnrichmentHook
 
+  /** @type {{ start: Function, stop: Function } | undefined} */
+  #configurationSource
+
   /**
    * @param {import('../tracer')} tracer - Datadog tracer instance
-   * @param {import('../config')} config - Tracer configuration object
+   * @param {import('../config/config-base')} config - Tracer configuration object
    */
   constructor (tracer, config) {
-    // Call parent constructor with required options and timeout
     super({
       exposureChannel: channel(EXPOSURE_CHANNEL),
       initializationTimeoutMs: config.experimental.flaggingProvider.initializationTimeoutMs,
     })
 
-    this._tracer = tracer
-    this._config = config
-
     this.hooks.push(new EvalMetricsHook(config))
 
     if (config.experimental.flaggingProvider.spanEnrichment?.enabled) {
       this.#spanEnrichmentHook = new SpanEnrichmentHook(tracer)
+      // @ts-expect-error The upstream constructor always initializes its optional hooks property.
       this.hooks.push(this.#spanEnrichmentHook)
       log.info('%s span enrichment enabled', this.constructor.name)
     } else {
@@ -43,6 +43,9 @@ class FlaggingProvider extends DatadogNodeServerProvider {
 
     log.debug('%s created with timeout: %dms', this.constructor.name,
       config.experimental.flaggingProvider.initializationTimeoutMs)
+
+    this.#configurationSource = configurationSource.create(config, this.setConfiguration.bind(this))
+    this.#configurationSource?.start()
   }
 
   /**
@@ -50,22 +53,10 @@ class FlaggingProvider extends DatadogNodeServerProvider {
    * Cleans up resources including channel subscriptions.
    */
   onClose () {
+    this.#configurationSource?.stop()
+    this.#configurationSource = undefined
     this.#spanEnrichmentHook?.destroy()
-  }
-
-  /**
-   * Internal method to update flag configuration from Remote Config.
-   * This method is called automatically when Remote Config delivers UFC updates.
-   *
-   * @internal
-   * @param {import('@datadog/openfeature-node-server').UniversalFlagConfigurationV1} ufc
-   * - Universal Flag Configuration object
-   */
-  _setConfiguration (ufc) {
-    if (typeof this.setConfiguration === 'function') {
-      this.setConfiguration(ufc)
-    }
-    log.debug('%s provider configuration updated', this.constructor.name)
+    this.#spanEnrichmentHook = undefined
   }
 }
 

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

@@ -47,8 +47,6 @@ function enable (config) {
   setAgentStrategy(config, hasAgent => {
     exposuresWriter?.setEnabled(hasAgent)
   })
-
-  log.debug('OpenFeature module enabled')
 }
 
 /**

package/packages/dd-trace/src/openfeature/noop.js

@@ -20,12 +20,7 @@ function resolveDefault (defaultValue) {
  * https://openfeature.dev/docs/reference/concepts/provider/
  */
 class NoopFlaggingProvider {
-  /**
-   * @param {object} [noopTracer] - Optional noop tracer instance
-   */
-  constructor (noopTracer) {
-    this._tracer = noopTracer
-    this._config = {}
+  constructor () {
     this.metadata = { name: 'NoopFlaggingProvider' }
     this.status = 'NOT_READY'
     this.runsOn = 'server'
@@ -78,28 +73,6 @@ class NoopFlaggingProvider {
   resolveObjectEvaluation (flagKey, defaultValue, context, logger) {
     return resolveDefault(defaultValue)
   }
-
-  /**
-   * @returns {object} Current configuration
-   */
-  getConfiguration () {
-    return this._config
-  }
-
-  /**
-   * @param {object} config - Configuration to set
-   */
-  setConfiguration (config) {
-    this._config = config
-  }
-
-  /**
-   * @internal
-   * @param {object} ufc - Universal Flag Configuration object
-   */
-  _setConfiguration (ufc) {
-    this.setConfiguration(ufc)
-  }
 }
 
 module.exports = NoopFlaggingProvider

package/packages/dd-trace/src/openfeature/register.js

@@ -4,43 +4,32 @@ const { registerFeature } = require('../feature-registry')
 
 const noop = new (require('./noop'))()
 
-/**
- * @param {import('../proxy')} proxy
- * @returns {boolean}
- */
-function hasFlaggingProvider (proxy) {
-  const descriptor = Reflect.getOwnPropertyDescriptor(proxy, 'openfeature')
-
-  return descriptor?.value !== undefined && descriptor.value !== noop
-}
+/** @typedef {import('../proxy') & { openfeature: object }} OpenFeatureProxy */
 
 registerFeature({
   name: 'openfeature',
   noop,
   factory: () => require('./index'),
+  provider: () => require('./flagging_provider'),
 
-  /**
-   * @param {object} rc - RemoteConfig instance
-   * @param {import('../config/config-base')} config
-   * @param {import('../proxy')} proxy
-   */
-  remoteConfig (rc, config, proxy) {
-    const openfeatureRemoteConfig = require('./remote_config')
-    openfeatureRemoteConfig.enable(rc, config, () => proxy.openfeature)
+  /** @param {import('../config/config-base')} config */
+  isEnabled (config) {
+    return config.featureFlags.DD_FEATURE_FLAGS_ENABLED
   },
 
   /**
+   * @param {import('../remote_config')} rc - RemoteConfig instance
    * @param {import('../config/config-base')} config
-   * @param {import('../tracer')} tracer
-   * @param {import('../proxy')} proxy
-   * @param {Function} lazyProxy
+   * @param {OpenFeatureProxy} proxy
    */
-  enable (config, tracer, proxy, lazyProxy) {
-    if (config.experimental.flaggingProvider.enabled) {
-      proxy._modules.openfeature.enable(config)
-      if (!hasFlaggingProvider(proxy)) {
-        lazyProxy(proxy, 'openfeature', () => require('./flagging_provider'), tracer, config)
-      }
-    }
+  remoteConfig (rc, config, proxy) {
+    const openfeatureRemoteConfig = require('./remote_config')
+    const subscribe = config.featureFlags.DD_FEATURE_FLAGS_ENABLED &&
+      config.featureFlags.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE === 'remote_config'
+    openfeatureRemoteConfig.enable(
+      rc,
+      () => proxy.openfeature,
+      subscribe
+    )
   },
 })

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

@@ -5,30 +5,27 @@ const RemoteConfigCapabilities = require('../remote_config/capabilities')
 /**
  * Configures remote config handlers for openfeature feature flagging
  *
- * @param {object} rc - RemoteConfig instance
- * @param {object} config - Tracer config
- * @param {Function} getOpenfeatureProxy - Function that returns the OpenFeature proxy from tracer
+ * @param {import('../remote_config')} rc - RemoteConfig instance
+ * @param {() => import('./flagging_provider')} getOpenfeatureProxy
+ * @param {boolean} subscribe - Whether Agent Remote Config owns UFC delivery
  */
-function enable (rc, config, getOpenfeatureProxy) {
-  // Always enable capability for feature flag configuration
-  // This indicates the library supports this capability via remote config
-  rc.updateCapabilities(RemoteConfigCapabilities.FFE_FLAG_CONFIGURATION_RULES, true)
+function enable (rc, getOpenfeatureProxy, subscribe) {
+  if (!subscribe) return
 
-  // Only register product handler if the experimental feature is enabled
-  if (!config.experimental.flaggingProvider.enabled) return
+  rc.updateCapabilities(RemoteConfigCapabilities.FFE_FLAG_CONFIGURATION_RULES, true)
 
-  // Set product handler for FFE_FLAGS
-  rc.setProductHandler('FFE_FLAGS', (action, conf) => {
+  /**
+   * @param {string} action
+   * @param {import('@datadog/openfeature-node-server').UniversalFlagConfigurationV1} conf
+   */
+  const updateConfiguration = (action, conf) => {
     if (action === 'apply' || action === 'modify') {
-      // Feed UFC config directly to OpenFeature provider
-      getOpenfeatureProxy()._setConfiguration(conf)
+      getOpenfeatureProxy().setConfiguration(conf)
     } else if (action === 'unapply') {
-      // Clear the configuration so evaluations return PROVIDER_NOT_READY,
-      // consistent with Go and Python which also set config to null on RC deletion.
-      // The evaluator returns PROVIDER_NOT_READY when config is null/undefined.
-      getOpenfeatureProxy()._setConfiguration(null)
+      getOpenfeatureProxy().setConfiguration(undefined)
     }
-  })
+  }
+  rc.setProductHandler('FFE_FLAGS', updateConfiguration)
 }
 
 module.exports = {

package/packages/dd-trace/src/openfeature/require-provider.js

@@ -0,0 +1,18 @@
+'use strict'
+
+/** @type {(request: string) => typeof import('@datadog/openfeature-node-server')} */
+let requireOptionalPeer
+
+// @ts-expect-error webpack exposes this escape hatch as a free variable.
+// eslint-disable-next-line camelcase
+if (typeof __non_webpack_require__ === 'function') {
+  // eslint-disable-next-line camelcase, no-undef
+  requireOptionalPeer = __non_webpack_require__
+} else {
+  // nft recognizes createRequire through a binding named `module`.
+  const module = require('node:module')
+  const runtimeRequire = module.createRequire(__filename)
+  requireOptionalPeer = runtimeRequire
+}
+
+module.exports = requireOptionalPeer('@datadog/openfeature-node-server')

package/packages/dd-trace/src/opentelemetry/span-ending-hook.js

@@ -0,0 +1,10 @@
+'use strict'
+
+// Pre-finish hook for OTel-bridge spans. `Span.end()` runs it before `finish()` formats and
+// (synchronously, for the last span in a trace) exports the trace, so a framework instrumentation
+// can rewrite the operation name / resource while the DD span is still unfinished; `onEnd` only sees
+// the already-built payload. Its own dependency-free module so an instrumentation can register
+// without loading the OTel bridge, and a plain holder so the caller gates on `hook` existing.
+
+/** @type {{ hook: ((ddSpan: import('../opentracing/span')) => void) | undefined }} */
+module.exports = { hook: undefined }

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

@@ -15,6 +15,7 @@ const kinds = require('../../../../ext/kinds')
 const id = require('../id')
 const BridgeSpanBase = require('./bridge-span-base')
 const SpanContext = require('./span_context')
+const spanEndingHook = require('./span-ending-hook')
 const { setOtelOperationName, setOtelResource } = require('./span-helpers')
 
 const spanKindNames = {
@@ -255,6 +256,10 @@ class Span extends BridgeSpanBase {
     const hrEndTime = timeInputToHrTime(timeInput || (performance.now() + timeOrigin))
     const endTime = hrTimeToMilliseconds(hrEndTime)
 
+    // Must run before `finish()`, while the DD span is still unfinished. See span-ending-hook.js.
+    if (spanEndingHook.hook !== undefined) {
+      spanEndingHook.hook(this._ddSpan)
+    }
     this._ddSpan.finish(endTime)
     this._spanProcessor.onEnd(this)
   }

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

@@ -181,6 +181,9 @@ module.exports = class CiPlugin extends Plugin {
       }
       this.tracer._exporter.getLibraryConfiguration(this.testConfiguration, (err, libraryConfig) => {
         if (err) {
+          this.libraryConfig = undefined
+          this.itrCorrelationId = undefined
+          this.skippableSuitesCoverage = undefined
           log.error('Library configuration could not be fetched. %s', err.message)
           this._addRequestErrorTag(DD_CI_LIBRARY_CONFIGURATION_ERROR_SETTINGS, err)
         } else {
@@ -955,17 +958,28 @@ module.exports = class CiPlugin extends Plugin {
     }
     log.debug('Removing all Dynamic Instrumentation probes')
     const promises = []
-    for (const fileLine of this.fileLineToProbeId.keys()) {
-      const [file, line] = fileLine.split(':')
-      promises.push(this.removeDiProbe({ file, line }))
+    for (const [activeProbeKey, probeId] of this.fileLineToProbeId) {
+      promises.push(this.#removeDiProbe(activeProbeKey, probeId))
     }
     return Promise.all(promises)
   }
 
+  /**
+   * @param {{ file: string, line: number }} location
+   */
   removeDiProbe ({ file, line }) {
-    const probeId = this.fileLineToProbeId.get(`${file}:${line}`)
-    log.warn('Removing probe from %s:%s, with id: %s', file, line, probeId)
-    this.fileLineToProbeId.delete(probeId)
+    const activeProbeKey = `${file}:${line}`
+    const probeId = this.fileLineToProbeId.get(activeProbeKey)
+    return this.#removeDiProbe(activeProbeKey, probeId)
+  }
+
+  /**
+   * @param {string} activeProbeKey
+   * @param {string|undefined} probeId
+   */
+  #removeDiProbe (activeProbeKey, probeId) {
+    log.warn('Removing probe from %s, with id: %s', activeProbeKey, probeId)
+    this.fileLineToProbeId.delete(activeProbeKey)
     return this.di.removeProbe(probeId)
   }
 

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

@@ -13,6 +13,7 @@ const {
   TELEMETRY_GIT_COMMAND_ERRORS,
 } = require('../../ci-visibility/telemetry')
 const { storage } = require('../../../../datadog-core')
+const { getSegment } = require('../../util')
 const {
   GIT_COMMIT_SHA,
   GIT_BRANCH,
@@ -251,7 +252,7 @@ function getGitRemoteName () {
   )
 
   if (upstreamRemote) {
-    return upstreamRemote.split('/')[0]
+    return getSegment(upstreamRemote, '/', 0)
   }
 
   const remotes = sanitizedExec(
@@ -263,7 +264,7 @@ function getGitRemoteName () {
     false
   )
 
-  return remotes.split('\n')[0] || 'origin'
+  return getSegment(remotes, '\n', 0) || 'origin'
 }
 
 function getSourceBranch () {

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

@@ -26,14 +26,27 @@ const supportedProxies = {
   'aws-apigateway': {
     spanName: 'aws.apigateway',
     component: 'aws-apigateway',
+    providesTimestamp: true,
   },
   'aws-httpapi': {
     spanName: 'aws.httpapi',
     component: 'aws-httpapi',
+    providesTimestamp: true,
   },
   'azure-apim': {
     spanName: 'azure.apim',
     component: 'azure-apim',
+    providesTimestamp: true,
+  },
+  'azure-gw': {
+    spanName: 'azure.app-gateway',
+    component: 'azure-gw',
+    providesTimestamp: false,
+  },
+  'azure-fd': {
+    spanName: 'azure.frontdoor',
+    component: 'azure-fd',
+    providesTimestamp: false,
   },
 }
 
@@ -109,21 +122,32 @@ function setInferredProxySpanTags (span, proxyContext) {
 }
 
 function extractInferredProxyContext (headers) {
-  if (!(PROXY_HEADER_START_TIME_MS in headers)) {
+  if (!(PROXY_HEADER_SYSTEM in headers)) {
+    return null
+  }
+  if (!Object.hasOwn(supportedProxies, headers[PROXY_HEADER_SYSTEM])) {
+    log.debug('Received headers to create inferred proxy span but headers include an unsupported proxy type: %s',
+      headers[PROXY_HEADER_SYSTEM])
+
     return null
   }
 
-  if (!(PROXY_HEADER_SYSTEM in headers && headers[PROXY_HEADER_SYSTEM] in supportedProxies)) {
-    log.debug('Received headers to create inferred proxy span but headers include an unsupported proxy type', headers)
+  const detectedProxy = supportedProxies[headers[PROXY_HEADER_SYSTEM]]
+
+  if (detectedProxy.providesTimestamp && !headers[PROXY_HEADER_START_TIME_MS]) {
     return null
   }
 
   return {
     requestTime: headers[PROXY_HEADER_START_TIME_MS]
       ? Number.parseInt(headers[PROXY_HEADER_START_TIME_MS], 10)
-      : null,
+      : Date.now(),
     method: headers[PROXY_HEADER_HTTPMETHOD],
-    path: headers[PROXY_HEADER_PATH],
+    path: headers[PROXY_HEADER_PATH]
+      ? (headers[PROXY_HEADER_PATH].startsWith('/')
+          ? headers[PROXY_HEADER_PATH]
+          : '/' + headers[PROXY_HEADER_PATH])
+      : headers[PROXY_HEADER_PATH],
     stage: headers[PROXY_HEADER_STAGE],
     domainName: headers[PROXY_HEADER_DOMAIN],
     proxySystemName: headers[PROXY_HEADER_SYSTEM],

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

@@ -6,6 +6,7 @@ const { URL } = require('url')
 const { getLageTestSessionName } = require('../../ci-visibility/lage')
 const log = require('../../log')
 const { getEnvironmentVariable } = require('../../config/helper')
+const { getSegment } = require('../../util')
 const satisfies = require('../../../../../vendor/dist/semifies')
 
 const istanbul = require('../../../../../vendor/dist/istanbul-lib-coverage')
@@ -77,6 +78,11 @@ const {
  *
  * @typedef {{ service?: string, isServiceUserProvided?: boolean }} TestEnvironmentConfig
  * @typedef {Record<string, string|number|undefined>} TestEnvironmentMetadata
+ * @typedef {{
+ *   isRumActive?: boolean,
+ *   browserVersion?: string,
+ *   testExecutionId?: string
+ * }} RumTestCorrelationContext
  */
 
 // session tags
@@ -130,7 +136,7 @@ const CI_APP_ORIGIN = 'ciapp-test'
 // - Math.random() float values (10+ decimal digits after 0.)
 const DYNAMIC_NAME_RE = new RegExp(
   String.raw`\b1[6-9]\d{8,11}\b|` +
-  String.raw`[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|` +
+  '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|' +
   String.raw`\b\d{4}-\d{2}-\d{2}|` +
   String.raw`(?:localhost|127\.0\.0\.1|0\.0\.0\.0):\d{4,5}\b|` +
   String.raw`\b0\.\d{10,}`,
@@ -434,6 +440,8 @@ module.exports = {
   TEST_PARAMETERS,
   TEST_SKIP_REASON,
   TEST_IS_RUM_ACTIVE,
+  setRumTestCorrelation,
+  setRumTestTags,
   TEST_SOURCE_FILE,
   TEST_FAILURE_SCREENSHOT_UPLOADED,
   TEST_FAILURE_SCREENSHOT_UPLOAD_ERROR,
@@ -567,7 +575,7 @@ module.exports = {
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
 function getPkgManager () {
   try {
-    return getEnvironmentVariable('npm_config_user_agent').split(' ')[0].replace('/', '-')
+    return getSegment(getEnvironmentVariable('npm_config_user_agent'), ' ', 0).replace('/', '-')
   } catch {
     return ''
   }
@@ -798,6 +806,9 @@ function getTestTypeFromFramework (testFramework) {
   return 'test'
 }
 
+/**
+ * @param {import('../../opentracing/span')} span
+ */
 function finishAllTraceSpans (span) {
   for (const traceSpan of span.context()._trace.started) {
     if (traceSpan !== span) {
@@ -806,6 +817,49 @@ function finishAllTraceSpans (span) {
   }
 }
 
+/**
+ * @param {import('../../opentracing/span')} testSpan
+ * @param {boolean|undefined} isRumActive
+ * @param {string} [browserVersion]
+ * @returns {void}
+ */
+function setRumTestTags (testSpan, isRumActive, browserVersion) {
+  if (isRumActive) {
+    testSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
+  }
+  if (browserVersion) {
+    testSpan.setTag(TEST_BROWSER_VERSION, browserVersion)
+  }
+}
+
+/**
+ * @param {RumTestCorrelationContext} context
+ * @param {import('../../opentracing/span')|undefined} activeSpan
+ * @returns {import('../../opentracing/span')|undefined}
+ */
+function setRumTestCorrelation (context, activeSpan) {
+  if (!activeSpan) return
+
+  const activeContext = activeSpan.context()
+  let testSpan
+  if (activeContext.getTag(SPAN_TYPE) === 'test') {
+    testSpan = activeSpan
+  } else {
+    for (const traceSpan of activeContext._trace.started) {
+      if (traceSpan.context().getTag(SPAN_TYPE) === 'test') {
+        testSpan = traceSpan
+        break
+      }
+    }
+  }
+
+  if (!testSpan) return
+
+  context.testExecutionId = testSpan.context().toTraceId()
+  setRumTestTags(testSpan, context.isRumActive, context.browserVersion)
+  return testSpan
+}
+
 function getTestParentSpan (tracer) {
   return tracer.extract('text_map', {
     'x-datadog-trace-id': id().toString(10),
@@ -1360,7 +1414,6 @@ function resetCoverage (coverage) {
 
   return coverageMap
     .files()
-    // eslint-disable-next-line unicorn/no-array-for-each
     .forEach(filename => {
       const fileCoverage = coverageMap.fileCoverageFor(filename)
       fileCoverage.resetHits()
@@ -1371,7 +1424,6 @@ function mergeCoverage (coverage, targetCoverage) {
   const coverageMap = istanbul.createCoverageMap(coverage)
   return coverageMap
     .files()
-    // eslint-disable-next-line unicorn/no-array-for-each
     .forEach(filename => {
       const fileCoverage = coverageMap.fileCoverageFor(filename)
 

package/packages/dd-trace/src/profiling/profilers/space.js

@@ -59,7 +59,7 @@ class NativeSpaceProfiler {
   }
 
   profile (restart) {
-    const profile = this.#pprof.heap.profile(undefined, this.#mapper, getThreadLabels)
+    const profile = this.#pprof.heap.profile(undefined, this.#mapper, getThreadLabels, 'pack')
     if (!restart) {
       this.stop()
     }

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -187,6 +187,7 @@ class NativeWallProfiler {
 
     this.#pprof.time.start({
       collectCpuTime: this.#cpuProfilingEnabled,
+      columnNumbers: 'pack',
       durationMillis: this.#flushIntervalMillis,
       intervalMicros: this.#samplingIntervalMicros,
       lineNumbers: false,