dd-trace 6.21.0 → 6.22.0

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

@@ -38,7 +38,7 @@ const id = require('../../id')
 const DatadogSpanContext = require('../span_context')
 const log = require('../../log')
 const tags = require('../../../../../ext/tags')
-const { getConfiguredEnvName } = require('../../config/helper')
+const { getValidatedConfiguredEnvName } = require('../../config/helper')
 const { setAllBaggageItems, getAllBaggageItems, removeAllBaggageItems } = require('../../baggage')
 const { hasTraceSourcePropagationTag } = require('../../standalone/tracesource')
 const telemetryMetrics = require('../../telemetry/metrics')
@@ -134,8 +134,7 @@ function isOptionalDatadogTraceStateField (key, injection) {
  * @returns {DatadogSpanContext | undefined}
  */
 function extractGenericContext (traceId, spanId, radix) {
-  if (!traceId || invalidSegment.test(traceId)) return
-  if (!spanId) return
+  if (!traceId || invalidSegment.test(traceId) || !spanId) return
 
   return new DatadogSpanContext({
     traceId: id(traceId, radix),
@@ -305,13 +304,25 @@ class TextMapPropagator {
   /** @type {string[] | undefined} Source array that `#baggageTagKeysSet` was built from. */
   #baggageTagKeysSetSource
 
-  /** @type {import('../../config')} */
+  /** @type {ReturnType<import('../../config')>} */
   #config
 
   /** @type {typeof extractB3SingleContext | typeof extractB3MultiContext} */
   #extractB3Context
 
-  /** @param {import('../../config')} config */
+  /** Whether the `b3` injection style resolves to single-header propagation. */
+  #b3InjectIsSingleHeader
+
+  /** Cached origin used to resolve the v5 `b3` injection style. */
+  #b3InjectOrigin
+
+  /** Cached state of the v5 experimental B3 setting. */
+  #b3ExperimentalEnabled
+
+  /** Cached origin of the shared v5 propagation style. */
+  #b3SharedOrigin
+
+  /** @param {ReturnType<import('../../config')>} config */
   constructor (config) {
     this.#config = config
 
@@ -319,16 +330,44 @@ class TextMapPropagator {
     // expect single, legacy `DD_TRACE_PROPAGATION_STYLE` callers expect multi.
     /* istanbul ignore else: v5 fallback */
     if (DD_MAJOR >= 6) {
+      this.#b3InjectIsSingleHeader = true
       this.#extractB3Context = extractB3SingleContext
     } else {
-      const envName = getConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
+      const envName = getValidatedConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
       // eslint-disable-next-line eslint-rules/eslint-env-aliases
       this.#extractB3Context = envName === 'OTEL_PROPAGATORS'
         ? extractB3SingleContext
         : extractB3MultiContext
+
+      this.#refreshB3InjectionStyle()
     }
   }
 
+  #refreshB3InjectionStyle () {
+    const origin = this.#config.getOrigin?.('tracePropagationStyle.inject') ?? 'default'
+    const experimentalEnabled = this.#config.experimental?.b3 === true
+    const sharedOrigin = origin === 'calculated'
+      ? this.#config.getOrigin?.('DD_TRACE_PROPAGATION_STYLE') ?? 'default'
+      : undefined
+    if (origin === this.#b3InjectOrigin &&
+      experimentalEnabled === this.#b3ExperimentalEnabled &&
+      sharedOrigin === this.#b3SharedOrigin) return
+
+    let envName
+    if (origin === 'calculated' && !experimentalEnabled && sharedOrigin !== 'remote_config') {
+      envName = getValidatedConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
+    } else if (origin === 'env_var' ||
+      origin === 'local_stable_config' ||
+      origin === 'fleet_stable_config') {
+      envName = getValidatedConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE_INJECT')
+    }
+    // eslint-disable-next-line eslint-rules/eslint-env-aliases
+    this.#b3InjectIsSingleHeader = envName === 'OTEL_PROPAGATORS'
+    this.#b3InjectOrigin = origin
+    this.#b3ExperimentalEnabled = experimentalEnabled
+    this.#b3SharedOrigin = sharedOrigin
+  }
+
   /**
    * Returns a `Set` view of `#config.baggageTagKeys` that is rebuilt only
    * when the source array reference changes. Avoids an `O(n)` `Set` alloc
@@ -574,9 +613,8 @@ class TextMapPropagator {
    * @returns {Record<string, string> | undefined}
    */
   #injectB3MultipleHeaders (spanContext, carrier) {
-    // v5 also accepts the legacy `'b3'` spelling for multi; v6+ routes `'b3'` to single-header.
     const hasB3multi = this.#hasPropagationStyle('inject', 'b3multi') ||
-      (DD_MAJOR < 6 && this.#hasPropagationStyle('inject', 'b3'))
+      (this.#hasPropagationStyle('inject', 'b3') && !this.#usesB3SingleHeaderInjection())
     if (!hasB3multi) return
 
     carrier ??= {}
@@ -603,7 +641,7 @@ class TextMapPropagator {
   #injectB3SingleHeader (spanContext, carrier) {
     // 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'))
+      (this.#hasPropagationStyle('inject', 'b3') && this.#usesB3SingleHeaderInjection())
     if (!hasB3SingleHeader) return
 
     carrier ??= {}
@@ -620,6 +658,11 @@ class TextMapPropagator {
     return carrier
   }
 
+  #usesB3SingleHeaderInjection () {
+    if (DD_MAJOR < 6) this.#refreshB3InjectionStyle()
+    return this.#b3InjectIsSingleHeader
+  }
+
   /**
    * @param {DatadogSpanContext} spanContext
    * @param {Record<string, string> | undefined} carrier
@@ -982,11 +1025,8 @@ class TextMapPropagator {
       const traceparent = { version }
       // W3C Trace Context §3.3.1.1: multiple tracestate fields MUST be combined per RFC 7230 §3.2.2.
       const tracestate = TraceState.fromString(readTracestate(carrier))
-      if (invalidSegment.test(traceId)) return
-      if (invalidSegment.test(spanId)) return
-
       // Version ff is considered invalid
-      if (version === 'ff') return
+      if (invalidSegment.test(traceId) || invalidSegment.test(spanId) || version === 'ff') return
 
       // Version 00 should have no tail, but future versions may
       if (tail && version === '00') return

package/packages/dd-trace/src/otel-sampling.js

@@ -11,11 +11,10 @@ const UINT64_MASK = 2n ** 64n - 1n
 /**
  * @param {unknown} value
  * @param {number} minLength
- * @param {number} maxLength
  * @returns {value is string}
  */
-function isLowerHex (value, minLength, maxLength) {
-  if (typeof value !== 'string' || value.length < minLength || value.length > maxLength) return false
+function isLowerHex (value, minLength) {
+  if (typeof value !== 'string' || value.length < minLength || value.length > 14) return false
 
   for (let index = 0; index < value.length; index++) {
     const code = value.charCodeAt(index)
@@ -112,11 +111,11 @@ function sanitizeFields (state) {
   let randomValue = state.get('rv')
   let threshold = state.get('th')
 
-  if (!isLowerHex(randomValue, 14, 14)) {
+  if (!isLowerHex(randomValue, 14)) {
     state.delete('rv')
     randomValue = undefined
   }
-  if (!isLowerHex(threshold, 1, 14)) {
+  if (!isLowerHex(threshold, 1)) {
     state.delete('th')
     threshold = undefined
   }

package/packages/dd-trace/src/otel-thread-ctx.js

@@ -20,8 +20,9 @@
 // and the OTel ContextManager activates spans via
 // storage('legacy').run({ span: ddSpan }, ...), so the active span
 // our writer reads from legacy storage is the same DatadogSpan in
-// both cases. The OTel-visible trace/span IDs come from the same
-// _ddContext.toTraceId/toSpanId calls we use here.
+// both cases. The record's trace/span IDs are read from the same
+// Identifier bytes (and _dd.p.tid) behind _ddContext.toTraceId/toSpanId,
+// and the spec pins them byte-for-byte to those methods.
 
 const { isMainThread, threadId } = require('worker_threads')
 
@@ -40,6 +41,10 @@ const {
 } = require('./profiling/webspan-utils')
 const webTagsCache = require('./web-tags-cache')
 
+/** @typedef {import('./opentracing/span')} DatadogSpan */
+/** @typedef {import('./opentracing/span_context')} DatadogSpanContext */
+/** @typedef {InstanceType<typeof import('@datadog/pprof').otelThreadCtx.ThreadContext>} ThreadContext */
+
 // OTEP-4947 duplicates are last-wins, so appending a later endpoint value would
 // correctly overwrite an earlier one — but an out-of-process reader sampling the
 // record mid-request would still see the interim value (e.g. a bare `GET`) as
@@ -124,6 +129,7 @@ function traceFlagsOf (spanContext) {
 //             waiting on; undefined while the span has no web-server ancestry.
 //             Distinguishes a stale announcement from a live one when a nearer
 //             web-server span takes over.
+//   awaitsOwnEndpoint: this is the request span, waiting on its own endpoint.
 const CachedSym = Symbol('OtelThreadCtx.cached')
 
 let started = false
@@ -131,12 +137,59 @@ let ThreadContext
 let getContext
 let clearContext
 
+// Reusable: the ThreadContext constructor copies the ids into its own record.
+const traceIdBytes = Buffer.alloc(16)
+const spanIdBytes = new Uint8Array(8)
+
+/**
+ * Same bytes as decoding toTraceId(true); unexpected shapes fall back to that.
+ *
+ * @param {DatadogSpanContext} spanContext
+ * @returns {Uint8Array}
+ */
+function getTraceIdBytes (spanContext) {
+  const low = spanContext._traceId.toBuffer()
+  if (low.length === 16) {
+    for (let i = 0; i < 16; i++) traceIdBytes[i] = low[i]
+    return traceIdBytes
+  }
+  if (low.length !== 8) return Buffer.from(spanContext.toTraceId(true), 'hex')
+  const high = spanContext._trace.tags['_dd.p.tid']
+  if (high) {
+    // write() stops at the first non-hex character, so only a valid _dd.p.tid fills all 8 bytes.
+    if (typeof high !== 'string' || high.length !== 16 || traceIdBytes.write(high, 0, 8, 'hex') !== 8) {
+      return Buffer.from(spanContext.toTraceId(true), 'hex')
+    }
+  } else {
+    for (let i = 0; i < 8; i++) traceIdBytes[i] = 0
+  }
+  for (let i = 0; i < 8; i++) traceIdBytes[i + 8] = low[i]
+  return traceIdBytes
+}
+
+/**
+ * @param {DatadogSpanContext} spanContext
+ * @returns {Uint8Array}
+ */
+function getSpanIdBytes (spanContext) {
+  const bytes = spanContext._spanId.toBuffer()
+  if (bytes.length !== 8) return Buffer.from(spanContext.toSpanId(true), 'hex')
+  for (let i = 0; i < 8; i++) spanIdBytes[i] = bytes[i]
+  return spanIdBytes
+}
+
+/**
+ * @param {DatadogSpan} span
+ * @returns {ThreadContext | undefined} The span's record, or undefined when the span's trace or span id is malformed.
+ */
 function getOrBuildContext (span) {
   let cached = span[CachedSym]
   if (cached !== undefined && cached.context !== undefined) return cached.context
   const spanContext = span.context()
-  const traceId = Uint8Array.from(Buffer.from(spanContext.toTraceId(true), 'hex'))
-  const spanId = Uint8Array.from(Buffer.from(spanContext.toSpanId(true), 'hex'))
+  const traceId = getTraceIdBytes(spanContext)
+  const spanId = getSpanIdBytes(spanContext)
+  // The native constructor throws on any other id length, and onEnter runs inside user code.
+  if (traceId.length !== 16 || spanId.length !== 8) return
   // Local root span: the first entry in the trace's started-spans list, or
   // this span itself when it IS the root. Encoded as 16-char lowercase hex
   // per the libdatadog convention.
@@ -152,7 +205,7 @@ function getOrBuildContext (span) {
   attrs[THREAD_NAME_IDX] = THREAD_NAME
   attrs[THREAD_ID_IDX] = THREAD_ID
   if (cached === undefined) {
-    cached = {}
+    cached = { context: undefined, webTags: undefined, awaitsOwnEndpoint: false }
     span[CachedSym] = cached
   }
   // The flags are the one part of the record that can still change after
@@ -163,17 +216,22 @@ function getOrBuildContext (span) {
   // built before the decision keeps reading as not sampled.
   cached.context = new ThreadContext(traceId, spanId, traceFlagsOf(spanContext), attrs)
   cached.webTags = webTags
-  if (endpoint === undefined) awaitEndpoint(webTags, cached)
+  if (endpoint === undefined) awaitEndpoint(span, webTags, cached)
   return cached.context
 }
 
 // Enlist a record built without an endpoint, so the resolution announcement for
 // its request fills it in.
-function awaitEndpoint (webTags, cached) {
+function awaitEndpoint (span, webTags, cached) {
   // No web-server span in this span's ancestry, so no endpoint is coming. Should
   // one appear later, webTagsCache announces that separately — see
   // onWebTagsResolved.
   if (webTags === undefined) return
+  // The request span waits on its own announcement; only descendants need the shared list.
+  if (webTags === span.context().getTags()) {
+    cached.awaitsOwnEndpoint = true
+    return
+  }
   const waiting = pendingEndpoints.get(webTags)
   if (waiting === undefined) {
     pendingEndpoints.set(webTags, [cached])
@@ -193,12 +251,13 @@ function appendEndpoint (context, endpoint) {
 
 function onEnter () {
   if (!started) return
-  const span = getActiveSpan()
-  if (!span) {
-    clearContext()
+  const span = /** @type {DatadogSpan | null | undefined} */ (getActiveSpan())
+  const context = span && getOrBuildContext(span)
+  if (!context) {
+    // Clearing an empty frame would still make pprof install a new AsyncContextFrame.
+    if (getContext() !== undefined) clearContext()
     return
   }
-  const context = getOrBuildContext(span)
   // Skip if this CPED already holds the same context. Same allocation-churn
   // fix as the wall profiler in dd-trace-js#8638.
   if (getContext() === context) return
@@ -246,11 +305,18 @@ function onSpanFinished (span) {
 function onEndpointResolved (span) {
   if (!started) return
   const webTags = span.context().getTags()
+  const own = span[CachedSym]
+  const ownWaits = own !== undefined && own.awaitsOwnEndpoint
   const waiting = pendingEndpoints.get(webTags)
-  if (waiting === undefined) return
+  if (!ownWaits && waiting === undefined) return
   const endpoint = finalEndpoint(webTags)
   // webTagsCache only announces settled endpoints, so this is belt and braces.
   if (endpoint === undefined) return
+  if (ownWaits) {
+    own.awaitsOwnEndpoint = false
+    if (own.context !== undefined && own.webTags === webTags) appendEndpoint(own.context, endpoint)
+  }
+  if (waiting === undefined) return
   pendingEndpoints.delete(webTags)
   for (const cached of waiting) {
     // A record whose span has since been attributed to a nearer web-server span
@@ -281,7 +347,7 @@ function onWebTagsResolved (span) {
     // ThreadContext would strand every async-context frame holding this one.
     // The work is still nested in the outer request, which makes that the least
     // wrong of the values available.
-    awaitEndpoint(webTags, cached)
+    awaitEndpoint(span, webTags, cached)
   } else {
     appendEndpoint(cached.context, endpoint)
   }

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

@@ -25,7 +25,7 @@ class DatabasePlugin extends StoragePlugin {
   // trails ddh — so per-query work shrinks to encoding dddb / dddbs / ddh and concatenating.
   #dbmEnvFragment
   #dbmEndFragment
-  // Cache the rendered prefix per `${db.name}\0${out.host}\0${dbmService}`. The triple is
+  // Cache the rendered prefix per `${db.name}\0${out.host}\0${serviceName}`. The triple is
   // connection-stable for a real workload, so the steady state is one `LRUCache.get` plus the
   // optional per-call `,ddprs='...'` suffix.
   #dbmPrefixCache = new LRUCache({ max: DBM_PREFIX_CACHE_MAX })
@@ -61,23 +61,15 @@ class DatabasePlugin extends StoragePlugin {
       this.#dbmPrefixCache.set(cacheKey, prefix)
     }
 
-    if (peerData !== undefined && peerData[PEER_SERVICE_SOURCE_KEY] === PEER_SERVICE_KEY) {
-      return `${prefix},ddprs='${encode(peerData[PEER_SERVICE_KEY])}'`
+    // `dddbs` never follows the peer service: it is always the configured database service, and the
+    // peer service is reported through `ddprs` only, and only when it was set explicitly.
+    const peerService = peerData?.[PEER_SERVICE_KEY]
+    if (peerService && peerData[PEER_SERVICE_SOURCE_KEY] === PEER_SERVICE_KEY) {
+      return `${prefix},ddprs='${encode(peerService)}'`
     }
     return prefix
   }
 
-  /**
-   * @param {string} tracerService
-   * @param {object} peerData
-   */
-  #getDbmServiceName (tracerService, peerData) {
-    if (this._tracerConfig.spanComputePeerService) {
-      return this.getPeerServiceRemap(peerData)[PEER_SERVICE_KEY] || tracerService
-    }
-    return tracerService
-  }
-
   /**
    * @param {import('../../../..').Span} span
    * @param {string} serviceName
@@ -91,8 +83,7 @@ class DatabasePlugin extends StoragePlugin {
     }
 
     const peerData = this.getPeerService(span.context().getTags())
-    const dbmService = this.#getDbmServiceName(serviceName, peerData)
-    const servicePropagation = this.#createDBMPropagationCommentService(dbmService, span, peerData)
+    const servicePropagation = this.#createDBMPropagationCommentService(serviceName, span, peerData)
 
     let dbmComment = servicePropagation
 

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

@@ -45,7 +45,6 @@ const legacyStorage = storage('legacy')
 const GIT_REV_LIST_MAX_BUFFER = 12 * 1024 * 1024 // 12MB
 
 function sanitizedExec (
-  cmd,
   flags,
   operationMetric,
   durationMetric,
@@ -61,7 +60,7 @@ function sanitizedExec (
       startTime = Date.now()
     }
     try {
-      let result = cachedExec(cmd, flags, { stdio: 'pipe' }).toString()
+      let result = cachedExec('git', flags, { stdio: 'pipe' }).toString()
 
       if (shouldTrim) {
         result = result.replaceAll(/(\r\n|\n|\r)/g, '')
@@ -106,7 +105,6 @@ function isGitAvailable () {
 
 function isShallowRepository () {
   return sanitizedExec(
-    'git',
     ['rev-parse', '--is-shallow-repository'],
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'check_shallow' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'check_shallow' } },
@@ -115,7 +113,7 @@ function isShallowRepository () {
 }
 
 function getGitVersion () {
-  const gitVersionString = sanitizedExec('git', ['version'])
+  const gitVersionString = sanitizedExec(['version'])
   const gitVersionMatches = /** @type {RegExpMatch} */ (gitVersionString.match(/git version (\d+)\.(\d+)\.(\d+)/))
   try {
     return {
@@ -138,8 +136,8 @@ function unshallowRepository (parentOnly = false) {
     log.warn('Git version is <2.27, so git unshallow will not proceed')
     return
   }
-  const defaultRemoteName = sanitizedExec('git', ['config', '--default', 'origin', '--get', 'clone.defaultRemoteName'])
-  const revParseHead = sanitizedExec('git', ['rev-parse', 'HEAD'])
+  const defaultRemoteName = sanitizedExec(['config', '--default', 'origin', '--get', 'clone.defaultRemoteName'])
+  const revParseHead = sanitizedExec(['rev-parse', 'HEAD'])
 
   const baseGitOptions = [
     'fetch',
@@ -167,7 +165,6 @@ function unshallowRepository (parentOnly = false) {
       { command: 'unshallow', errorType: err.code, exitCode: err.status || err.errno }
     )
     const upstreamRemote = sanitizedExec(
-      'git',
       ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}']
     )
     flags = [
@@ -186,7 +183,6 @@ function unshallowRepository (parentOnly = false) {
       )
       // We use sanitizedExec here because if this last option fails, we'll give up.
       sanitizedExec(
-        'git',
         baseGitOptions,
         null,
         null,
@@ -199,7 +195,6 @@ function unshallowRepository (parentOnly = false) {
 
 function getRepositoryUrl () {
   return sanitizedExec(
-    'git',
     ['config', '--get', 'remote.origin.url'],
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_repository' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_repository' } },
@@ -233,7 +228,6 @@ function getGitDiff (baseCommit, targetCommit) {
     flags.push(targetCommit)
   }
   return sanitizedExec(
-    'git',
     flags,
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'diff' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'diff' } },
@@ -244,7 +238,6 @@ function getGitDiff (baseCommit, targetCommit) {
 
 function getGitRemoteName () {
   const upstreamRemote = sanitizedExec(
-    'git',
     ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'],
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_remote_name' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_remote_name' } },
@@ -256,7 +249,6 @@ function getGitRemoteName () {
   }
 
   const remotes = sanitizedExec(
-    'git',
     ['remote'],
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_remote_name' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_remote_name' } },
@@ -269,7 +261,6 @@ function getGitRemoteName () {
 
 function getSourceBranch () {
   return sanitizedExec(
-    'git',
     ['rev-parse', '--abbrev-ref', 'HEAD'],
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_source_branch' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_source_branch' } },
@@ -315,7 +306,6 @@ function checkAndFetchBranch (branch, remoteName) {
 
 function getLocalBranches (remoteName) {
   const localBranches = sanitizedExec(
-    'git',
     ['for-each-ref', '--format=%(refname:short)', `refs/remotes/${remoteName}`],
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_local_branches' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_local_branches' } },
@@ -331,7 +321,6 @@ function getLocalBranches (remoteName) {
 
 function getMergeBase (baseBranch, sourceBranch) {
   return sanitizedExec(
-    'git',
     ['merge-base', baseBranch, sourceBranch],
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_merge_base' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_merge_base' } },
@@ -341,7 +330,6 @@ function getMergeBase (baseBranch, sourceBranch) {
 
 function getCounts (sourceBranch, candidateBranch) {
   const counts = sanitizedExec(
-    'git',
     ['rev-list', '--left-right', '--count', `${candidateBranch}...${sourceBranch}`],
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_counts' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_counts' } },
@@ -460,7 +448,6 @@ function generatePackFilesForCommits (commitsToUpload) {
 
 function getRepositoryRoot () {
   return sanitizedExec(
-    'git',
     ['rev-parse', '--show-toplevel']
   )
 }
@@ -488,13 +475,13 @@ function getGitMetadata (ciMetadata) {
     committerName,
     committerEmail,
     committerDate,
-  ] = sanitizedExec('git', ['show', '-s', '--format=%an,%ae,%aI,%cn,%ce,%cI']).split(',')
+  ] = sanitizedExec(['show', '-s', '--format=%an,%ae,%aI,%cn,%ce,%cI']).split(',')
 
   const tags = {
     [GIT_COMMIT_MESSAGE]:
-      commitMessage || sanitizedExec('git', ['show', '-s', '--format=%B'], null, null, null, false),
-    [GIT_BRANCH]: branch || sanitizedExec('git', ['rev-parse', '--abbrev-ref', 'HEAD']),
-    [GIT_COMMIT_SHA]: commitSHA || sanitizedExec('git', ['rev-parse', 'HEAD']),
+      commitMessage || sanitizedExec(['show', '-s', '--format=%B'], null, null, null, false),
+    [GIT_BRANCH]: branch || sanitizedExec(['rev-parse', '--abbrev-ref', 'HEAD']),
+    [GIT_COMMIT_SHA]: commitSHA || sanitizedExec(['rev-parse', 'HEAD']),
     [CI_WORKSPACE_PATH]: ciWorkspacePath || getRepositoryRoot(),
   }
 
@@ -513,7 +500,6 @@ function getGitMetadata (ciMetadata) {
       headCommitterEmail,
       headCommitMessage,
     ] = sanitizedExec(
-      'git',
       [
         'show',
         '-s',
@@ -539,7 +525,7 @@ function getGitMetadata (ciMetadata) {
 
   const entries = [
     GIT_REPOSITORY_URL,
-    filterSensitiveInfoFromRepository(repositoryUrl || sanitizedExec('git', ['ls-remote', '--get-url'])),
+    filterSensitiveInfoFromRepository(repositoryUrl || sanitizedExec(['ls-remote', '--get-url'])),
     GIT_COMMIT_AUTHOR_DATE, authorDate,
     GIT_COMMIT_AUTHOR_NAME, ciAuthorName || authorName,
     GIT_COMMIT_AUTHOR_EMAIL, ciAuthorEmail || authorEmail,
@@ -563,7 +549,6 @@ function getGitInformationDiscrepancy () {
   const gitRepositoryUrl = getRepositoryUrl()
 
   const gitCommitSHA = sanitizedExec(
-    'git',
     ['rev-parse', 'HEAD'],
     { name: TELEMETRY_GIT_COMMAND, tags: { command: 'get_commit_sha' } },
     { name: TELEMETRY_GIT_COMMAND_MS, tags: { command: 'get_commit_sha' } },
@@ -577,7 +562,6 @@ function fetchHeadCommitSha (headSha) {
   const remoteName = getGitRemoteName()
 
   sanitizedExec(
-    'git',
     [
       'fetch',
       '--update-shallow',

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

@@ -51,11 +51,7 @@ const supportedProxies = {
 }
 
 function createInferredProxySpan (headers, childOf, tracer, reqCtx, traceCtx, config, startSpanHelper) {
-  if (!headers) {
-    return null
-  }
-
-  if (!tracer._config?.inferredProxyServicesEnabled) {
+  if (!headers || !tracer._config?.inferredProxyServicesEnabled) {
     return null
   }
 

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

@@ -5,6 +5,7 @@ const fs = require('fs')
 const { URL } = require('url')
 const { stripVTControlCharacters } = require('node:util')
 const { getLageTestSessionName } = require('../../ci-visibility/lage')
+const resolveRunfilePath = require('../../ci-visibility/resolve-runfile-path')
 const log = require('../../log')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../../config/helper')
 const { getSegment } = require('../../util')
@@ -250,8 +251,11 @@ const TEST_LEVEL_EVENT_TYPES = [
   'test_module_end',
   'test_session_end',
 ]
+const TEST_PARALLELIZATION_ENABLED = 'test.parallelization.enabled'
+const TEST_PARALLELIZATION_PLAN_TAG_PREFIX = 'test.parallelization.plan.'
 const TEST_LEVELS_METADATA = 'test_levels'
 const TEST_LEVELS_METADATA_TAGS = [
+  TEST_PARALLELIZATION_ENABLED,
   CI_JOB_ID,
   CI_JOB_NAME,
   CI_JOB_URL,
@@ -809,12 +813,49 @@ function getTestEnvironmentMetadata (testFramework, config, shouldSkipGitMetadat
     ...userProvidedGitMetadata,
     ...runtimeAndOSMetadata,
   }
+  if (/^(true|1)$/i.test(getEnvironmentVariable('_DD_TEST_PARALLELIZATION_ENABLED'))) {
+    metadata[TEST_PARALLELIZATION_ENABLED] = 'true'
+    Object.assign(metadata, getTestParallelizationPlanMetadata())
+  }
   if (config && config.service) {
     metadata['service.name'] = config.service
   }
   return removeInvalidMetadata(metadata)
 }
 
+/** @returns {Record<string, string>} */
+function getTestParallelizationPlanMetadata () {
+  try {
+    let metadataFile = getEnvironmentVariable('_DD_TEST_PARALLELIZATION_METADATA_FILE')
+    if (!metadataFile) {
+      // The manifest locator belongs to DDTest's artifact protocol, rather than tracer configuration.
+      // eslint-disable-next-line eslint-rules/eslint-process-env
+      const env = process.env
+      const manifestFile = env.TEST_OPTIMIZATION_MANIFEST_FILE || env.DD_TEST_OPTIMIZATION_MANIFEST_FILE
+      const planDirectory = manifestFile
+        ? path.dirname(resolveRunfilePath(manifestFile, env))
+        : path.join(process.cwd(), '.testoptimization')
+      metadataFile = path.join(planDirectory, 'plan-metadata.json')
+    }
+    const { tags } = JSON.parse(fs.readFileSync(metadataFile, 'utf8'))
+    if (!tags || typeof tags !== 'object' || Array.isArray(tags) ||
+        Object.values(tags).some(value => typeof value !== 'string')) {
+      return {}
+    }
+    const metadata = {}
+    for (const [tag, value] of Object.entries(tags)) {
+      if (tag.startsWith(TEST_PARALLELIZATION_PLAN_TAG_PREFIX) &&
+          tag.length > TEST_PARALLELIZATION_PLAN_TAG_PREFIX.length && value) {
+        metadata[tag] = value
+      }
+    }
+    return metadata
+  } catch (err) {
+    log.debug('Failed to read DDTest plan metadata: %s', err.message)
+    return {}
+  }
+}
+
 function getTestParametersString (parametersByTestName, testName) {
   if (!parametersByTestName[testName]) {
     return ''
@@ -845,6 +886,11 @@ function getTestLevelsMetadataTags (testEnvironmentMetadata) {
       testLevelsMetadataTags[key] = value
     }
   }
+  for (const [key, value] of Object.entries(testEnvironmentMetadata)) {
+    if (key.startsWith(TEST_PARALLELIZATION_PLAN_TAG_PREFIX) && value !== undefined) {
+      testLevelsMetadataTags[key] = value
+    }
+  }
   return testLevelsMetadataTags
 }
 
@@ -1556,8 +1602,7 @@ function applySkippedCoverageToFileCoverage (fileCoverage, skippedBitmap) {
   let updated = false
   for (const [statementId, statementLocation] of Object.entries(fileCoverage.data.statementMap)) {
     const startLine = statementLocation?.start?.line
-    if (!isLineCoveredByBitmap(skippedBitmap, startLine)) continue
-    if (fileCoverage.data.s[statementId] > 0) continue
+    if (!isLineCoveredByBitmap(skippedBitmap, startLine) || fileCoverage.data.s[statementId] > 0) continue
 
     fileCoverage.data.s[statementId] = 1
     updated = true
@@ -2256,8 +2301,7 @@ function recordTestManagementExecution (execution, executions = testManagementEx
  * }} execution
  */
 function recordAttemptToFixExecution (attemptToFixExecutions, execution) {
-  if (!execution?.testName) return
-  if (getValueFromEnvSources('DD_TEST_MANAGEMENT_REPORT_ENABLED') === false) return
+  if (!execution?.testName || getValueFromEnvSources('DD_TEST_MANAGEMENT_REPORT_ENABLED') === false) return
 
   const { testSuite, testName, status, isDisabled, isQuarantined } = execution
   const identity = getTestOptimizationIdentity(testSuite, testName)