dd-trace 5.53.0 → 5.55.0

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

@@ -1,5 +1,6 @@
 const os = require('os')
 const fs = require('fs')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
 class StableConfig {
   constructor () {
@@ -27,7 +28,7 @@ class StableConfig {
     try {
       libdatadog = require('@datadog/libdatadog')
       this.wasm_loaded = true
-    } catch (e) {
+    } catch {
       this.warnings.push('Can\'t load libdatadog library')
       return
     }
@@ -40,6 +41,8 @@ class StableConfig {
 
     try {
       const configurator = new libconfig.JsConfigurator()
+      // Intentionally pass through the raw environment variables for reporting.
+      // eslint-disable-next-line eslint-rules/eslint-process-env
       configurator.set_envp(Object.entries(process.env).map(([key, value]) => `${key}=${value}`))
       configurator.set_args(process.argv)
       configurator.get_configuration(localConfig.toString(), fleetConfig.toString()).forEach((entry) => {
@@ -78,19 +81,19 @@ class StableConfig {
         fleetConfigPath = '/opt/datadog-agent/etc/managed/datadog-agent/stable/application_monitoring.yaml'
         break
       case 'win32':
-        localConfigPath = 'C:\\ProgramData\\Datadog\\application_monitoring.yaml'
-        fleetConfigPath = 'C:\\ProgramData\\Datadog\\managed\\datadog-agent\\stable\\application_monitoring.yaml'
+        localConfigPath = String.raw`C:\ProgramData\Datadog\application_monitoring.yaml`
+        fleetConfigPath = String.raw`C:\ProgramData\Datadog\managed\datadog-agent\stable\application_monitoring.yaml`
         break
       default:
         break
     }
 
     // Allow overriding the paths for testing
-    if (process.env.DD_TEST_LOCAL_CONFIG_PATH !== undefined) {
-      localConfigPath = process.env.DD_TEST_LOCAL_CONFIG_PATH
+    if (getEnvironmentVariable('DD_TEST_LOCAL_CONFIG_PATH') !== undefined) {
+      localConfigPath = getEnvironmentVariable('DD_TEST_LOCAL_CONFIG_PATH')
     }
-    if (process.env.DD_TEST_FLEET_CONFIG_PATH !== undefined) {
-      fleetConfigPath = process.env.DD_TEST_FLEET_CONFIG_PATH
+    if (getEnvironmentVariable('DD_TEST_FLEET_CONFIG_PATH') !== undefined) {
+      fleetConfigPath = getEnvironmentVariable('DD_TEST_FLEET_CONFIG_PATH')
     }
 
     return { localConfigPath, fleetConfigPath }

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

@@ -6,10 +6,10 @@ function encodeVarint (v) {
   // we leave the least significant bit for the sign.
   const double = Math.abs(v) * 2
   if (double > Number.MAX_SAFE_INTEGER) {
-    return undefined
+    return
   }
-  const high = Math.floor(double / 0x100000000)
-  const low = (double & 0xffffffff) | sign
+  const high = Math.floor(double / 0x1_00_00_00_00)
+  const low = (double & 0xFF_FF_FF_FF) | sign
   return encodeUvarint64(low, high)
 }
 
@@ -21,7 +21,7 @@ function decodeVarint (b) {
     return [undefined, bytes]
   }
   const positive = (low & 1) === 0
-  const abs = (low >>> 1) + high * 0x80000000
+  const abs = (low >>> 1) + high * 0x80_00_00_00
   return [positive ? abs : -abs, bytes]
 }
 
@@ -32,13 +32,13 @@ function encodeUvarint64 (low, high) {
   let i = 0
   // if first byte is 1, the number is negative in javascript, but we want to interpret it as positive
   while ((high !== 0 || low < 0 || low > 0x80) && i < maxVarLen64 - 1) {
-    result[i] = (low & 0x7f) | 0x80
+    result[i] = (low & 0x7F) | 0x80
     low >>>= 7
-    low |= (high & 0x7f) << 25
+    low |= (high & 0x7F) << 25
     high >>>= 7
     i++
   }
-  result[i] = low & 0x7f
+  result[i] = low & 0x7F
   return result.slice(0, i + 1)
 }
 
@@ -64,11 +64,11 @@ function decodeUvarint64 (
       return [low, high, bytes]
     }
     if (s < 32) {
-      low |= (n & 0x7f) << s
+      low |= (n & 0x7F) << s
     }
     if (s > 0) {
       high |=
-        s - 32 > 0 ? (n & 0x7f) << (s - 32) : (n & 0x7f) >> (32 - s)
+        s - 32 > 0 ? (n & 0x7F) << (s - 32) : (n & 0x7F) >> (32 - s)
     }
     s += 7
   }

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

@@ -5,14 +5,14 @@ function fnv (data, hvalInit, fnvPrime, fnvSize) {
   let hval = hvalInit
   for (const byte of data) {
     hval = (hval * fnvPrime) % fnvSize
-    hval = hval ^ BigInt(byte)
+    hval ^= BigInt(byte)
   }
   return hval
 }
 
 function fnv64 (data) {
   if (!Buffer.isBuffer(data)) {
-    data = Buffer.from(data, 'utf-8')
+    data = Buffer.from(data, 'utf8')
   }
   const byteArray = new Uint8Array(data)
   return fnv(byteArray, FNV1_64_INIT, FNV_64_PRIME, 2n ** 64n)

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

@@ -77,19 +77,19 @@ function decodePathwayContextBase64 (pathwayContext) {
   return decodePathwayContext(encodedPathway)
 }
 
-class DsmPathwayCodec {
+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.
-  static encode (dataStreamsContext, carrier) {
+  encode (dataStreamsContext, carrier) {
     if (!dataStreamsContext || !dataStreamsContext.hash) {
       return
     }
     carrier[CONTEXT_PROPAGATION_KEY_BASE64] = encodePathwayContextBase64(dataStreamsContext)
 
     log.debug(() => `Injected into DSM carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
-  }
+  },
 
-  static decode (carrier) {
+  decode (carrier) {
     log.debug(() => `Attempting extract from DSM carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
 
     if (carrier == null) return

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

@@ -103,10 +103,8 @@ class StatsBucket {
   forBacklog (backlogData) {
     const backlog = new Backlog(backlogData)
     const existingBacklog = this._backlogs.get(backlog.hash)
-    if (existingBacklog !== undefined) {
-      if (existingBacklog.offset > backlog.offset) {
-        return existingBacklog
-      }
+    if (existingBacklog !== undefined && existingBacklog.offset > backlog.offset) {
+      return existingBacklog
     }
     this._backlogs.set(backlog.hash, backlog)
     return backlog
@@ -205,7 +203,9 @@ class DataStreamsProcessor {
     let parentHash = ENTRY_PARENT_HASH
     let closestOppositeDirectionHash = ENTRY_PARENT_HASH
     let closestOppositeDirectionEdgeStart = nowNs
-    if (ctx != null) {
+    if (ctx == null) {
+      log.debug(() => 'Setting DSM Checkpoint with empty parent context.')
+    } else {
       pathwayStartNs = ctx.pathwayStartNs
       edgeStartNs = ctx.edgeStartNs
       parentHash = ctx.hash
@@ -229,8 +229,6 @@ class DataStreamsProcessor {
       log.debug(
         () => `Setting DSM Checkpoint from extracted parent context with hash: ${parentHash} and edge tags: ${edgeTags}`
       )
-    } else {
-      log.debug(() => 'Setting DSM Checkpoint with empty parent context.')
     }
     const hash = computePathwayHash(this.service, this.env, edgeTags, parentHash)
     const edgeLatencyNs = nowNs - edgeStartNs

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

@@ -20,7 +20,7 @@ class SchemaBuilder {
   static getSchemaDefinition (schema) {
     const noNones = convertToJsonCompatible(schema)
     const definition = jsonStringify(noNones)
-    const id = fnv64(Buffer.from(definition, 'utf-8')).toString()
+    const id = fnv64(Buffer.from(definition, 'utf8')).toString()
     return new Schema(definition, id)
   }
 
@@ -117,12 +117,12 @@ function convertKey (key) {
 function jsonStringify (obj, indent = 2) {
   // made to stringify json exactly similar to python / java in order for hashing to be the same
   const jsonString = JSON.stringify(obj, (_, value) => value, indent)
-  return jsonString.replace(/^ +/gm, ' ') // Replace leading spaces with single space
-    .replace(/\n/g, '') // Remove newlines
-    .replace(/{ /g, '{') // Remove space after '{'
-    .replace(/ }/g, '}') // Remove space before '}'
-    .replace(/\[ /g, '[') // Remove space after '['
-    .replace(/ \]/g, ']') // Remove space before ']'
+  return jsonString.replaceAll(/^ +/gm, ' ') // Replace leading spaces with single space
+    .replaceAll('\n', '') // Remove newlines
+    .replaceAll('{ ', '{') // Remove space after '{'
+    .replaceAll(' }', '}') // Remove space before '}'
+    .replaceAll('[ ', '[') // Remove space after '['
+    .replaceAll(' ]', ']') // Remove space before ']'
 }
 
 module.exports = {

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

@@ -8,12 +8,10 @@ class SchemaSampler {
 
   trySample (currentTimeMs) {
     if (currentTimeMs >= this.lastSampleMs + SAMPLE_INTERVAL_MILLIS) {
-      if (currentTimeMs >= this.lastSampleMs + SAMPLE_INTERVAL_MILLIS) {
-        this.lastSampleMs = currentTimeMs
-        const weight = this.weight
-        this.weight = 0
-        return weight
-      }
+      this.lastSampleMs = currentTimeMs
+      const weight = this.weight
+      this.weight = 0
+      return weight
     }
     return 0
   }

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

@@ -4,7 +4,7 @@ const { types } = require('util')
 
 function getSizeOrZero (obj) {
   if (typeof obj === 'string') {
-    return Buffer.from(obj, 'utf-8').length
+    return Buffer.from(obj, 'utf8').length
   }
   if (types.isArrayBuffer(obj)) {
     return obj.byteLength

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,98 +90,93 @@ 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.
+  // need to update the condition of the breakpoint.
   if (probe) {
     probesAtLocation.set(probe.id, probe)
     probeToLocation.set(probe.id, breakpoint.locationKey)
   }
 
-  const condition = compileCompoundCondition(Array.from(probesAtLocation.values()))
+  const condition = compileCompoundCondition([...probesAtLocation.values()])
 
   if (condition || conditionBeforeNewProbe !== condition) {
     try {
@@ -198,7 +194,6 @@ async function updateBreakpoint (breakpoint, probe) {
     } catch (err) {
       throw new Error(`Error setting breakpoint for probe ${probe.id}`, { cause: err })
     }
-    breakpoint.id = result.breakpointId
     breakpointToProbes.set(result.breakpointId, probesAtLocation)
   }
 }
@@ -235,6 +230,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'
@@ -107,9 +105,8 @@ function compile (node) {
       return '$dd_key'
     } else if (value === '@value') {
       return '$dd_value'
-    } else {
-      return assertIdentifier(value)
     }
+    return assertIdentifier(value)
   } else if (Array.isArray(value)) {
     const args = value.map(compile)
     switch (type) {

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) {
@@ -103,6 +109,7 @@ session.on('Debugger.paused', async ({ params }) => {
       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,
@@ -128,7 +135,7 @@ session.on('Debugger.paused', async ({ params }) => {
 
   const timestamp = Date.now()
 
-  let evalResults = null
+  let evalResults
   const { result } = await session.post('Debugger.evaluateOnCallFrame', {
     callFrameId: params.callFrames[0].callFrameId,
     expression: templateExpressions.length === 0
@@ -155,7 +162,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/send.js

@@ -9,6 +9,7 @@ const request = require('../../exporters/common/request')
 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')
 
 module.exports = send
 
@@ -21,8 +22,8 @@ const hostname = getHostname()
 const service = config.service
 
 const ddtags = [
-  ['env', process.env.DD_ENV],
-  ['version', process.env.DD_VERSION],
+  ['env', getEnvironmentVariable('DD_ENV')],
+  ['version', getEnvironmentVariable('DD_VERSION')],
   ['debugger_version', version],
   ['host_name', hostname],
   [GIT_COMMIT_SHA, config.commitSHA],

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

@@ -77,9 +77,8 @@ function getObjectProperties (subtype, objectId, opts, depth) {
     return getProxy(objectId, opts, depth)
   } else if (subtype === 'arraybuffer') {
     return getArrayBuffer(objectId, opts, depth)
-  } else {
-    return getObject(objectId, opts, depth + 1, subtype === 'array' || subtype === 'typedarray')
   }
+  return getObject(objectId, opts, depth + 1, subtype === 'array' || subtype === 'typedarray')
 }
 
 // TODO: The following extra information from `internalProperties` might be relevant to include for functions:

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