dd-trace 5.80.0 → 5.81.0

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

@@ -2,7 +2,7 @@
 
 const fs = require('fs')
 const os = require('os')
-const uuid = require('crypto-randomuuid') // we need to keep the old uuid dep because of cypress
+const uuid = require('../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
 const { URL } = require('url')
 
 const log = require('./log')
@@ -446,6 +446,7 @@ class Config {
       DD_DBM_PROPAGATION_MODE,
       DD_DOGSTATSD_HOST,
       DD_DOGSTATSD_PORT,
+      DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS,
       DD_DYNAMIC_INSTRUMENTATION_ENABLED,
       DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE,
       DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS,
@@ -453,6 +454,7 @@ class Config {
       DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS,
       DD_ENV,
       DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED,
+      DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED,
       DD_PROFILING_ENABLED,
       DD_GRPC_CLIENT_ERROR_STATUSES,
       DD_GRPC_SERVER_ERROR_STATUSES,
@@ -477,6 +479,7 @@ class Config {
       DD_INSTRUMENTATION_CONFIG_ID,
       DD_LOGS_INJECTION,
       DD_LOGS_OTEL_ENABLED,
+      DD_METRICS_OTEL_ENABLED,
       DD_LANGCHAIN_SPAN_CHAR_LIMIT,
       DD_LANGCHAIN_SPAN_PROMPT_COMPLETION_SAMPLE_RATE,
       DD_LLMOBS_AGENTLESS_ENABLED,
@@ -543,6 +546,7 @@ class Config {
       DD_TRACE_RATE_LIMIT,
       DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED,
       DD_TRACE_REPORT_HOSTNAME,
+      DD_TRACE_RESOURCE_RENAMING_ENABLED,
       DD_TRACE_SAMPLE_RATE,
       DD_TRACE_SAMPLING_RULES,
       DD_TRACE_SCOPE,
@@ -571,12 +575,20 @@ class Config {
       OTEL_EXPORTER_OTLP_LOGS_HEADERS,
       OTEL_EXPORTER_OTLP_LOGS_PROTOCOL,
       OTEL_EXPORTER_OTLP_LOGS_TIMEOUT,
+      OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
+      OTEL_EXPORTER_OTLP_METRICS_HEADERS,
+      OTEL_EXPORTER_OTLP_METRICS_PROTOCOL,
+      OTEL_EXPORTER_OTLP_METRICS_TIMEOUT,
+      OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE,
+      OTEL_METRIC_EXPORT_TIMEOUT,
       OTEL_EXPORTER_OTLP_PROTOCOL,
       OTEL_EXPORTER_OTLP_ENDPOINT,
       OTEL_EXPORTER_OTLP_HEADERS,
       OTEL_EXPORTER_OTLP_TIMEOUT,
       OTEL_BSP_SCHEDULE_DELAY,
-      OTEL_BSP_MAX_EXPORT_BATCH_SIZE
+      OTEL_BSP_MAX_EXPORT_BATCH_SIZE,
+      OTEL_BSP_MAX_QUEUE_SIZE,
+      OTEL_METRIC_EXPORT_INTERVAL
     } = source
 
     const tags = {}
@@ -603,16 +615,51 @@ class Config {
     this.#setString(target, 'otelLogsHeaders', OTEL_EXPORTER_OTLP_LOGS_HEADERS || target.otelHeaders)
     this.#setString(target, 'otelProtocol', OTEL_EXPORTER_OTLP_PROTOCOL)
     this.#setString(target, 'otelLogsProtocol', OTEL_EXPORTER_OTLP_LOGS_PROTOCOL || target.otelProtocol)
-    target.otelTimeout = maybeInt(OTEL_EXPORTER_OTLP_TIMEOUT)
-    target.otelLogsTimeout = maybeInt(OTEL_EXPORTER_OTLP_LOGS_TIMEOUT) || target.otelTimeout
-    target.otelLogsBatchTimeout = maybeInt(OTEL_BSP_SCHEDULE_DELAY)
-    target.otelLogsMaxExportBatchSize = maybeInt(OTEL_BSP_MAX_EXPORT_BATCH_SIZE)
+    const otelTimeout = nonNegInt(OTEL_EXPORTER_OTLP_TIMEOUT, 'OTEL_EXPORTER_OTLP_TIMEOUT')
+    if (otelTimeout !== undefined) {
+      target.otelTimeout = otelTimeout
+    }
+    const otelLogsTimeout = nonNegInt(OTEL_EXPORTER_OTLP_LOGS_TIMEOUT, 'OTEL_EXPORTER_OTLP_LOGS_TIMEOUT')
+    target.otelLogsTimeout = otelLogsTimeout === undefined ? target.otelTimeout : otelLogsTimeout
+    const otelBatchTimeout = nonNegInt(OTEL_BSP_SCHEDULE_DELAY, 'OTEL_BSP_SCHEDULE_DELAY', false)
+    if (otelBatchTimeout !== undefined) {
+      target.otelBatchTimeout = otelBatchTimeout
+    }
+    target.otelMaxExportBatchSize = nonNegInt(OTEL_BSP_MAX_EXPORT_BATCH_SIZE, 'OTEL_BSP_MAX_EXPORT_BATCH_SIZE', false)
+    target.otelMaxQueueSize = nonNegInt(OTEL_BSP_MAX_QUEUE_SIZE, 'OTEL_BSP_MAX_QUEUE_SIZE', false)
+
+    const otelMetricsExporterEnabled = OTEL_METRICS_EXPORTER?.toLowerCase() !== 'none'
+    this.#setBoolean(
+      target,
+      'otelMetricsEnabled',
+      DD_METRICS_OTEL_ENABLED && isTrue(DD_METRICS_OTEL_ENABLED) && otelMetricsExporterEnabled
+    )
+    // Set OpenTelemetry metrics configuration with specific _METRICS_ vars
+    // taking precedence over generic _EXPORTERS_ vars
+    if (OTEL_EXPORTER_OTLP_ENDPOINT || OTEL_EXPORTER_OTLP_METRICS_ENDPOINT) {
+      this.#setString(target, 'otelMetricsUrl', OTEL_EXPORTER_OTLP_METRICS_ENDPOINT || target.otelUrl)
+    }
+    this.#setString(target, 'otelMetricsHeaders', OTEL_EXPORTER_OTLP_METRICS_HEADERS || target.otelHeaders)
+    this.#setString(target, 'otelMetricsProtocol', OTEL_EXPORTER_OTLP_METRICS_PROTOCOL || target.otelProtocol)
+    const otelMetricsTimeout = nonNegInt(OTEL_EXPORTER_OTLP_METRICS_TIMEOUT, 'OTEL_EXPORTER_OTLP_METRICS_TIMEOUT')
+    target.otelMetricsTimeout = otelMetricsTimeout === undefined ? target.otelTimeout : otelMetricsTimeout
+    target.otelMetricsExportTimeout = nonNegInt(OTEL_METRIC_EXPORT_TIMEOUT, 'OTEL_METRIC_EXPORT_TIMEOUT')
+    target.otelMetricsExportInterval = nonNegInt(OTEL_METRIC_EXPORT_INTERVAL, 'OTEL_METRIC_EXPORT_INTERVAL', false)
+
+    // Parse temporality preference (default to DELTA for Datadog)
+    if (OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE) {
+      const temporalityPref = OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE.toUpperCase()
+      if (['DELTA', 'CUMULATIVE', 'LOWMEMORY'].includes(temporalityPref)) {
+        this.#setString(target, 'otelMetricsTemporalityPreference', temporalityPref)
+      }
+    }
     this.#setBoolean(
       target,
       'apmTracingEnabled',
       DD_APM_TRACING_ENABLED ??
         (DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED && isFalse(DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED))
     )
+    this.#setBoolean(target, 'propagateProcessTags.enabled', DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED)
     this.#setString(target, 'appKey', DD_APP_KEY)
     this.#setBoolean(target, 'appsec.apiSecurity.enabled', DD_API_SECURITY_ENABLED && isTrue(DD_API_SECURITY_ENABLED))
     target['appsec.apiSecurity.sampleDelay'] = maybeFloat(DD_API_SECURITY_SAMPLE_DELAY)
@@ -684,6 +731,8 @@ class Config {
     this.#setString(target, 'dogstatsd.hostname', DD_DOGSTATSD_HOST)
     this.#setString(target, 'dogstatsd.port', DD_DOGSTATSD_PORT)
     this.#setBoolean(target, 'dsmEnabled', DD_DATA_STREAMS_ENABLED)
+    target['dynamicInstrumentation.captureTimeoutMs'] = maybeInt(DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS)
+    unprocessedTarget['dynamicInstrumentation.captureTimeoutMs'] = DD_DYNAMIC_INSTRUMENTATION_CAPTURE_TIMEOUT_MS
     this.#setBoolean(target, 'dynamicInstrumentation.enabled', DD_DYNAMIC_INSTRUMENTATION_ENABLED)
     this.#setString(target, 'dynamicInstrumentation.probeFile', DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE)
     this.#setArray(target, 'dynamicInstrumentation.redactedIdentifiers',
@@ -787,6 +836,9 @@ class Config {
     target['remoteConfig.pollInterval'] = maybeFloat(DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS)
     unprocessedTarget['remoteConfig.pollInterval'] = DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS
     this.#setBoolean(target, 'reportHostname', DD_TRACE_REPORT_HOSTNAME)
+    if (DD_TRACE_RESOURCE_RENAMING_ENABLED !== undefined) {
+      this.#setBoolean(target, 'resourceRenamingEnabled', DD_TRACE_RESOURCE_RENAMING_ENABLED)
+    }
     // only used to explicitly set runtimeMetrics to false
     const otelSetRuntimeMetrics = String(OTEL_METRICS_EXPORTER).toLowerCase() === 'none'
       ? false
@@ -984,6 +1036,8 @@ class Config {
       this.#setString(opts, 'dogstatsd.port', options.dogstatsd.port)
     }
     this.#setBoolean(opts, 'dsmEnabled', options.dsmEnabled)
+    opts['dynamicInstrumentation.captureTimeoutMs'] = maybeInt(options.dynamicInstrumentation?.captureTimeoutMs)
+    this.#optsUnprocessed['dynamicInstrumentation.captureTimeoutMs'] = options.dynamicInstrumentation?.captureTimeoutMs
     this.#setBoolean(opts, 'dynamicInstrumentation.enabled', options.dynamicInstrumentation?.enabled)
     this.#setString(opts, 'dynamicInstrumentation.probeFile', options.dynamicInstrumentation?.probeFile)
     this.#setArray(
@@ -1201,14 +1255,24 @@ class Config {
 
     calc['dogstatsd.hostname'] = this.#getHostname()
 
-    // Compute OTLP logs URL to send payloads to the active Datadog Agent
+    // Compute OTLP logs and metrics URLs to send payloads to the active Datadog Agent
     const agentHostname = this.#getHostname()
     calc.otelLogsUrl = `http://${agentHostname}:${DEFAULT_OTLP_PORT}`
+    calc.otelMetricsUrl = `http://${agentHostname}:${DEFAULT_OTLP_PORT}/v1/metrics`
     calc.otelUrl = `http://${agentHostname}:${DEFAULT_OTLP_PORT}`
 
     this.#setBoolean(calc, 'isGitUploadEnabled',
       calc.isIntelligentTestRunnerEnabled && !isFalse(getEnv('DD_CIVISIBILITY_GIT_UPLOAD_ENABLED')))
 
+    // Enable resourceRenamingEnabled when appsec is enabled and only
+    // if DD_TRACE_RESOURCE_RENAMING_ENABLED is not explicitly set
+    if (this.#env.resourceRenamingEnabled === undefined) {
+      const appsecEnabled = this.#options['appsec.enabled'] ?? this.#env['appsec.enabled']
+      if (appsecEnabled) {
+        this.#setBoolean(calc, 'resourceRenamingEnabled', true)
+      }
+    }
+
     this.#setBoolean(calc, 'spanComputePeerService', this.#getSpanComputePeerService())
     this.#setBoolean(calc, 'stats.enabled', this.#isTraceStatsComputationEnabled())
     const defaultPropagationStyle = this.#getDefaultPropagationStyle(this.#optionsArg)
@@ -1492,6 +1556,16 @@ function maybeFloat (number) {
   return Number.isNaN(parsed) ? undefined : parsed
 }
 
+function nonNegInt (value, envVarName, allowZero = true) {
+  if (value === undefined) return
+  const parsed = Number.parseInt(value)
+  if (Number.isNaN(parsed) || parsed < 0 || (parsed === 0 && !allowZero)) {
+    log.warn(`Invalid value ${parsed} for ${envVarName}. Using default value.`)
+    return
+  }
+  return parsed
+}
+
 function getAgentUrl (url, options) {
   if (url) return new URL(url)
 

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

@@ -63,6 +63,7 @@ module.exports = {
   'dogstatsd.hostname': '127.0.0.1',
   'dogstatsd.port': '8125',
   dsmEnabled: false,
+  'dynamicInstrumentation.captureTimeoutMs': 15,
   'dynamicInstrumentation.enabled': false,
   'dynamicInstrumentation.probeFile': undefined,
   'dynamicInstrumentation.redactedIdentifiers': [],
@@ -139,8 +140,17 @@ module.exports = {
   otelLogsProtocol: 'http/protobuf',
   otelLogsTimeout: 10_000,
   otelTimeout: 10_000,
-  otelLogsBatchTimeout: 5000,
-  otelLogsMaxExportBatchSize: 512,
+  otelBatchTimeout: 5000,
+  otelMaxExportBatchSize: 512,
+  otelMaxQueueSize: 2048,
+  otelMetricsEnabled: false,
+  otelMetricsUrl: undefined, // Will be computed using agent host
+  otelMetricsHeaders: '',
+  otelMetricsProtocol: 'http/protobuf',
+  otelMetricsTimeout: 10_000,
+  otelMetricsExportTimeout: 7500,
+  otelMetricsExportInterval: 10_000,
+  otelMetricsTemporalityPreference: 'DELTA', // DELTA, CUMULATIVE, or LOWMEMORY
   lookup: undefined,
   inferredProxyServicesEnabled: false,
   memcachedCommandEnabled: false,
@@ -151,6 +161,7 @@ module.exports = {
   plugins: true,
   port: '8126',
   'profiling.enabled': undefined,
+  'propagateProcessTags.enabled': undefined,
   'profiling.exporters': 'agent',
   'profiling.sourceMap': true,
   'profiling.longLivedThreshold': undefined,
@@ -159,6 +170,7 @@ module.exports = {
   'remoteConfig.enabled': true,
   'remoteConfig.pollInterval': 5, // seconds
   reportHostname: false,
+  resourceRenamingEnabled: false,
   'runtimeMetrics.enabled': false,
   'runtimeMetrics.eventLoop': true,
   'runtimeMetrics.gc': true,

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

@@ -1,11 +1,15 @@
 'use strict'
 
-// encodes positive and negative numbers, using zig zag encoding to reduce the size of the variable length encoding.
-// uses high and low part to ensure those parts are under the limit for byte operations in javascript (32 bits)
-// maximum number possible to encode is MAX_SAFE_INTEGER/2 (using zig zag shifts the bits by 1 to the left)
+/**
+ * Encodes positive and negative numbers, using zig zag encoding to reduce the size of the variable length encoding.
+ * Uses high and low part to ensure those parts are under the limit for byte operations in javascript (32 bits)
+ * Maximum number possible to encode is MAX_SAFE_INTEGER/2 (using zig zag shifts the bits by 1 to the left)
+ * @param {number} v
+ * @returns {Uint8Array|undefined}
+ */
 function encodeVarint (v) {
   const sign = v >= 0 ? 0 : 1
-  // we leave the least significant bit for the sign.
+  // We leave the least significant bit for the sign.
   const double = Math.abs(v) * 2
   if (double > Number.MAX_SAFE_INTEGER) {
     return
@@ -15,8 +19,12 @@ function encodeVarint (v) {
   return encodeUvarint64(low, high)
 }
 
-// decodes positive and negative numbers, using zig zag encoding to reduce the size of the variable length encoding.
-// uses high and low part to ensure those parts are under the limit for byte operations in javascript (32 bits)
+/**
+ * Decodes positive and negative numbers, using zig zag encoding to reduce the size of the variable length encoding.
+ * Uses high and low part to ensure those parts are under the limit for byte operations in javascript (32 bits)
+ * @param {Uint8Array} b
+ * @returns {[number|undefined, Uint8Array]}
+ */
 function decodeVarint (b) {
   const [low, high, bytes] = decodeUvarint64(b)
   if (low === undefined || high === undefined) {
@@ -29,6 +37,11 @@ function decodeVarint (b) {
 
 const maxVarLen64 = 9
 
+/**
+ * @param {number} low
+ * @param {number} high
+ * @returns {Uint8Array}
+ */
 function encodeUvarint64 (low, high) {
   const result = new Uint8Array(maxVarLen64)
   let i = 0
@@ -44,6 +57,10 @@ function encodeUvarint64 (low, high) {
   return result.slice(0, i + 1)
 }
 
+/**
+ * @param {Uint8Array} bytes
+ * @returns {[number|undefined, number|undefined, Uint8Array]}
+ */
 function decodeUvarint64 (
   bytes
 ) {

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

@@ -5,7 +5,7 @@
 // this inconsistency is ok because hashes do not need to be consistent across services
 const crypto = require('crypto')
 const { encodeVarint, decodeVarint } = require('./encoding')
-const { LRUCache } = require('lru-cache')
+const { LRUCache } = require('../../../../vendor/dist/lru-cache')
 const log = require('../log')
 const pick = require('../../../datadog-core/src/utils/src/pick')
 
@@ -21,6 +21,12 @@ function shaHash (checkpointString) {
   return Buffer.from(hash, 'hex')
 }
 
+/**
+ * @param {string} service
+ * @param {string} env
+ * @param {string[]} edgeTags
+ * @param {Buffer} parentHash
+ */
 function computeHash (service, env, edgeTags, parentHash) {
   edgeTags.sort()
   const hashableEdgeTags = edgeTags.filter(item => item !== 'manual_checkpoint:true')
@@ -37,6 +43,13 @@ function computeHash (service, env, edgeTags, parentHash) {
   return value
 }
 
+/**
+ * @param {Object} dataStreamsContext
+ * @param {Buffer} dataStreamsContext.hash
+ * @param {number} dataStreamsContext.pathwayStartNs
+ * @param {number} dataStreamsContext.edgeStartNs
+ * @returns {Buffer}
+ */
 function encodePathwayContext (dataStreamsContext) {
   return Buffer.concat([
     dataStreamsContext.hash,
@@ -45,11 +58,22 @@ function encodePathwayContext (dataStreamsContext) {
   ], 20)
 }
 
+/**
+ * @param {Object} dataStreamsContext
+ * @param {Buffer} dataStreamsContext.hash
+ * @param {number} dataStreamsContext.pathwayStartNs
+ * @param {number} dataStreamsContext.edgeStartNs
+ * @returns {string}
+ */
 function encodePathwayContextBase64 (dataStreamsContext) {
   const encodedPathway = encodePathwayContext(dataStreamsContext)
   return encodedPathway.toString('base64')
 }
 
+/**
+ * @param {Buffer} pathwayContext
+ * @returns {Object}
+ */
 function decodePathwayContext (pathwayContext) {
   if (pathwayContext == null || pathwayContext.length < 8) {
     return null
@@ -68,6 +92,10 @@ function decodePathwayContext (pathwayContext) {
   return { hash: pathwayHash, pathwayStartNs: pathwayStartMs * 1e6, edgeStartNs: edgeStartMs * 1e6 }
 }
 
+/**
+ * @param {string} pathwayContext
+ * @returns {ReturnType<typeof decodePathwayContext>|undefined}
+ */
 function decodePathwayContextBase64 (pathwayContext) {
   if (pathwayContext == null || pathwayContext.length < 8) {
     return
@@ -82,6 +110,13 @@ function decodePathwayContextBase64 (pathwayContext) {
 const DsmPathwayCodec = {
   // we use a class for encoding / decoding in case we update our encoding/decoding. A class will make updates easier
   // instead of using individual functions.
+  /**
+   * @param {Object} dataStreamsContext
+   * @param {Buffer} dataStreamsContext.hash
+   * @param {number} dataStreamsContext.pathwayStartNs
+   * @param {number} dataStreamsContext.edgeStartNs
+   * @param {Object} carrier
+   */
   encode (dataStreamsContext, carrier) {
     if (!dataStreamsContext || !dataStreamsContext.hash) {
       return
@@ -91,6 +126,10 @@ const DsmPathwayCodec = {
     log.debug(() => `Injected into DSM carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
   },
 
+  /**
+   * @param {Object} carrier
+   * @returns {ReturnType<typeof decodePathwayContext>|undefined}
+   */
   decode (carrier) {
     log.debug(() => `Attempting extract from DSM carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
 

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

@@ -3,7 +3,7 @@
 const os = require('os')
 const pkg = require('../../../../package.json')
 
-const { LogCollapsingLowestDenseDDSketch } = require('@datadog/sketches-js')
+const { LogCollapsingLowestDenseDDSketch } = require('../../../../vendor/dist/@datadog/sketches-js')
 const { DsmPathwayCodec } = require('./pathway')
 const { DataStreamsWriter } = require('./writer')
 const { computePathwayHash } = require('./pathway')

package/packages/dd-trace/src/datastreams/schemas/schema_builder.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { LRUCache } = require('lru-cache')
+const { LRUCache } = require('../../../../../vendor/dist/lru-cache')
 const { fnv64 } = require('../fnv')
 const { Schema } = require('./schema')
 

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const mutex = require('mutexify/promise')()
+const mutex = require('../../../../../vendor/dist/mutexify/promise')()
 const { getGeneratedPosition } = require('./source-maps')
 const session = require('./session')
 const { compile: compileCondition, compileSegments, templateRequiresEvaluation } = require('./condition')
@@ -64,8 +64,9 @@ async function addBreakpoint (probe) {
   const snapshotsPerSecond = probe.sampling?.snapshotsPerSecond ?? (probe.captureSnapshot
     ? MAX_SNAPSHOTS_PER_SECOND_PER_PROBE
     : MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE)
-  probe.nsBetweenSampling = BigInt(1 / snapshotsPerSecond * 1e9)
-  probe.lastCaptureNs = 0n
+  probe.nsBetweenSampling = BigInt(Math.trunc(1 / snapshotsPerSecond * 1e9))
+  // Initialize to a large negative value to ensure first probe hit is always captured
+  probe.lastCaptureNs = BigInt(Number.MIN_SAFE_INTEGER)
 
   // Warning: The code below relies on undocumented behavior of the inspector!
   // It expects that `await session.post('Debugger.enable')` will wait for all loaded scripts to be emitted as
@@ -80,8 +81,17 @@ async function addBreakpoint (probe) {
     log.debug(
       '[debugger:devtools_client] Translating location using source map for %s:%d:%d (probe: %s, version: %d)',
       file, lineNumber, columnNumber, probe.id, probe.version
-    );
-    ({ line: lineNumber, column: columnNumber } = await getGeneratedPosition(url, source, lineNumber, sourceMapURL))
+    )
+    const position = await getGeneratedPosition(url, source, lineNumber, sourceMapURL)
+    if (position.line !== null && position.column !== null) {
+      lineNumber = position.line
+      columnNumber = position.column
+    } else {
+      throw new Error(
+        // eslint-disable-next-line @stylistic/max-len
+        `Could not find generated position for ${url}:${lineNumber}:${columnNumber} (probe: ${probe.id}, version: ${probe.version})`
+      )
+    }
   }
 
   try {

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

@@ -33,7 +33,7 @@ const reservedWords = new Set([
   // Future reserved words in strict mode
   'implements', 'interface', 'package', 'private', 'protected', 'public',
 
-  // Litterals
+  // Literals
   'NaN'
 ])
 

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

@@ -24,4 +24,6 @@ function updateUrl (updates) {
     hostname: updates.hostname || defaults.hostname,
     port: updates.port
   })
+
+  config.dynamicInstrumentation.captureTimeoutNs = BigInt(updates.dynamicInstrumentation.captureTimeoutMs) * 1_000_000n
 }

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

@@ -7,7 +7,7 @@ const { getLocalStateForCallFrame } = require('./snapshot')
 const send = require('./send')
 const { getStackFromCallFrames } = require('./state')
 const { ackEmitting } = require('./status')
-const { parentThreadId } = require('./config')
+const config = require('./config')
 const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./defaults')
 const log = require('./log')
 const { version } = require('../../../../../package.json')
@@ -33,8 +33,8 @@ const getDDTagsExpression = `(() => {
 
 // There doesn't seem to be an official standard for the content of these fields, so we're just populating them with
 // something that should be useful to a Node.js developer.
-const threadId = parentThreadId === 0 ? `pid:${process.pid}` : `pid:${process.pid};tid:${parentThreadId}`
-const threadName = parentThreadId === 0 ? 'MainThread' : `WorkerThread:${parentThreadId}`
+const threadId = config.parentThreadId === 0 ? `pid:${process.pid}` : `pid:${process.pid};tid:${config.parentThreadId}`
+const threadName = config.parentThreadId === 0 ? 'MainThread' : `WorkerThread:${config.parentThreadId}`
 
 const SUPPORT_ARRAY_BUFFER_RESIZE = NODE_MAJOR >= 20
 const oneSecondNs = 1_000_000_000n
@@ -46,6 +46,7 @@ let snapshotProbeIndexBuffer, snapshotProbeIndex
 
 if (SUPPORT_ARRAY_BUFFER_RESIZE) {
   // TODO: Is a limit of 256 snapshots ever going to be a problem?
+  // @ts-ignore - ArrayBuffer constructor with maxByteLength is available in Node.js 20+ but not in @types/node@18
   // eslint-disable-next-line n/no-unsupported-features/es-syntax
   snapshotProbeIndexBuffer = new ArrayBuffer(1, { maxByteLength: 256 })
   // TODO: Is a limit of 256 probes ever going to be a problem?
@@ -165,13 +166,20 @@ session.on('Debugger.paused', async ({ params }) => {
   }
 
   // TODO: Create unique states for each affected probe based on that probes unique `capture` settings (DEBUG-2863)
-  const processLocalState = numberOfProbesWithSnapshots !== 0 && await getLocalStateForCallFrame(
-    params.callFrames[0],
-    { maxReferenceDepth, maxCollectionSize, maxFieldCount, maxLength }
-  )
+  let processLocalState, captureErrors
+  if (numberOfProbesWithSnapshots !== 0) {
+    const opts = {
+      maxReferenceDepth,
+      maxCollectionSize,
+      maxFieldCount,
+      maxLength,
+      deadlineNs: start + config.dynamicInstrumentation.captureTimeoutNs
+    }
+    ;({ processLocalState, captureErrors } = await getLocalStateForCallFrame(params.callFrames[0], opts))
+  }
 
   await session.post('Debugger.resume')
-  const diff = process.hrtime.bigint() - start // TODO: Recored as telemetry (DEBUG-2858)
+  const diff = process.hrtime.bigint() - start // TODO: Recorded as telemetry (DEBUG-2858)
 
   // This doesn't measure the overhead of the CDP protocol. The actual pause time is slightly larger.
   // On my machine I'm seeing around 1.7ms of overhead.
@@ -208,14 +216,21 @@ session.on('Debugger.paused', async ({ params }) => {
     }
 
     if (probe.captureSnapshot) {
-      const state = processLocalState()
-      if (state instanceof Error) {
-        snapshot.captureError = state.message
-      } else if (state) {
-        snapshot.captures = {
-          lines: { [probe.location.lines[0]]: { locals: state } }
-        }
+      if (captureErrors?.length > 0) {
+        // There was an error collecting the snapshot for this probe, let's not try again
+        probe.captureSnapshot = false
+        probe.permanentEvaluationErrors = captureErrors.map(error => ({
+          expr: '',
+          message: error.message
+        }))
       }
+      snapshot.captures = {
+        lines: { [probe.location.lines[0]]: { locals: processLocalState() } }
+      }
+    }
+
+    if (probe.permanentEvaluationErrors !== undefined) {
+      snapshot.evaluationErrors = [...probe.permanentEvaluationErrors]
     }
 
     let message = ''

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

@@ -5,6 +5,7 @@
 const { builtinModules } = require('node:module')
 
 if (builtinModules.includes('inspector/promises')) {
+  // @ts-ignore - inspector/promises is available in Node.js 20+ but not in @types/node@18
   module.exports = require('node:inspector/promises')
 } else {
   const inspector = require('node:inspector')
@@ -12,6 +13,7 @@ if (builtinModules.includes('inspector/promises')) {
 
   // The rest of the code in this file is lifted from:
   // https://github.com/nodejs/node/blob/1d4d76ff3fb08f9a0c55a1d5530b46c4d5d550c7/lib/inspector/promises.js
+  // @ts-expect-error - We intentionally override 'post' with a promisified version, changing its signature
   class Session extends inspector.Session {
     constructor () { super() } // eslint-disable-line no-useless-constructor
   }

package/packages/dd-trace/src/debugger/devtools_client/json-buffer.js

@@ -1,34 +1,40 @@
 'use strict'
 
 class JSONBuffer {
+  #maxSize
+  #timeout
+  #onFlush
+  #timer
+  #partialJson
+
   constructor ({ size, timeout, onFlush }) {
-    this._maxSize = size
-    this._timeout = timeout
-    this._onFlush = onFlush
-    this._reset()
+    this.#maxSize = size
+    this.#timeout = timeout
+    this.#onFlush = onFlush
+    this.#reset()
   }
 
-  _reset () {
-    clearTimeout(this._timer)
-    this._timer = null
-    this._partialJson = null
+  #reset () {
+    clearTimeout(this.#timer)
+    this.#timer = undefined
+    this.#partialJson = undefined
   }
 
-  _flush () {
-    const json = `${this._partialJson}]`
-    this._reset()
-    this._onFlush(json)
+  #flush () {
+    const json = `${this.#partialJson}]`
+    this.#reset()
+    this.#onFlush(json)
   }
 
   write (str, size = Buffer.byteLength(str)) {
-    if (this._timer === null) {
-      this._partialJson = `[${str}`
-      this._timer = setTimeout(() => this._flush(), this._timeout)
-    } else if (Buffer.byteLength(this._partialJson) + size + 2 > this._maxSize) {
-      this._flush()
+    if (this.#timer === undefined) {
+      this.#partialJson = `[${str}`
+      this.#timer = setTimeout(() => this.#flush(), this.#timeout)
+    } else if (Buffer.byteLength(/** @type {string} */ (this.#partialJson)) + size + 2 > this.#maxSize) {
+      this.#flush()
       this.write(str, size)
     } else {
-      this._partialJson += `,${str}`
+      this.#partialJson += `,${str}`
     }
   }
 }

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

@@ -10,6 +10,7 @@ const { GIT_COMMIT_SHA, GIT_REPOSITORY_URL } = require('../../plugins/util/tags'
 const log = require('./log')
 const { version } = require('../../../../../package.json')
 const { getEnvironmentVariable } = require('../../config-helper')
+const { pruneSnapshot } = require('./snapshot-pruner')
 
 module.exports = send
 
@@ -55,14 +56,23 @@ function send (message, logger, dd, snapshot) {
   let size = Buffer.byteLength(json)
 
   if (size > MAX_LOG_PAYLOAD_SIZE_BYTES) {
-    // TODO: This is a very crude way to handle large payloads. Proper pruning will be implemented later (DEBUG-2624)
-    delete payload.debugger.snapshot.captures
-    payload.debugger.snapshot.captureError =
-      `Snapshot was too large (max allowed size is ${MAX_LOG_PAYLOAD_SIZE_MB} MiB). ` +
-      'Consider reducing the capture depth or turn off "Capture Variables" completely, ' +
-      'and instead include the variables of interest directly in the message template.'
-    json = JSON.stringify(payload)
-    size = Buffer.byteLength(json)
+    let pruned
+    try {
+      pruned = pruneSnapshot(json, size, MAX_LOG_PAYLOAD_SIZE_BYTES)
+    } catch (err) {
+      log.error('[debugger:devtools_client] Error pruning snapshot', err)
+    }
+
+    if (pruned) {
+      json = pruned
+      size = Buffer.byteLength(json)
+    } else {
+      // Fallback if pruning fails
+      const line = Object.keys(snapshot.captures.lines)[0]
+      snapshot.captures.lines[line] = { pruned: true }
+      json = JSON.stringify(payload)
+      size = Buffer.byteLength(json)
+    }
   }
 
   jsonBuffer.write(json, size)