dd-trace 5.31.0 → 5.33.0

package/packages/dd-trace/src/ci-visibility/dynamic-instrumentation/index.js

@@ -1,12 +1,12 @@
 'use strict'
 
 const { join } = require('path')
-const { Worker } = require('worker_threads')
+const { Worker, threadId: parentThreadId } = require('worker_threads')
 const { randomUUID } = require('crypto')
 const log = require('../../log')
 
 const probeIdToResolveBreakpointSet = new Map()
-const probeIdToResolveBreakpointHit = new Map()
+const probeIdToResolveBreakpointRemove = new Map()
 
 class TestVisDynamicInstrumentation {
   constructor () {
@@ -16,28 +16,34 @@ class TestVisDynamicInstrumentation {
     })
     this.breakpointSetChannel = new MessageChannel()
     this.breakpointHitChannel = new MessageChannel()
+    this.breakpointRemoveChannel = new MessageChannel()
+    this.onHitBreakpointByProbeId = new Map()
   }
 
-  // Return 3 elements:
-  // 1. Snapshot ID
+  removeProbe (probeId) {
+    return new Promise(resolve => {
+      this.breakpointRemoveChannel.port2.postMessage(probeId)
+
+      probeIdToResolveBreakpointRemove.set(probeId, resolve)
+    })
+  }
+
+  // Return 2 elements:
+  // 1. Probe ID
   // 2. Promise that's resolved when the breakpoint is set
