dd-trace 5.104.0 → 5.106.0

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

@@ -6,10 +6,18 @@ const { AgentEncoder: BaseEncoder, stringifySpanEvents } = require('./0.4')
 const ARRAY_OF_TWO = 0x92
 const ARRAY_OF_TWELVE = 0x9C
 
+// Per-span fused head: `[0x9C, service-idx, name-idx, resource-idx,
+// trace-id, span-id, parent-id]` — three uint32 indexes (5 bytes each) +
+// three uint64 IDs (9 bytes each) + the array marker. Replaces seven
+// separate reserves (`writeByte` + 3 × `writeInteger` + 3 × `_encodeId`)
+// with one block-sized reserve per span.
+const HEAD_BLOCK_SIZE = 1 + 5 * 3 + 9 * 3
+
 function formatSpan (span) {
   span = normalizeSpan(span)
   // v0.5 has no native span_events slot; always serialize as a meta tag.
   if (span.span_events) {
+    // TODO: this is a costly operation. Consolidate this with the formatter
     span.meta.events = stringifySpanEvents(span.span_events)
     // `= undefined` over `delete` to keep the span's hidden class.
     span.span_events = undefined
@@ -35,20 +43,36 @@ class AgentEncoder extends BaseEncoder {
   }
 
   _encode (bytes, trace) {
-    this._encodeArrayPrefix(bytes, trace)
+    bytes.writeArrayPrefix(trace)
+
+    const stringMap = this._stringMap
 
     for (let span of trace) {
       span = formatSpan(span)
-      this._encodeByte(bytes, ARRAY_OF_TWELVE)
-      this._encodeString(bytes, span.service)
-      this._encodeString(bytes, span.name)
-      this._encodeString(bytes, span.resource)
-      this._encodeId(bytes, span.trace_id)
-      this._encodeId(bytes, span.span_id)
-      this._encodeId(bytes, span.parent_id)
-      this._encodeIntOrFloat(bytes, span.start || 0)
-      this._encodeIntOrFloat(bytes, span.duration || 0)
-      this._encodeIntOrFloat(bytes, span.error)
+
+      // Resolve the three head string indices up front. `_cacheString`
+      // writes into `_stringBytes`, an independent chunk, so the side
+      // effect is safe to interleave with the `_traceBytes` reserve
+      // below.
+      const serviceIndex = stringMap[span.service] ?? this._cacheString(span.service)
+      const nameIndex = stringMap[span.name] ?? this._cacheString(span.name)
+      const resourceIndex = stringMap[span.resource] ?? this._cacheString(span.resource)
+
+      const blockOffset = bytes.length
+      bytes.reserve(HEAD_BLOCK_SIZE)
+      const target = bytes.buffer
+
+      target[blockOffset] = ARRAY_OF_TWELVE
+      let cursor = this.#writeIndexAt(target, blockOffset + 1, serviceIndex)
+      cursor = this.#writeIndexAt(target, cursor, nameIndex)
+      cursor = this.#writeIndexAt(target, cursor, resourceIndex)
+      cursor = this.#writeIdAt(target, cursor, span.trace_id)
+      cursor = this.#writeIdAt(target, cursor, span.span_id)
+      this.#writeIdAt(target, cursor, span.parent_id)
+
+      bytes.writeIntOrFloat(span.start || 0)
+      bytes.writeIntOrFloat(span.duration || 0)
+      bytes.writeIntOrFloat(span.error)
       this._encodeMap(bytes, span.meta || {})
       this._encodeMap(bytes, span.metrics || {})
       this._encodeString(bytes, span.type)
@@ -65,18 +89,41 @@ class AgentEncoder extends BaseEncoder {
     bytes.reserve(5)
     bytes.buffer[offset] = 0xDF
 
+    const stringMap = this._stringMap
     let count = 0
     for (const key of Object.keys(value)) {
       const entryValue = value[key]
+      if (typeof entryValue !== 'string' && typeof entryValue !== 'number') continue
+
+      const keyIndex = stringMap[key] ?? this._cacheString(key)
+      const writeOffset = bytes.length
+
       if (typeof entryValue === 'string') {
-        this._encodeString(bytes, key)
-        this._encodeString(bytes, entryValue)
-        count++
-      } else if (typeof entryValue === 'number') {
-        this._encodeString(bytes, key)
-        this._encodeIntOrFloat(bytes, entryValue)
-        count++
+        // Both halves are uint32 indices on the v0.5 wire — known
+        // size, so the key and value pair fuses into one reserve.
+        const valueIndex = stringMap[entryValue] ?? this._cacheString(entryValue)
+        bytes.reserve(10)
+        const target = bytes.buffer
+        this.#writeIndexAt(target, writeOffset, keyIndex)
+        this.#writeIndexAt(target, writeOffset + 5, valueIndex)
+      } else {
+        // Speculate that the value is a positive fixint (0..127). The
+        // metrics map is mostly small unsigned integers (sample priority,
+        // `_dd.measured`, attribute counts), so one reserve covers the
+        // key (5 bytes) and the value (1 byte). Misses rewind the
+        // speculative value byte and route the value through the full
+        // encoder so the wire still picks the shortest valid encoding.
+        bytes.reserve(6)
+        const target = bytes.buffer
+        this.#writeIndexAt(target, writeOffset, keyIndex)
+        if (entryValue === (entryValue & 0x7F)) {
+          target[writeOffset + 5] = entryValue
+        } else {
+          bytes.length = writeOffset + 5
+          bytes.writeIntOrFloat(entryValue)
+        }
       }
+      count++
     }
 
     const target = bytes.buffer
@@ -87,20 +134,18 @@ class AgentEncoder extends BaseEncoder {
   }
 
   _encodeString (bytes, value = '') {
+    const index = this._stringMap[value] ?? this._cacheString(value)
+    bytes.writeInteger(index)
+  }
+
+  _cacheString (value) {
     let index = this._stringMap[value]
     if (index === undefined) {
       index = this._stringCount++
       this._stringMap[value] = index
       this._stringBytes.write(value)
     }
-    this._encodeInteger(bytes, index)
-  }
-
-  _cacheString (value) {
-    if (this._stringMap[value] === undefined) {
-      this._stringMap[value] = this._stringCount++
-      this._stringBytes.write(value)
-    }
+    return index
   }
 
   _writeStrings (buffer, offset) {
@@ -109,6 +154,49 @@ class AgentEncoder extends BaseEncoder {
 
     return offset
   }
+
+  /**
+   * Write `[0xCE, uint32(index)]` into `target` at `offset` and return the
+   * new cursor. Caller is responsible for having reserved enough room.
+   *
+   * @param {Uint8Array} target
+   * @param {number} offset
+   * @param {number} index
+   * @returns {number}
+   */
+  #writeIndexAt (target, offset, index) {
+    target[offset] = 0xCE
+    target[offset + 1] = index >> 24
+    target[offset + 2] = index >> 16
+    target[offset + 3] = index >> 8
+    target[offset + 4] = index
+    return offset + 5
+  }
+
+  /**
+   * Write `[0xCF, uint64(id)]` into `target` at `offset` and return the
+   * new cursor. The id is truncated to the low 8 bytes, matching the
+   * inherited `_encodeId` behavior.
+   *
+   * @param {Uint8Array} target
+   * @param {number} offset
+   * @param {{ toBuffer: () => Uint8Array | number[] }} identifier
+   * @returns {number}
+   */
+  #writeIdAt (target, offset, identifier) {
+    target[offset] = 0xCF
+    const idBuffer = identifier.toBuffer()
+    const start = idBuffer.length - 8
+    target[offset + 1] = idBuffer[start]
+    target[offset + 2] = idBuffer[start + 1]
+    target[offset + 3] = idBuffer[start + 2]
+    target[offset + 4] = idBuffer[start + 3]
+    target[offset + 5] = idBuffer[start + 4]
+    target[offset + 6] = idBuffer[start + 5]
+    target[offset + 7] = idBuffer[start + 6]
+    target[offset + 8] = idBuffer[start + 7]
+    return offset + 9
+  }
 }
 
 module.exports = { AgentEncoder }

package/packages/dd-trace/src/encode/agentless-ci-visibility.js

@@ -9,7 +9,7 @@ const {
 } = require('../ci-visibility/telemetry')
 const { MsgpackChunk } = require('../msgpack')
 const { AgentEncoder } = require('./0.4')
-const { truncateSpan, normalizeSpan } = require('./tags-processors')
+const { truncateSpanTestOpt, normalizeSpan } = require('./tags-processors')
 
 const ENCODING_VERSION = 1
 const ALLOWED_CONTENT_TYPES = new Set(['test_session_end', 'test_module_end', 'test_suite_end', 'test'])
@@ -32,7 +32,7 @@ function formatSpan (span) {
   return {
     type: ALLOWED_CONTENT_TYPES.has(span.type) ? span.type : 'span',
     version: encodingVersion,
-    content: normalizeSpan(truncateSpan(span)),
+    content: normalizeSpan(truncateSpanTestOpt(span)),
   }
 }
 
@@ -48,11 +48,18 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._eventCount = 0
 
     this.metadataTags = {}
+    this.wildcardMetadataTags = {}
 
     this.reset()
   }
 
   addMetadataTags (tags) {
+    if (tags['*']) {
+      this.wildcardMetadataTags = {
+        ...this.wildcardMetadataTags,
+        ...tags['*'],
+      }
+    }
     for (const type of ALLOWED_CONTENT_TYPES) {
       if (tags[type]) {
         this.metadataTags[type] = {
@@ -70,7 +77,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
       keysLength++
     }
 
-    this._encodeMapPrefix(bytes, keysLength)
+    bytes.writeMapPrefix(keysLength)
     this._encodeString(bytes, 'type')
     this._encodeString(bytes, content.type)
 
@@ -90,7 +97,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     }
 
     this._encodeString(bytes, 'error')
-    this._encodeNumber(bytes, content.error)
+    bytes.writeNumber(content.error)
     this._encodeString(bytes, 'name')
     this._encodeString(bytes, content.name)
     this._encodeString(bytes, 'service')
@@ -98,9 +105,9 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeString(bytes, 'resource')
     this._encodeString(bytes, content.resource)
     this._encodeString(bytes, 'start')
-    this._encodeNumber(bytes, content.start)
+    bytes.writeNumber(content.start)
     this._encodeString(bytes, 'duration')
-    this._encodeNumber(bytes, content.duration)
+    bytes.writeNumber(content.duration)
     this._encodeString(bytes, 'meta')
     this._encodeMap(bytes, content.meta)
     this._encodeString(bytes, 'metrics')
@@ -108,7 +115,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
   }
 
   _encodeTestModule (bytes, content) {
-    this._encodeMapPrefix(bytes, TEST_MODULE_KEYS_LENGTH)
+    bytes.writeMapPrefix(TEST_MODULE_KEYS_LENGTH)
     this._encodeString(bytes, 'type')
     this._encodeString(bytes, content.type)
 
@@ -119,7 +126,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeId(bytes, content.span_id)
 
     this._encodeString(bytes, 'error')
-    this._encodeNumber(bytes, content.error)
+    bytes.writeNumber(content.error)
     this._encodeString(bytes, 'name')
     this._encodeString(bytes, content.name)
     this._encodeString(bytes, 'service')
@@ -127,9 +134,9 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeString(bytes, 'resource')
     this._encodeString(bytes, content.resource)
     this._encodeString(bytes, 'start')
-    this._encodeNumber(bytes, content.start)
+    bytes.writeNumber(content.start)
     this._encodeString(bytes, 'duration')
-    this._encodeNumber(bytes, content.duration)
+    bytes.writeNumber(content.duration)
     this._encodeString(bytes, 'meta')
     this._encodeMap(bytes, content.meta)
     this._encodeString(bytes, 'metrics')
@@ -137,7 +144,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
   }
 
   _encodeTestSession (bytes, content) {
-    this._encodeMapPrefix(bytes, TEST_SESSION_KEYS_LENGTH)
+    bytes.writeMapPrefix(TEST_SESSION_KEYS_LENGTH)
     this._encodeString(bytes, 'type')
     this._encodeString(bytes, content.type)
 
@@ -145,7 +152,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeId(bytes, content.trace_id)
 
     this._encodeString(bytes, 'error')
-    this._encodeNumber(bytes, content.error)
+    bytes.writeNumber(content.error)
     this._encodeString(bytes, 'name')
     this._encodeString(bytes, content.name)
     this._encodeString(bytes, 'service')
@@ -153,9 +160,9 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeString(bytes, 'resource')
     this._encodeString(bytes, content.resource)
     this._encodeString(bytes, 'start')
-    this._encodeNumber(bytes, content.start)
+    bytes.writeNumber(content.start)
     this._encodeString(bytes, 'duration')
-    this._encodeNumber(bytes, content.duration)
+    bytes.writeNumber(content.duration)
     this._encodeString(bytes, 'meta')
     this._encodeMap(bytes, content.meta)
     this._encodeString(bytes, 'metrics')
@@ -180,7 +187,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     if (content.type) {
       totalKeysLength += 1
     }
-    this._encodeMapPrefix(bytes, totalKeysLength)
+    bytes.writeMapPrefix(totalKeysLength)
     if (content.type) {
       this._encodeString(bytes, 'type')
       this._encodeString(bytes, content.type)
@@ -198,11 +205,11 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeString(bytes, 'service')
     this._encodeString(bytes, content.service)
     this._encodeString(bytes, 'error')
-    this._encodeNumber(bytes, content.error)
+    bytes.writeNumber(content.error)
     this._encodeString(bytes, 'start')
-    this._encodeNumber(bytes, content.start)
+    bytes.writeNumber(content.start)
     this._encodeString(bytes, 'duration')
-    this._encodeNumber(bytes, content.duration)
+    bytes.writeNumber(content.duration)
     /**
      * We include `test_session_id` and `test_suite_id`
      * in the root of the event by passing them via the `meta` dict.
@@ -243,12 +250,12 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
   }
 
   _encodeEvent (bytes, event) {
-    this._encodeMapPrefix(bytes, Object.keys(event).length)
+    bytes.writeMapPrefix(Object.keys(event).length)
     this._encodeString(bytes, 'type')
     this._encodeString(bytes, event.type)
 
     this._encodeString(bytes, 'version')
-    this._encodeNumber(bytes, event.version)
+    bytes.writeNumber(event.version)
 
     this._encodeString(bytes, 'content')
     if (event.type === 'span' || event.type === 'test') {
@@ -318,6 +325,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
         '*': {
           language: 'javascript',
           library_version: ddTraceVersion,
+          ...this.wildcardMetadataTags,
         },
         ...this.metadataTags,
       },
@@ -331,11 +339,11 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
       payload.metadata['*']['runtime-id'] = this.runtimeId
     }
 
-    this._encodeMapPrefix(bytes, Object.keys(payload).length)
+    bytes.writeMapPrefix(Object.keys(payload).length)
     this._encodeString(bytes, 'version')
-    this._encodeNumber(bytes, payload.version)
+    bytes.writeNumber(payload.version)
     this._encodeString(bytes, 'metadata')
-    this._encodeMapPrefix(bytes, Object.keys(payload.metadata).length)
+    bytes.writeMapPrefix(Object.keys(payload.metadata).length)
     this._encodeString(bytes, '*')
     this._encodeMap(bytes, payload.metadata['*'])
     if (payload.metadata.test) {

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

@@ -86,10 +86,12 @@ class AgentlessJSONEncoder {
   /**
    * @param {object} writer - Writer instance with a flush() method, called when the buffer exceeds the soft limit
    * @param {object} [metadata] - Shared metadata spread into each trace object (hostname, env, tracerVersion, etc.)
+   * @param {number} [softLimit] - Estimated payload-size threshold that triggers an early flush. Defaults to 8 MiB.
    */
-  constructor (writer, metadata = {}) {
+  constructor (writer, metadata = {}, softLimit = SOFT_LIMIT) {
     this._writer = writer
     this._metadata = metadata
+    this._softLimit = softLimit
     this._reset()
   }
 
@@ -134,7 +136,7 @@ class AgentlessJSONEncoder {
       log.error('All %d span(s) in trace failed to encode. Entire trace dropped.', trace.length)
     }
 
-    if (this._estimatedSize > SOFT_LIMIT) {
+    if (this._estimatedSize > this._softLimit) {
       log.debug('Buffer went over soft limit, flushing')
       try {
         this._writer.flush()

package/packages/dd-trace/src/encode/coverage-ci-visibility.js

@@ -12,6 +12,17 @@ const { AgentEncoder } = require('./0.4')
 const COVERAGE_PAYLOAD_VERSION = 2
 const COVERAGE_KEYS_LENGTH = 2
 
+function getBitmapBuffer (bitmap) {
+  if (!bitmap) return
+  if (Buffer.isBuffer(bitmap)) return bitmap
+  if (ArrayBuffer.isView(bitmap)) {
+    return Buffer.from(bitmap.buffer, bitmap.byteOffset, bitmap.byteLength)
+  }
+  if (bitmap.type === 'Buffer' && Array.isArray(bitmap.data)) {
+    return Buffer.from(bitmap.data)
+  }
+}
+
 class CoverageCIVisibilityEncoder extends AgentEncoder {
   constructor () {
     super(...arguments)
@@ -39,32 +50,40 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
   }
 
   encodeCodeCoverage (bytes, coverage) {
-    if (coverage.testId) {
-      this._encodeMapPrefix(bytes, 4)
-    } else {
-      this._encodeMapPrefix(bytes, 3)
-    }
+    let keysLength = 2
+    if (coverage.suiteId) keysLength++
+    if (coverage.testId) keysLength++
+
+    bytes.writeMapPrefix(keysLength)
     this._encodeString(bytes, 'test_session_id')
     this._encodeId(bytes, coverage.sessionId)
-    this._encodeString(bytes, 'test_suite_id')
-    this._encodeId(bytes, coverage.suiteId)
+    if (coverage.suiteId) {
+      this._encodeString(bytes, 'test_suite_id')
+      this._encodeId(bytes, coverage.suiteId)
+    }
     if (coverage.testId) {
       this._encodeString(bytes, 'span_id')
       this._encodeId(bytes, coverage.testId)
     }
     this._encodeString(bytes, 'files')
-    this._encodeArrayPrefix(bytes, coverage.files)
-    for (const filename of coverage.files) {
-      this._encodeMapPrefix(bytes, 1)
+    bytes.writeArrayPrefix(coverage.files)
+    for (const file of coverage.files) {
+      const filename = typeof file === 'string' ? file : file.filename
+      const bitmap = getBitmapBuffer(file.bitmap)
+      bytes.writeMapPrefix(bitmap ? 2 : 1)
       this._encodeString(bytes, 'filename')
       this._encodeString(bytes, filename)
+      if (bitmap) {
+        this._encodeString(bytes, 'bitmap')
+        bytes.writeBin(bitmap)
+      }
     }
   }
 
   reset () {
     this._reset()
     if (this._coverageBytes) {
-      this._coverageBytes.length = 0
+      this._coverageBytes.reset()
     }
     this._coveragesCount = 0
     this._encodePayloadStart(this._coverageBytes)
@@ -75,9 +94,9 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
       version: COVERAGE_PAYLOAD_VERSION,
       coverages: [],
     }
-    this._encodeMapPrefix(bytes, COVERAGE_KEYS_LENGTH)
+    bytes.writeMapPrefix(COVERAGE_KEYS_LENGTH)
     this._encodeString(bytes, 'version')
-    this._encodeInteger(bytes, payload.version)
+    bytes.writeInteger(payload.version)
     this._encodeString(bytes, 'coverages')
     // Get offset of the coverages list to update the length of the array when calling `makePayload`
     this._coveragesOffset = bytes.length

package/packages/dd-trace/src/encode/span-stats.js

@@ -31,7 +31,7 @@ class SpanStatsEncoder extends AgentEncoder {
   }
 
   _encodeStat (bytes, stat) {
-    this._encodeMapPrefix(bytes, 15)
+    bytes.writeMapPrefix(15)
 
     this._encodeString(bytes, 'Service')
     const service = stat.Service || DEFAULT_SERVICE_NAME
@@ -45,31 +45,31 @@ class SpanStatsEncoder extends AgentEncoder {
     this._encodeString(bytes, truncate(stat.Resource, MAX_RESOURCE_NAME_LENGTH, '...'))
 
     this._encodeString(bytes, 'HTTPStatusCode')
-    this._encodeInteger(bytes, stat.HTTPStatusCode)
+    bytes.writeInteger(stat.HTTPStatusCode)
 
     this._encodeString(bytes, 'Type')
     this._encodeString(bytes, truncate(stat.Type, MAX_TYPE_LENGTH))
 
     this._encodeString(bytes, 'Hits')
-    this._encodeLong(bytes, stat.Hits)
+    bytes.writeLong(stat.Hits)
 
     this._encodeString(bytes, 'Errors')
-    this._encodeLong(bytes, stat.Errors)
+    bytes.writeLong(stat.Errors)
 
     this._encodeString(bytes, 'Duration')
-    this._encodeLong(bytes, stat.Duration)
+    bytes.writeLong(stat.Duration)
 
     this._encodeString(bytes, 'OkSummary')
-    this._encodeBuffer(bytes, stat.OkSummary)
+    bytes.writeBin(stat.OkSummary)
 
     this._encodeString(bytes, 'ErrorSummary')
-    this._encodeBuffer(bytes, stat.ErrorSummary)
+    bytes.writeBin(stat.ErrorSummary)
 
     this._encodeString(bytes, 'Synthetics')
-    this._encodeBool(bytes, stat.Synthetics)
+    bytes.writeBoolean(stat.Synthetics)
 
     this._encodeString(bytes, 'TopLevelHits')
-    this._encodeLong(bytes, stat.TopLevelHits)
+    bytes.writeLong(stat.TopLevelHits)
 
     this._encodeString(bytes, 'HTTPMethod')
     this._encodeString(bytes, stat.HTTPMethod)
@@ -82,23 +82,23 @@ class SpanStatsEncoder extends AgentEncoder {
   }
 
   _encodeBucket (bytes, bucket) {
-    this._encodeMapPrefix(bytes, 3)
+    bytes.writeMapPrefix(3)
 
     this._encodeString(bytes, 'Start')
-    this._encodeLong(bytes, bucket.Start)
+    bytes.writeLong(bucket.Start)
 
     this._encodeString(bytes, 'Duration')
-    this._encodeLong(bytes, bucket.Duration)
+    bytes.writeLong(bucket.Duration)
 
     this._encodeString(bytes, 'Stats')
-    this._encodeArrayPrefix(bytes, bucket.Stats)
+    bytes.writeArrayPrefix(bucket.Stats)
     for (const stat of bucket.Stats) {
       this._encodeStat(bytes, stat)
     }
   }
 
   _encode (bytes, stats) {
-    this._encodeMapPrefix(bytes, stats.ProcessTags ? 9 : 8)
+    bytes.writeMapPrefix(stats.ProcessTags ? 9 : 8)
 
     this._encodeString(bytes, 'Hostname')
     this._encodeString(bytes, stats.Hostname)
@@ -110,7 +110,7 @@ class SpanStatsEncoder extends AgentEncoder {
     this._encodeString(bytes, stats.Version)
 
     this._encodeString(bytes, 'Stats')
-    this._encodeArrayPrefix(bytes, stats.Stats)
+    bytes.writeArrayPrefix(stats.Stats)
     for (const bucket of stats.Stats) {
       this._encodeBucket(bytes, bucket)
     }
@@ -125,7 +125,7 @@ class SpanStatsEncoder extends AgentEncoder {
     this._encodeString(bytes, stats.RuntimeID)
 
     this._encodeString(bytes, 'Sequence')
-    this._encodeLong(bytes, stats.Sequence)
+    bytes.writeLong(stats.Sequence)
 
     if (stats.ProcessTags) {
       this._encodeString(bytes, 'ProcessTags')

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

@@ -9,6 +9,8 @@ const MAX_RESOURCE_NAME_LENGTH = 5000
 const MAX_META_KEY_LENGTH = 200
 // MAX_META_VALUE_LENGTH the maximum length of metadata value
 const MAX_META_VALUE_LENGTH = 25_000
+// MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION the maximum length of metadata value for Test Optimization
+const MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION = 5000
 // MAX_METRIC_KEY_LENGTH the maximum length of a metric name key
 const MAX_METRIC_KEY_LENGTH = MAX_META_KEY_LENGTH
 
@@ -32,6 +34,18 @@ function truncateSpan (span) {
   return span
 }
 
+function truncateSpanTestOpt (span) {
+  truncateSpan(span)
+  if (span.meta) {
+    for (const key of Object.keys(span.meta)) {
+      if (span.meta[key].length > MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION) {
+        span.meta[key] = `${span.meta[key].slice(0, MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION)}...`
+      }
+    }
+  }
+  return span
+}
+
 function normalizeSpan (span) {
   span.service = span.service || DEFAULT_SERVICE_NAME
   if (span.service.length > MAX_SERVICE_LENGTH) {
@@ -53,9 +67,11 @@ function normalizeSpan (span) {
 
 module.exports = {
   truncateSpan,
+  truncateSpanTestOpt,
   normalizeSpan,
   MAX_META_KEY_LENGTH,
   MAX_META_VALUE_LENGTH,
+  MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION,
   MAX_METRIC_KEY_LENGTH,
   MAX_NAME_LENGTH,
   MAX_SERVICE_LENGTH,

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

@@ -78,6 +78,21 @@ class Identifier {
     return this.toString()
   }
 
+  /**
+   * Returns the full hex trace ID. When this is a 64-bit identifier and `traceIdHigh`
+   * is provided, prepends it to form the 128-bit trace ID. Otherwise returns
+   * only this identifier's hex representation.
+   *
+   * @param {string | undefined} traceIdHigh - 16-char hex of the upper 64 bits, or undefined
+   * @returns {string}
+   */
+  toTraceIdHex (traceIdHigh) {
+    if (traceIdHigh && this.#buffer.length <= 8) {
+      return traceIdHigh + this.toString(16)
+    }
+    return this.toString(16)
+  }
+
   /**
    * @param {Identifier} other
    * @returns {boolean}