dd-trace 5.83.0 → 5.85.0

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

@@ -16,6 +16,8 @@ const log = require('./log')
 
 require('./remote_config')
 
+/** @typedef {import('node:inspector').Debugger.EvaluateOnCallFrameReturnType} EvaluateOnCallFrameResult */
+
 // Expression to run on a call frame of the paused thread to get its active trace and span id.
 const templateExpressionSetupCode = `
   const $dd_inspect = global.require('node:util').inspect;
@@ -115,21 +117,23 @@ session.on('Debugger.paused', async ({ params }) => {
         }
 
         snapshotProbeIndex[numberOfProbesWithSnapshots++] = probes.length
-        maxReferenceDepth = highestOrUndefined(probe.capture.maxReferenceDepth, maxReferenceDepth)
-        maxCollectionSize = highestOrUndefined(probe.capture.maxCollectionSize, maxCollectionSize)
-        maxFieldCount = highestOrUndefined(probe.capture.maxFieldCount, maxFieldCount)
-        maxLength = highestOrUndefined(probe.capture.maxLength, maxLength)
+        maxReferenceDepth = highestOrUndefined(probe.capture?.maxReferenceDepth, maxReferenceDepth)
+        maxCollectionSize = highestOrUndefined(probe.capture?.maxCollectionSize, maxCollectionSize)
+        maxFieldCount = highestOrUndefined(probe.capture?.maxFieldCount, maxFieldCount)
+        maxLength = highestOrUndefined(probe.capture?.maxLength, maxLength)
       }
 
       if (probe.condition !== undefined) {
         // TODO: Bundle all conditions and evaluate them in a single call
         // TODO: Handle errors
-        // eslint-disable-next-line no-await-in-loop
-        const { result } = await session.post('Debugger.evaluateOnCallFrame', {
-          callFrameId: params.callFrames[0].callFrameId,
-          expression: probe.condition,
-          returnByValue: true
-        })
+        const { result } = /** @type {EvaluateOnCallFrameResult} */ (
+          // eslint-disable-next-line no-await-in-loop
+          await session.post('Debugger.evaluateOnCallFrame', {
+            callFrameId: params.callFrames[0].callFrameId,
+            expression: probe.condition,
+            returnByValue: true,
+          })
+        )
         if (result.value !== true) continue
       }
 
@@ -151,14 +155,16 @@ session.on('Debugger.paused', async ({ params }) => {
   const timestamp = Date.now()
 
   let evalResults
-  const { result } = await session.post('Debugger.evaluateOnCallFrame', {
-    callFrameId: params.callFrames[0].callFrameId,
-    expression: templateExpressions.length === 0
-      ? `[${getDDTagsExpression}]`
-      : `${templateExpressionSetupCode}[${getDDTagsExpression}${templateExpressions}]`,
-    returnByValue: true,
-    includeCommandLineAPI: true
-  })
+  const { result } = /** @type {EvaluateOnCallFrameResult} */ (
+    await session.post('Debugger.evaluateOnCallFrame', {
+      callFrameId: params.callFrames[0].callFrameId,
+      expression: templateExpressions.length === 0
+        ? `[${getDDTagsExpression}]`
+        : `${templateExpressionSetupCode}[${getDDTagsExpression}${templateExpressions}]`,
+      returnByValue: true,
+      includeCommandLineAPI: true,
+    })
+  )
   if (result?.subtype === 'error') {
     log.error('[debugger:devtools_client] Error evaluating code on call frame: %s', result?.description)
     evalResults = []
@@ -174,7 +180,7 @@ session.on('Debugger.paused', async ({ params }) => {
       maxCollectionSize,
       maxFieldCount,
       maxLength,
-      deadlineNs: start + config.dynamicInstrumentation.captureTimeoutNs
+      deadlineNs: start + config.dynamicInstrumentation.captureTimeoutNs,
     }
     ;({ processLocalState, captureErrors } = await getLocalStateForCallFrame(params.callFrames[0], opts))
   }
@@ -184,6 +190,7 @@ session.on('Debugger.paused', async ({ params }) => {
 
   // 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.
+  // eslint-disable-next-line eslint-rules/eslint-log-printf-style
   log.debug(() => `[debugger:devtools_client] Finished processing breakpoints - main thread paused for: ~${
     Number(diff) / 1_000_000
   } ms`)
@@ -195,10 +202,10 @@ session.on('Debugger.paused', async ({ params }) => {
     method: params.callFrames[0].functionName, // name of the method/function emitting the snapshot
     version,
     thread_id: threadId,
-    thread_name: threadName
+    thread_name: threadName,
   }
 
-  const stack = getStackFromCallFrames(params.callFrames)
+  const stack = await getStackFromCallFrames(params.callFrames)
   const dd = processDD(evalResults[0]) // the first result is the dd tags, the rest are the probe template results
   let messageIndex = 1
 
@@ -210,10 +217,10 @@ session.on('Debugger.paused', async ({ params }) => {
       probe: {
         id: probe.id,
         version: probe.version,
-        location: probe.location
+        location: probe.location,
       },
       stack,
-      language: 'javascript'
+      language: 'javascript',
     }
 
     if (config.propagateProcessTags.enabled) {
@@ -226,11 +233,11 @@ session.on('Debugger.paused', async ({ params }) => {
         probe.captureSnapshot = false
         probe.permanentEvaluationErrors = captureErrors.map(error => ({
           expr: '',
-          message: error.message
+          message: error.message,
         }))
       }
       snapshot.captures = {
-        lines: { [probe.location.lines[0]]: { locals: processLocalState() } }
+        lines: { [probe.location.lines[0]]: { locals: processLocalState() } },
       }
     }
 

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

@@ -22,6 +22,6 @@ if (builtinModules.includes('inspector/promises')) {
 
   module.exports = {
     ...inspector,
-    Session
+    Session,
   }
 }

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

@@ -11,26 +11,25 @@ class JSONBuffer {
     this.#maxSize = size
     this.#timeout = timeout
     this.#onFlush = onFlush
-    this.#reset()
-  }
-
-  #reset () {
-    clearTimeout(this.#timer)
-    this.#timer = undefined
-    this.#partialJson = undefined
   }
 
   #flush () {
     const json = `${this.#partialJson}]`
-    this.#reset()
+    this.#partialJson = undefined
     this.#onFlush(json)
   }
 
   write (str, size = Buffer.byteLength(str)) {
-    if (this.#timer === undefined) {
+    if (this.#partialJson === undefined) {
       this.#partialJson = `[${str}`
-      this.#timer = setTimeout(() => this.#flush(), this.#timeout)
-    } else if (Buffer.byteLength(/** @type {string} */ (this.#partialJson)) + size + 2 > this.#maxSize) {
+      if (this.#timer === undefined) {
+        this.#timer = setTimeout(() => this.#flush(), this.#timeout)
+      } else {
+        this.#timer.refresh()
+      }
+    } else if (Buffer.byteLength(this.#partialJson) + size + 2 > this.#maxSize) {
+      clearTimeout(this.#timer)
+      this.#timer = undefined
       this.#flush()
       this.write(str, size)
     } else {

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

@@ -25,6 +25,6 @@ const threshold = LEVELS.indexOf(logLevel)
 module.exports = Object.fromEntries(
   LEVELS.map(level => [
     level,
-    debug && threshold >= LEVELS.indexOf(level) ? on.bind(null, level) : off
+    debug && threshold >= LEVELS.indexOf(level) ? on.bind(null, level) : off,
   ])
 )

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

@@ -3,10 +3,11 @@
 const { hostname: getHostname } = require('os')
 const { stringify } = require('querystring')
 
+const { version } = require('../../../../../package.json')
 const request = require('../../exporters/common/request')
 const { GIT_COMMIT_SHA, GIT_REPOSITORY_URL } = require('../../plugins/util/tags')
-const { version } = require('../../../../../package.json')
 const { getValueFromEnvSources } = require('../../config/helper')
+const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2 } = require('../constants')
 const log = require('./log')
 const JSONBuffer = require('./json-buffer')
 const config = require('./config')
@@ -28,15 +29,16 @@ const ddtags = [
   ['debugger_version', version],
   ['host_name', hostname],
   [GIT_COMMIT_SHA, config.commitSHA],
-  [GIT_REPOSITORY_URL, config.repositoryUrl]
+  [GIT_REPOSITORY_URL, config.repositoryUrl],
 ].filter(([, value]) => value !== undefined).map((pair) => pair.join(':')).join(',')
 
-const path = `/debugger/v1/input?${stringify({ ddtags })}`
+let path
+setInputPath(config.inputPath)
 
 const jsonBuffer = new JSONBuffer({
   size: config.maxTotalPayloadSize,
   timeout: config.dynamicInstrumentation.uploadIntervalSeconds * 1000,
-  onFlush
+  onFlush,
 })
 
 function send (message, logger, dd, snapshot) {
@@ -49,7 +51,7 @@ function send (message, logger, dd, snapshot) {
       : message,
     logger,
     dd,
-    debugger: { snapshot }
+    debugger: { snapshot },
   }
 
   let json = JSON.stringify(payload)
@@ -78,17 +80,59 @@ function send (message, logger, dd, snapshot) {
   jsonBuffer.write(json, size)
 }
 
+/**
+ * @param {string} payload - The payload to send
+ */
 function onFlush (payload) {
   log.debug('[debugger:devtools_client] Flushing probe payload buffer')
 
-  const opts = {
+  request(payload, buildRequestOpts(), (err, res, statusCode) => {
+    if (!handleV2FallbackIfNeeded(statusCode, payload) && err) {
+      log.error('[debugger:devtools_client] Error sending probe payload', err)
+    }
+  })
+}
+
+/**
+ * @param {number} statusCode - The status code of the response
+ * @param {string} payload - The payload to send
+ * @returns {boolean} True if the fallback was needed, false otherwise
+ */
+function handleV2FallbackIfNeeded (statusCode, payload) {
+  if (statusCode !== 404 || config.inputPath !== DEBUGGER_INPUT_V2) {
+    return false
+  }
+
+  log.warn('[debugger:devtools_client] Received 404 from %s, falling back to %s',
+    DEBUGGER_INPUT_V2,
+    DEBUGGER_DIAGNOSTICS_V1)
+
+  setInputPath(DEBUGGER_DIAGNOSTICS_V1)
+
+  request(payload, buildRequestOpts(), (err) => {
+    if (err) {
+      log.error('[debugger:devtools_client] Error sending probe payload after fallback to %s',
+        DEBUGGER_DIAGNOSTICS_V1,
+        err)
+    }
+  })
+
+  return true
+}
+
+function buildRequestOpts () {
+  return {
     method: 'POST',
     url: config.url,
     path,
-    headers: { 'Content-Type': 'application/json; charset=utf-8' }
+    headers: { 'Content-Type': 'application/json; charset=utf-8' },
   }
+}
 
-  request(payload, opts, (err) => {
-    if (err) log.error('[debugger:devtools_client] Error sending probe payload', err)
-  })
+/**
+ * @param {string} newPath - The new debugger input path
+ */
+function setInputPath (newPath) {
+  config.inputPath = newPath
+  path = `${newPath}?${stringify({ ddtags })}`
 }

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

@@ -9,9 +9,51 @@ const ITERABLE_SUBTYPES = new Set(['map', 'set', 'weakmap', 'weakset'])
 const SIZE_IN_DESCRIPTION_SUBTYPES = new Set(['array', 'typedarray', 'arraybuffer', 'dataview', 'map', 'set'])
 
 module.exports = {
-  collectObjectProperties
+  collectObjectProperties,
 }
 
+/** @typedef {import('node:inspector').Runtime.PropertyDescriptor} PropertyDescriptor */
+/** @typedef {import('node:inspector').Runtime.InternalPropertyDescriptor} InternalPropertyDescriptor */
+
+// TODO: Once @types/node include privateProperties, we should clean this typedef up:
+/**
+ * Extended version of Runtime.GetPropertiesReturnType that includes privateProperties
+ * which is not in the base type but is returned by the CDP API.
+ *
+ * @typedef {import('node:inspector').Runtime.GetPropertiesReturnType & {
+ *   privateProperties?: PropertyDescriptor[]
+ * }} GetPropertiesResult
+ */
+
+/**
+ * Extended version of GetPropertiesResult where internalProperties is guaranteed to exist.
+ * Use this typedef when calling Runtime.getProperties on objects that always have internal properties
+ * (e.g., iterables, proxies, ArrayBuffers).
+ *
+ * @typedef {GetPropertiesResult & {
+ *   internalProperties: InternalPropertyDescriptor[]
+ * }} GetPropertiesResultWithInternals
+ */
+
+/**
+ * Extended version of InternalPropertyDescriptor where value is guaranteed to exist.
+ * Use this typedef for internal properties that always have values (e.g., [[Entries]] for iterables).
+ *
+ * @typedef {InternalPropertyDescriptor & {
+ *   value: NonNullable<InternalPropertyDescriptor['value']>
+ * }} InternalPropertyDescriptorWithValue
+ */
+
+/**
+ * Extended version of GetPropertiesResult where internalProperties exist and all properties have values.
+ * Use this typedef when all internal properties are guaranteed to have values in practice.
+ * Examples: [[Entries]] for iterables, [[Target]] for Proxies, [[Uint8Array]] for ArrayBuffers.
+ *
+ * @typedef {GetPropertiesResult & {
+ *   internalProperties: InternalPropertyDescriptorWithValue[]
+ * }} GetPropertiesResultWithInternalValues
+ */
+
 /**
  * @typedef {object} GetObjectOptions
  * @property {object} maxReferenceDepth - The maximum depth of the object to traverse
@@ -37,10 +79,12 @@ module.exports = {
  * @returns {Promise<object[]>} The properties of the object
  */
 async function collectObjectProperties (objectId, opts, depth = 0, collection = false) {
-  const { result, privateProperties } = await session.post('Runtime.getProperties', {
-    objectId,
-    ownProperties: true // exclude inherited properties
-  })
+  const { result, privateProperties } = /** @type {GetPropertiesResult} */ (
+    await session.post('Runtime.getProperties', {
+      objectId,
+      ownProperties: true, // exclude inherited properties
+    })
+  )
 
   if (collection) {
     // Trim the collection if it's too large.
@@ -95,14 +139,14 @@ async function traverseGetPropertiesResult (props, opts, depth) {
         prop.value,
         () => collectPropertiesBySubtype(subtype, objectId, opts, depth).then((properties) => {
           prop.value.properties = properties
-        })
+        }),
       ])
     } else if (type === 'function') {
       work.push([
         prop.value,
         () => getFunctionProperties(objectId, opts, depth + 1).then((properties) => {
           prop.value.properties = properties
-        })
+        }),
       ])
     }
   }
@@ -122,7 +166,7 @@ async function traverseGetPropertiesResult (props, opts, depth) {
       // eslint-disable-next-line no-await-in-loop
       await Promise.all([
         work[i][1](),
-        work[i + 1]?.[1]()
+        work[i + 1]?.[1](),
       ])
     }
   }
@@ -147,10 +191,10 @@ function collectPropertiesBySubtype (subtype, objectId, opts, depth) {
 // - Bound function: `[[TargetFunction]]`, `[[BoundThis]]` and `[[BoundArgs]]`
 // - Non-bound function: `[[FunctionLocation]]`, and `[[Scopes]]`
 async function getFunctionProperties (objectId, opts, depth) {
-  let { result } = await session.post('Runtime.getProperties', {
+  let { result } = /** @type {GetPropertiesResult} */ (await session.post('Runtime.getProperties', {
     objectId,
-    ownProperties: true // exclude inherited properties
-  })
+    ownProperties: true, // exclude inherited properties
+  }))
 
   // For legacy reasons (I assume) functions has a `prototype` property besides the internal `[[Prototype]]`
   result = result.filter(({ name }) => name !== 'prototype')
@@ -161,22 +205,25 @@ async function getFunctionProperties (objectId, opts, depth) {
 async function getIterable (objectId, opts, depth) {
   // TODO: If the iterable has any properties defined on the object directly, instead of in its collection, they will
   // exist in the return value below in the `result` property. We currently do not collect these.
-  const { internalProperties } = await session.post('Runtime.getProperties', {
-    objectId,
-    ownProperties: true // exclude inherited properties
-  })
+  const { internalProperties } = /** @type {GetPropertiesResultWithInternalValues} */ (
+    await session.post('Runtime.getProperties', {
+      objectId,
+      ownProperties: true, // exclude inherited properties
+    })
+  )
 
   let entry = internalProperties[1]
   if (entry.name !== '[[Entries]]') {
     // Currently `[[Entries]]` is the last of 2 elements, but in case this ever changes, fall back to searching
+    // @ts-expect-error - findLast is available in Node.js 18+ but TypeScript doesn't know about it without ES2023 lib
     entry = internalProperties.findLast(({ name }) => name === '[[Entries]]')
   }
 
   // Skip the `[[Entries]]` level and go directly to the content of the iterable
-  const { result } = await session.post('Runtime.getProperties', {
+  const { result } = /** @type {GetPropertiesResult} */ (await session.post('Runtime.getProperties', {
     objectId: entry.value.objectId,
-    ownProperties: true // exclude inherited properties
-  })
+    ownProperties: true, // exclude inherited properties
+  }))
 
   removeNonEnumerableProperties(result) // remove the `length` property
   const size = result.length
@@ -189,10 +236,12 @@ async function getIterable (objectId, opts, depth) {
 }
 
 async function getInternalProperties (objectId, opts, depth) {
-  const { internalProperties } = await session.post('Runtime.getProperties', {
-    objectId,
-    ownProperties: true // exclude inherited properties
-  })
+  const { internalProperties } = /** @type {GetPropertiesResultWithInternals} */ (
+    await session.post('Runtime.getProperties', {
+      objectId,
+      ownProperties: true, // exclude inherited properties
+    })
+  )
 
   // We want all internal properties except the prototype
   const props = internalProperties.filter(({ name }) => name !== '[[Prototype]]')
@@ -201,23 +250,26 @@ async function getInternalProperties (objectId, opts, depth) {
 }
 
 async function getProxy (objectId, opts, depth) {
-  const { internalProperties } = await session.post('Runtime.getProperties', {
-    objectId,
-    ownProperties: true // exclude inherited properties
-  })
+  const { internalProperties } = /** @type {GetPropertiesResultWithInternalValues} */ (
+    await session.post('Runtime.getProperties', {
+      objectId,
+      ownProperties: true, // exclude inherited properties
+    })
+  )
 
   // TODO: If we do not skip the proxy wrapper, we can add a `revoked` boolean
   let entry = internalProperties[1]
   if (entry.name !== '[[Target]]') {
     // Currently `[[Target]]` is the last of 2 elements, but in case this ever changes, fall back to searching
+    // @ts-expect-error - findLast is available in Node.js 18+ but TypeScript doesn't know about it without ES2023 lib
     entry = internalProperties.findLast(({ name }) => name === '[[Target]]')
   }
 
   // Skip the `[[Target]]` level and go directly to the target of the Proxy
-  const { result } = await session.post('Runtime.getProperties', {
+  const { result } = /** @type {GetPropertiesResult} */ (await session.post('Runtime.getProperties', {
     objectId: entry.value.objectId,
-    ownProperties: true // exclude inherited properties
-  })
+    ownProperties: true, // exclude inherited properties
+  }))
 
   return traverseGetPropertiesResult(result, opts, depth)
 }
@@ -227,19 +279,24 @@ async function getProxy (objectId, opts, depth) {
 // UInt8Array(3), whereas ArrayBuffer(8) internally contains both Int8Array(8), Uint8Array(8), Int16Array(4), and
 // Int32Array(2) - all representing the same data in different ways.
 async function getArrayBuffer (objectId, opts, depth) {
-  const { internalProperties } = await session.post('Runtime.getProperties', {
-    objectId,
-    ownProperties: true // exclude inherited properties
-  })
+  const { internalProperties } = /** @type {GetPropertiesResultWithInternalValues} */ (
+    await session.post('Runtime.getProperties', {
+      objectId,
+      ownProperties: true, // exclude inherited properties
+    })
+  )
 
   // Use Uint8 to make it easy to convert to a string later.
-  const entry = internalProperties.find(({ name }) => name === '[[Uint8Array]]')
+  // [[Uint8Array]] always exists for ArrayBuffers
+  const entry = /** @type {InternalPropertyDescriptorWithValue} */ (
+    internalProperties.find(({ name }) => name === '[[Uint8Array]]')
+  )
 
   // Skip the `[[Uint8Array]]` level and go directly to the content of the ArrayBuffer
-  const { result } = await session.post('Runtime.getProperties', {
+  const { result } = /** @type {GetPropertiesResult} */ (await session.post('Runtime.getProperties', {
     objectId: entry.value.objectId,
-    ownProperties: true // exclude inherited properties
-  })
+    ownProperties: true, // exclude inherited properties
+  }))
 
   return traverseGetPropertiesResult(result, opts, depth)
 }

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

@@ -4,7 +4,7 @@ const {
   DEFAULT_MAX_REFERENCE_DEPTH,
   DEFAULT_MAX_COLLECTION_SIZE,
   DEFAULT_MAX_FIELD_COUNT,
-  DEFAULT_MAX_LENGTH
+  DEFAULT_MAX_LENGTH,
 } = require('./constants')
 const { collectObjectProperties } = require('./collector')
 const { processRawState } = require('./processor')
@@ -12,7 +12,7 @@ const { processRawState } = require('./processor')
 const BIGINT_MAX = (1n << 256n) - 1n
 
 module.exports = {
-  getLocalStateForCallFrame
+  getLocalStateForCallFrame,
 }
 
 /**
@@ -43,7 +43,7 @@ async function getLocalStateForCallFrame (
     maxCollectionSize = DEFAULT_MAX_COLLECTION_SIZE,
     maxFieldCount = DEFAULT_MAX_FIELD_COUNT,
     maxLength = DEFAULT_MAX_LENGTH,
-    deadlineNs = BIGINT_MAX
+    deadlineNs = BIGINT_MAX,
   } = {}
 ) {
   /** @type {{ deadlineReached: boolean, captureErrors: Error[] }} */
@@ -78,6 +78,6 @@ async function getLocalStateForCallFrame (
       processedState = processedState ?? processRawState(rawState, maxLength)
       return processedState
     },
-    captureErrors: ctx.captureErrors
+    captureErrors: ctx.captureErrors,
   }
 }

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

@@ -5,7 +5,7 @@ const { collectionSizeSym, largeCollectionSkipThresholdSym, fieldCountSym, timeB
 const { normalizeName, REDACTED_IDENTIFIERS } = require('./redaction')
 
 module.exports = {
-  processRawState: processProperties
+  processRawState: processProperties,
 }
 
 // Matches classes in source code, no matter how it's written:
@@ -150,7 +150,7 @@ function toString (str, maxLength) {
     type: 'string',
     value: str.slice(0, maxLength),
     truncated: true,
-    size
+    size,
   }
 }
 
@@ -160,7 +160,7 @@ function toObject (type, props, maxLength, timeBudgetReached) {
 
   const result = {
     type,
-    fields: processProperties(props, maxLength)
+    fields: processProperties(props, maxLength),
   }
 
   if (props[fieldCountSym] !== undefined) {
@@ -179,7 +179,7 @@ function toArray (type, elements, maxLength, timeBudgetReached) {
     type,
     elements: elements.map((element) => {
       return getPropertyValue(element, maxLength)
-    })
+    }),
   }
 
   setNotCaptureReasonOnCollection(result, elements)
@@ -218,7 +218,7 @@ function toMap (type, pairs, maxLength, timeBudgetReached) {
         ? notCapturedRedacted(value.properties[1].value.type)
         : getPropertyValue(value.properties[1], maxLength)
       return [key, val]
-    })
+    }),
   }
 
   setNotCaptureReasonOnCollection(result, pairs)
@@ -250,7 +250,7 @@ function toSet (type, values, maxLength, timeBudgetReached) {
       if (value.properties === undefined) return { notCapturedReason: 'unknown' }
 
       return getPropertyValue(value.properties[0], maxLength)
-    })
+    }),
   }
 
   setNotCaptureReasonOnCollection(result, values)
