dd-trace 5.53.0 → 5.54.0

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const lock = require('mutexify/promise')()
+const mutex = require('mutexify/promise')()
 const { getGeneratedPosition } = require('./source-maps')
 const session = require('./session')
 const { compile: compileCondition, compileSegments, templateRequiresEvaluation } = require('./condition')
@@ -36,8 +36,9 @@ session.on('scriptLoadingStabilized', () => {
 })
 
 module.exports = {
-  addBreakpoint,
-  removeBreakpoint
+  addBreakpoint: lock(addBreakpoint),
+  removeBreakpoint: lock(removeBreakpoint),
+  modifyBreakpoint: lock(modifyBreakpoint)
 }
 
 async function addBreakpoint (probe) {
@@ -89,89 +90,84 @@ async function addBreakpoint (probe) {
     throw new Error(`Cannot compile expression: ${probe.when.dsl}`, { cause: err })
   }
 
-  const release = await lock()
-
-  try {
-    const locationKey = generateLocationKey(scriptId, lineNumber, columnNumber)
-    const breakpoint = locationToBreakpoint.get(locationKey)
-
-    log.debug(
-      '[debugger:devtools_client] %s breakpoint at %s:%d:%d (probe: %s, version: %d)',
-      breakpoint ? 'Updating' : 'Adding', url, lineNumber, columnNumber, probe.id, probe.version
-    )
-
-    if (breakpoint) {
-      // A breakpoint already exists at this location, so we need to add the probe to the existing breakpoint
-      await updateBreakpoint(breakpoint, probe)
-    } else {
-      // No breakpoint exists at this location, so we need to create a new one
-      const location = {
-        scriptId,
-        lineNumber: lineNumber - 1, // Beware! lineNumber is zero-indexed
-        columnNumber
-      }
-      let result
-      try {
-        result = await session.post('Debugger.setBreakpoint', {
-          location,
-          condition: probe.condition
-        })
-      } catch (err) {
-        throw new Error(`Error setting breakpoint for probe ${probe.id}`, { cause: err })
-      }
-      probeToLocation.set(probe.id, locationKey)
-      locationToBreakpoint.set(locationKey, { id: result.breakpointId, location, locationKey })
-      breakpointToProbes.set(result.breakpointId, new Map([[probe.id, probe]]))
+  const locationKey = generateLocationKey(scriptId, lineNumber, columnNumber)
+  const breakpoint = locationToBreakpoint.get(locationKey)
+
+  log.debug(
+    '[debugger:devtools_client] %s breakpoint at %s:%d:%d (probe: %s, version: %d)',
+    breakpoint ? 'Updating' : 'Adding', url, lineNumber, columnNumber, probe.id, probe.version
+  )
+
+  if (breakpoint) {
+    // A breakpoint already exists at this location, so we need to add the probe to the existing breakpoint
+    await updateBreakpointInternal(breakpoint, probe)
+  } else {
+    // No breakpoint exists at this location, so we need to create a new one
+    const location = {
+      scriptId,
+      lineNumber: lineNumber - 1, // Beware! lineNumber is zero-indexed
+      columnNumber
+    }
+    let result
+    try {
+      result = await session.post('Debugger.setBreakpoint', {
+        location,
+        condition: probe.condition
+      })
+    } catch (err) {
+      throw new Error(`Error setting breakpoint for probe ${probe.id}`, { cause: err })
     }
-  } finally {
-    release()
+    probeToLocation.set(probe.id, locationKey)
+    locationToBreakpoint.set(locationKey, { id: result.breakpointId, location, locationKey })
+    breakpointToProbes.set(result.breakpointId, new Map([[probe.id, probe]]))
   }
 }
 
 async function removeBreakpoint ({ id }) {
   if (!sessionStarted) {
     // We should not get in this state, but abort if we do, so the code doesn't fail unexpected
-    throw Error(`Cannot remove probe ${id}: Debugger not started`)
+    throw new Error(`Cannot remove probe ${id}: Debugger not started`)
   }
   if (!probeToLocation.has(id)) {
-    throw Error(`Unknown probe id: ${id}`)
+    throw new Error(`Unknown probe id: ${id}`)
   }
 
   probes.delete(id)
 
-  const release = await lock()
+  const locationKey = probeToLocation.get(id)
+  const breakpoint = locationToBreakpoint.get(locationKey)
+  const probesAtLocation = breakpointToProbes.get(breakpoint.id)
 
-  try {
-    const locationKey = probeToLocation.get(id)
-    const breakpoint = locationToBreakpoint.get(locationKey)
-    const probesAtLocation = breakpointToProbes.get(breakpoint.id)
-
-    probesAtLocation.delete(id)
-    probeToLocation.delete(id)
-
-    if (probesAtLocation.size === 0) {
-      locationToBreakpoint.delete(locationKey)
-      breakpointToProbes.delete(breakpoint.id)
-      if (breakpointToProbes.size === 0) {
-        await stop() // TODO: Will this actually delete the breakpoint?
-      } else {
-        try {
-          await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
-        } catch (err) {
-          throw new Error(`Error removing breakpoint for probe ${id}`, { cause: err })
-        }
-      }
+  probesAtLocation.delete(id)
+  probeToLocation.delete(id)
+
+  if (probesAtLocation.size === 0) {
+    locationToBreakpoint.delete(locationKey)
+    breakpointToProbes.delete(breakpoint.id)
+    // TODO: If anything below in this if-block throws, the state is out of sync.
+    if (breakpointToProbes.size === 0) {
+      await stop() // This will also remove the breakpoint
     } else {
-      await updateBreakpoint(breakpoint)
+      try {
+        await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
+      } catch (err) {
+        throw new Error(`Error removing breakpoint for probe ${id}`, { cause: err })
+      }
     }
-  } finally {
-    release()
+  } else {
+    await updateBreakpointInternal(breakpoint)
   }
 }
 
-async function updateBreakpoint (breakpoint, probe) {
+// TODO: Modify existing probe instead of removing it (DEBUG-2817)
+async function modifyBreakpoint (probe) {
+  await removeBreakpoint(probe)
+  await addBreakpoint(probe)
+}
+
+async function updateBreakpointInternal (breakpoint, probe) {
   const probesAtLocation = breakpointToProbes.get(breakpoint.id)
-  const conditionBeforeNewProbe = compileCompoundCondition(Array.from(probesAtLocation.values()))
+  const conditionBeforeNewProbe = compileCompoundCondition([...probesAtLocation.values()])
 
   // If a probe is provided, add it to the breakpoint. If not, it's because we're removing a probe, but potentially
   // need to update the condtion of the breakpoint.
@@ -180,7 +176,7 @@ async function updateBreakpoint (breakpoint, probe) {
     probeToLocation.set(probe.id, breakpoint.locationKey)
   }
 
-  const condition = compileCompoundCondition(Array.from(probesAtLocation.values()))
+  const condition = compileCompoundCondition([...probesAtLocation.values()])
 
   if (condition || conditionBeforeNewProbe !== condition) {
     try {
@@ -235,6 +231,17 @@ function stop () {
   return session.post('Debugger.disable')
 }
 
+function lock (fn) {
+  return async function (...args) {
+    const release = await mutex()
+    try {
+      return await fn(...args)
+    } finally {
+      release()
+    }
+  }
+}
+
 // Only if all probes have a condition can we use a compound condition.
 // Otherwise, we need to evaluate each probe individually once the breakpoint is hit.
 function compileCompoundCondition (probes) {

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

@@ -51,9 +51,8 @@ function compileSegments (segments) {
   let result = '['
   for (let i = 0; i < segments.length; i++) {
     const { str, dsl, json } = segments[i]
-    result += str !== undefined
-      ? JSON.stringify(str)
-      : `(() => {
+    result += str === undefined
+      ? `(() => {
           try {
             const result = ${compile(json)}
             return typeof result === 'string' ? result : $dd_inspect(result, $dd_segmentInspectOptions)
@@ -61,6 +60,7 @@ function compileSegments (segments) {
             return { expr: ${JSON.stringify(dsl)}, message: \`\${e.name}: \${e.message}\` }
           }
         })()`
+      : JSON.stringify(str)
     if (i !== segments.length - 1) {
       result += ','
     }
@@ -95,11 +95,9 @@ function compile (node) {
       }
     })()`
   } else if (type === 'instanceof') {
-    if (isPrimitiveType(value[1])) {
-      return `(typeof ${compile(value[0])} === '${value[1]}')` // TODO: Is parenthesizing necessary?
-    } else {
-      return `Function.prototype[Symbol.hasInstance].call(${assertIdentifier(value[1])}, ${compile(value[0])})`
-    }
+    return isPrimitiveType(value[1])
+      ? `(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'

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

@@ -3,5 +3,5 @@
 module.exports = {
   MAX_SNAPSHOTS_PER_SECOND_GLOBALLY: 25,
   MAX_SNAPSHOTS_PER_SECOND_PER_PROBE: 1,
-  MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE: 5_000
+  MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE: 5000
 }

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

@@ -65,6 +65,12 @@ session.on('Debugger.paused', async ({ params }) => {
   for (let i = 0; i < params.hitBreakpoints.length; i++) {
     const probesAtLocation = breakpointToProbes.get(params.hitBreakpoints[i])
 
+    if (probesAtLocation === undefined) {
+      // This might happen due to a race condition where the breakpoint is in the process of being removed
+      log.error('[debugger:devtools_client] No probes found for breakpoint %s', params.hitBreakpoints[i])
+      continue
+    }
+
     if (probesAtLocation.size !== 1) {
       numberOfProbesOnBreakpoint = numberOfProbesOnBreakpoint + probesAtLocation.size - 1
       if (numberOfProbesOnBreakpoint > snapshotProbeIndex.length) {
@@ -155,7 +161,7 @@ session.on('Debugger.paused', async ({ params }) => {
 
   log.debug(
     '[debugger:devtools_client] Finished processing breakpoints - main thread paused for: %d ms',
-    Number(diff) / 1000000
+    Number(diff) / 1_000_000
   )
 
   const logger = {

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

@@ -1,8 +1,7 @@
 'use strict'
 
 const { workerData: { rcPort } } = require('node:worker_threads')
-const lock = require('mutexify/promise')()
-const { addBreakpoint, removeBreakpoint } = require('./breakpoints')
+const { addBreakpoint, removeBreakpoint, modifyBreakpoint } = require('./breakpoints')
 const { ackReceived, ackInstalled, ackError } = require('./status')
 const log = require('../../log')
 
@@ -57,45 +56,26 @@ async function processMsg (action, probe) {
   }
   if (!probe.where.sourceFile && !probe.where.lines) {
     throw new Error(
-      // eslint-disable-next-line @stylistic/js/max-len
+      // eslint-disable-next-line @stylistic/max-len
       `Unsupported probe insertion point! Only line-based probes are supported (id: ${probe.id}, version: ${probe.version})`
     )
   }
 
-  // This lock is to ensure that we don't get the following race condition:
-  //
-  // When a breakpoint is being removed and there are no other breakpoints, we disable the debugger by calling
-  // `Debugger.disable` to free resources. However, if a new breakpoint is being added around the same time, we might
-  // have a race condition where the new breakpoint thinks that the debugger is already enabled because the removal of
-  // the other breakpoint hasn't had a chance to call `Debugger.disable` yet. Then once the code that's adding the new
-  // breakpoints tries to call `Debugger.setBreakpoint` it fails because in the meantime `Debugger.disable` was called.
-  //
-  // If the code is ever refactored to not tear down the debugger if there's no active breakpoints, we can safely remove
-  // this lock.
-  const release = await lock()
-
-  try {
-    switch (action) {
-      case 'unapply':
-        await removeBreakpoint(probe)
-        break
-      case 'apply':
-        await addBreakpoint(probe)
-        ackInstalled(probe)
-        break
-      case 'modify':
-        // TODO: Modify existing probe instead of removing it (DEBUG-2817)
-        await removeBreakpoint(probe)
-        await addBreakpoint(probe)
-        ackInstalled(probe) // TODO: Should we also send ackInstalled when modifying a probe?
-        break
-      default:
-        throw new Error(
-          // eslint-disable-next-line @stylistic/js/max-len
-          `Cannot process probe ${probe.id} (version: ${probe.version}) - unknown remote configuration action: ${action}`
-        )
-    }
-  } finally {
-    release()
+  switch (action) {
+    case 'unapply':
+      await removeBreakpoint(probe)
+      break
+    case 'apply':
+      await addBreakpoint(probe)
+      ackInstalled(probe)
+      break
+    case 'modify':
+      await modifyBreakpoint(probe)
+      ackInstalled(probe)
+      break
+    default:
+      throw new Error(
+        `Cannot process probe ${probe.id} (version: ${probe.version}) - unknown remote configuration action: ${action}`
+      )
   }
 }

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

@@ -40,7 +40,7 @@ async function getLocalStateForCallFrame (
     return () => new Error('Error getting local state')
   }
 
-  // Deplay calling `processRawState` so the caller gets a chance to resume the main thread before processing `rawState`
+  // Delay calling `processRawState` so the caller gets a chance to resume the main thread before processing `rawState`
   return () => {
     processedState = processedState ?? processRawState(rawState, maxLength)
     return processedState

package/packages/dd-trace/src/debugger/devtools_client/snapshot/processor.js

@@ -238,16 +238,14 @@ function toArrayBuffer (type, bytes, maxLength) {
 
   const size = bytes.length
 
-  if (size > maxLength) {
-    return {
-      type,
-      value: arrayBufferToString(bytes, maxLength),
-      truncated: true,
-      size: bytes.length
-    }
-  } else {
-    return { type, value: arrayBufferToString(bytes, size) }
-  }
+  return size > maxLength
+    ? {
+        type,
+        value: arrayBufferToString(bytes, maxLength),
+        truncated: true,
+        size: bytes.length
+      }
+    : { type, value: arrayBufferToString(bytes, size) }
 }
 
 function arrayBufferToString (bytes, size) {

package/packages/dd-trace/src/debugger/devtools_client/snapshot/redaction.js

@@ -2,8 +2,8 @@
 
 const config = require('../config')
 
-const excludedIdentifiers = config.dynamicInstrumentation.redactionExcludedIdentifiers
-  .map((name) => normalizeName(name))
+const excludedIdentifiers = new Set(config.dynamicInstrumentation.redactionExcludedIdentifiers
+  .map((name) => normalizeName(name)))
 
 const REDACTED_IDENTIFIERS = new Set(
   [
@@ -98,7 +98,7 @@ const REDACTED_IDENTIFIERS = new Set(
     ...config.dynamicInstrumentation.redactedIdentifiers
   ]
     .map((name) => normalizeName(name))
-    .filter((name) => excludedIdentifiers.includes(name) === false)
+    .filter((name) => excludedIdentifiers.has(name) === false)
 )
 
 function normalizeName (name, isSymbol) {

package/packages/dd-trace/src/debugger/devtools_client/source-maps.js

@@ -4,7 +4,6 @@ const { join, dirname } = require('path')
 const { readFileSync } = require('fs')
 const { readFile } = require('fs/promises')
 const { SourceMapConsumer } = require('source-map')
-const { NODE_MAJOR } = require('../../../../../version')
 
 const cache = new Map()
 let cacheTimer = null
@@ -35,14 +34,7 @@ const self = module.exports = {
   }
 }
 
-// The version check inside this function is to guard against a bug Node.js version 18, in which calls to `setTimeout`
-// might throw an uncatchable error from within `AsyncLocalStorage._propagate` with the following error message:
-//
-//     TypeError: Cannot read properties of undefined (reading 'Symbol(kResourceStore)')
-//
-// Source: https://github.com/nodejs/node/blob/v18.20.6/lib/async_hooks.js#L312
 function cacheIt (key, value) {
-  if (NODE_MAJOR < 20) return value
   cacheTime = Date.now()
   setCacheTTL()
   cache.set(key, value)
@@ -54,7 +46,7 @@ function setCacheTTL () {
 
   cacheTimer = setTimeout(function () {
     cacheTimer = null
-    if (Date.now() - cacheTime < 2_500) {
+    if (Date.now() - cacheTime < 2500) {
       // If the last cache entry was added recently, keep the cache alive
       setCacheTTL()
     } else {
@@ -62,7 +54,7 @@ function setCacheTTL () {
       // Clear cache a few seconds after it was last used
       cache.clear()
     }
-  }, 5_000).unref()
+  }, 5000).unref()
 }
 
 function loadInlineSourceMap (data) {

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const { join, dirname } = require('path')
+const { normalize } = require('source-map/lib/util')
 const { loadSourceMapSync } = require('./source-maps')
 const session = require('./session')
 const log = require('../../log')
@@ -92,7 +93,7 @@ module.exports = {
       }
     }
 
-    return maxMatchLength !== -1 ? bestMatch : null
+    return maxMatchLength === -1 ? null : bestMatch
   },
 
   getStackFromCallFrames (callFrames) {
@@ -102,7 +103,7 @@ module.exports = {
       // the `scriptUrls` map. That might result in this the `scriptUrls.get` call above returning `undefined`, which
       // will throw when `startsWith` is called on it.
       let fileName = scriptUrls.get(frame.location.scriptId)
-      if (fileName.startsWith('file://')) fileName = fileName.substr(7) // TODO: This might not be required
+      if (fileName.startsWith('file://')) fileName = fileName.slice(7) // TODO: This might not be required
       return {
         fileName,
         function: frame.functionName,
@@ -151,7 +152,13 @@ session.on('Debugger.scriptParsed', ({ params }) => {
           ...params,
           sourceUrl: params.url,
           url: new URL(join(dir, source), 'file:').href,
-          source
+          // The source url provided by V8 unfortunately doesn't always match the source url used internally in the
+          // `source-map` dependency. Both read the same source maps, but the `source-map` dependency iterates over all
+          // the `sources` and normalize them using an internal `normalize` function. If these two strings don't match,
+          // the `source-map` dependency will not be able to find the generated position. Below we use the same
+          // internal `normalize` function, to ensure compatibility.
+          // TODO: Consider swapping out the `source-map` dependency for something better so we don't have to do this.
+          source: normalize(source)
         })
       }
     } else {

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

@@ -94,13 +94,13 @@ class DogStatsDClient {
   }
 
   _sendUdp (queue) {
-    if (this._family !== 0) {
-      this._sendUdpFromQueue(queue, this._host, this._family)
-    } else {
+    if (this._family === 0) {
       lookup(this._host, (err, address, family) => {
         if (err) return log.error('DogStatsDClient: Host not found', err)
         this._sendUdpFromQueue(queue, address, family)
       })
+    } else {
+      this._sendUdpFromQueue(queue, this._host, this._family)
     }
   }
 
@@ -116,7 +116,8 @@ class DogStatsDClient {
   _add (stat, value, type, tags) {
     const message = `${this._prefix + stat}:${value}|${type}`
 
-    tags = tags ? this._tags.concat(tags) : this._tags
+    // Don't manipulate this._tags as it is still used
+    tags = tags ? [...this._tags, ...tags] : this._tags
 
     if (tags.length > 0) {
       this._write(`${message}|#${tags.join(',')}\n`)

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

@@ -13,11 +13,11 @@ function formatSpan (span, config) {
   span = normalizeSpan(truncateSpan(span, false))
   if (span.span_events) {
     // ensure span events are encoded as tags if agent doesn't support native top level span events
-    if (!config?.trace?.nativeSpanEvents) {
+    if (config?.trace?.nativeSpanEvents) {
+      formatSpanEvents(span)
+    } else {
       span.meta.events = JSON.stringify(span.span_events)
       delete span.span_events
-    } else {
-      formatSpanEvents(span)
     }
   }
   return span
@@ -175,7 +175,7 @@ class AgentEncoder {
 
     id = id.toArray()
 
-    bytes.buffer[offset] = 0xcf
+    bytes.buffer[offset] = 0xCF
     bytes.buffer[offset + 1] = id[0]
     bytes.buffer[offset + 2] = id[1]
     bytes.buffer[offset + 3] = id[2]
@@ -266,7 +266,7 @@ class AgentEncoder {
 
     // we should do it after encoding the object to know the real length
     const length = bytes.length - offset - prefixLength
-    bytes.buffer[offset] = 0xc6
+    bytes.buffer[offset] = 0xC6
     bytes.buffer[offset + 1] = length >> 24
     bytes.buffer[offset + 2] = length >> 16
     bytes.buffer[offset + 3] = length >> 8
@@ -326,7 +326,7 @@ class AgentEncoder {
   }
 
   _writeArrayPrefix (buffer, offset, count) {
-    buffer[offset++] = 0xdd
+    buffer[offset++] = 0xDD
     buffer.writeUInt32BE(count, offset)
 
     return offset + 4
@@ -351,10 +351,10 @@ function formatSpanEvents (span) {
     if (spanEvent.attributes) {
       for (const [key, value] of Object.entries(spanEvent.attributes)) {
         const newValue = convertSpanEventAttributeValues(key, value)
-        if (newValue !== undefined) {
-          spanEvent.attributes[key] = newValue
-        } else {
+        if (newValue === undefined) {
           delete spanEvent.attributes[key] // delete from attributes if undefined
+        } else {
+          spanEvent.attributes[key] = newValue
         }
       }
       if (Object.keys(spanEvent.attributes).length === 0) {

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

@@ -4,7 +4,7 @@ const { truncateSpan, normalizeSpan } = require('./tags-processors')
 const { AgentEncoder: BaseEncoder } = require('./0.4')
 
 const ARRAY_OF_TWO = 0x92
-const ARRAY_OF_TWELVE = 0x9c
+const ARRAY_OF_TWELVE = 0x9C
 
 function formatSpan (span) {
   span = normalizeSpan(truncateSpan(span, false))

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

@@ -11,7 +11,7 @@ const {
 } = require('../ci-visibility/telemetry')
 
 const ENCODING_VERSION = 1
-const ALLOWED_CONTENT_TYPES = ['test_session_end', 'test_module_end', 'test_suite_end', 'test']
+const ALLOWED_CONTENT_TYPES = new Set(['test_session_end', 'test_module_end', 'test_suite_end', 'test'])
 
 const TEST_SUITE_KEYS_LENGTH = 12
 const TEST_MODULE_KEYS_LENGTH = 11
@@ -26,7 +26,7 @@ function formatSpan (span) {
     encodingVersion = 2
   }
   return {
-    type: ALLOWED_CONTENT_TYPES.includes(span.type) ? span.type : 'span',
+    type: ALLOWED_CONTENT_TYPES.has(span.type) ? span.type : 'span',
     version: encodingVersion,
     content: normalizeSpan(truncateSpan(span))
   }
@@ -292,7 +292,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     const eventsOffset = this._eventsOffset
     const eventsCount = this._eventCount
 
-    bytes.buffer[eventsOffset] = 0xdd
+    bytes.buffer[eventsOffset] = 0xDD
     bytes.buffer[eventsOffset + 1] = eventsCount >> 24
     bytes.buffer[eventsOffset + 2] = eventsCount >> 16
     bytes.buffer[eventsOffset + 3] = eventsCount >> 8

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

@@ -92,7 +92,7 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
     const coveragesCount = this._coveragesCount
 
     // update with number of coverages
-    bytes.buffer[coveragesOffset] = 0xdd
+    bytes.buffer[coveragesOffset] = 0xDD
     bytes.buffer[coveragesOffset + 1] = coveragesCount >> 24
     bytes.buffer[coveragesOffset + 2] = coveragesCount >> 16
     bytes.buffer[coveragesOffset + 3] = coveragesCount >> 8

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

@@ -6,7 +6,7 @@ const MAX_RESOURCE_NAME_LENGTH = 5000
 // MAX_META_KEY_LENGTH the maximum length of metadata key
 const MAX_META_KEY_LENGTH = 200
 // MAX_META_VALUE_LENGTH the maximum length of metadata value
-const MAX_META_VALUE_LENGTH = 25000
+const MAX_META_VALUE_LENGTH = 25_000
 // MAX_METRIC_KEY_LENGTH the maximum length of a metric name key
 const MAX_METRIC_KEY_LENGTH = MAX_META_KEY_LENGTH
 

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

@@ -4,10 +4,7 @@ const exporters = require('../../../ext/exporters')
 const fs = require('fs')
 const constants = require('./constants')
 
-module.exports = name => {
-  const inAWSLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined
-  const usingLambdaExtension = inAWSLambda && fs.existsSync(constants.DATADOG_LAMBDA_EXTENSION_PATH)
-
+module.exports = function getExporter (name) {
   switch (name) {
     case exporters.LOG:
       return require('./exporters/log')
@@ -22,7 +19,10 @@ module.exports = name => {
     case exporters.MOCHA_WORKER:
     case exporters.PLAYWRIGHT_WORKER:
       return require('./ci-visibility/exporters/test-worker')
-    default:
-      return inAWSLambda && !usingLambdaExtension ? require('./exporters/log') : require('./exporters/agent')
+    default: {
+      const inAWSLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined
+      const usingLambdaExtension = inAWSLambda && fs.existsSync(constants.DATADOG_LAMBDA_EXTENSION_PATH)
+      return require(inAWSLambda && !usingLambdaExtension ? './exporters/log' : './exporters/agent')
+    }
   }
 }

package/packages/dd-trace/src/exporters/agent/writer.js

@@ -69,11 +69,7 @@ function setHeader (headers, key, value) {
 }
 
 function getEncoder (protocolVersion) {
-  if (protocolVersion === '0.5') {
-    return require('../../encode/0.5').AgentEncoder
-  } else {
-    return require('../../encode/0.4').AgentEncoder
-  }
+  return require(`../../encode/${protocolVersion === '0.5' ? '0.5' : '0.4'}`).AgentEncoder
 }
 
 function makeRequest (version, data, count, url, headers, lookup, needsStartupLog, cb) {