dd-trace 6.20.0 → 6.21.0

package/packages/datadog-plugin-mocha/src/webdriverio-video.js

@@ -0,0 +1,449 @@
+'use strict'
+
+const { spawn, spawnSync } = require('node:child_process')
+const { mkdtempSync, rmSync, writeFileSync } = require('node:fs')
+const { tmpdir } = require('node:os')
+const { join } = require('node:path')
+const { performance } = require('node:perf_hooks')
+const { clearInterval, clearTimeout, setInterval, setTimeout } = require('node:timers')
+
+const {
+  VIDEO_UPLOAD_RESULT_ERROR,
+  VIDEO_UPLOAD_RESULT_UPLOADED,
+} = require('../../dd-trace/src/ci-visibility/test-video')
+const log = require('../../dd-trace/src/log')
+
+const CAPTURE_INTERVAL_MS = 500
+const CAPTURE_TIMEOUT_MS = 5000
+const ENCODING_TIMEOUT_MS = 30_000
+const MAX_PENDING_ENCODINGS = 32
+const MAX_PIXELS = 16 * 1024 * 1024
+const MAX_FRAME_BYTES = 200 * 1024 * 1024
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])
+const { queueMicrotask } = globalThis
+const captureOwners = new WeakMap()
+// A local timeout does not cancel the WebDriver request; keep its slot until it actually settles.
+const pendingCaptures = new WeakSet()
+const unsafePromptBrowsers = new WeakSet()
+
+let ffmpegAvailable
+// PNGs remain charged through encoding and upload, until their temporary files are removed.
+let frameBytes = 0
+
+/** @type {Array<() => void>} */
+const encodingQueue = []
+
+/**
+ * Runs one encoder at a time across all attempts in this WDIO process. Uploads do not hold the slot.
+ *
+ * @param {{ directory: string, index: number, frames: number[], filePath: string, size: number[] }} recording
+ * @param {(error?: Error) => void} onDone
+ */
+function encodeVideo (recording, onDone) {
+  // Include the active encoder in the queue limit.
+  if (encodingQueue.length > MAX_PENDING_ENCODINGS) {
+    queueMicrotask(() => onDone(new Error('WebdriverIO video encoding queue is full')))
+    return
+  }
+  let encoder
+  let timeout
+  const complete = error => {
+    const index = encodingQueue.indexOf(start)
+    if (index === -1) return
+    encodingQueue.splice(index, 1)
+    // Defer the next start so repeated process startup failures cannot recurse through the queue.
+    if (encodingQueue.length) queueMicrotask(encodingQueue[0])
+    onDone(error)
+  }
+  const start = () => {
+    // A queued start may have been cancelled before its microtask runs.
+    if (encoder || !encodingQueue.includes(start)) return
+    try {
+      const { directory, index, frames, filePath, size: [width, height] } = recording
+      const manifestPath = join(directory, `${index}.ffconcat`)
+      let manifest = 'ffconcat version 1.0\n'
+      for (let frame = 0; frame < frames.length; frame++) {
+        // Command captures are irregular: fixed 2 fps stretches assertion polling into long videos.
+        const duration = frame + 1 < frames.length ? (frames[frame + 1] - frames[frame]) / 1000 : 0.04
+        manifest += `file ${index}-${frame}.png\nduration ${duration.toFixed(6)}\n`
+      }
+      // The PNG demuxer uses 25 Hz timestamps. Repeat the final image one tick later so it survives
+      // rounding when the last two captures are less than 40 ms apart. WebM preserves variable timing.
+      manifest += `file ${index}-${frames.length - 1}.png\n`
+      writeFileSync(manifestPath, manifest)
+      encoder = spawn('ffmpeg', [
+        '-hide_banner', '-loglevel', 'error', '-nostdin', '-y',
+        '-threads', '1', '-f', 'concat', '-i', manifestPath,
+        '-frames:v', String(frames.length + 1), '-an', '-c:v', 'libvpx', '-deadline', 'realtime',
+        '-threads', '1', '-filter_threads', '1', '-pix_fmt', 'yuv420p',
+        '-vf', `scale=${width}:${height},setsar=1`, filePath,
+      ], { windowsHide: true, stdio: 'ignore' })
+      let encodingError
+      timeout = setTimeout(() => {
+        encodingError = new Error('WebdriverIO video encoding timed out')
+        // A kill request does not release the slot until the process actually closes.
+        encoder.kill('SIGKILL')
+      }, ENCODING_TIMEOUT_MS)
+      encoder.once('error', error => { encodingError = error })
+      encoder.once('close', code => {
+        clearTimeout(timeout)
+        if (code !== 0) encodingError ||= new Error(`WebdriverIO video encoder exited with code ${code}`)
+        complete(encodingError)
+      })
+    } catch (error) {
+      // Let the caller retain its cancellation callback even when process startup throws.
+      queueMicrotask(() => complete(error))
+    }
+  }
+  encodingQueue.push(start)
+  if (encodingQueue.length === 1) start()
+  return () => {
+    const index = encodingQueue.indexOf(start)
+    if (index === -1) return
+    if (encoder) {
+      clearTimeout(timeout)
+      // Shutdown must not wait for a process that cannot terminate. Keep its slot until close.
+      encoder.unref?.()
+      if (!encoder.kill('SIGKILL')) log.error('Error stopping WebdriverIO video encoder')
+    } else {
+      encodingQueue.splice(index, 1)
+      if (index === 0 && encodingQueue.length) queueMicrotask(encodingQueue[0])
+    }
+  }
+}
+
+// Like wdio-video-reporter, collect WebDriver screenshots and encode only failed attempts.
+// Encoding uses a customer-installed FFmpeg executable, isolated from the WDIO test process.
+class WebdriverioVideo {
+  #browser
+  #directory
+  #frames = []
+  #sizes = []
+  #bytes = 0
+  #capturing = false
+  #finalCapture = false
+  #completeCapture
+  #disabled = false
+  #stopped = false
+  #captureTimeout
+  #interval
+  #onCapture
+  #error
+  #onResult
+  #cancelEncoding
+  #finished = false
+  #onDone
+
+  /** @param {object} browser - WebdriverIO browser or multiremote browser */
+  constructor (browser) {
+    this.#browser = browser
+    this.#directory = mkdtempSync(join(tmpdir(), 'dd-trace-wdio-video-'))
+    captureOwners.set(browser, this)
+    this.#onResult = /** @param {{command?: string, endpoint?: string}} event */ (event) => {
+      const { command, endpoint } = event
+      if (command === 'takeScreenshot' || endpoint?.endsWith('/screenshot')) return
+      // WDIO looks up the context before BiDi navigation. Capturing in that gap can block navigation.
+      if (command === 'getWindowHandle' || command === 'getWindowHandles') return
+      this.capture()
+    }
+    browser.on?.('result', this.#onResult)
+    this.#interval = setInterval(() => this.capture(), CAPTURE_INTERVAL_MS)
+    this.#interval.unref?.()
+    this.capture()
+  }
+
+  /** Captures at most one in-flight screenshot, including all multiremote sessions. */
+  capture () {
+    if ((this.#stopped && !this.#finalCapture) || this.#capturing || this.#error || this.#disabled ||
+        pendingCaptures.has(this.#browser) || captureOwners.get(this.#browser) !== this) return
+    this.#finalCapture = false
+    this.#capturing = true
+    let completed = false
+    const complete = (error, screenshots, capturedAt) => {
+      if (completed || this.#finished) return
+      completed = true
+      this.#capturing = false
+      if (error) {
+        log.error('Error capturing WebdriverIO video frame: %s', error.message)
+      } else if (!this.#disabled && captureOwners.get(this.#browser) === this) {
+        try {
+          this.#writeFrames(screenshots, capturedAt)
+        } catch (error) {
+          this.#error = error
+        }
+      }
+      if (this.#finalCapture) {
+        this.capture()
+        if (this.#capturing) return
+      }
+      this.#finalCapture = false
+      clearTimeout(this.#captureTimeout)
+      this.#captureTimeout = undefined
+      this.#completeCapture = undefined
+      const onCapture = this.#onCapture
+      this.#onCapture = undefined
+      onCapture?.()
+    }
+    this.#completeCapture = complete
+    // An overlapping capture and its fresh final frame share the existing five-second deadline.
+    this.#captureTimeout ??= setTimeout(() => {
+      this.#completeCapture?.(new Error('WebdriverIO video screenshot capture timed out'))
+    }, CAPTURE_TIMEOUT_MS)
+    this.#captureTimeout.unref?.()
+    try {
+      if (!hasSafePromptPolicy(this.#browser)) {
+        this.#disabled = true
+        clearInterval(this.#interval)
+        this.#browser.removeListener?.('result', this.#onResult)
+        return complete()
+      }
+      if (this.#browser.isMultiremote || this.#browser.isMultiRemote) {
+        const names = this.#browser.instances
+        if (!names.length) return complete(new Error('WebdriverIO returned no browser sessions'))
+        const browsers = names.map(name => this.#browser.getInstance(name))
+        const frames = new Array(names.length)
+        const captureTimes = new Array(names.length)
+        let pending = names.length
+        let captureError
+        pendingCaptures.add(this.#browser)
+        for (let index = 0; index < names.length; index++) {
+          this.#captureBrowser(browsers[index], (error, frame, capturedAt) => {
+            captureError ||= error
+            frames[index] = frame
+            captureTimes[index] = capturedAt
+            if (--pending === 0) {
+              pendingCaptures.delete(this.#browser)
+              complete(captureError, frames, captureTimes)
+            }
+          })
+        }
+      } else {
+        pendingCaptures.add(this.#browser)
+        this.#captureBrowser(this.#browser, (error, frame, capturedAt) => {
+          pendingCaptures.delete(this.#browser)
+          complete(error, frame, capturedAt)
+        })
+      }
+    } catch (error) {
+      complete(error)
+    }
+  }
+
+  /**
+   * @param {object} browser - A single WebDriver session, including sessions with BiDi enabled
+   * @param {(error?: Error, frame?: string, capturedAt?: number) => void} onDone
+   */
+  #captureBrowser (browser, onDone) {
+    try {
+      // Use the session's WebDriver screenshot command. Direct BiDi captures can lose their
+      // browsing context during concurrent navigation and never return a frame.
+      // Timestamp each session before waiting for the rest of a multiremote batch.
+      browser.takeScreenshot().then(result => onDone(undefined, result, performance.now()), onDone)
+    } catch (error) {
+      onDone(error)
+    }
+  }
+
+  /**
+   * @param {string|string[]} screenshots - Base64 PNG screenshots, in session order
+   * @param {number|number[]} capturedAt - Completion timestamps in the same session order
+   */
+  #writeFrames (screenshots, capturedAt) {
+    const frames = Array.isArray(screenshots) ? screenshots : [screenshots]
+    if (!frames.length) throw new Error('WebdriverIO returned no video frames')
+    for (let index = 0; index < frames.length; index++) {
+      if (typeof frames[index] !== 'string') throw new Error('WebdriverIO returned an invalid video frame')
+      if (Buffer.byteLength(frames[index], 'base64') > MAX_FRAME_BYTES - frameBytes) {
+        throw new Error('WebdriverIO video frames exceeded the 200 MiB worker limit')
+      }
+      const frame = Buffer.from(frames[index], 'base64')
+      if (frame.length < 24 || !frame.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) {
+        throw new Error('WebdriverIO returned an invalid PNG video frame')
+      }
+      const width = frame.readUInt32BE(16)
+      const height = frame.readUInt32BE(20)
+      if (!width || !height || width * height > MAX_PIXELS) {
+        throw new Error('WebdriverIO video frame exceeds the 16 megapixel limit or has invalid dimensions')
+      }
+      if (!this.#sizes[index]) {
+        // Keep a fixed, even output size across viewport changes.
+        const scale = Math.min(1, 1280 / width, 720 / height)
+        this.#sizes[index] = [
+          Math.max(2, Math.floor(width * scale / 2) * 2),
+          Math.max(2, Math.floor(height * scale / 2) * 2),
+        ]
+      }
+      const timestamps = this.#frames[index] ||= []
+      const frameNumber = timestamps.length
+      // Reserve before writing so a partial write stays accounted for until cleanup.
+      frameBytes += frame.length
+      this.#bytes += frame.length
+      writeFileSync(join(this.#directory, `${index}-${frameNumber}.png`), frame)
+      timestamps.push(Array.isArray(capturedAt) ? capturedAt[index] : capturedAt)
+    }
+  }
+
+  /**
+   * Stops capture, uploads failed attempts, and removes all owned files after upload completion.
+   *
+   * @param {boolean} failed - Whether this attempt failed
+   * @param {(filePath: string, index: number, onDone: (error?: Error) => void) => void} upload
+   * @param {(result?: string) => void} onDone
+   */
+  finish (failed, upload, onDone) {
+    if (this.#stopped) return
+    this.#onDone = onDone
+    if (failed) {
+      if (this.#capturing) this.#finalCapture = true
+      else this.capture()
+    }
+    this.#stopped = true
+    clearInterval(this.#interval)
+    this.#browser.removeListener?.('result', this.#onResult)
+    const finish = () => {
+      if (this.#finished) return
+      if (!failed || this.#disabled) return this.#cleanup(undefined, onDone)
+      if (this.#error || !this.#frames.length) {
+        log.error('Error recording WebdriverIO failure video: %s', this.#error?.message || 'No frames captured')
+        return this.#cleanup(VIDEO_UPLOAD_RESULT_ERROR, onDone)
+      }
+      this.#encode(0, upload, false, onDone)
+    }
+    if (this.#capturing) this.#onCapture = finish
+    else finish()
+  }
+
+  /** @param {() => void} onDone - Releases a retry once this attempt's final capture settles. */
+  waitForCapture (onDone) {
+    if (!this.#capturing || this.#finished) return onDone()
+    const previous = this.#onCapture
+    this.#onCapture = () => {
+      previous?.()
+      onDone()
+    }
+  }
+
+  /** Cancels a finishing attempt at the worker's final-flush deadline. */
+  cancel () {
+    if (this.#finished) return
+    this.#cancelEncoding?.()
+    this.#cleanup(VIDEO_UPLOAD_RESULT_ERROR, this.#onDone)
+  }
+
+  /**
+   * Encodes multiremote sessions sequentially to bound encoder resource use.
+   *
+   * @param {number} index
+   * @param {(filePath: string, index: number, onDone: (error?: Error) => void) => void} upload
+   * @param {boolean} hasError
+   * @param {(result?: string) => void} onDone
+   */
+  #encode (index, upload, hasError, onDone) {
+    if (index === this.#frames.length) {
+      return this.#cleanup(hasError ? VIDEO_UPLOAD_RESULT_ERROR : VIDEO_UPLOAD_RESULT_UPLOADED, onDone)
+    }
+    const filePath = join(this.#directory, `${index}.webm`)
+    let completed = false
+    const next = error => {
+      if (completed) return
+      completed = true
+      // Cancellation may try cleanup while encoding or upload still holds files open.
+      if (this.#finished) return this.#cleanup(undefined, () => {})
+      if (error) log.error('Error uploading WebdriverIO failure video: %s', error.message)
+      this.#encode(index + 1, upload, hasError || Boolean(error), onDone)
+    }
+    const recording = {
+      directory: this.#directory,
+      index,
+      frames: this.#frames[index],
+      filePath,
+      size: this.#sizes[index],
+    }
+    this.#cancelEncoding = encodeVideo(recording, error => {
+      if (this.#finished || error) return next(error)
+      try {
+        upload(filePath, index, next)
+      } catch (error) {
+        next(error)
+      }
+    })
+  }
+
+  /**
+   * @param {string|undefined} result
+   * @param {(result?: string) => void} onDone
+   */
+  #cleanup (result, onDone) {
+    this.#finished = true
+    if (captureOwners.get(this.#browser) === this) captureOwners.delete(this.#browser)
+    clearTimeout(this.#captureTimeout)
+    this.#completeCapture = undefined
+    const onCapture = this.#onCapture
+    this.#onCapture = undefined
+    onCapture?.()
+    try {
+      rmSync(this.#directory, { recursive: true, force: true })
+      frameBytes -= this.#bytes
+      this.#bytes = 0
+    } catch (error) {
+      log.error('Error removing WebdriverIO video files: %s', error.message)
+    }
+    onDone(result)
+  }
+}
+
+/** @param {object} browser - Current WebdriverIO browser or multiremote browser */
+function hasSafePromptPolicy (browser) {
+  const sessions = (browser.isMultiremote || browser.isMultiRemote)
+    ? browser.instances.map(name => browser.getInstance(name))
+    : [browser]
+  for (const session of sessions) {
+    const behavior = session.capabilities?.unhandledPromptBehavior
+    if (behavior === 'ignore' || (behavior?.default === 'ignore' &&
+      Object.values(behavior).every(value => value === 'ignore'))) continue
+    if (!unsafePromptBrowsers.has(browser)) {
+      unsafePromptBrowsers.add(browser)
+      log.warn('WebdriverIO failure video recording is disabled: every session must use %s to preserve open dialogs.',
+        'unhandledPromptBehavior: "ignore"')
+    }
+    return false
+  }
+  return true
+}
+
+/** Checks FFmpeg once in the worker, before configuring browser sessions or recording attempts. */
+function isFfmpegAvailable () {
+  if (ffmpegAvailable !== undefined) return ffmpegAvailable
+  ffmpegAvailable = false
+  try {
+    const result = spawnSync('ffmpeg', ['-hide_banner', '-encoders'], {
+      timeout: 5000, killSignal: 'SIGKILL', windowsHide: true, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    })
+    ffmpegAvailable = !result.error && result.status === 0 && /^[ \t]*V\S{5}[ \t]+libvpx[ \t]/m.test(result.stdout)
+  } catch (error) {
+    log.error('Error checking WebdriverIO video FFmpeg availability: %s', error.message)
+  }
+  if (!ffmpegAvailable) {
+    log.warn('WebdriverIO failure video recording requires FFmpeg on PATH with the libvpx encoder.')
+  }
+  return ffmpegAvailable
+}
+
+/**
+ * Creates a recorder when a browser is available. The encoder is loaded only for failed attempts.
+ *
+ * @param {object} browser
+ * @returns {WebdriverioVideo|void}
+ */
+function createWebdriverioVideo (browser) {
+  if (typeof browser?.takeScreenshot !== 'function') return
+  try {
+    if (ffmpegAvailable === false || !hasSafePromptPolicy(browser) || !isFfmpegAvailable()) return
+    return new WebdriverioVideo(browser)
+  } catch (error) {
+    log.error('Error starting WebdriverIO video recording: %s', error.message)
+  }
+}
+
+module.exports = createWebdriverioVideo
+module.exports.isFfmpegAvailable = isFfmpegAvailable

package/packages/dd-trace/src/config/supported-configurations.json

@@ -3655,9 +3655,9 @@
     ],
     "DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP": [
       {
-        "implementation": "F",
+        "implementation": "I",
         "type": "string",
-        "default": "(?:p(?:ass)?w(?:or)?d|pass(?:_?phrase)?|secret|(?:api_?|private_?|public_?|access_?|secret_?)key(?:_?id)?|token|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)(?:(?:\\s|%20)*(?:=|%3D)[^&]+|(?:\"|%22)(?:\\s|%20)*(?::|%3A)(?:\\s|%20)*(?:\"|%22)(?:%2[^2]|%[^2]|[^\"%])+(?:\"|%22))|bearer(?:\\s|%20)+[a-z0-9\\._\\-]+|token(?::|%3A)[a-z0-9]{13}|gh[opsu]_[0-9a-zA-Z]{36}|ey[I-L](?:[\\w=-]|%3D)+\\.ey[I-L](?:[\\w=-]|%3D)+(?:\\.(?:[\\w.+\\/=-]|%3D|%2F|%2B)+)?|[\\-]{5}BEGIN(?:[a-z\\s]|%20)+PRIVATE(?:\\s|%20)KEY[\\-]{5}[^\\-]+[\\-]{5}END(?:[a-z\\s]|%20)+PRIVATE(?:\\s|%20)KEY|ssh-rsa(?:\\s|%20)*(?:[a-z0-9\\/\\.+]|%2F|%5C|%2B){100,}"
+        "default": "(?:(?:\"|%22)?)(?:(?:old[-_]?|new[-_]?)?p(?:ass)?w(?:or)?d(?:1|2)?|pass(?:[-_]?phrase)?|secret|(?:api[-_]?|private[-_]?|public[-_]?|access[-_]?|secret[-_]?|app(?:lication)?[-_]?)key(?:[-_]?id)?|token|consumer[-_]?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)(?:(?:\\s|%20)*(?:=|%3D)[^&]+|(?:\"|%22)(?:\\s|%20)*(?::|%3A)(?:\\s|%20)*(?:\"|%22)(?:%2[^2]|%[^2]|[^\"%])+(?:\"|%22))|(?:bearer(?:\\s|%20)+[a-z0-9._\\-]+|token(?::|%3A)[a-z0-9]{13}|gh[opsu]_[0-9a-zA-Z]{36}|(^|[^\\w%-]|%[0-9a-f]{2})ey[I-L][\\w-]+(?:=|%3D)*\\.ey[I-L][\\w-]+(?:=|%3D)*(?:\\.(?:[\\w.+/=-]|%3D|%2F|%2B)+)?|-{5}BEGIN(?:[a-z\\s]|%20)+PRIVATE(?:\\s|%20)KEY-{5}[^\\-]+-{5}END(?:[a-z\\s]|%20)+PRIVATE(?:\\s|%20)KEY(?:-{5})?(?:\\n|%0A)?|(?:ssh-(?:rsa|dss)|ecdsa-[a-z0-9]+-[a-z0-9]+)(?:\\s|%20|%09)+(?:[a-z0-9/.+]|%2F|%5C|%2B){100,}(?:=|%3D)*(?:(?:\\s|%20|%09)+[a-z0-9._-]+)?)"
       }
     ],
     "DD_TRACE_OPENAI_ENABLED": [

package/packages/dd-trace/src/debugger/constants.js

@@ -6,6 +6,7 @@ const WORKER_ERROR_REASON = Object.freeze({
   UNSUPPORTED_INSERTION_POINT: 'unsupported_insertion_point',
   CONFLICTING_CAPTURE_OPTIONS: 'conflicting_capture_options',
   UNKNOWN_REMOTE_CONFIG_ACTION: 'unknown_remote_config_action',
+  WORKER_ENTRY_POINT_NOT_FOUND: 'worker_entry_point_not_found',
 })
 
 module.exports = {

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

@@ -22,6 +22,7 @@ const { getLocalStateForCallFrame, evaluateCaptureExpressions } = require('./sna
 const send = require('./send')
 const { getStackFromCallFrames } = require('./state')
 const { ackEmitting } = require('./status')
+const WorkerError = require('./worker-error')
 const config = require('./config')
 const log = require('./log')
 
@@ -51,9 +52,10 @@ session.on('Debugger.paused', async ({ params }) => {
 
   if (params.reason !== 'other') {
     // This error should not be caught, and should exit the worker thread, effectively stopping the debugging session
-    throw Object.assign(new Error(`Unexpected Debugger.paused reason: ${params.reason}`), {
-      reason: WORKER_ERROR_REASON.UNEXPECTED_PAUSE_REASON,
-    })
+    throw new WorkerError(
+      `Unexpected Debugger.paused reason: ${params.reason}`,
+      WORKER_ERROR_REASON.UNEXPECTED_PAUSE_REASON
+    )
   }
 
   let maxReferenceDepth = 0

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

@@ -4,6 +4,7 @@ const { workerData: { probePort } } = require('node:worker_threads')
 const { WORKER_ERROR_REASON } = require('../constants')
 const { addBreakpoint, removeBreakpoint, modifyBreakpoint } = require('./breakpoints')
 const { ackReceived, ackInstalled, ackError } = require('./status')
+const WorkerError = require('./worker-error')
 const log = require('./log')
 
 // Example log line probe with captureSnapshot (simplified):
@@ -74,20 +75,23 @@ async function processMsg (action, probe) {
   if (action !== 'unapply') ackReceived(probe)
 
   if (probe.type !== 'LOG_PROBE') {
-    throw Object.assign(new Error(
-      `Unsupported probe type: ${probe.type} (id: ${probe.id}, version: ${probe.version})`
-    ), { reason: WORKER_ERROR_REASON.UNSUPPORTED_PROBE_TYPE })
+    throw new WorkerError(
+      `Unsupported probe type: ${probe.type} (id: ${probe.id}, version: ${probe.version})`,
+      WORKER_ERROR_REASON.UNSUPPORTED_PROBE_TYPE
+    )
   }
   if (!probe.where.sourceFile && !probe.where.lines) {
-    throw Object.assign(new Error(
+    throw new WorkerError(
       // eslint-disable-next-line @stylistic/max-len
-      `Unsupported probe insertion point! Only line-based probes are supported (id: ${probe.id}, version: ${probe.version})`
-    ), { reason: WORKER_ERROR_REASON.UNSUPPORTED_INSERTION_POINT })
+      `Unsupported probe insertion point! Only line-based probes are supported (id: ${probe.id}, version: ${probe.version})`,
+      WORKER_ERROR_REASON.UNSUPPORTED_INSERTION_POINT
+    )
   }
   if (probe.captureSnapshot && probe.captureExpressions?.length > 0) {
-    throw Object.assign(new Error(
-      `Cannot set both captureSnapshot and captureExpressions (probe: ${probe.id}, version: ${probe.version})`
-    ), { reason: WORKER_ERROR_REASON.CONFLICTING_CAPTURE_OPTIONS })
+    throw new WorkerError(
+      `Cannot set both captureSnapshot and captureExpressions (probe: ${probe.id}, version: ${probe.version})`,
+      WORKER_ERROR_REASON.CONFLICTING_CAPTURE_OPTIONS
+    )
   }
 
   switch (action) {
@@ -103,8 +107,9 @@ async function processMsg (action, probe) {
       ackInstalled(probe)
       break
     default:
-      throw Object.assign(new Error(
-        `Cannot process probe ${probe.id} (version: ${probe.version}) - unknown remote configuration action: ${action}`
-      ), { reason: WORKER_ERROR_REASON.UNKNOWN_REMOTE_CONFIG_ACTION })
+      throw new WorkerError(
+        `Cannot process probe ${probe.id} (version: ${probe.version}) - unknown remote configuration action: ${action}`,
+        WORKER_ERROR_REASON.UNKNOWN_REMOTE_CONFIG_ACTION
+      )
   }
 }

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

@@ -17,8 +17,12 @@ const buildTags = require('./tags')
 
 module.exports = send
 
-const MAX_LOG_PAYLOAD_SIZE_MB = 1
-const MAX_LOG_PAYLOAD_SIZE_BYTES = MAX_LOG_PAYLOAD_SIZE_MB * 1024 * 1024
+// The backend caps a single debugger event at 1 MiB, but measures the CBOR-encoded event *after* the
+// intake has enriched it with host tags, `ddtags` and other metadata we cannot size from here. Leave
+// the same 4 KiB of headroom as dd-trace-go: crossing the backend cap is worse than pruning, since
+// its truncation destroys the log message before it drops the snapshot.
+const BACKEND_ENRICHMENT_HEADROOM_BYTES = 4 * 1024
+const MAX_LOG_PAYLOAD_SIZE_BYTES = 1024 * 1024 - BACKEND_ENRICHMENT_HEADROOM_BYTES
 
 const ddsource = 'dd_debugger'
 const hostname = getHostname()

package/packages/dd-trace/src/debugger/devtools_client/worker-error.js

@@ -0,0 +1,21 @@
+'use strict'
+
+/** @typedef {typeof import('../constants').WORKER_ERROR_REASON} WorkerErrorReasons */
+
+/**
+ * An error carrying a failure reason for telemetry. Its prototype does not survive the worker boundary, so the main
+ * thread must read `reason` instead of checking `instanceof`. `name` is left as `Error` because structured cloning
+ * only keeps built-in error names, and telemetry should report the same name however the error leaves the worker.
+ */
+class WorkerError extends Error {
+  /**
+   * @param {string} message - The error message
+   * @param {WorkerErrorReasons[keyof WorkerErrorReasons]} reason - The failure reason reported in telemetry
+   */
+  constructor (message, reason) {
+    super(message)
+    this.reason = reason
+  }
+}
+
+module.exports = WorkerError

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

@@ -8,6 +8,7 @@ const dc = require('dc-polyfill')
 const log = require('../log')
 const { fetchAgentInfo } = require('../agent/info')
 const telemetryMetrics = require('../telemetry/metrics')
+const { logGenericError } = require('../startup-log')
 const getDebuggerConfig = require('./config')
 const {
   DEBUGGER_DIAGNOSTICS_V1,
@@ -15,6 +16,7 @@ const {
   DEBUGGER_INPUT_V2,
   INSPECT_SEGMENT_GLOBAL_PROPERTY,
   METRICS_FLUSH_INTERVAL_MS,
+  WORKER_ERROR_REASON,
 } = require('./constants')
 const { GuardrailMetrics, TELEMETRY_NAMESPACE } = require('./guardrail-metrics')
 const { PauseDurationHistogram } = require('./pause-duration-histogram')
@@ -33,6 +35,8 @@ const { configureProbeSampler, installProbeSampler, uninstallProbeSampler } = re
 // be lost when the application exits on its own.
 const TELEMETRY_APP_CLOSING_CHANNEL = 'datadog:telemetry:app-closing'
 
+const WORKER_FILENAME = join(__dirname, 'devtools_client', 'index.js')
+
 let worker = null
 let configChannel = null
 let ackId = 0
@@ -139,7 +143,7 @@ function start (config, rcInstance) {
     inputPath = _inputPath
 
     worker = new Worker(
-      join(__dirname, 'devtools_client', 'index.js'),
+      WORKER_FILENAME,
       {
         name: 'dd-debugger',
         execArgv: [], // Avoid worker thread inheriting the `-r` command line argument
@@ -165,7 +169,7 @@ function start (config, rcInstance) {
       )
     })
 
-    worker.on('error', (err) => logWorkerError(err))
+    worker.on('error', onWorkerError)
     worker.on('messageerror', (err) => log.error('[debugger] received "messageerror" from worker', err))
 
     worker.once('exit', (code) => {
@@ -186,6 +190,24 @@ function start (config, rcInstance) {
   })
 }
 
+/**
+ * @param {Error & { code?: unknown, requireStack?: unknown }} error - The error emitted by the worker thread
+ */
+function onWorkerError (error) {
+  // Node.js reports an empty require stack when the module it cannot find is the worker entry point itself, rather
+  // than one of its dependencies. This happens when the dd-trace files are not on disk where dd-trace expects them,
+  // e.g. because dd-trace was bundled into the application, or because some of its files were not deployed.
+  if (error.code === 'MODULE_NOT_FOUND' && Array.isArray(error.requireStack) && error.requireStack.length === 0) {
+    logGenericError(
+      `Dynamic Instrumentation is disabled, because its worker thread could not load ${WORKER_FILENAME}. ` +
+      'Make sure dd-trace is installed as regular files on disk and is not bundled into the application.'
+    )
+    logWorkerError(error, WORKER_ERROR_REASON.WORKER_ENTRY_POINT_NOT_FOUND)
+    return
+  }
+  logWorkerError(error)
+}
+
 /**
  * Failure metadata belongs in the telemetry message; exception messages remain in the redacted cause.
  *