dd-trace 5.103.0 → 5.105.0

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

@@ -4,11 +4,9 @@ const zlib = require('zlib')
 const pkg = require('../../../../package.json')
 const log = require('../log')
 const request = require('../exporters/common/request')
-const { MsgpackEncoder } = require('../msgpack')
+const { encode: encodeMsgpack } = require('../msgpack')
 const { getAgentUrl } = require('../agent/url')
 
-const msgpack = new MsgpackEncoder()
-
 function makeRequest (data, url, cb) {
   const options = {
     path: '/v0.1/pipeline_stats',
@@ -39,7 +37,7 @@ class DataStreamsWriter {
       log.debug('Maximum number of active requests reached. Payload discarded: %j', payload)
       return
     }
-    const encodedPayload = msgpack.encode(payload)
+    const encodedPayload = encodeMsgpack(payload)
 
     zlib.gzip(encodedPayload, { level: 1 }, (err, compressedData) => {
       if (err) {

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

@@ -6,7 +6,7 @@ module.exports = {
   templateRequiresEvaluation,
 }
 
-const identifierRegex = /^[@a-zA-Z_$][\w$]*$/
+const identifierRegex = /^(@[\w$]+|[a-zA-Z_$][\w$]*)$/
 
 // The following identifiers have purposefully not been included in this list:
 // - The reserved words `this` and `super` as they can have valid use cases as `ref` values
@@ -99,14 +99,11 @@ function compile (node) {
       ? `(typeof ${compile(value[0])} === '${value[1]}')` // TODO: Is parenthesizing necessary?
       : `Function.prototype[Symbol.hasInstance].call(${assertIdentifier(value[1])}, ${compile(value[0])})`
   } else if (type === 'ref') {
-    if (value === '@it') {
-      return '$dd_it'
-    } else if (value === '@key') {
-      return '$dd_key'
-    } else if (value === '@value') {
-      return '$dd_value'
+    const refValue = assertIdentifier(value)
+    if (refValue.startsWith('@')) {
+      return `$dd_${refValue.slice(1)}`
     }
-    return assertIdentifier(value)
+    return refValue
   } else if (Array.isArray(value)) {
     const args = value.map(compile)
     switch (type) {

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

@@ -1,11 +1,17 @@
 'use strict'
 
 const getConfig = require('../config')
-const { MsgpackChunk, MsgpackEncoder } = require('../msgpack')
+const { MsgpackChunk } = require('../msgpack')
 const log = require('../log')
 const { normalizeSpan } = require('./tags-processors')
 
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
+// Values longer than this byte threshold skip the `_stringMap` lookup and
+// emit through `bytes.write` directly. Hashing a multi-KiB string for
+// `Map.get` costs more than the cache hit saves on the inputs that produce
+// strings this long (events JSON, stack traces, large query bodies) — they
+// are unique per span, so the cache hit rate stays near zero anyway.
+const STRING_CACHE_BYPASS_LIMIT = 1024
 
 // Pre-encoded static keys + value-prefix bytes; the hot encode loop emits
 // each via one Uint8Array.set instead of routing through the string cache.
@@ -43,6 +49,17 @@ const KEY_SERVICE = buildKey('service')
 const KEY_ERROR = buildKey('error')
 const KEY_START = buildKey('start')
 const KEY_DURATION = buildKey('duration')
+
+// Fused `[KEY_ERROR, fixint]` payloads. `error` is `0` or `1` on nearly every
+// span (the boolean-shaped tracer field collapsed onto a single byte). One
+// `bytes.set` writes the key and the value together instead of routing the
+// value through `writeIntOrFloat`'s reserve + branch table.
+const KEY_ERROR_0 = Buffer.concat([KEY_ERROR, Buffer.from([0x00])])
+const KEY_ERROR_1 = Buffer.concat([KEY_ERROR, Buffer.from([0x01])])
+// `[KEY_START, 0xCF]` — `start` is always a nanosecond timestamp ≥ 2³², so
+// the msgpack u64 type byte is statically known and fuses with the key. The
+// 8-byte value is written inline right after.
+const KEY_START_PREFIX = buildKeyWithPrefix('start', 0xCF)
 const KEY_SPAN_EVENTS = buildKey('span_events')
 const KEY_META_STRUCT = buildKey('meta_struct')
 const KEY_TRACE_ID_PREFIX = buildKeyWithPrefix('trace_id', 0xCF)
@@ -97,6 +114,8 @@ const ATTR_PAYLOAD_BOOL_FALSE = Buffer.concat([ATTR_PREFIX_BOOL, Buffer.from([0x
 function formatSpanWithLegacyEvents (span) {
   span = normalizeSpan(span)
   if (span.span_events) {
+    // TODO: this is currently a main cost driver. By unifying it with the formatter
+    // it should be possible to improve performance significantly overall.
     span.meta.events = stringifySpanEvents(span.span_events)
     // `= undefined` over `delete` to keep the span's hidden class — `delete`
     // would push every event-bearing span into V8 dictionary mode.
@@ -201,8 +220,12 @@ function escapeJsonString (value) {
   return '"' + value + '"'
 }
 
+function lazyEncodedTraceBufferLogger (bytes, start, end) {
+  const hex = bytes.buffer.subarray(start, end).toString('hex').match(/../g).join(' ')
+  return `Adding encoded trace to buffer: ${hex}`
+}
+
 class AgentEncoder {
-  #msgpack = new MsgpackEncoder()
   #limit
   #writer
   #config
@@ -239,11 +262,7 @@ class AgentEncoder {
 
     if (this.#debugEncoding) {
       const end = bytes.length
-      // eslint-disable-next-line eslint-rules/eslint-log-printf-style
-      log.debug(() => {
-        const hex = bytes.buffer.subarray(start, end).toString('hex').match(/../g).join(' ')
-        return `Adding encoded trace to buffer: ${hex}`
-      })
+      log.debug(lazyEncodedTraceBufferLogger, bytes, start, end)
     }
 
     // Soft limit overshoot is fine — the agent caps at 50 MB.
@@ -269,7 +288,7 @@ class AgentEncoder {
   }
 
   _encode (bytes, trace) {
-    this._encodeArrayPrefix(bytes, trace)
+    bytes.writeArrayPrefix(trace)
 
     const formatSpan = this.#formatSpan
     const stringMap = this._stringMap
@@ -286,10 +305,10 @@ class AgentEncoder {
       if (span.span_events) mapSize++
 
       // Pre-fetch the cached string entries up front and fuse the map prefix,
-      // optional `type`, three IDs, and `name` / `resource` / `service`
+      // optional `type`, three IDs, `name` / `resource` / `service`, and —
+      // in the common fixint-error case — the error/start/duration_key
       // emissions into a single `bytes.reserve` + sequential native writes.
-      // Replaces seven `bytes.reserve` calls per span (one each for the
-      // header, type, three IDs, three strings) with one.
+      // Replaces up to ten separate `bytes.reserve` calls per span with one.
       let typeEntry
       if (span.type) {
         typeEntry = stringMap[span.type] ?? this._cacheString(span.type)
@@ -301,8 +320,17 @@ class AgentEncoder {
       const resourceLen = resourceEntry.length
       const serviceLen = serviceEntry.length
 
-      // 1 byte map prefix + 3 ID fields (10/9/11 bytes prefix + 8 bytes value
-      // each) + the three string fields.
+      // Almost every span carries `error: 0` or `error: 1` AND a nanosecond
+      // `start` timestamp ≥ 2³² (so `start` always encodes as a u64). When
+      // both hold, the block fuses error key+value, the start key + 0xCF
+      // type byte + 8-byte timestamp, and the duration key into the per-span
+      // reserve. The fallback path covers synthetic/test inputs with small
+      // starts and rare non-binary error flags by keeping per-field emits so
+      // each integer picks the shortest msgpack encoding.
+      const errorIsFixint = span.error === 0 || span.error === 1
+      const startFitsU64 = span.start >= 0x1_00_00_00_00
+      const fuseTail = errorIsFixint && startFitsU64
+
       let blockSize = 1 +
         KEY_TRACE_ID_PREFIX.length + 8 +
         KEY_SPAN_ID_PREFIX.length + 8 +
@@ -311,6 +339,9 @@ class AgentEncoder {
         KEY_RESOURCE.length + resourceLen +
         KEY_SERVICE.length + serviceLen
       if (typeEntry) blockSize += KEY_TYPE.length + typeEntry.length
+      if (fuseTail) {
+        blockSize += KEY_ERROR_0.length + KEY_START_PREFIX.length + 8 + KEY_DURATION.length
+      }
 
       const blockOffset = bytes.length
       bytes.reserve(blockSize)
@@ -343,13 +374,35 @@ class AgentEncoder {
       target.set(KEY_SERVICE, cursor)
       cursor += KEY_SERVICE.length
       target.set(serviceEntry, cursor)
+      cursor += serviceLen
+
+      if (fuseTail) {
+        target.set(span.error === 0 ? KEY_ERROR_0 : KEY_ERROR_1, cursor)
+        cursor += KEY_ERROR_0.length
 
-      bytes.set(KEY_ERROR)
-      this._encodeIntOrFloat(bytes, span.error)
-      bytes.set(KEY_START)
-      this._encodeIntOrFloat(bytes, span.start)
-      bytes.set(KEY_DURATION)
-      this._encodeIntOrFloat(bytes, span.duration)
+        target.set(KEY_START_PREFIX, cursor)
+        cursor += KEY_START_PREFIX.length
+        // Inline u64 write so the 0xCF type byte and the 8 timestamp bytes
+        // share the same reserve as the keys.
+        target.writeUInt32BE((span.start / 0x1_00_00_00_00) >>> 0, cursor)
+        target.writeUInt32BE(span.start >>> 0, cursor + 4)
+        cursor += 8
+
+        target.set(KEY_DURATION, cursor)
+      } else {
+        if (span.error === 0) {
+          bytes.set(KEY_ERROR_0)
+        } else if (span.error === 1) {
+          bytes.set(KEY_ERROR_1)
+        } else {
+          bytes.set(KEY_ERROR)
+          bytes.writeIntOrFloat(span.error)
+        }
+        bytes.set(KEY_START)
+        bytes.writeIntOrFloat(span.start)
+        bytes.set(KEY_DURATION)
+      }
+      bytes.writeIntOrFloat(span.duration)
 
       this.#encodeMetaEntries(bytes, KEY_META_PREFIX, span.meta)
       this.#encodeMetaEntries(bytes, KEY_METRICS_PREFIX, span.metrics)
@@ -390,34 +443,14 @@ class AgentEncoder {
 
   _reset () {
     this._traceCount = 0
-    this._traceBytes.length = 0
+    this._traceBytes.reset()
     this._stringCount = 0
-    this._stringBytes.length = 0
+    this._stringBytes.reset()
     this._stringMap = Object.create(null)
 
     this._cacheString('')
   }
 
-  _encodeBuffer (bytes, buffer) {
-    this.#msgpack.encodeBin(bytes, buffer)
-  }
-
-  _encodeBool (bytes, value) {
-    this.#msgpack.encodeBoolean(bytes, value)
-  }
-
-  _encodeArrayPrefix (bytes, value) {
-    this.#msgpack.encodeArrayPrefix(bytes, value)
-  }
-
-  _encodeMapPrefix (bytes, keysLength) {
-    this.#msgpack.encodeMapPrefix(bytes, keysLength)
-  }
-
-  _encodeByte (bytes, value) {
-    this.#msgpack.encodeByte(bytes, value)
-  }
-
   // TODO: Use BigInt instead.
   _encodeId (bytes, identifier) {
     const idBuffer = identifier.toBuffer()
@@ -438,18 +471,6 @@ class AgentEncoder {
     target[offset + 8] = idBuffer[start + 7]
   }
 
-  _encodeNumber (bytes, value) {
-    this.#msgpack.encodeNumber(bytes, value)
-  }
-
-  _encodeInteger (bytes, value) {
-    this.#msgpack.encodeInteger(bytes, value)
-  }
-
-  _encodeLong (bytes, value) {
-    this.#msgpack.encodeLong(bytes, value)
-  }
-
   // Single pass: reserve the count slot, encode entries while counting, patch the count.
   // Subclasses (0.5, CI visibility encoders) inherit this; the wire stays on float64
   // for numeric values to keep their established trace / events intake unchanged.
@@ -467,7 +488,7 @@ class AgentEncoder {
         count++
       } else if (typeof entryValue === 'number') {
         this._encodeString(bytes, key)
-        this.#encodeFloat(bytes, entryValue)
+        bytes.writeFloat(entryValue)
         count++
       }
     }
@@ -480,6 +501,10 @@ class AgentEncoder {
   }
 
   _encodeString (bytes, value = '') {
+    if (value.length > STRING_CACHE_BYPASS_LIMIT) {
+      bytes.write(value)
+      return
+    }
     const entry = this._stringMap[value] ?? this._cacheString(value)
     const length = entry.length
     const offset = bytes.length
@@ -540,6 +565,17 @@ class AgentEncoder {
       const writeOffset = bytes.length
 
       if (typeof entryValue === 'string') {
+        if (entryValue.length > STRING_CACHE_BYPASS_LIMIT) {
+          // Long values (events JSON, stack traces, large query bodies) are
+          // unique per span; hashing them for the cache lookup costs more
+          // than the lookup ever recovers. Emit the key from the cache and
+          // stream the value directly.
+          bytes.reserve(keyEntryLen)
+          bytes.buffer.set(keyEntry, writeOffset)
+          bytes.write(entryValue)
+          count++
+          continue
+        }
         const valueEntry = stringMap[entryValue] ?? this._cacheString(entryValue)
         const valueEntryLen = valueEntry.length
         bytes.reserve(keyEntryLen + valueEntryLen)
@@ -547,9 +583,22 @@ class AgentEncoder {
         target.set(keyEntry, writeOffset)
         target.set(valueEntry, writeOffset + keyEntryLen)
       } else {
-        bytes.reserve(keyEntryLen)
-        bytes.buffer.set(keyEntry, writeOffset)
-        this._encodeIntOrFloat(bytes, entryValue)
+        // Speculate that `entryValue` is a positive fixint (0..127): one
+        // reserve covers both the key and the value. The metrics map (sample
+        // rate, priority, `_dd.measured`, attribute counts) is mostly small
+        // unsigned integers, so the speculation wins on every entry that
+        // doesn't go through the slow `writeIntOrFloat` dispatch chain.
+        bytes.reserve(keyEntryLen + 1)
+        const target = bytes.buffer
+        target.set(keyEntry, writeOffset)
+        if (entryValue === (entryValue & 0x7F)) {
+          target[writeOffset + keyEntryLen] = entryValue
+        } else {
+          // Speculation missed; rewind the speculative byte and route the
+          // value through the full encoder so it picks the right type.
+          bytes.length = writeOffset + keyEntryLen
+          bytes.writeIntOrFloat(entryValue)
+        }
       }
       count++
     }
@@ -589,41 +638,6 @@ class AgentEncoder {
     return offset + 8
   }
 
-  /**
-   * Emit `value` as the smallest valid msgpack number encoding: compact
-   * unsigned/signed int when integer, float64 otherwise. Unlike
-   * `MsgpackEncoder#encodeNumber`, NaN keeps its float64 bits instead of
-   * coercing to fixint 0.
-   *
-   * Underscore-protected so the 0.5 subclass can call it from its own
-   * `_encode` / `_encodeMap` overrides.
-   *
-   * @param {MsgpackChunk} bytes
-   * @param {number} value
-   */
-  _encodeIntOrFloat (bytes, value) {
-    // Fast path: positive fixint (0..127). `value === (value & 0x7F)` is true
-    // iff `value` is an exact integer in that range — covers `error: 0/1`,
-    // priority flags, attribute counts, HTTP status codes mapped to numbers,
-    // and most small metrics. NaN, ±Infinity, negatives, and any non-integer
-    // float fall through.
-    if (value === (value & 0x7F)) {
-      const offset = bytes.length
-      bytes.reserve(1)
-      bytes.buffer[offset] = value
-      return
-    }
-    if (Number.isInteger(value)) {
-      if (value >= 0) {
-        this.#msgpack.encodeUnsigned(bytes, value)
-      } else {
-        this.#msgpack.encodeSigned(bytes, value)
-      }
-    } else {
-      this.#encodeFloat(bytes, value)
-    }
-  }
-
   /**
    * @param {MsgpackChunk} bytes
    * @param {string | number | boolean} value
@@ -634,21 +648,17 @@ class AgentEncoder {
         this._encodeString(bytes, value)
         break
       case 'number':
-        this.#encodeFloat(bytes, value)
+        bytes.writeFloat(value)
         break
       case 'boolean':
-        this._encodeBool(bytes, value)
+        bytes.writeBoolean(value)
         break
     }
   }
 
-  #encodeFloat (bytes, value) {
-    this.#msgpack.encodeFloat(bytes, value)
-  }
-
   #encodeMetaStruct (bytes, value) {
     if (Array.isArray(value)) {
-      this._encodeMapPrefix(bytes, 0)
+      bytes.writeMapPrefix(0)
       return
     }
 
@@ -774,7 +784,7 @@ class AgentEncoder {
       bytes.set(KEY_NAME)
       this._encodeString(bytes, event.name)
       bytes.set(KEY_EVENT_TIME)
-      this.#encodeFloat(bytes, event.time_unix_nano)
+      bytes.writeFloat(event.time_unix_nano)
 
       const attributes = event.attributes
       if (attributes !== null && typeof attributes === 'object') {
@@ -844,7 +854,7 @@ class AgentEncoder {
     if (typeof value === 'number') {
       this._encodeString(bytes, key)
       bytes.set(Number.isInteger(value) ? ATTR_PREFIX_INT : ATTR_PREFIX_DOUBLE)
-      this._encodeIntOrFloat(bytes, value)
+      bytes.writeIntOrFloat(value)
       return true
     }
     if (typeof value === 'boolean') {
@@ -855,8 +865,11 @@ class AgentEncoder {
     if (Array.isArray(value)) {
       return this.#emitArrayAttribute(bytes, key, value)
     }
-    memoizedLogDebug(key, 'Encountered unsupported data type for span event v0.4 encoding, key: ' +
-      `${key}: with value: ${typeof value}. Skipping encoding of pair.`
+    memoizedLogDebug(
+      key,
+      'Encountered unsupported data type for span event v0.4 encoding, key: ' +
+        '%s: with value: %s. Skipping encoding of pair.',
+      value
     )
     return false
   }
@@ -914,7 +927,7 @@ class AgentEncoder {
     }
     if (typeof value === 'number') {
       bytes.set(Number.isInteger(value) ? ATTR_PREFIX_INT : ATTR_PREFIX_DOUBLE)
-      this._encodeIntOrFloat(bytes, value)
+      bytes.writeIntOrFloat(value)
       return true
     }
     if (typeof value === 'boolean') {
@@ -922,8 +935,11 @@ class AgentEncoder {
       return true
     }
     if (Array.isArray(value)) {
-      memoizedLogDebug(key, 'Encountered nested array data type for span event v0.4 encoding. ' +
-        `Skipping encoding key: ${key}: with value: ${typeof value}.`
+      memoizedLogDebug(
+        key,
+        'Encountered nested array data type for span event v0.4 encoding. ' +
+          'Skipping encoding key: %s: with value: %s.',
+        value
       )
     }
     return false
@@ -931,10 +947,10 @@ class AgentEncoder {
 }
 
 const seenKeys = new Set()
-function memoizedLogDebug (key, message) {
+function memoizedLogDebug (key, message, value) {
   if (!seenKeys.has(key)) {
     seenKeys.add(key)
-    log.debug(message)
+    log.debug(message, key, typeof value)
   }
 }
 

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 }