-  // 3. Promise that's resolved when the breakpoint is hit
-  addLineProbe ({ file, line }) {
-    const snapshotId = randomUUID()
+  addLineProbe ({ file, line }, onHitBreakpoint) {
     const probeId = randomUUID()
 
-    this.breakpointSetChannel.port2.postMessage({
-      snapshotId,
-      probe: { id: probeId, file, line }
-    })
+    this.breakpointSetChannel.port2.postMessage(
+      { id: probeId, file, line }
+    )
+
+    this.onHitBreakpointByProbeId.set(probeId, onHitBreakpoint)
 
     return [
-      snapshotId,
+      probeId,
       new Promise(resolve => {
         probeIdToResolveBreakpointSet.set(probeId, resolve)
-      }),
-      new Promise(resolve => {
-        probeIdToResolveBreakpointHit.set(probeId, resolve)
       })
     ]
   }
@@ -46,23 +52,42 @@ class TestVisDynamicInstrumentation {
     return this._readyPromise
   }
 
-  start () {
+  start (config) {
     if (this.worker) return
 
-    const { NODE_OPTIONS, ...envWithoutNodeOptions } = process.env
-
     log.debug('Starting Test Visibility - Dynamic Instrumentation client...')
 
+    const rcChannel = new MessageChannel() // mock channel
+    const configChannel = new MessageChannel() // mock channel
+
     this.worker = new Worker(
       join(__dirname, 'worker', 'index.js'),
       {
         execArgv: [],
-        env: envWithoutNodeOptions,
+        // Not passing `NODE_OPTIONS` results in issues with yarn, which relies on NODE_OPTIONS
+        // for PnP support, hence why we deviate from the DI pattern here.
+        // To avoid infinite initialization loops, we're disabling DI and tracing in the worker.
+        env: {
+          ...process.env,
+          DD_TRACE_ENABLED: 0,
+          DD_TEST_DYNAMIC_INSTRUMENTATION_ENABLED: 0
+        },
         workerData: {
+          config: config.serialize(),
+          parentThreadId,
+          rcPort: rcChannel.port1,
+          configPort: configChannel.port1,
           breakpointSetChannel: this.breakpointSetChannel.port1,
-          breakpointHitChannel: this.breakpointHitChannel.port1
+          breakpointHitChannel: this.breakpointHitChannel.port1,
+          breakpointRemoveChannel: this.breakpointRemoveChannel.port1
         },
-        transferList: [this.breakpointSetChannel.port1, this.breakpointHitChannel.port1]
+        transferList: [
+          rcChannel.port1,
+          configChannel.port1,
+          this.breakpointSetChannel.port1,
+          this.breakpointHitChannel.port1,
+          this.breakpointRemoveChannel.port1
+        ]
       }
     )
     this.worker.on('online', () => {
@@ -70,10 +95,18 @@ class TestVisDynamicInstrumentation {
       this._onReady()
     })
 
+    this.worker.on('error', (err) => {
+      log.error('Test Visibility - Dynamic Instrumentation worker error', err)
+    })
+
+    this.worker.on('messageerror', (err) => {
+      log.error('Test Visibility - Dynamic Instrumentation worker messageerror', err)
+    })
+
     // Allow the parent to exit even if the worker is still running
     this.worker.unref()
 
-    this.breakpointSetChannel.port2.on('message', ({ probeId }) => {
+    this.breakpointSetChannel.port2.on('message', (probeId) => {
       const resolve = probeIdToResolveBreakpointSet.get(probeId)
       if (resolve) {
         resolve()
@@ -83,15 +116,19 @@ class TestVisDynamicInstrumentation {
 
     this.breakpointHitChannel.port2.on('message', ({ snapshot }) => {
       const { probe: { id: probeId } } = snapshot
-      const resolve = probeIdToResolveBreakpointHit.get(probeId)
-      if (resolve) {
-        resolve({ snapshot })
-        probeIdToResolveBreakpointHit.delete(probeId)
+      const onHit = this.onHitBreakpointByProbeId.get(probeId)
+      if (onHit) {
+        onHit({ snapshot })
       }
     }).unref()
 
-    this.worker.on('error', (err) => log.error('ci-visibility DI worker error', err))
-    this.worker.on('messageerror', (err) => log.error('ci-visibility DI worker messageerror', err))
+    this.breakpointRemoveChannel.port2.on('message', (probeId) => {
+      const resolve = probeIdToResolveBreakpointRemove.get(probeId)
+      if (resolve) {
+        resolve()
+        probeIdToResolveBreakpointRemove.delete(probeId)
+      }
+    }).unref()
   }
 }
 

package/packages/dd-trace/src/ci-visibility/dynamic-instrumentation/worker/index.js

@@ -1,7 +1,14 @@
 'use strict'
-const sourceMap = require('source-map')
 const path = require('path')
-const { workerData: { breakpointSetChannel, breakpointHitChannel } } = require('worker_threads')
+const {
+  workerData: {
+    breakpointSetChannel,
+    breakpointHitChannel,
+    breakpointRemoveChannel
+  }
+} = require('worker_threads')
+const { randomUUID } = require('crypto')
+const sourceMap = require('source-map')
 
 // TODO: move debugger/devtools_client/session to common place
 const session = require('../../../debugger/devtools_client/session')
@@ -16,8 +23,8 @@ const log = require('../../../log')
 
 let sessionStarted = false
 
-const breakpointIdToSnapshotId = new Map()
 const breakpointIdToProbe = new Map()
+const probeIdToBreakpointId = new Map()
 
 session.on('Debugger.paused', async ({ params: { hitBreakpoints: [hitBreakpoint], callFrames } }) => {
   const probe = breakpointIdToProbe.get(hitBreakpoint)
@@ -32,13 +39,11 @@ session.on('Debugger.paused', async ({ params: { hitBreakpoints: [hitBreakpoint]
 
   await session.post('Debugger.resume')
 
-  const snapshotId = breakpointIdToSnapshotId.get(hitBreakpoint)
-
   const snapshot = {
-    id: snapshotId,
+    id: randomUUID(),
     timestamp: Date.now(),
     probe: {
-      id: probe.probeId,
+      id: probe.id,
       version: '0',
       location: probe.location
     },
@@ -56,13 +61,32 @@ session.on('Debugger.paused', async ({ params: { hitBreakpoints: [hitBreakpoint]
   breakpointHitChannel.postMessage({ snapshot })
 })
 
-// TODO: add option to remove breakpoint
-breakpointSetChannel.on('message', async ({ snapshotId, probe: { id: probeId, file, line } }) => {
-  await addBreakpoint(snapshotId, { probeId, file, line })
-  breakpointSetChannel.postMessage({ probeId })
+breakpointRemoveChannel.on('message', async (probeId) => {
+  await removeBreakpoint(probeId)
+  breakpointRemoveChannel.postMessage(probeId)
+})
+
+breakpointSetChannel.on('message', async (probe) => {
+  await addBreakpoint(probe)
+  breakpointSetChannel.postMessage(probe.id)
 })
 
-async function addBreakpoint (snapshotId, probe) {
+async function removeBreakpoint (probeId) {
+  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 ${probeId}: Debugger not started`)
+  }
+
+  const breakpointId = probeIdToBreakpointId.get(probeId)
+  if (!breakpointId) {
+    throw Error(`Unknown probe id: ${probeId}`)
+  }
+  await session.post('Debugger.removeBreakpoint', { breakpointId })
+  probeIdToBreakpointId.delete(probeId)
+  breakpointIdToProbe.delete(breakpointId)
+}
+
+async function addBreakpoint (probe) {
   if (!sessionStarted) await start()
   const { file, line } = probe
 
@@ -81,7 +105,7 @@ async function addBreakpoint (snapshotId, probe) {
     try {
       lineNumber = await processScriptWithInlineSourceMap({ file, line, sourceMapURL })
     } catch (err) {
-      log.error(err)
+      log.error('Error processing script with inline source map', err)
     }
   }
 
@@ -93,7 +117,7 @@ async function addBreakpoint (snapshotId, probe) {
   })
 
   breakpointIdToProbe.set(breakpointId, probe)
-  breakpointIdToSnapshotId.set(breakpointId, snapshotId)
+  probeIdToBreakpointId.set(probe.id, breakpointId)
 }
 
 function start () {
@@ -113,14 +137,30 @@ async function processScriptWithInlineSourceMap (params) {
   // Parse the source map
   const consumer = await new sourceMap.SourceMapConsumer(decodedSourceMap)
 
-  // Map to the generated position
-  const generatedPosition = consumer.generatedPositionFor({
-    source: path.basename(file), // this needs to be the file, not the filepath
+  let generatedPosition
+
+  // Map to the generated position. We'll attempt with the full file path first, then with the basename.
+  // TODO: figure out why sometimes the full path doesn't work
+  generatedPosition = consumer.generatedPositionFor({
+    source: file,
     line,
     column: 0
   })
+  if (generatedPosition.line === null) {
+    generatedPosition = consumer.generatedPositionFor({
+      source: path.basename(file),
+      line,
+      column: 0
+    })
+  }
 
   consumer.destroy()
 
+  // If we can't find the line, just return the original line
+  if (generatedPosition.line === null) {
+    log.error(`Could not find generated position for ${file}:${line}`)
+    return line
+  }
+
   return generatedPosition.line
 }

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -87,9 +87,8 @@ class CiVisibilityExporter extends AgentInfoExporter {
 
   shouldRequestKnownTests () {
     return !!(
-      this._config.isEarlyFlakeDetectionEnabled &&
       this._canUseCiVisProtocol &&
-      this._libraryConfig?.isEarlyFlakeDetectionEnabled
+      this._libraryConfig?.isKnownTestsEnabled
     )
   }
 
@@ -197,7 +196,8 @@ class CiVisibilityExporter extends AgentInfoExporter {
       earlyFlakeDetectionNumRetries,
       earlyFlakeDetectionFaultyThreshold,
       isFlakyTestRetriesEnabled,
-      isDiEnabled
+      isDiEnabled,
+      isKnownTestsEnabled
     } = remoteConfiguration
     return {
       isCodeCoverageEnabled,
@@ -209,7 +209,8 @@ class CiVisibilityExporter extends AgentInfoExporter {
       earlyFlakeDetectionFaultyThreshold,
       isFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled && this._config.isFlakyTestRetriesEnabled,
       flakyTestRetriesCount: this._config.flakyTestRetriesCount,
-      isDiEnabled: isDiEnabled && this._config.isTestDynamicInstrumentationEnabled
+      isDiEnabled: isDiEnabled && this._config.isTestDynamicInstrumentationEnabled,
+      isKnownTestsEnabled
     }
   }
 

package/packages/dd-trace/src/ci-visibility/exporters/test-worker/index.js

@@ -5,7 +5,8 @@ const {
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
   JEST_WORKER_TRACE_PAYLOAD_CODE,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
-  MOCHA_WORKER_TRACE_PAYLOAD_CODE
+  MOCHA_WORKER_TRACE_PAYLOAD_CODE,
+  JEST_WORKER_LOGS_PAYLOAD_CODE
 } = require('../../../plugins/util/test')
 
 function getInterprocessTraceCode () {
@@ -29,18 +30,27 @@ function getInterprocessCoverageCode () {
   return null
 }
 
+function getInterprocessLogsCode () {
+  if (process.env.JEST_WORKER_ID) {
+    return JEST_WORKER_LOGS_PAYLOAD_CODE
+  }
+  return null
+}
+
 /**
  * Lightweight exporter whose writers only do simple JSON serialization
- * of trace and coverage payloads, which they send to the test framework's main process.
- * Currently used by Jest and Cucumber workers.
+ * of trace, coverage and logs payloads, which they send to the test framework's main process.
+ * Currently used by Jest, Cucumber and Mocha workers.
  */
 class TestWorkerCiVisibilityExporter {
   constructor () {
     const interprocessTraceCode = getInterprocessTraceCode()
     const interprocessCoverageCode = getInterprocessCoverageCode()
+    const interprocessLogsCode = getInterprocessLogsCode()
 
     this._writer = new Writer(interprocessTraceCode)
     this._coverageWriter = new Writer(interprocessCoverageCode)
+    this._logsWriter = new Writer(interprocessLogsCode)
   }
 
   export (payload) {
@@ -51,9 +61,14 @@ class TestWorkerCiVisibilityExporter {
     this._coverageWriter.append(formattedCoverage)
   }
 
+  exportDiLogs (testConfiguration, logMessage) {
+    this._logsWriter.append({ testConfiguration, logMessage })
+  }
+
   flush () {
     this._writer.flush()
     this._coverageWriter.flush()
+    this._logsWriter.flush()
   }
 }
 

package/packages/dd-trace/src/ci-visibility/requests/get-library-configuration.js

@@ -93,7 +93,8 @@ function getLibraryConfiguration ({
               require_git: requireGit,
               early_flake_detection: earlyFlakeDetectionConfig,
               flaky_test_retries_enabled: isFlakyTestRetriesEnabled,
-              di_enabled: isDiEnabled
+              di_enabled: isDiEnabled,
+              known_tests_enabled: isKnownTestsEnabled
             }
           }
         } = JSON.parse(res)
@@ -103,13 +104,14 @@ function getLibraryConfiguration ({
           isSuitesSkippingEnabled,
           isItrEnabled,
           requireGit,
-          isEarlyFlakeDetectionEnabled: earlyFlakeDetectionConfig?.enabled ?? false,
+          isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
           earlyFlakeDetectionNumRetries:
             earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] || DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
           earlyFlakeDetectionFaultyThreshold:
             earlyFlakeDetectionConfig?.faulty_session_threshold ?? DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
           isFlakyTestRetriesEnabled,
-          isDiEnabled: isDiEnabled && isFlakyTestRetriesEnabled
+          isDiEnabled: isDiEnabled && isFlakyTestRetriesEnabled,
+          isKnownTestsEnabled
         }
 
         log.debug(() => `Remote settings: ${JSON.stringify(settings)}`)

package/packages/dd-trace/src/ci-visibility/test-api-manual/test-api-manual-plugin.js

@@ -13,15 +13,16 @@ class TestApiManualPlugin extends CiPlugin {
 
   constructor (...args) {
     super(...args)
+    this._isEnvDataCalcualted = false
     this.sourceRoot = process.cwd()
 
-    this.addSub('dd-trace:ci:manual:test:start', ({ testName, testSuite }) => {
+    this.unconfiguredAddSub('dd-trace:ci:manual:test:start', ({ testName, testSuite }) => {
       const store = storage.getStore()
       const testSuiteRelative = getTestSuitePath(testSuite, this.sourceRoot)
       const testSpan = this.startTestSpan(testName, testSuiteRelative)
       this.enter(testSpan, store)
     })
-    this.addSub('dd-trace:ci:manual:test:finish', ({ status, error }) => {
+    this.unconfiguredAddSub('dd-trace:ci:manual:test:finish', ({ status, error }) => {
       const store = storage.getStore()
       const testSpan = store && store.span
       if (testSpan) {
@@ -33,7 +34,7 @@ class TestApiManualPlugin extends CiPlugin {
         finishAllTraceSpans(testSpan)
       }
     })
-    this.addSub('dd-trace:ci:manual:test:addTags', (tags) => {
+    this.unconfiguredAddSub('dd-trace:ci:manual:test:addTags', (tags) => {
       const store = storage.getStore()
       const testSpan = store && store.span
       if (testSpan) {
@@ -41,6 +42,22 @@ class TestApiManualPlugin extends CiPlugin {
       }
     })
   }
+
+  // To lazily calculate env data.
+  unconfiguredAddSub (channelName, handler) {
+    this.addSub(channelName, (...args) => {
+      if (!this._isEnvDataCalcualted) {
+        this._isEnvDataCalcualted = true
+        this.configure(this._config, true)
+      }
+      return handler(...args)
+    })
+  }
+
+  configure (config, shouldGetEnvironmentData) {
+    this._config = config
+    super.configure(config, shouldGetEnvironmentData)
+  }
 }
 
 module.exports = TestApiManualPlugin

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

@@ -472,7 +472,9 @@ class Config {
     this._setValue(defaults, 'dogstatsd.hostname', '127.0.0.1')
     this._setValue(defaults, 'dogstatsd.port', '8125')
     this._setValue(defaults, 'dsmEnabled', false)
-    this._setValue(defaults, 'dynamicInstrumentationEnabled', false)
+    this._setValue(defaults, 'dynamicInstrumentation.enabled', false)
+    this._setValue(defaults, 'dynamicInstrumentation.redactedIdentifiers', [])
+    this._setValue(defaults, 'dynamicInstrumentation.redactionExcludedIdentifiers', [])
     this._setValue(defaults, 'env', undefined)
     this._setValue(defaults, 'experimental.enableGetRumData', false)
     this._setValue(defaults, 'experimental.exporter', undefined)
@@ -495,6 +497,7 @@ class Config {
     this._setValue(defaults, 'iast.redactionValuePattern', null)
     this._setValue(defaults, 'iast.requestSampling', 30)
     this._setValue(defaults, 'iast.telemetryVerbosity', 'INFORMATION')
+    this._setValue(defaults, 'iast.stackTrace.enabled', true)
     this._setValue(defaults, 'injectionEnabled', [])
     this._setValue(defaults, 'isAzureFunction', false)
     this._setValue(defaults, 'isCiVisibility', false)
@@ -600,6 +603,8 @@ class Config {
       DD_DOGSTATSD_HOST,
       DD_DOGSTATSD_PORT,
       DD_DYNAMIC_INSTRUMENTATION_ENABLED,
+      DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS,
+      DD_DYNAMIC_INSTRUMENTATION_REDACTION_EXCLUDED_IDENTIFIERS,
       DD_ENV,
       DD_EXPERIMENTAL_API_SECURITY_ENABLED,
       DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED,
@@ -618,6 +623,7 @@ class Config {
       DD_IAST_REDACTION_VALUE_PATTERN,
       DD_IAST_REQUEST_SAMPLING,
       DD_IAST_TELEMETRY_VERBOSITY,
+      DD_IAST_STACK_TRACE_ENABLED,
       DD_INJECTION_ENABLED,
       DD_INSTRUMENTATION_TELEMETRY_ENABLED,
       DD_INSTRUMENTATION_CONFIG_ID,
@@ -746,7 +752,13 @@ class Config {
     this._setString(env, 'dogstatsd.hostname', DD_DOGSTATSD_HOST || DD_DOGSTATSD_HOSTNAME)
     this._setString(env, 'dogstatsd.port', DD_DOGSTATSD_PORT)
     this._setBoolean(env, 'dsmEnabled', DD_DATA_STREAMS_ENABLED)
-    this._setBoolean(env, 'dynamicInstrumentationEnabled', DD_DYNAMIC_INSTRUMENTATION_ENABLED)
+    this._setBoolean(env, 'dynamicInstrumentation.enabled', DD_DYNAMIC_INSTRUMENTATION_ENABLED)
+    this._setArray(env, 'dynamicInstrumentation.redactedIdentifiers', DD_DYNAMIC_INSTRUMENTATION_REDACTED_IDENTIFIERS)
+    this._setArray(
+      env,
+      'dynamicInstrumentation.redactionExcludedIdentifiers',
+      DD_DYNAMIC_INSTRUMENTATION_REDACTION_EXCLUDED_IDENTIFIERS
+    )
     this._setString(env, 'env', DD_ENV || tags.env)
     this._setBoolean(env, 'traceEnabled', DD_TRACE_ENABLED)
     this._setBoolean(env, 'experimental.enableGetRumData', DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED)
@@ -777,6 +789,7 @@ class Config {
     }
     this._envUnprocessed['iast.requestSampling'] = DD_IAST_REQUEST_SAMPLING
     this._setString(env, 'iast.telemetryVerbosity', DD_IAST_TELEMETRY_VERBOSITY)
+    this._setBoolean(env, 'iast.stackTrace.enabled', DD_IAST_STACK_TRACE_ENABLED)
     this._setArray(env, 'injectionEnabled', DD_INJECTION_ENABLED)
     this._setBoolean(env, 'isAzureFunction', getIsAzureFunction())
     this._setBoolean(env, 'isGCPFunction', getIsGCPFunction())
@@ -926,7 +939,17 @@ class Config {
       this._setString(opts, 'dogstatsd.port', options.dogstatsd.port)
     }
     this._setBoolean(opts, 'dsmEnabled', options.dsmEnabled)
-    this._setBoolean(opts, 'dynamicInstrumentationEnabled', options.experimental?.dynamicInstrumentationEnabled)
+    this._setBoolean(opts, 'dynamicInstrumentation.enabled', options.dynamicInstrumentation?.enabled)
+    this._setArray(
+      opts,
+      'dynamicInstrumentation.redactedIdentifiers',
+      options.dynamicInstrumentation?.redactedIdentifiers
+    )
+    this._setArray(
+      opts,
+      'dynamicInstrumentation.redactionExcludedIdentifiers',
+      options.dynamicInstrumentation?.redactionExcludedIdentifiers
+    )
     this._setString(opts, 'env', options.env || tags.env)
     this._setBoolean(opts, 'experimental.enableGetRumData', options.experimental?.enableGetRumData)
     this._setString(opts, 'experimental.exporter', options.experimental?.exporter)
@@ -956,6 +979,7 @@ class Config {
       this._optsUnprocessed['iast.requestSampling'] = options.iast?.requestSampling
     }
     this._setString(opts, 'iast.telemetryVerbosity', options.iast && options.iast.telemetryVerbosity)
+    this._setBoolean(opts, 'iast.stackTrace.enabled', options.iast?.stackTrace?.enabled)
     this._setBoolean(opts, 'isCiVisibility', options.isCiVisibility)
     this._setBoolean(opts, 'legacyBaggageEnabled', options.legacyBaggageEnabled)
     this._setBoolean(opts, 'llmobs.agentlessEnabled', options.llmobs?.agentlessEnabled)
@@ -1312,6 +1336,22 @@ class Config {
     this.sampler.sampleRate = this.sampleRate
     updateConfig(changes, this)
   }
+
+  // TODO: Refactor the Config class so it never produces any config objects that are incompatible with MessageChannel
+  /**
+   * Serializes the config object so it can be passed over a Worker Thread MessageChannel.
+   * @returns {Object} The serialized config object.
+   */
+  serialize () {
+    // URL objects cannot be serialized over the MessageChannel, so we need to convert them to strings first
+    if (this.url instanceof URL) {
+      const config = { ...this }
+      config.url = this.url.toString()
+      return config
+    }
+
+    return this
+  }
 }
 
 function maybeInt (number) {

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -40,6 +40,15 @@ class Crashtracker {
     }
   }
 
+  withProfilerSerializing (f) {
+    binding.beginProfilerSerializing()
+    try {
+      return f()
+    } finally {
+      binding.endProfilerSerializing()
+    }
+  }
+
   // TODO: Send only configured values when defaults are fixed.
   _getConfig (config) {
     const { hostname = '127.0.0.1', port = 8126 } = config

package/packages/dd-trace/src/crashtracking/noop.js

@@ -3,6 +3,9 @@
 class NoopCrashtracker {
   configure () {}
   start () {}
+  withProfilerSerializing (f) {
+    return f()
+  }
 }
 
 module.exports = new NoopCrashtracker()

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

@@ -15,7 +15,7 @@ function fnv64 (data) {
     data = Buffer.from(data, 'utf-8')
   }
   const byteArray = new Uint8Array(data)
-  return fnv(byteArray, FNV1_64_INIT, FNV_64_PRIME, BigInt(2) ** BigInt(64))
+  return fnv(byteArray, FNV1_64_INIT, FNV_64_PRIME, 2n ** 64n)
 }
 
 module.exports = {

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

@@ -23,10 +23,10 @@ async function addBreakpoint (probe) {
   delete probe.where
 
   // Optimize for fast calculations when probe is hit
-  const snapshotsPerSecond = probe.sampling.snapshotsPerSecond ?? (probe.captureSnapshot
+  const snapshotsPerSecond = probe.sampling?.snapshotsPerSecond ?? (probe.captureSnapshot
     ? MAX_SNAPSHOTS_PER_SECOND_PER_PROBE
     : MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE)
-  probe.sampling.nsBetweenSampling = BigInt(1 / snapshotsPerSecond * 1e9)
+  probe.nsBetweenSampling = BigInt(1 / snapshotsPerSecond * 1e9)
   probe.lastCaptureNs = 0n
 
   // TODO: Inbetween `await session.post('Debugger.enable')` and here, the scripts are parsed and cached.

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

@@ -5,6 +5,7 @@ const { format } = require('node:url')
 const log = require('../../log')
 
 const config = module.exports = {
+  dynamicInstrumentation: parentConfig.dynamicInstrumentation,
   runtimeId: parentConfig.tags['runtime-id'],
   service: parentConfig.service,
   commitSHA: parentConfig.commitSHA,

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

@@ -1,6 +1,7 @@
 'use strict'
 
 module.exports = {
+  MAX_SNAPSHOTS_PER_SECOND_GLOBALLY: 25,
   MAX_SNAPSHOTS_PER_SECOND_PER_PROBE: 1,
   MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE: 5_000
 }