dd-trace 5.104.0 → 5.105.0

package/packages/dd-trace/src/ci-visibility/test-optimization-cache.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { writeFileSync } = require('node:fs')
+const { existsSync, readFileSync, writeFileSync } = require('node:fs')
 const { tmpdir } = require('node:os')
 const { randomUUID } = require('node:crypto')
 const path = require('node:path')
@@ -8,6 +8,9 @@ const path = require('node:path')
 const { getValueFromEnvSources } = require('../config/helper')
 const log = require('../log')
 
+const COVERAGE_BACKFILL_KEY = '_ddCoverageBackfill'
+const COVERAGE_BACKFILL_ROOT_DIR_KEY = '_ddCoverageBackfillRootDir'
+
 /**
  * Gets the test optimization settings cache file path from the env var.
  * @returns {string|undefined} The cache file path, or undefined if not set.
@@ -36,26 +39,87 @@ function setupSettingsCachePath () {
 }
 
 /**
- * Writes the settings to the cache file specified by DD_EXPERIMENTAL_TEST_OPT_SETTINGS_CACHE.
- * Does nothing if the env var is not set.
- * @param {object} settings - The settings object to cache.
+ * Reads the shared test optimization cache file.
+ * @returns {object} Cached settings and metadata.
  */
-function writeSettingsToCache (settings) {
+function readCacheFile () {
+  const settingsCachePath = getSettingsCachePath()
+  if (!settingsCachePath || !existsSync(settingsCachePath)) {
+    return {}
+  }
+
+  try {
+    return JSON.parse(readFileSync(settingsCachePath, 'utf8'))
+  } catch (err) {
+    log.debug('Failed to read settings cache: %s', err.message)
+    return {}
+  }
+}
+
+/**
+ * Writes the shared test optimization cache file.
+ * @param {object} cache - Cached settings and metadata.
+ */
+function writeCacheFile (cache) {
   const settingsCachePath = getSettingsCachePath()
   if (!settingsCachePath) {
     return
   }
 
   try {
-    writeFileSync(settingsCachePath, JSON.stringify(settings), 'utf8')
+    writeFileSync(settingsCachePath, JSON.stringify(cache), 'utf8')
     log.debug('Settings written to %s', settingsCachePath)
   } catch (err) {
     log.error('Failed to write settings to cache file', err)
   }
 }
 
+/**
+ * Writes the settings to the cache file specified by DD_EXPERIMENTAL_TEST_OPT_SETTINGS_CACHE.
+ * Does nothing if the env var is not set.
+ * @param {object} settings - The settings object to cache.
+ */
+function writeSettingsToCache (settings) {
+  writeCacheFile({
+    ...readCacheFile(),
+    ...settings,
+  })
+}
+
+/**
+ * Writes TIA coverage backfill to the shared nyc settings cache.
+ * @param {object} coverage - Repository-relative coverage bitmaps by filename.
+ * @param {string} [rootDir] - Root directory that coverage filenames are relative to.
+ */
+function writeCoverageBackfillToCache (coverage, rootDir) {
+  writeCacheFile({
+    ...readCacheFile(),
+    [COVERAGE_BACKFILL_KEY]: coverage,
+    [COVERAGE_BACKFILL_ROOT_DIR_KEY]: rootDir,
+  })
+}
+
+/**
+ * Reads TIA coverage backfill from the shared nyc settings cache.
+ * @returns {object|undefined} Repository-relative coverage bitmaps by filename.
+ */
+function readCoverageBackfillFromCache () {
+  return readCacheFile()[COVERAGE_BACKFILL_KEY]
+}
+
+/**
+ * Reads TIA coverage backfill root directory from the shared nyc settings cache.
+ * @returns {string|undefined} Root directory that cached coverage filenames are relative to.
+ */
+function readCoverageBackfillRootDirFromCache () {
+  return readCacheFile()[COVERAGE_BACKFILL_ROOT_DIR_KEY]
+}
+
 module.exports = {
   getSettingsCachePath,
+  readCoverageBackfillFromCache,
+  readCoverageBackfillRootDirFromCache,
   setupSettingsCachePath,
+  writeCoverageBackfillToCache,
   writeSettingsToCache,
 }

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

@@ -65,7 +65,7 @@ export interface GeneratedConfig {
   dbm: {
     injectSqlBaseHash: boolean;
   };
-  dbmPropagationMode: string;
+  dbmPropagationMode: "disabled" | "service" | "full" | "dynamic_service";
   DD_ACTION_EXECUTION_ID: string | undefined;
   DD_AGENTLESS_LOG_SUBMISSION_ENABLED: boolean;
   DD_AGENTLESS_LOG_SUBMISSION_URL: string | undefined;
@@ -162,7 +162,6 @@ export interface GeneratedConfig {
   DD_TEST_FLEET_CONFIG_PATH: string | undefined;
   DD_TEST_LOCAL_CONFIG_PATH: string | undefined;
   DD_TEST_SESSION_NAME: string | undefined;
-  DD_TEST_TIA_KEEP_COV_CONFIG: boolean;
   DD_TRACE_AEROSPIKE_ENABLED: boolean;
   DD_TRACE_AI_ENABLED: boolean;
   DD_TRACE_AMQP10_ENABLED: boolean;
@@ -211,6 +210,7 @@ export interface GeneratedConfig {
   DD_TRACE_AWS_SDK_STEPFUNCTIONS_BATCH_PROPAGATION_ENABLED: boolean;
   DD_TRACE_AWS_SDK_STEPFUNCTIONS_ENABLED: boolean;
   DD_TRACE_AXIOS_ENABLED: boolean;
+  DD_TRACE_AZURE_COSMOS_ENABLED: boolean;
   DD_TRACE_AZURE_DURABLE_FUNCTIONS_ENABLED: boolean;
   DD_TRACE_AZURE_EVENT_HUBS_ENABLED: boolean;
   DD_TRACE_AZURE_EVENTHUBS_BATCH_LINKS_ENABLED: boolean;
@@ -331,6 +331,7 @@ export interface GeneratedConfig {
   DD_TRACE_MYSQL_ENABLED: boolean;
   DD_TRACE_MYSQL2_ENABLED: boolean;
   DD_TRACE_NATIVE_SPAN_EVENTS: boolean;
+  DD_TRACE_NATS_ENABLED: boolean;
   DD_TRACE_NET_ENABLED: boolean;
   DD_TRACE_NEXT_ENABLED: boolean;
   DD_TRACE_NODE_CHILD_PROCESS_ENABLED: boolean;
@@ -428,6 +429,9 @@ export interface GeneratedConfig {
     flaggingProvider: {
       enabled: boolean;
       initializationTimeoutMs: number;
+      spanEnrichment: {
+        enabled: boolean;
+      };
     };
   };
   flakyTestRetriesCount: number;

package/packages/dd-trace/src/config/supported-configurations.json

@@ -640,7 +640,9 @@
         "configurationNames": [
           "dbmPropagationMode"
         ],
-        "default": "disabled"
+        "default": "disabled",
+        "allowed": "disabled|service|full|dynamic_service",
+        "transform": "toLowerCase"
       }
     ],
     "DD_DOGSTATSD_HOST": [
@@ -773,6 +775,16 @@
         "default": "false"
       }
     ],
+    "DD_EXPERIMENTAL_FLAGGING_PROVIDER_SPAN_ENRICHMENT_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "configurationNames": [
+          "experimental.flaggingProvider.spanEnrichment.enabled"
+        ],
+        "default": "false"
+      }
+    ],
     "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED": [
       {
         "implementation": "B",
@@ -1773,13 +1785,6 @@
         "internalPropertyName": "isTestManagementEnabled"
       }
     ],
-    "DD_TEST_TIA_KEEP_COV_CONFIG": [
-      {
-        "implementation": "A",
-        "type": "boolean",
-        "default": "false"
-      }
-    ],
     "DD_TEST_SESSION_NAME": [
       {
         "implementation": "A",
@@ -2176,6 +2181,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_AZURE_COSMOS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
     "DD_TRACE_AZURE_DURABLE_FUNCTIONS_ENABLED": [
       {
         "implementation": "B",
@@ -3184,6 +3196,13 @@
         "default": "false"
       }
     ],
+    "DD_TRACE_NATS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "false"
+      }
+    ],
     "DD_TRACE_NET_ENABLED": [
       {
         "implementation": "A",

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)
   }
 }