dd-trace 5.99.1 → 5.101.0

package/packages/dd-trace/src/datastreams/pathway.js

@@ -7,18 +7,24 @@ const crypto = require('crypto')
 const { LRUCache } = require('../../../../vendor/dist/lru-cache')
 const log = require('../log')
 const pick = require('../../../datadog-core/src/utils/src/pick')
-const { encodeVarint, decodeVarint } = require('./encoding')
+const { encodeVarintInto, decodeVarint } = require('./encoding')
 
 const cache = new LRUCache({ max: 500 })
 
 const CONTEXT_PROPAGATION_KEY = 'dd-pathway-ctx'
 const CONTEXT_PROPAGATION_KEY_BASE64 = 'dd-pathway-ctx-base64'
 
+const PATHWAY_CONTEXT_BYTES = 20
+
+// Reused across `encodePathwayContext` calls; the buffer is fully rewritten before each
+// `Buffer.from(...)` copy-out so callers never observe mutation between checkpoints.
+const pathwayScratch = Buffer.allocUnsafe(PATHWAY_CONTEXT_BYTES)
+
 const logKeys = [CONTEXT_PROPAGATION_KEY, CONTEXT_PROPAGATION_KEY_BASE64]
 
 function shaHash (checkpointString) {
-  const hash = crypto.createHash('sha256').update(checkpointString).digest('hex').slice(0, 16)
-  return Buffer.from(hash, 'hex')
+  // Copy out of the 32-byte digest so the LRU cache doesn't retain it.
+  return Buffer.from(crypto.createHash('sha256').update(checkpointString).digest().subarray(0, 8))
 }
 
 /**
@@ -30,30 +36,25 @@ function shaHash (checkpointString) {
  */
 function computeHash (service, env, edgeTags, parentHash, propagationHashBigInt = null) {
   edgeTags.sort()
-  const hashableEdgeTags = edgeTags.filter(item => item !== 'manual_checkpoint:true')
-
-  // Cache key includes parentHash to handle fan-in/fan-out scenarios where the same
-  // service+env+tags+propagationHash can have different parents. This ensures we cache
-  // the complete pathway context, not just the current node's identity.
-  const propagationPart = propagationHashBigInt ? `:${propagationHashBigInt.toString(16)}` : ''
-  const key = `${service}${env}${hashableEdgeTags.join('')}${parentHash}${propagationPart}`
+  const hashableEdgeTags = edgeTags.includes('manual_checkpoint:true')
+    ? edgeTags.filter(item => item !== 'manual_checkpoint:true')
+    : edgeTags
+
+  // The cache key includes parentHash so a fan-in node with different parents
+  // gets distinct cache entries; the hash input below excludes parentHash and
+  // gets combined with it via a second sha pass to produce the final hash.
+  const joinedEdgeTags = hashableEdgeTags.join('')
+  const propagationHex = propagationHashBigInt ? propagationHashBigInt.toString(16) : ''
+  const propagationPart = propagationHex ? `:${propagationHex}` : ''
+  const key = `${service}${env}${joinedEdgeTags}${parentHash}${propagationPart}`
 
   let value = cache.get(key)
   if (value) {
     return value
   }
 
-  // Key vs hashInput distinction:
-  // - 'key' (above) is used for caching and includes parentHash to differentiate pathways
-  //   with the same node but different parents (e.g., multiple queues feeding one consumer)
-  // - 'hashInput' (below) excludes parentHash to compute only the current node's identity hash,
-  //   which is then XORed with parentHash (line 54) to build the complete pathway hash
-  // This two-step approach (hash current node independently, then combine with parent) is
-  // required for proper pathway construction in the DSM protocol.
-  const baseString = `${service}${env}` + hashableEdgeTags.join('')
-  const hashInput = propagationHashBigInt
-    ? `${baseString}:${propagationHashBigInt.toString(16)}`
-    : baseString
+  const baseString = `${service}${env}${joinedEdgeTags}`
+  const hashInput = propagationHex ? `${baseString}:${propagationHex}` : baseString
 
   const currentHash = shaHash(hashInput)
   const buf = Buffer.concat([currentHash, parentHash], 16)
@@ -70,11 +71,12 @@ function computeHash (service, env, edgeTags, parentHash, propagationHashBigInt
  * @returns {Buffer}
  */
 function encodePathwayContext (dataStreamsContext) {
-  return Buffer.concat([
-    dataStreamsContext.hash,
-    Buffer.from(encodeVarint(Math.round(dataStreamsContext.pathwayStartNs / 1e6))),
-    Buffer.from(encodeVarint(Math.round(dataStreamsContext.edgeStartNs / 1e6))),
-  ], 20)
+  let offset = dataStreamsContext.hash.copy(pathwayScratch, 0)
+  offset = encodeVarintInto(pathwayScratch, offset, Math.round(dataStreamsContext.pathwayStartNs / 1e6))
+  offset = encodeVarintInto(pathwayScratch, offset, Math.round(dataStreamsContext.edgeStartNs / 1e6))
+  // No-op when offset >= PATHWAY_CONTEXT_BYTES; otherwise pads stale bytes from a previous call.
+  pathwayScratch.fill(0, offset, PATHWAY_CONTEXT_BYTES)
+  return Buffer.from(pathwayScratch.subarray(0, PATHWAY_CONTEXT_BYTES))
 }
 
 /**
@@ -178,6 +180,7 @@ const DsmPathwayCodec = {
 }
 
 module.exports = {
+  CONTEXT_PROPAGATION_KEY_BASE64,
   computePathwayHash: computeHash,
   encodePathwayContext,
   decodePathwayContext,

package/packages/dd-trace/src/datastreams/processor.js

@@ -8,15 +8,21 @@ const { PATHWAY_HASH, DSM_TRANSACTION_ID, DSM_TRANSACTION_CHECKPOINT } = require
 const log = require('../log')
 const processTags = require('../process-tags')
 const propagationHash = require('../propagation-hash')
-const { DsmPathwayCodec } = require('./pathway')
+const { CONTEXT_PROPAGATION_KEY_BASE64, computePathwayHash } = require('./pathway')
 const { DataStreamsWriter } = require('./writer')
-const { computePathwayHash } = require('./pathway')
 const { getAmqpMessageSize, getHeadersSize, getMessageSize, getSizeOrZero } = require('./size')
 const { SchemaBuilder } = require('./schemas/schema_builder')
 const { SchemaSampler } = require('./schemas/schema_sampler')
 
 const ENTRY_PARENT_HASH = Buffer.from('0000000000000000', 'hex')
 
+// A direction:out checkpoint estimates the size cost of the header the
+// producer plugin will inject. The pathway context is always 20 binary
+// bytes, encoded as 28 base64 chars; together with the header key and
+// JSON framing (matching the prior `JSON.stringify({key: value})` byte
+// count minus 1), this is a fixed value.
+const PATHWAY_HEADER_BYTES = CONTEXT_PROPAGATION_KEY_BASE64.length + 28 + 6
+
 class StatsPoint {
   constructor (hash, parentHash, edgeTags) {
     this.hash = hash.readBigUInt64LE()
@@ -271,19 +277,19 @@ class DataStreamsProcessor {
 
   recordCheckpoint (checkpoint, span = null) {
     if (!this.enabled) return
-    this.bucketFromTimestamp(checkpoint.currentTimestamp)
-      .forCheckpoint(checkpoint)
-      .addLatencies(checkpoint)
-    // set DSM pathway hash on span to enable related traces feature on DSM tab, convert from buffer to uint64
+    const statsPoint = this.bucketFromTimestamp(checkpoint.currentTimestamp).forCheckpoint(checkpoint)
+    statsPoint.addLatencies(checkpoint)
     if (span) {
-      span.setTag(PATHWAY_HASH, checkpoint.hash.readBigUInt64LE(0).toString())
+      // StatsPoint already converted the 8-byte Buffer hash to a uint64 BigInt.
+      span.setTag(PATHWAY_HASH, statsPoint.hash.toString())
     }
   }
 
-  setCheckpoint (edgeTags, span, ctx = null, payloadSize = 0) {
-    if (!this.enabled) return null
+  setCheckpoint (edgeTags, span, ctx, payloadSize = 0) {
+    if (!this.enabled) return
     const nowNs = Date.now() * 1e6
-    const direction = edgeTags.find(t => t.startsWith('direction:'))
+    // Callers must place the direction tag at index 0.
+    const direction = edgeTags[0]
     let pathwayStartNs = nowNs
     let edgeStartNs = nowNs
     let parentHash = ENTRY_PARENT_HASH
@@ -334,11 +340,7 @@ class DataStreamsProcessor {
       closestOppositeDirectionEdgeStart,
     }
     if (direction === 'direction:out') {
-      // Add the header for this now, as the callee doesn't have access to context when producing
-      // - 1 to account for extra byte for {
-      const ddInfoContinued = {}
-      DsmPathwayCodec.encode(dataStreamsContext, ddInfoContinued)
-      payloadSize += getSizeOrZero(JSON.stringify(ddInfoContinued)) - 1
+      payloadSize += PATHWAY_HEADER_BYTES
     }
     const checkpoint = {
       currentTimestamp: nowNs,

package/packages/dd-trace/src/datastreams/size.js

@@ -4,7 +4,7 @@ const { types } = require('util')
 
 function getSizeOrZero (obj) {
   if (typeof obj === 'string') {
-    return Buffer.from(obj, 'utf8').length
+    return Buffer.byteLength(obj, 'utf8')
   }
   if (types.isArrayBuffer(obj)) {
     return obj.byteLength
@@ -32,7 +32,11 @@ function getSizeOrZero (obj) {
 
 function getHeadersSize (headers) {
   if (headers === undefined) return 0
-  return Object.entries(headers).reduce((prev, [key, val]) => getSizeOrZero(key) + getSizeOrZero(val) + prev, 0)
+  let size = 0
+  for (const key of Object.keys(headers)) {
+    size += Buffer.byteLength(key, 'utf8') + getSizeOrZero(headers[key])
+  }
+  return size
 }
 
 function getMessageSize (message) {

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

@@ -1,16 +1,19 @@
 'use strict'
 
+const getGitMetadata = require('../git_metadata')
+
 module.exports = function getDebuggerConfig (config, inputPath) {
+  const { commitSHA, repositoryUrl } = getGitMetadata(config)
   return {
-    commitSHA: config.commitSHA,
+    commitSHA,
     debug: config.debug,
     dynamicInstrumentation: config.dynamicInstrumentation,
     env: config.env,
     hostname: config.hostname,
     logLevel: config.logLevel,
     port: config.port,
-    propagateProcessTags: config.propagateProcessTags,
-    repositoryUrl: config.repositoryUrl,
+    propagateProcessTags: { enabled: config.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED },
+    repositoryUrl,
     runtimeId: config.tags['runtime-id'],
     service: config.service,
     url: config.url?.toString(),

package/packages/dd-trace/src/debugger/devtools_client/index.js

@@ -247,10 +247,6 @@ session.on('Debugger.paused', async ({ params }) => {
       language: 'javascript',
     }
 
-    if (config.propagateProcessTags.enabled) {
-      snapshot[processTags.DYNAMIC_INSTRUMENTATION_FIELD_NAME] = processTags.tagsObject
-    }
-
     if (probe.captureSnapshot) {
       if (fatalSnapshotErrors && fatalSnapshotErrors.length > 0) {
         // There was an error collecting the snapshot for this probe, let's not try again
@@ -327,7 +323,8 @@ session.on('Debugger.paused', async ({ params }) => {
 
     ackEmitting(probe)
 
-    send(message, logger, dd, snapshot)
+    send(message, logger, dd, snapshot,
+      config.propagateProcessTags.enabled ? processTags.serialized : undefined)
   }
 })
 

package/packages/dd-trace/src/debugger/devtools_client/send.js

@@ -40,7 +40,7 @@ const jsonBuffer = new JSONBuffer({
   onFlush,
 })
 
-function send (message, logger, dd, snapshot) {
+function send (message, logger, dd, snapshot, processTags) {
   const payload = {
     ddsource,
     hostname,
@@ -50,6 +50,7 @@ function send (message, logger, dd, snapshot) {
       : message,
     logger,
     dd,
+    process_tags: processTags,
     debugger: { snapshot },
   }
 

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

@@ -22,6 +22,7 @@ const TYPE_HISTOGRAM = 'h'
  */
 class DogStatsDClient {
   #lookup
+  #tagsPrefix
   constructor (options) {
     this.#lookup = options.lookup
     if (options.metricsProxyUrl) {
@@ -36,6 +37,7 @@ class DogStatsDClient {
     this._family = isIP(this._host)
     this._port = options.port
     this._tags = options.tags
+    this.#tagsPrefix = this._tags?.length ? `|#${this._tags.join(',')}` : ''
     this._queue = []
     this._buffer = ''
     this._offset = 0
@@ -66,9 +68,9 @@ class DogStatsDClient {
   flush () {
     const queue = this._enqueue()
 
-    log.debug('Flushing %s metrics via', queue.length, this._httpOptions ? 'HTTP' : 'UDP')
+    if (queue.length === 0) return
 
-    if (this._queue.length === 0) return
+    log.debug('Flushing %s metrics via %s', queue.length, this._httpOptions ? 'HTTP' : 'UDP')
 
     this._queue = []
 
@@ -119,11 +121,12 @@ class DogStatsDClient {
   _add (stat, value, type, tags) {
     let message = `${stat}:${value}|${type}`
 
-    // Don't manipulate this._tags as it is still used
-    tags = tags ? [...this._tags, ...tags] : this._tags
-
-    if (tags.length > 0) {
-      message += `|#${tags.join(',')}`
+    if (tags?.length) {
+      message += this.#tagsPrefix
+        ? `${this.#tagsPrefix},${tags.join(',')}`
+        : `|#${tags.join(',')}`
+    } else {
+      message += this.#tagsPrefix
     }
 
     if (entityId) {

package/packages/dd-trace/src/encode/0.4.js

@@ -3,15 +3,15 @@
 const getConfig = require('../config')
 const { MsgpackChunk, MsgpackEncoder } = require('../msgpack')
 const log = require('../log')
-const { truncateSpan, normalizeSpan } = require('./tags-processors')
+const { normalizeSpan } = require('./tags-processors')
 
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
 
 function formatSpan (span, config) {
-  span = normalizeSpan(truncateSpan(span, false))
+  span = normalizeSpan(span)
   if (span.span_events) {
     // ensure span events are encoded as tags if agent doesn't support native top level span events
-    if (config.trace.nativeSpanEvents) {
+    if (config.DD_TRACE_NATIVE_SPAN_EVENTS) {
       formatSpanEvents(span)
     } else {
       span.meta.events = JSON.stringify(span.span_events)

package/packages/dd-trace/src/encode/0.5.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const { truncateSpan, normalizeSpan } = require('./tags-processors')
+const { normalizeSpan } = require('./tags-processors')
 const { AgentEncoder: BaseEncoder } = require('./0.4')
 
 const ARRAY_OF_TWO = 0x92
 const ARRAY_OF_TWELVE = 0x9C
 
 function formatSpan (span) {
-  span = normalizeSpan(truncateSpan(span, false))
+  span = normalizeSpan(span)
   // ensure span events are encoded as tags
   if (span.span_events) {
     span.meta.events = JSON.stringify(span.span_events)

package/packages/dd-trace/src/encode/agentless-json.js

@@ -2,7 +2,7 @@
 
 const log = require('../log')
 const { TOP_LEVEL_KEY } = require('../constants')
-const { truncateSpan, normalizeSpan } = require('./tags-processors')
+const { normalizeSpan } = require('./tags-processors')
 
 // Soft limit for estimated payload size. Triggers an early flush to stay under intake request size limits.
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
@@ -14,7 +14,7 @@ const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
  * @returns {object} The formatted span
  */
 function formatSpan (span, isFirstSpan) {
-  span = normalizeSpan(truncateSpan(span, false))
+  span = normalizeSpan(span)
 
   // Remove _dd.p.tid (the upper 64 bits of a 128-bit trace ID) since trace_id is truncated to lower 64 bits
   delete span.meta['_dd.p.tid']

package/packages/dd-trace/src/encode/tags-processors.js

@@ -25,35 +25,10 @@ const MAX_SERVICE_LENGTH = 100
 // MAX_TYPE_LENGTH the maximum length a span type can have
 const MAX_TYPE_LENGTH = 100
 
-// TODO (bengl) Pretty much everything in this file should happen in
-// `format.js`, so that we're not iterating over all the spans and modifying
-// them yet again.
-
-// normally the agent truncates the resource and parses it in certain scenarios (e.g. SQL Queries)
-function truncateSpan (span, shouldTruncateResourceName = true) {
-  if (shouldTruncateResourceName && span.resource && span.resource.length > MAX_RESOURCE_NAME_LENGTH) {
+function truncateSpan (span) {
+  if (span.resource && span.resource.length > MAX_RESOURCE_NAME_LENGTH) {
     span.resource = `${span.resource.slice(0, MAX_RESOURCE_NAME_LENGTH)}...`
   }
-  for (let metaKey in span.meta) {
-    const val = span.meta[metaKey]
-    if (metaKey.length > MAX_META_KEY_LENGTH) {
-      delete span.meta[metaKey]
-      metaKey = `${metaKey.slice(0, MAX_META_KEY_LENGTH)}...`
-      span.metrics[metaKey] = val
-    }
-    if (val && val.length > MAX_META_VALUE_LENGTH) {
-      span.meta[metaKey] = `${val.slice(0, MAX_META_VALUE_LENGTH)}...`
-    }
-  }
-  for (let metricsKey in span.metrics) {
-    const val = span.metrics[metricsKey]
-    if (metricsKey.length > MAX_METRIC_KEY_LENGTH) {
-      delete span.metrics[metricsKey]
-      metricsKey = `${metricsKey.slice(0, MAX_METRIC_KEY_LENGTH)}...`
-      span.metrics[metricsKey] = val
-    }
-  }
-
   return span
 }
 

package/packages/dd-trace/src/exporters/common/request.js

@@ -13,6 +13,12 @@ const log = require('../../log')
 const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
 const docker = require('./docker')
 const { httpAgent, httpsAgent } = require('./agents')
+const {
+  getMaxAttempts,
+  getRetryDelay,
+  isRetriableNetworkError,
+  markEndpointReached,
+} = require('./retry')
 
 const maxActiveBufferSize = 1024 * 1024 * 64
 
@@ -92,6 +98,8 @@ function request (data, options, callback) {
   options.agent = isSecure ? httpsAgent : httpAgent
 
   const onResponse = (res, finalize) => {
+    markEndpointReached(options)
+
     const chunks = []
 
     res.setTimeout(timeout)
@@ -142,7 +150,10 @@ function request (data, options, callback) {
     })
   }
 
-  const makeRequest = onError => {
+  // Retries always run via setTimeout so the AsyncLocalStorage store survives
+  // the gap before socket.connect(); ALS.run() does not call ALS.enterWith()
+  // outside AsyncContextFrame, so a synchronous re-entry would lose the store.
+  const attempt = attemptIndex => {
     if (!request.writable) {
       log.debug('Maximum number of active requests reached: payload is discarded.')
       return callback(null)
@@ -163,9 +174,16 @@ function request (data, options, callback) {
       req.once('close', finalize)
       req.once('timeout', finalize)
 
-      req.once('error', err => {
+      req.once('error', error => {
         finalize()
-        onError(err)
+        if (attemptIndex < getMaxAttempts(options) && isRetriableNetworkError(error)) {
+          // Unref so a pending retry never keeps the host process alive past
+          // its natural exit point; long-running apps still retry because the
+          // event loop is held open by their own work.
+          setTimeout(attempt, getRetryDelay(options, attemptIndex), attemptIndex + 1).unref()
+        } else {
+          callback(error)
+        }
       })
 
       req.setTimeout(timeout, () => {
@@ -185,14 +203,7 @@ function request (data, options, callback) {
     })
   }
 
-  // The setTimeout is needed to avoid losing the async context in the retry
-  // request before socket.connect() is called. This is a workaround for the
-  // issue that the AsyncLocalStorage.run() method does not call the
-  // AsyncLocalStorage.enterWith() method when not using AsyncContextFrame.
-  //
-  // TODO: Test that this doesn't trace itself on retry when the diagnostics
-  // channel events are available in the agent exporter.
-  makeRequest(() => setTimeout(() => makeRequest(callback)))
+  attempt(1)
 }
 
 function byteLength (data) {

package/packages/dd-trace/src/exporters/common/retry.js

@@ -0,0 +1,104 @@
+'use strict'
+
+const RATE_LIMIT_MAX_WAIT_MS = 30_000
+
+const SINGLE_RETRY_BASE_MS = 5000
+const SINGLE_RETRY_JITTER_MS = 2500
+
+const STARTUP_GRACE_MS = 30_000
+const STARTUP_BACKOFF_BASE_MS = 1000
+const STARTUP_BACKOFF_MAX_MS = 8000
+const STARTUP_BACKOFF_JITTER_MS = 500
+const STARTUP_MAX_ATTEMPTS = 5
+const POST_STARTUP_MAX_ATTEMPTS = 2
+
+// `ECONNREFUSED` and `ENOENT` cover the agent-not-yet-listening cases (TCP and
+// UDS). `EAI_AGAIN` covers transient DNS in agentless intake. `ENOTFOUND` is
+// excluded because it usually means a misconfigured host, not a transient state.
+const RETRIABLE_NETWORK_CODES = new Set([
+  'EAI_AGAIN',
+  'ECONNREFUSED',
+  'ECONNRESET',
+  'ENOENT',
+  'EPIPE',
+  'ETIMEDOUT',
+])
+
+const startedAtMs = Date.now()
+const reachedEndpoints = new Set()
+
+/**
+ * @typedef {object} EndpointOptions
+ * @property {string} [socketPath]
+ * @property {string} [hostname]
+ * @property {string} [host]
+ * @property {string|number} [port]
+ */
+
+/**
+ * @param {Error & { code?: string }} error
+ */
+function isRetriableNetworkError (error) {
+  return error?.code !== undefined && RETRIABLE_NETWORK_CODES.has(error.code)
+}
+
+function singleJitteredDelay () {
+  return SINGLE_RETRY_BASE_MS + Math.random() * SINGLE_RETRY_JITTER_MS
+}
+
+/**
+ * Stable key identifying the destination so the startup-phase gate is scoped
+ * per endpoint. UDS path beats host:port because both can coexist on the same
+ * options object after `parseUrl` runs.
+ *
+ * @param {EndpointOptions} options
+ */
+function getEndpointKey (options) {
+  if (options.socketPath) return options.socketPath
+  return `${options.hostname || options.host || ''}:${options.port || ''}`
+}
+
+/**
+ * @param {EndpointOptions} options
+ */
+function inStartupPhase (options) {
+  if ((Date.now() - startedAtMs) >= STARTUP_GRACE_MS) return false
+  return !reachedEndpoints.has(getEndpointKey(options))
+}
+
+/**
+ * Wait time before the next attempt when the previous one just failed. Bounded
+ * exponential backoff with small jitter inside the startup grace window;
+ * single 5–7.5 s jittered retry afterwards.
+ *
+ * @param {EndpointOptions} options
+ * @param {number} previousAttempt 1-based index of the attempt that just failed.
+ */
+function getRetryDelay (options, previousAttempt) {
+  if (!inStartupPhase(options)) return singleJitteredDelay()
+  const exp = Math.min(STARTUP_BACKOFF_MAX_MS, STARTUP_BACKOFF_BASE_MS << (previousAttempt - 1))
+  return exp + Math.random() * STARTUP_BACKOFF_JITTER_MS
+}
+
+/**
+ * @param {EndpointOptions} options
+ */
+function getMaxAttempts (options) {
+  return inStartupPhase(options) ? STARTUP_MAX_ATTEMPTS : POST_STARTUP_MAX_ATTEMPTS
+}
+
+/**
+ * @param {EndpointOptions} options
+ */
+function markEndpointReached (options) {
+  reachedEndpoints.add(getEndpointKey(options))
+}
+
+module.exports = {
+  RATE_LIMIT_MAX_WAIT_MS,
+  getMaxAttempts,
+  getRetryDelay,
+  isRetriableNetworkError,
+  markEndpointReached,
+  singleJitteredDelay,
+}

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

@@ -0,0 +1,66 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const log = require('./log')
+const { GIT_COMMIT_SHA, GIT_REPOSITORY_URL } = require('./plugins/util/tags')
+const {
+  getGitMetadataFromGitProperties,
+  getRemoteOriginURL,
+  removeUserSensitiveInfo,
+  resolveGitHeadSHA,
+} = require('./config/git_properties')
+
+/** @type {{ commitSHA: string | undefined, repositoryUrl: string | undefined } | undefined} */
+let cached
+
+/**
+ * @param {import('./config/config-types').ConfigProperties} config
+ */
+function getGitMetadata (config) {
+  if (cached) return cached
+
+  if (!config.DD_TRACE_GIT_METADATA_ENABLED) {
+    cached = { commitSHA: undefined, repositoryUrl: undefined }
+    return cached
+  }
+
+  let repositoryUrl = removeUserSensitiveInfo(config.DD_GIT_REPOSITORY_URL ?? config.tags[GIT_REPOSITORY_URL])
+  let commitSHA = config.DD_GIT_COMMIT_SHA ?? config.tags[GIT_COMMIT_SHA]
+
+  if (!repositoryUrl || !commitSHA) {
+    const propertiesFile = config.DD_GIT_PROPERTIES_FILE
+    const gitPropertiesFile = propertiesFile ?? `${process.cwd()}/git.properties`
+    try {
+      const fromProperties = getGitMetadataFromGitProperties(fs.readFileSync(gitPropertiesFile, 'utf8'))
+      commitSHA ??= fromProperties.commitSHA
+      repositoryUrl ??= fromProperties.repositoryUrl
+    } catch (error) {
+      if (propertiesFile) {
+        log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', gitPropertiesFile, error)
+      }
+    }
+  }
+
+  const folderPath = config.DD_GIT_FOLDER_PATH
+  const gitFolderPath = folderPath ?? path.join(process.cwd(), '.git')
+
+  if (!repositoryUrl) {
+    const gitConfigPath = path.join(gitFolderPath, 'config')
+    try {
+      repositoryUrl = getRemoteOriginURL(fs.readFileSync(gitConfigPath, 'utf8'))
+    } catch (error) {
+      if (folderPath) {
+        log.error('Error reading git config: %s', gitConfigPath, error)
+      }
+    }
+  }
+
+  commitSHA ??= resolveGitHeadSHA(gitFolderPath)
+
+  cached = { commitSHA, repositoryUrl }
+  return cached
+}
+
+module.exports = getGitMetadata

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

@@ -1,17 +1,25 @@
 'use strict'
 
 const { SCI_COMMIT_SHA, SCI_REPOSITORY_URL } = require('./constants')
+const getGitMetadata = require('./git_metadata')
 
 class GitMetadataTagger {
+  #commitSHA
+  #repositoryUrl
+  #enabled
+
   constructor (config) {
-    this._config = config
+    this.#enabled = config.DD_TRACE_GIT_METADATA_ENABLED
+    const { commitSHA, repositoryUrl } = getGitMetadata(config)
+    this.#commitSHA = commitSHA
+    this.#repositoryUrl = repositoryUrl
   }
 
   tagGitMetadata (spanContext) {
-    if (this._config.DD_TRACE_GIT_METADATA_ENABLED) {
-      // These tags are added only to the local root span
-      spanContext._trace.tags[SCI_COMMIT_SHA] = this._config.commitSHA
-      spanContext._trace.tags[SCI_REPOSITORY_URL] = this._config.repositoryUrl
+    if (this.#enabled) {
+      const tags = spanContext._trace.tags
+      tags[SCI_COMMIT_SHA] = this.#commitSHA
+      tags[SCI_REPOSITORY_URL] = this.#repositoryUrl
     }
   }
 }