dd-trace 5.100.0 → 5.101.0

package/packages/datadog-plugin-cypress/src/plugin.js

@@ -23,22 +23,13 @@ const noopTask = {
 module.exports = function CypressPlugin (on, config) {
   const tracer = require('../../dd-trace')
 
-  if (satisfies(config.version, '<10.2.0')) {
-    if (DD_MAJOR >= 6) {
-      // eslint-disable-next-line no-console
-      console.error(
-        'ERROR: dd-trace v6 has deleted support for Cypress<10.2.0.'
-      )
-      on('task', noopTask)
-      return config
-    }
-
-    // console.warn does not seem to work in cypress, so using console.log instead
+  if (DD_MAJOR >= 6 && satisfies(config.version, '<12.0.0')) {
     // eslint-disable-next-line no-console
-    console.log(
-      'WARNING: dd-trace support for Cypress<10.2.0 is deprecated' +
-      ' and will not be supported in future versions of dd-trace.'
+    console.error(
+      'ERROR: dd-trace v6 has deleted support for Cypress<12.0.0.'
     )
+    on('task', noopTask)
+    return config
   }
 
   // The tracer was not init correctly for whatever reason (such as invalid DD_SITE)

package/packages/datadog-plugin-kafkajs/src/consumer.js

@@ -56,15 +56,8 @@ class KafkajsConsumerPlugin extends ConsumerPlugin {
 
   commit (commitList) {
     if (!this.config.dsmEnabled) return
-    const keys = [
-      'consumer_group',
-      'type',
-      'partition',
-      'offset',
-      'topic',
-    ]
-    for (const commit of commitList.map(this.transformCommit)) {
-      if (keys.some(key => !commit.hasOwnProperty(key))) continue
+    for (const rawCommit of commitList) {
+      const commit = this.transformCommit(rawCommit)
       this.tracer.setOffset(commit)
     }
   }

package/packages/datadog-plugin-kafkajs/src/producer.js

@@ -64,14 +64,8 @@ class KafkajsProducerPlugin extends ProducerPlugin {
 
     if (!this.config.dsmEnabled) return
     if (!commitList || !Array.isArray(commitList)) return
-    const keys = [
-      'type',
-      'partition',
-      'offset',
-      'topic',
-    ]
-    for (const commit of commitList.map(r => this.transformProduceResponse(r, clusterId))) {
-      if (keys.some(key => !commit.hasOwnProperty(key))) continue
+    for (const rawCommit of commitList) {
+      const commit = this.transformProduceResponse(rawCommit, clusterId)
       this.tracer.setOffset(commit)
     }
   }

package/packages/dd-trace/src/appsec/reporter.js

@@ -8,6 +8,7 @@ const web = require('../plugins/util/web')
 const { ipHeaderList } = require('../plugins/util/ip_extractor')
 const { keepTrace } = require('../priority_sampler')
 const { ASM } = require('../standalone/product')
+const { isEmpty } = require('../util')
 const { getActiveRequest } = require('./store')
 const {
   incrementWafInitMetric,
@@ -170,7 +171,9 @@ function getCollectedHeaders (req, res, shouldCollectEventHeaders, storedRespons
   // Basic collection
   if (!shouldCollectEventHeaders) return mandatoryCollectedHeaders
 
-  const responseHeaders = Object.keys(storedResponseHeaders).length === 0
+  // Skip the spread when the stored side is empty -- common during the early
+  // request lifecycle when no upstream response headers have been captured.
+  const responseHeaders = isEmpty(storedResponseHeaders)
     ? res.getHeaders()
     : { ...storedResponseHeaders, ...res.getHeaders() }
 

package/packages/dd-trace/src/ci-visibility/lage.js

@@ -2,6 +2,7 @@
 
 const { getEnvironmentVariable } = require('../config/helper')
 const { isTrue } = require('../util')
+const { DD_MAJOR } = require('../../../../version')
 
 /**
  * Returns the current Lage package name if the Lage package name override is enabled.
@@ -9,7 +10,7 @@ const { isTrue } = require('../util')
  * @returns {string|undefined}
  */
 function getLagePackageName () {
-  if (!isTrue(getEnvironmentVariable('DD_ENABLE_LAGE_PACKAGE_NAME'))) {
+  if (DD_MAJOR < 6 && !isTrue(getEnvironmentVariable('DD_ENABLE_LAGE_PACKAGE_NAME'))) {
     return
   }
 

package/packages/dd-trace/src/ci-visibility/requests/request.js

@@ -7,39 +7,13 @@ const zlib = require('zlib')
 const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
 const { httpAgent, httpsAgent } = require('../../exporters/common/agents')
+const {
+  RATE_LIMIT_MAX_WAIT_MS,
+  isRetriableNetworkError,
+  singleJitteredDelay,
+} = require('../../exporters/common/retry')
 const { urlToHttpOptions } = require('../../exporters/common/url-to-http-options-polyfill')
 
-const RATE_LIMIT_MAX_WAIT_MS = 30_000
-const RETRY_BASE_MS = 5000
-const RETRY_JITTER_MS = 2500
-
-/**
- * Calculates retry delay with jitter to prevent thundering herd.
- * Delay is RETRY_BASE_MS + random(0, RETRY_JITTER_MS) (e.g. 5–7.5 seconds).
- *
- * @returns {number} Delay in milliseconds
- */
-function getRetryDelay () {
-  return RETRY_BASE_MS + (Math.random() * RETRY_JITTER_MS)
-}
-
-/**
- * Determines if a network error is retriable (transient failures only).
- * ECONNREFUSED is retried because it can be transient (service starting up,
- * restarts, rolling deploys, k8s pod/readiness transitions). ENOTFOUND is
- * excluded as it indicates DNS failure or wrong host and is usually not transient.
- *
- * @param {Error} err - The error to check
- * @returns {boolean}
- */
-function isRetriableNetworkError (err) {
-  if (!err.code) return false
-  return err.code === 'ECONNREFUSED' ||
-    err.code === 'ECONNRESET' ||
-    err.code === 'ETIMEDOUT' ||
-    err.code === 'EPIPE'
-}
-
 function parseUrl (urlObjOrString) {
   if (urlObjOrString !== null && typeof urlObjOrString === 'object') {
     return urlToHttpOptions(urlObjOrString)
@@ -63,6 +37,10 @@ function parseUrl (urlObjOrString) {
  * Destroys connections on errors to prevent reuse of bad connections. Preserves
  * original status code across retries for telemetry.
  *
+ * Retry timers stay ref'd. Test-runner plugins block the suite via
+ * `delay: true` channels until this callback fires; an unref'd retry would
+ * let the host exit first and the suite would never run.
+ *
  * @param {string} data - Request body (e.g. JSON string)
  * @param {object} options - { url, path?, method?, headers?, timeout? } (may be mutated)
  * @param {Function} callback - (err, res, statusCode) => void
@@ -157,7 +135,7 @@ function request (data, options, callback) {
               // ignore
             }
             hasRetried = true
-            setTimeout(makeRequest, getRetryDelay())
+            setTimeout(makeRequest, singleJitteredDelay())
             return
           }
 
@@ -177,7 +155,7 @@ function request (data, options, callback) {
         // Retry on retriable network errors
         if (!hasRetried && isRetriableNetworkError(err)) {
           hasRetried = true
-          setTimeout(makeRequest, getRetryDelay())
+          setTimeout(makeRequest, singleJitteredDelay())
           return
         }
 

package/packages/dd-trace/src/config/config-types.d.ts

@@ -8,7 +8,6 @@ export interface ConfigProperties extends GeneratedConfig {
     responsesEnabled: boolean
     rules: PayloadTaggingRules
   }
-  commitSHA: string | undefined
   debug: boolean
   instrumentationSource: 'manual' | 'ssi'
   isCiVisibility: boolean
@@ -18,7 +17,6 @@ export interface ConfigProperties extends GeneratedConfig {
   lookup: NonNullable<import('../../../../index').TracerOptions['lookup']>
   readonly parsedDdTags: Record<string, string>
   plugins: boolean
-  repositoryUrl: string | undefined
   sampler: {
     rateLimit: number
     rules: import('../../../../index').SamplingRule[]

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

@@ -3,7 +3,6 @@
 const fs = require('node:fs')
 const os = require('node:os')
 const { URL } = require('node:url')
-const path = require('node:path')
 
 const rfdc = require('../../../../vendor/dist/rfdc')({ proto: false, circles: false })
 const uuid = require('../../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
@@ -12,7 +11,6 @@ const { DD_MAJOR } = require('../../../../version')
 const log = require('../log')
 const pkg = require('../pkg')
 const { isTrue } = require('../util')
-const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const telemetry = require('../telemetry')
 const telemetryMetrics = require('../telemetry/metrics')
 const {
@@ -22,8 +20,6 @@ const {
 } = require('../serverless')
 const { ORIGIN_KEY, DATADOG_MINI_AGENT_PATH } = require('../constants')
 const { appendRules } = require('../payload-tagging/config')
-const { getGitMetadataFromGitProperties, removeUserSensitiveInfo, getRemoteOriginURL, resolveGitHeadSHA } =
-  require('./git_properties')
 const ConfigBase = require('./config-base')
 const {
   getEnvironmentVariable,
@@ -215,10 +211,6 @@ class Config extends ConfigBase {
 
     warnWrongOtelSettings()
 
-    if (this.DD_TRACE_GIT_METADATA_ENABLED) {
-      this.#loadGitMetadata()
-    }
-
     parseErrors.clear()
   }
 
@@ -513,7 +505,7 @@ class Config extends ConfigBase {
       } else {
         const NX_TASK_TARGET_PROJECT = getEnvironmentVariable('NX_TASK_TARGET_PROJECT')
         if (NX_TASK_TARGET_PROJECT) {
-          if (this.DD_ENABLE_NX_SERVICE_NAME) {
+          if (DD_MAJOR >= 6 || this.DD_ENABLE_NX_SERVICE_NAME) {
             setAndTrack(this, 'service', normalizeService(NX_TASK_TARGET_PROJECT) || 'node')
             isServiceNameInferred = true
           } else if (DD_MAJOR < 6) {
@@ -628,52 +620,6 @@ class Config extends ConfigBase {
 
     telemetry.updateConfig([...configWithOrigin.values()], this)
   }
-
-  // TODO: Move outside of config. This is unrelated to the config system.
-  #loadGitMetadata () {
-    // Try to read Git metadata from the environment variables
-    this.repositoryUrl = removeUserSensitiveInfo(this.DD_GIT_REPOSITORY_URL ?? this.tags[GIT_REPOSITORY_URL])
-    this.commitSHA = this.DD_GIT_COMMIT_SHA ?? this.tags[GIT_COMMIT_SHA]
-
-    // Otherwise, try to read Git metadata from the git.properties file
-    if (!this.repositoryUrl || !this.commitSHA) {
-      const DD_GIT_PROPERTIES_FILE = this.DD_GIT_PROPERTIES_FILE
-      const gitPropertiesFile = DD_GIT_PROPERTIES_FILE ?? `${process.cwd()}/git.properties`
-      try {
-        const gitPropertiesString = fs.readFileSync(gitPropertiesFile, 'utf8')
-        const { commitSHA, repositoryUrl } = getGitMetadataFromGitProperties(gitPropertiesString)
-        this.commitSHA ??= commitSHA
-        this.repositoryUrl ??= repositoryUrl
-      } catch (error) {
-        // Only log error if the user has set a git.properties path
-        if (DD_GIT_PROPERTIES_FILE) {
-          log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', gitPropertiesFile, error)
-        }
-      }
-    }
-
-    // Otherwise, try to read Git metadata from the .git/ folder
-    const DD_GIT_FOLDER_PATH = this.DD_GIT_FOLDER_PATH
-    const gitFolderPath = DD_GIT_FOLDER_PATH ?? path.join(process.cwd(), '.git')
-
-    if (!this.repositoryUrl) {
-      // Try to read git config (repository URL)
-      const gitConfigPath = path.join(gitFolderPath, 'config')
-      try {
-        const gitConfigContent = fs.readFileSync(gitConfigPath, 'utf8')
-        if (gitConfigContent) {
-          this.repositoryUrl = getRemoteOriginURL(gitConfigContent)
-        }
-      } catch (error) {
-        // Only log error if the user has set a .git/ path
-        if (DD_GIT_FOLDER_PATH) {
-          log.error('Error reading git config: %s', gitConfigPath, error)
-        }
-      }
-    }
-    // Try to read git HEAD (commit SHA)
-    this.commitSHA ??= resolveGitHeadSHA(gitFolderPath)
-  }
 }
 
 /**

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

@@ -19,10 +19,9 @@ class DataStreamsCheckpointer {
     if (!this.config.dsmEnabled) return
 
     const ctx = this.dsmProcessor.setCheckpoint(
-      ['type:' + type, 'topic:' + target, 'direction:out', 'manual_checkpoint:true'],
+      ['direction:out', 'type:' + type, 'topic:' + target, 'manual_checkpoint:true'],
       null,
-      DataStreamsContext.getDataStreamsContext(),
-      null
+      DataStreamsContext.getDataStreamsContext()
     )
     DataStreamsContext.setDataStreamsContext(ctx)
 
@@ -45,17 +44,12 @@ class DataStreamsCheckpointer {
     const parentCtx = this.tracer.extract('text_map_dsm', carrier)
     DataStreamsContext.setDataStreamsContext(parentCtx)
 
-    const tags = ['type:' + type, 'topic:' + source, 'direction:in']
+    const tags = ['direction:in', 'type:' + type, 'topic:' + source]
     if (manualCheckpoint) {
       tags.push('manual_checkpoint:true')
     }
 
-    const ctx = this.dsmProcessor.setCheckpoint(
-      tags,
-      null,
-      parentCtx,
-      null
-    )
+    const ctx = this.dsmProcessor.setCheckpoint(tags, null, parentCtx)
     DataStreamsContext.setDataStreamsContext(ctx)
 
     return ctx

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const maxVarLen64 = 9
+
 /**
  * Encodes positive and negative numbers, using zig zag encoding to reduce the size of the variable length encoding.
  * Uses high and low part to ensure those parts are under the limit for byte operations in javascript (32 bits)
@@ -8,15 +10,45 @@
  * @returns {Uint8Array|undefined}
  */
 function encodeVarint (v) {
-  const sign = v >= 0 ? 0 : 1
+  const result = new Uint8Array(maxVarLen64)
+  const written = encodeVarintInto(result, 0, v)
+  if (written === 0) {
+    return
+  }
+  return result.slice(0, written)
+}
+
+/**
+ * Writes a zig-zag varint at `target[offset..]` and returns the offset just past the last
+ * byte written. Returns `offset` unchanged when the value exceeds MAX_SAFE_INTEGER/2, mirroring
+ * the `encodeVarint` overflow contract. Used on the DSM checkpoint hot path to avoid
+ * per-call Uint8Array / Buffer allocations.
+ * @param {Uint8Array | Buffer} target
+ * @param {number} offset
+ * @param {number} value
+ * @returns {number}
+ */
+function encodeVarintInto (target, offset, value) {
+  const sign = value >= 0 ? 0 : 1
   // We leave the least significant bit for the sign.
-  const double = Math.abs(v) * 2
+  const double = Math.abs(value) * 2
   if (double > Number.MAX_SAFE_INTEGER) {
-    return
+    return offset
   }
-  const high = Math.floor(double / 0x1_00_00_00_00)
-  const low = (double & 0xFF_FF_FF_FF) | sign
-  return encodeUvarint64(low, high)
+  let high = Math.floor(double / 0x1_00_00_00_00)
+  let low = (double & 0xFF_FF_FF_FF) | sign
+  let i = offset
+  const limit = offset + maxVarLen64 - 1
+  // if first byte is 1, the number is negative in javascript, but we want to interpret it as positive
+  while ((high !== 0 || low < 0 || low > 0x80) && i < limit) {
+    target[i] = (low & 0x7F) | 0x80
+    low >>>= 7
+    low |= (high & 0x7F) << 25
+    high >>>= 7
+    i++
+  }
+  target[i] = low & 0x7F
+  return i + 1
 }
 
 /**
@@ -35,28 +67,6 @@ function decodeVarint (b) {
   return [positive ? abs : -abs, bytes]
 }
 
-const maxVarLen64 = 9
-
-/**
- * @param {number} low
- * @param {number} high
- * @returns {Uint8Array}
- */
-function encodeUvarint64 (low, high) {
-  const result = new Uint8Array(maxVarLen64)
-  let i = 0
-  // if first byte is 1, the number is negative in javascript, but we want to interpret it as positive
-  while ((high !== 0 || low < 0 || low > 0x80) && i < maxVarLen64 - 1) {
-    result[i] = (low & 0x7F) | 0x80
-    low >>>= 7
-    low |= (high & 0x7F) << 25
-    high >>>= 7
-    i++
-  }
-  result[i] = low & 0x7F
-  return result.slice(0, i + 1)
-}
-
 /**
  * @param {Uint8Array} bytes
  * @returns {[number|undefined, number|undefined, Uint8Array]}
@@ -95,5 +105,6 @@ function decodeUvarint64 (
 
 module.exports = {
   encodeVarint,
+  encodeVarintInto,
   decodeVarint,
 }

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,8 +1,11 @@
 '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,
@@ -10,7 +13,7 @@ module.exports = function getDebuggerConfig (config, inputPath) {
     logLevel: config.logLevel,
     port: config.port,
     propagateProcessTags: { enabled: config.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED },
-    repositoryUrl: config.repositoryUrl,
+    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 },
   }