dd-trace 5.80.0 → 5.82.0

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

@@ -1,6 +1,7 @@
 'use strict'
 
-const { collectionSizeSym, fieldCountSym } = require('./symbols')
+const { LARGE_OBJECT_SKIP_THRESHOLD } = require('./constants')
+const { collectionSizeSym, largeCollectionSkipThresholdSym, fieldCountSym, timeBudgetSym } = require('./symbols')
 const { normalizeName, REDACTED_IDENTIFIERS } = require('./redaction')
 
 module.exports = {
@@ -38,7 +39,7 @@ function getPropertyValue (prop, maxLength) {
 
 function getPropertyValueRaw (prop, maxLength) {
   // Special case for getters and setters which does not have a value property
-  if (Object.hasOwn(prop, 'get')) {
+  if (prop.get) {
     const hasGet = prop.get.type !== 'undefined'
     const hasSet = prop.set.type !== 'undefined'
     if (hasGet) {
@@ -74,11 +75,13 @@ function getPropertyValueRaw (prop, maxLength) {
 }
 
 function getObjectValue (obj, maxLength) {
+  const timeBudgetReached = obj[timeBudgetSym] === true
+
   switch (obj.subtype) {
     case undefined:
-      return toObject(obj.className, obj.properties, maxLength)
+      return toObject(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'array':
-      return toArray(obj.className, obj.properties, maxLength)
+      return toArray(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'null':
       return { type: 'null', isNull: true }
     // case 'node': // TODO: What does this subtype represent?
@@ -89,28 +92,28 @@ function getObjectValue (obj, maxLength) {
       // in the `description` field. Unfortunately that's all we get from the Chrome DevTools Protocol.
       return { type: obj.className, value: `${new Date(obj.description).toISOString().slice(0, -5)}Z` }
     case 'map':
-      return toMap(obj.className, obj.properties, maxLength)
+      return toMap(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'set':
-      return toSet(obj.className, obj.properties, maxLength)
+      return toSet(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'error':
       // TODO: Convert stack trace to array to avoid string truncation or disable truncation in this case?
-      return toObject(obj.className, obj.properties, maxLength)
+      return toObject(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'proxy':
       // Use `description` instead of `className` as the `type` to get type of target object (`Proxy(Error)` vs `proxy`)
-      return toObject(obj.description, obj.properties, maxLength)
+      return toObject(obj.description, obj.properties, maxLength, timeBudgetReached)
     case 'promise':
-      return toObject(obj.className, obj.properties, maxLength)
+      return toObject(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'typedarray':
-      return toArray(obj.className, obj.properties, maxLength)
+      return toArray(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'generator':
       // Use `subtype` instead of `className` to make it obvious it's a generator
-      return toObject(obj.subtype, obj.properties, maxLength)
+      return toObject(obj.subtype, obj.properties, maxLength, timeBudgetReached)
     case 'arraybuffer':
-      return toArrayBuffer(obj.className, obj.properties, maxLength)
+      return toArrayBuffer(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'weakmap':
-      return toMap(obj.className, obj.properties, maxLength)
+      return toMap(obj.className, obj.properties, maxLength, timeBudgetReached)
     case 'weakset':
-      return toSet(obj.className, obj.properties, maxLength)
+      return toSet(obj.className, obj.properties, maxLength, timeBudgetReached)
     // case 'iterator': // TODO: I've not been able to trigger this subtype
     // case 'dataview': // TODO: Looks like the internal ArrayBuffer is only accessible via the `buffer` getter
     // case 'webassemblymemory': // TODO: Looks like the internal ArrayBuffer is only accessible via the `buffer` getter
@@ -127,8 +130,9 @@ function toFunctionOrClass (value, maxLength) {
 
   if (classMatch === null) {
     // This is a function
+    const timeBudgetReached = value[timeBudgetSym] === true
     // TODO: Would it make sense to detect if it's an arrow function or not?
-    return toObject(value.className, value.properties, maxLength)
+    return toObject(value.className, value.properties, maxLength, timeBudgetReached)
   }
   // This is a class
   const className = classMatch[1].trim()
@@ -150,7 +154,8 @@ function toString (str, maxLength) {
   }
 }
 
-function toObject (type, props, maxLength) {
+function toObject (type, props, maxLength, timeBudgetReached) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
   if (props === undefined) return notCapturedDepth(type)
 
   const result = {
@@ -158,7 +163,7 @@ function toObject (type, props, maxLength) {
     fields: processProperties(props, maxLength)
   }
 
-  if (Object.hasOwn(props, fieldCountSym)) {
+  if (props[fieldCountSym] !== undefined) {
     result.notCapturedReason = 'fieldCount'
     result.size = props[fieldCountSym]
   }
@@ -166,7 +171,8 @@ function toObject (type, props, maxLength) {
   return result
 }
 
-function toArray (type, elements, maxLength) {
+function toArray (type, elements, maxLength, timeBudgetReached) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
   if (elements === undefined) return notCapturedDepth(type)
 
   const result = {
@@ -177,12 +183,15 @@ function toArray (type, elements, maxLength) {
   }
 
   setNotCaptureReasonOnCollection(result, elements)
+  setNotCaptureReasonOnTooLargeCollection(result, elements)
 
   return result
 }
 
-function toMap (type, pairs, maxLength) {
+function toMap (type, pairs, maxLength, timeBudgetReached) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
   if (pairs === undefined) return notCapturedDepth(type)
+  if (pairs.length > 0 && pairs.every(({ value }) => value[timeBudgetSym] === true)) return notCapturedTimeBudget(type)
 
   const result = {
     type,
@@ -195,6 +204,14 @@ function toMap (type, pairs, maxLength) {
       // This can be skipped and we can go directly to its children, of which
       // there will always be exactly two, the first containing the key, and the
       // second containing the value of this entry of the Map.
+
+      if (value[timeBudgetSym] === true) {
+        return [{ notCapturedReason: 'timeout' }, { notCapturedReason: 'timeout' }]
+      }
+      if (value.properties === undefined) {
+        return [{ notCapturedReason: 'unknown' }, { notCapturedReason: 'unknown' }]
+      }
+
       const shouldRedact = shouldRedactMapValue(value.properties[0])
       const key = getPropertyValue(value.properties[0], maxLength)
       const val = shouldRedact
@@ -205,12 +222,17 @@ function toMap (type, pairs, maxLength) {
   }
 
   setNotCaptureReasonOnCollection(result, pairs)
+  setNotCaptureReasonOnTooLargeCollection(result, pairs)
 
   return result
 }
 
-function toSet (type, values, maxLength) {
+function toSet (type, values, maxLength, timeBudgetReached) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
   if (values === undefined) return notCapturedDepth(type)
+  if (values.length > 0 && values.every(({ value }) => value[timeBudgetSym] === true)) {
+    return notCapturedTimeBudget(type)
+  }
 
   const result = {
     type,
@@ -223,16 +245,22 @@ function toSet (type, values, maxLength) {
       // `internal#entry`. This can be skipped and we can go directly to its
       // children, of which there will always be exactly one, which contain the
       // actual value in this entry of the Set.
+
+      if (value[timeBudgetSym] === true) return { notCapturedReason: 'timeout' }
+      if (value.properties === undefined) return { notCapturedReason: 'unknown' }
+
       return getPropertyValue(value.properties[0], maxLength)
     })
   }
 
   setNotCaptureReasonOnCollection(result, values)
+  setNotCaptureReasonOnTooLargeCollection(result, values)
 
   return result
 }
 
-function toArrayBuffer (type, bytes, maxLength) {
+function toArrayBuffer (type, bytes, maxLength, timeBudgetReached) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
   if (bytes === undefined) return notCapturedDepth(type)
 
   const size = bytes.length
@@ -271,16 +299,25 @@ function shouldRedactMapValue (key) {
 }
 
 function getNormalizedNameFromProp (prop) {
-  return normalizeName(prop.name, Object.hasOwn(prop, 'symbol'))
+  return normalizeName(prop.name, prop.symbol !== undefined)
 }
 
 function setNotCaptureReasonOnCollection (result, collection) {
-  if (Object.hasOwn(collection, collectionSizeSym)) {
+  if (collection[collectionSizeSym] !== undefined) {
     result.notCapturedReason = 'collectionSize'
     result.size = collection[collectionSizeSym]
   }
 }
 
+function setNotCaptureReasonOnTooLargeCollection (result, collection) {
+  if (collection[largeCollectionSkipThresholdSym] !== undefined) {
+    result.notCapturedReason = `Large collection with too many elements (skip threshold: ${
+      LARGE_OBJECT_SKIP_THRESHOLD
+    })`
+    result.size = collection[largeCollectionSkipThresholdSym]
+  }
+}
+
 function notCapturedDepth (type) {
   return { type, notCapturedReason: 'depth' }
 }
@@ -288,3 +325,7 @@ function notCapturedDepth (type) {
 function notCapturedRedacted (type) {
   return { type, notCapturedReason: 'redactedIdent' }
 }
+
+function notCapturedTimeBudget (type) {
+  return { type, notCapturedReason: 'timeout' }
+}

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

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

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

@@ -0,0 +1,404 @@
+'use strict'
+
+/**
+ * This module provides functionality to intelligently prune oversized JSON snapshots by selectively removing the
+ * largest and deepest leaf nodes while preserving the schema structure.
+ */
+
+// The RFC specifies that we should prune nodes at level 5 or deeper, but the Node.js implementation has an extra level
+// of depth because it doesn't use the compound key `debugger.snapshot`, but individual `debugger` and `snapshot` keys,
+// so we prune at level 6 or deeper. This level contains the `locals` key.
+const MIN_PRUNE_LEVEL = 6
+const PRUNED_JSON = '{"pruned":true}'
+const PRUNED_JSON_BYTES = Buffer.byteLength(PRUNED_JSON)
+
+module.exports = { pruneSnapshot }
+
+/**
+ * Tree node representing a JSON object in the parsed structure
+ */
+class TreeNode {
+  /** @type {number} End position in JSON string (set when object closes) */
+  end = -1
+  /** @type {TreeNode[]} Child nodes */
+  children = []
+  /** @type {boolean} Has notCapturedReason: "depth" */
+  notCapturedDepth = false
+  /** @type {boolean} Has any notCapturedReason */
+  notCaptured = false
+  /** @type {number} Cached byte size */
+  #sizeCache = -1
+  /** @type {[number, number, number, number]|null} Cached priority key */
+  #priorityKeyCache = null
+
+  /**
+   * @param {number} start - Start position in JSON string
+   * @param {number} level - Depth in tree (root = 0)
+   * @param {string} json - Reference to original JSON string
+   * @param {TreeNode|null} [parent] - Parent node reference
+   */
+  constructor (start, level, json, parent = null) {
+    /** @type {number} Start position in JSON string */
+    this.start = start
+    /** @type {number} Depth in tree (root = 0) */
+    this.level = level
+    /** @type {string} Reference to original JSON string */
+    this.json = json
+    /** @type {TreeNode|null} Parent node reference */
+    this.parent = parent
+  }
+
+  get size () {
+    if (this.#sizeCache === -1) {
+      if (this.end === -1) {
+        throw new Error('Cannot get size: node.end has not been set yet')
+      }
+      this.#sizeCache = Buffer.byteLength(this.json.slice(this.start, this.end + 1))
+    }
+    return this.#sizeCache
+  }
+
+  get isLeaf () {
+    return this.children.length === 0
+  }
+
+  /**
+   * Priority key for sorting in queue (higher values = higher priority for pruning).
+   * Cached to avoid repeated computation during heap operations.
+   *
+   * @returns {[number, number, number, number]} Priority key tuple: [not_captured_depth, level, not_captured, size]
+   */
+  get priorityKey () {
+    if (this.#priorityKeyCache === null) {
+      this.#priorityKeyCache = [
+        this.notCapturedDepth ? 1 : 0,
+        this.level,
+        this.notCaptured ? 1 : 0,
+        this.size
+      ]
+    }
+    return this.#priorityKeyCache
+  }
+}
+
+/**
+ * Priority queue implementation using a binary heap.
+ * Items with higher priority (by priorityKey) are popped first.
+ */
+class PriorityQueue {
+  /** @type {TreeNode[]} Binary heap of nodes */
+  #heap = []
+
+  push (node) {
+    this.#heap.push(node)
+    this.#bubbleUp(this.#heap.length - 1)
+  }
+
+  pop () {
+    if (this.#heap.length === 0) return
+    if (this.#heap.length === 1) return /** @type {TreeNode} */ (this.#heap.pop())
+
+    const top = this.#heap[0]
+    this.#heap[0] = /** @type {TreeNode} */ (this.#heap.pop())
+    this.#bubbleDown(0)
+    return top
+  }
+
+  get size () {
+    return this.#heap.length
+  }
+
+  #bubbleUp (index) {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2)
+      if (this.#compare(this.#heap[index], this.#heap[parentIndex]) <= 0) break
+
+      [this.#heap[index], this.#heap[parentIndex]] = [this.#heap[parentIndex], this.#heap[index]]
+      index = parentIndex
+    }
+  }
+
+  #bubbleDown (index) {
+    while (true) {
+      let largest = index
+      const leftChild = 2 * index + 1
+      const rightChild = 2 * index + 2
+
+      if (leftChild < this.#heap.length && this.#compare(this.#heap[leftChild], this.#heap[largest]) > 0) {
+        largest = leftChild
+      }
+      if (rightChild < this.#heap.length && this.#compare(this.#heap[rightChild], this.#heap[largest]) > 0) {
+        largest = rightChild
+      }
+
+      if (largest === index) break
+
+      [this.#heap[index], this.#heap[largest]] = [this.#heap[largest], this.#heap[index]]
+      index = largest
+    }
+  }
+
+  /**
+   * Compare two nodes by their priority keys.
+   *
+   * @param {TreeNode} a - First node to compare
+   * @param {TreeNode} b - Second node to compare
+   * @returns {number} - > 0 if a has higher priority, < 0 if b has higher priority, 0 if equal
+   */
+  #compare (a, b) {
+    const keyA = a.priorityKey
+    const keyB = b.priorityKey
+    for (let i = 0; i < 4; i++) {
+      if (keyA[i] !== keyB[i]) {
+        return keyA[i] - keyB[i]
+      }
+    }
+    return 0
+  }
+}
+
+/**
+ * Parse JSON string and build a tree of objects with position tracking.
+ * Also detects notCapturedReason properties to set node flags.
+ *
+ * @param {string} json - The JSON string to parse
+ * @returns {TreeNode|null} The root node of the tree, or null if parsing fails
+ */
+function parseJsonToTree (json) {
+  /** @type {TreeNode[]} Stack of nodes */
+  const stack = []
+  /** @type {TreeNode|null} The root node of the tree, or null if parsing fails */
+  let root = null
+  let depth = 0
+
+  for (let index = 0; index < json.length; index++) {
+    switch (json.charCodeAt(index)) {
+      case 34: { // 34: double quote
+        const stringStart = index + 1
+        index = skipString(json, index)
+        const stringLength = index - stringStart
+
+        // Check if this is "notCapturedReason" property (check length first for performance)
+        if (stringLength === 17 && json.startsWith('notCapturedReason', stringStart)) {
+          // Look ahead for colon and value
+          let ahead = index + 1
+
+          // Skip whitespace and colon
+          while (ahead < json.length) {
+            const code = json.charCodeAt(ahead)
+            // 32: space, 9: tab, 10: newline, 13: carriage return, 58: colon
+            if (code === 32 || code === 9 || code === 10 || code === 13 || code === 58) {
+              ahead++
+            } else {
+              break
+            }
+          }
+
+          // Check if value is a string (34: double quote)
+          if (ahead < json.length && json.charCodeAt(ahead) === 34) {
+            const valueStart = ahead + 1
+            ahead = skipString(json, ahead)
+            const reason = json.slice(valueStart, ahead)
+
+            const currentNode = /** @type {TreeNode} */ (stack.at(-1))
+            currentNode.notCaptured = true
+            if (reason === 'depth') {
+              currentNode.notCapturedDepth = true
+            }
+          }
+        }
+        break
+      }
+      case 123: { // 123: opening brace
+        const parentNode = stack.at(-1)
+        const level = depth
+        const node = new TreeNode(index, level, json, parentNode)
+
+        if (parentNode) {
+          parentNode.children.push(node)
+        } else {
+          root = node
+        }
+
+        stack.push(node)
+        depth++
+        break
+      }
+      case 125: { // 125: closing brace
+        const node = stack.pop()
+        if (node === undefined) throw new SyntaxError('Invalid JSON: unexpected closing brace')
+        node.end = index
+        depth--
+        break
+      }
+    }
+  }
+
+  return root
+}
+
+/**
+ * Skip to the end of a JSON string, properly handling escape sequences.
+ *
+ * @param {string} json - The JSON string to skip
+ * @param {number} startIndex - The index to start skipping from
+ * @returns {number} The index of the closing quote
+ */
+function skipString (json, startIndex) {
+  let index = startIndex + 1 // Skip opening quote
+
+  while (index < json.length) {
+    const code = json.charCodeAt(index)
+
+    if (code === 92) { // 92: backslash
+      // Skip the backslash and the next character (whatever it is)
+      index += 2
+      continue
+    }
+
+    if (code === 34) { // 34: double quote
+      // Found unescaped closing quote
+      return index
+    }
+
+    index++
+  }
+
+  return index
+}
+
+/**
+ * Collect all leaf nodes at MIN_PRUNE_LEVEL or deeper.
+ *
+ * @param {TreeNode} root - The root node of the tree
+ * @returns {TreeNode[]} The array of leaf nodes
+ */
+function collectPrunableLeaves (root) {
+  const leaves = []
+
+  function traverse (node) {
+    if (!node) return
+
+    if (node.isLeaf && node.level >= MIN_PRUNE_LEVEL) {
+      leaves.push(node)
+    }
+
+    for (const child of node.children) {
+      traverse(child)
+    }
+  }
+
+  traverse(root)
+  return leaves
+}
+
+/**
+ * Select nodes to prune using the priority queue algorithm.
+ *
+ * @param {TreeNode} root - The root node of the tree
+ * @param {number} bytesToRemove - The number of bytes to remove
+ * @returns {Set<TreeNode>} The set of nodes marked for pruning
+ */
+function selectNodesToPrune (root, bytesToRemove) {
+  const queue = new PriorityQueue()
+  const prunedNodes = new Set()
+  const promotedParents = new Set()
+
+  // Collect initial leaf nodes
+  const leaves = collectPrunableLeaves(root)
+  for (const leaf of leaves) {
+    queue.push(leaf)
+  }
+
+  let bytesRemoved = 0
+
+  while (queue.size > 0 && bytesRemoved < bytesToRemove) {
+    const node = /** @type {TreeNode} */ (queue.pop())
+
+    if (prunedNodes.has(node)) continue
+    prunedNodes.add(node)
+
+    bytesRemoved += node.size - PRUNED_JSON_BYTES
+
+    // Check if parent should be promoted to leaf
+    const parent = node.parent
+    if (parent && parent.level >= MIN_PRUNE_LEVEL && !promotedParents.has(parent)) {
+      // Check if all children are now pruned
+      const allChildrenPruned = parent.children.every(child => prunedNodes.has(child))
+
+      if (allChildrenPruned) {
+        // Unmark all children as pruned (parent will represent them)
+        for (const child of parent.children) {
+          prunedNodes.delete(child)
+          bytesRemoved -= child.size - PRUNED_JSON_BYTES
+        }
+
+        // Promote parent to leaf by marking it with notCapturedDepth flag
+        parent.notCaptured = true
+        parent.notCapturedDepth = true
+        promotedParents.add(parent)
+
+        // Add parent to queue for potential pruning
+        queue.push(parent)
+      }
+    }
+  }
+
+  return prunedNodes
+}
+
+/**
+ * Rebuild JSON string with pruned nodes replaced by {"pruned":true}
+ *
+ * @param {string} json - The JSON string to rebuild
+ * @param {Set<TreeNode>} prunedNodes - The set of nodes to replace with {"pruned":true}
+ * @returns {string} The rebuilt JSON string
+ */
+function rebuildJson (json, prunedNodes) {
+  // Convert set to array and sort by start position (descending)
+  const sortedNodes = [...prunedNodes].sort((a, b) => b.start - a.start)
+
+  // Replace from end to start to maintain position indices
+  for (const node of sortedNodes) {
+    const before = json.slice(0, node.start)
+    const after = json.slice(node.end + 1)
+    json = before + PRUNED_JSON + after
+  }
+
+  return json
+}
+
+/**
+ * Main pruning function
+ *
+ * @param {string} json - The JSON string to prune
+ * @param {number} originalSize - Size of the original JSON string in bytes
+ * @param {number} maxSize - Maximum allowed size in bytes
+ * @returns {string|undefined} - Pruned JSON string, or undefined if pruning fails
+ */
+function pruneSnapshot (json, originalSize, maxSize) {
+  const bytesToRemove = originalSize - maxSize
+
+  if (bytesToRemove <= 0) return json // No pruning needed
+
+  let prunedSize = originalSize
+  let attempts = 0
+  const maxAttempts = 6
+
+  while (prunedSize > maxSize && attempts < maxAttempts) {
+    attempts++
+
+    const root = parseJsonToTree(json)
+    if (!root) break
+
+    const targetBytesToRemove = prunedSize - maxSize
+    const prunedNodes = selectNodesToPrune(root, targetBytesToRemove)
+    if (prunedNodes.size === 0) break
+
+    json = rebuildJson(json, prunedNodes)
+    prunedSize = Buffer.byteLength(json)
+  }
+
+  // If pruning didn't help, return undefined
+  return prunedSize >= originalSize ? undefined : json
+}

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

@@ -3,7 +3,7 @@
 const { join, dirname } = require('path')
 const { readFileSync } = require('fs')
 const { readFile } = require('fs/promises')
-const { SourceMapConsumer } = require('source-map')
+const { SourceMapConsumer } = require('../../../../../vendor/dist/source-map')
 
 const cache = new Map()
 let cacheTimer = null

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { join, dirname } = require('path')
-const { normalize } = require('source-map/lib/util')
+const { normalize } = require('../../../../../vendor/dist/source-map/lib/util')
 const { loadSourceMapSync } = require('./source-maps')
 const session = require('./session')
 const log = require('./log')
@@ -24,7 +24,7 @@ module.exports = {
    * Find the script to inspect based on a partial or absolute path. Handles both Windows and POSIX paths.
    *
    * @param {string} path - Partial or absolute path to match against loaded scripts
-   * @returns {Object | null} - Object containing `url`, `scriptId`, `sourceMapURL`, and `source` - or null if no match
+   * @returns {object | null} - Object containing `url`, `scriptId`, `sourceMapURL`, and `source` - or null if no match
    */
   findScriptFromPartialPath (path) {
     if (!path) return null // This shouldn't happen, but better safe than sorry
@@ -81,9 +81,14 @@ module.exports = {
       }
 
       // If we found a valid match and it's better than our previous best
+      // Note: bestMatch.url cannot be null when comparing lengths because:
+      // - The first time we enter this block, lastBoundaryPos > maxMatchLength is always true
+      // - We set bestMatch.url before we could evaluate the second condition
+      // - Subsequent evaluations have bestMatch.url already set
       if (atBoundary && (
         lastBoundaryPos > maxMatchLength ||
-        (lastBoundaryPos === maxMatchLength && url.length < bestMatch.url.length) // Prefer shorter paths
+        (lastBoundaryPos === maxMatchLength &&
+          url.length < /** @type {string} */ (/** @type {unknown} */ (bestMatch.url)).length) // Prefer shorter paths
       )) {
         maxMatchLength = lastBoundaryPos
         bestMatch.url = sourceUrl || url

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

@@ -1,10 +1,10 @@
 'use strict'
 
-const TTLSet = require('ttl-set')
-const config = require('./config')
-const JSONBuffer = require('./json-buffer')
+const TTLSet = require('../../../../../vendor/dist/ttl-set')
 const request = require('../../exporters/common/request')
 const FormData = require('../../exporters/common/form-data')
+const config = require('./config')
+const JSONBuffer = require('./json-buffer')
 const log = require('./log')
 
 module.exports = {