@@ -270,7 +270,7 @@ function toArrayBuffer (type, bytes, maxLength, timeBudgetReached) {
         type,
         value: arrayBufferToString(bytes, maxLength),
         truncated: true,
-        size: bytes.length
+        size: bytes.length,
       }
     : { type, value: arrayBufferToString(bytes, size) }
 }

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

@@ -95,7 +95,7 @@ const REDACTED_IDENTIFIERS = new Set(
     'x_forwarded_for',
     'x_real_ip',
     'XSRF-TOKEN',
-    ...config.dynamicInstrumentation.redactedIdentifiers
+    ...config.dynamicInstrumentation.redactedIdentifiers,
   ]
     .map((name) => normalizeName(name))
     .filter((name) => excludedIdentifiers.has(name) === false)
@@ -108,5 +108,5 @@ function normalizeName (name, isSymbol) {
 
 module.exports = {
   REDACTED_IDENTIFIERS,
-  normalizeName
+  normalizeName,
 }

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

@@ -4,5 +4,5 @@ module.exports = {
   collectionSizeSym: Symbol('datadog.collectionSize'),
   largeCollectionSkipThresholdSym: Symbol('datadog.largeCollectionSkipThresholdSym'),
   fieldCountSym: Symbol('datadog.fieldCount'),
-  timeBudgetSym: Symbol('datadog.timeout')
+  timeBudgetSym: Symbol('datadog.timeout'),
 }

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

@@ -74,7 +74,7 @@ class TreeNode {
         this.notCapturedDepth ? 1 : 0,
         this.level,
         this.notCaptured ? 1 : 0,
-        this.size
+        this.size,
       ]
     }
     return this.#priorityKeyCache

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

@@ -31,7 +31,16 @@ const self = module.exports = {
       null,
       (consumer) => consumer.generatedPositionFor({ source, line, column: 0 })
     )
-  }
+  },
+
+  async getOriginalPosition (url, line, column, sourceMapURL) {
+    const dir = dirname(new URL(url).pathname)
+    return SourceMapConsumer.with(
+      await self.loadSourceMap(dir, sourceMapURL),
+      null,
+      (consumer) => consumer.originalPositionFor({ line, column })
+    )
+  },
 }
 
 function cacheIt (key, value) {