[Debugger] Add memory pressure monitoring telemetry for Dynamic Instrumentation (observe-only) (#7834)

## Summary of changes

- Adds an observe-only memory pressure monitor for Dynamic
Instrumentation.
- Samples runtime/system memory pressure around DI activity (no
background timer).
- Emits low-cardinality telemetry only when entering or exiting high
memory pressure, plus a one-shot counter if the monitor disables itself.
- Does not block, throttle, skip, or otherwise change probe behavior.

## Reason for change

Dynamic Instrumentation can perform memory-sensitive work when capturing
variables, creating snapshots, serializing payloads, and
enqueueing/uploading data.

Before using memory pressure to affect DI behavior, we need production
data showing how often high pressure occurs, what drives it, how severe
each signal is at entry, how long episodes last, where the signal is
even available, and whether it is stable enough for future throttling
decisions. This PR adds exactly that observability and nothing else.

## Implementation details

The monitor detects high pressure from concrete runtime/system signals
only:

- Memory load ratio (fraction of available memory in use, so the value
is comparable across platforms):
- On .NET Core 3.1+, uses `GC.GetGCMemoryInfo()` (`MemoryLoadBytes /
TotalAvailableMemoryBytes`). This is container/cgroup-aware, and is
system/container-wide load rather than process-private bytes - the right
scope for "are we close to an OOM".
- On .NET Framework/Windows, uses `GlobalMemoryStatusEx`
(`dwMemoryLoad`, clamped to `[0,1]`). This is machine-wide and **not**
container/job-object aware.
- On runtimes/platforms where neither is available, the memory signal is
reported as unsupported.
- Gen2 collections per second:
- Calculated from `GC.CollectionCount(2)` deltas over elapsed time.
Identical and process-specific on every platform.

Sampling is activity-driven rather than always-on. DI calls into the
monitor around capture/snapshot/upload-relevant work, and the monitor
refreshes only when the last sample is stale (default min interval
`1s`). If DI is idle, the monitor does not continuously sample memory.

Time is read from `Environment.TickCount64` on .NET Core 3.0+ (a
monotonic `Stopwatch`-based fallback is used on net461/netstandard2.0),
so the hot `RefreshIfStale()` fast path is a couple of volatile reads
with no clock abstraction.

If neither memory nor GC signals are available on the host, or a
provider throws, the monitor **permanently disables itself** (it never
samples again), writes a single log line (debug for "no signals", error
for an exception), and records a one-shot `disabled` counter tagged by
reason so a silent zero in the transition metrics is explainable rather
than ambiguous.

Telemetry is emitted on transitions only (enter high pressure / exit
high pressure):

- Transition count tagged by `state` (`enter`/`exit`) and `trigger`
(`memory`/`gen2`/`both` on enter; `none` on exit) - i.e. which signal
drove entry.
- Severity values on transition: memory usage percent and Gen2
collections/sec (tagged by `state`).
- Duration of the high-pressure period, recorded on exit.

No high-cardinality tags such as probe ID, service name, file path,
exception type, or method name are added.

```mermaid
flowchart TD
    diStart["DynamicInstrumentation starts"] --> createMonitor["Create MemoryPressureMonitor"]
    createMonitor --> idleMonitor["No background sampling while idle"]

    probeActivity["DI capture/snapshot/upload activity"] --> refreshIfStale["RefreshIfStale (min interval)"]
    refreshIfStale --> signalsAvailable{"Memory or GC signal available?"}
    signalsAvailable -->|"No / provider error"| disable["Disable monitor (logged) + disabled{reason}"]
    signalsAvailable -->|"Yes"| sampleSignals["Sample memory load and Gen2/sec"]
    sampleSignals --> pressureDecision{"High pressure transition?"}

    pressureDecision -->|"ENTER"| enterTelemetry["transitions{state:enter, trigger:*} + severity"]
    pressureDecision -->|"EXIT"| exitTelemetry["transitions{state:exit, trigger:none} + severity + duration"]
    pressureDecision -->|"No transition"| noOp["No telemetry emission"]

    enterTelemetry --> observeOnly["No DI behavior change"]
    exitTelemetry --> observeOnly
    noOp --> observeOnly
    disable --> observeOnly

    diStart --> dispose["DynamicInstrumentation.Dispose"]
    dispose --> stopMonitor["Dispose monitor (lock-free)"]
```

Risk is kept low by avoiding per-second telemetry gauges, background
sampling while idle, probe-level cardinality and allocation on hot
paths. Refreshes are guarded by a non-blocking single-writer CAS so
concurrent DI activity does not run overlapping samples.

## Metrics implementation

All metrics are instrumentation-telemetry metrics, defined as **common**
metrics (`isCommon: true`) under the `live_debugger` namespace. They
surface in the backend as
`dd.instrumentation_telemetry_data.live_debugger.memory_pressure.*`.
Tags are fixed, low-cardinality enums.

| Metric | Type | Tags | Emitted |
|---|---|---|---|
| `memory_pressure.transitions` | count | `state` = `enter`\|`exit`,
`trigger` = `none`\|`memory`\|`gen2`\|`both` | Once per high-pressure
state change. `trigger` is the entry cause on `enter`; `none` on `exit`.
|
| `memory_pressure.disabled` | count | `reason` = `no_signals`\|`error`
| Once, when the monitor permanently disables itself (no signals
available, or a provider threw). |
| `memory_pressure.memory_usage_pct` | count | `state` =
`enter`\|`exit`, `bucket` = `lt_70`\|`70_80`\|`80_85`\|`85_90`\|`gte_90`
| On each transition - count bucketed by memory load percent at that
moment. |
| `memory_pressure.gen2_per_sec` | count | `state` = `enter`\|`exit`,
`bucket` = `lt_1`\|`1_2`\|`2_5`\|`gte_5` | On each transition - count
bucketed by Gen2 collections/sec at that moment. |
| `memory_pressure.duration_ms` | count | `bucket` =
`lt_1s`\|`1_5s`\|`5_30s`\|`gte_30s` | On `exit` - count bucketed by
length of the high-pressure episode. |

Runtime/platform segmentation (runtime name, OS, architecture, tracer
version) is **not** added as per-metric tags; it comes from the
telemetry payload's `application`/`host` metadata and is applied at
query time in the backend. This keeps series count bounded while still
allowing per-runtime analysis.

The severity and duration metrics use normal telemetry `count` metrics
with a fixed `bucket` tag instead of distributions. Distribution
telemetry is not supported for this internal telemetry path, and
bucketed counts preserve the decision-making signal with bounded
cardinality.

The `trigger` tag lives only on the transition count, not on the
severity bucket counts: if `trigger:memory`, the memory bucket already
captures how severe the memory signal was, and splitting every bucket by
trigger would mostly restate the transition breakdown with extra series.
The transition count's `trigger` plus the `state`-tagged bucket counts
answer "what drove it" and "how severe / how long".

## Dashboards and how we will use the data

The goal is a single dashboard that answers, per runtime/OS, whether DI
should ever gate capture under memory pressure and, if so, on which
signal and at what threshold.

| Widget | Source metric | Question | Decision it informs |
|---|---|---|---|
| Coverage timeseries / count by `reason` | `memory_pressure.disabled` |
Where does the monitor not run at all? | Defines the observed population
- distinguishes "no pressure" from "no data". |
| Enter rate timeseries, split by `trigger` |
`memory_pressure.transitions{state:enter}` | How often does high
pressure happen, and is it memory- or GC-driven? | Whether gating is
worth building at all, and which signal to gate on. |
| Trigger breakdown (top-list/pie) |
`memory_pressure.transitions{state:enter}` | `memory` vs `gen2` vs
`both` mix | Which threshold actually matters. |
| Memory severity bucket breakdown |
`memory_pressure.memory_usage_pct{state:enter}` | How deep is memory
pressure at entry? | Where to set a memory gating threshold. |
| GC severity bucket breakdown |
`memory_pressure.gen2_per_sec{state:enter}` | How hot is GC at entry? |
Where to set a gen2 gating threshold. |
| Episode duration bucket breakdown | `memory_pressure.duration_ms` |
How long do episodes last? | Whether gating needs hysteresis/cooldown or
episodes are too short to act on. |

Every widget can be grouped by the dimensions the telemetry intake
stamps onto each series from the payload's `application`/`host`
metadata.

How the data is gathered:

1. These metrics flow through the existing tracer telemetry pipeline
(generate-metrics payloads) to the Datadog backend - no new transport.
2. Because emission is transition-only and activity-driven, idle apps
cost nothing and noisy apps cannot spam per-second points.
3. We collect across runtimes for a few weeks, then read the dashboard
top-down: `memory_pressure.disabled` (coverage) →
`memory_pressure.transitions{state:enter}` by `trigger` (frequency +
cause) → severity distributions (thresholds) → duration (persistence).
4. The resulting numbers define concrete gating thresholds (or show that
gating is unnecessary) for a follow-up PR.

### Scope: what this telemetry answers (and what it doesn't)

This is a fleet-aggregate, pre-decision dataset: it tells us whether
high memory pressure occurs during DI work often, severely, and long
enough to justify gating capture, and on which signal at what threshold.
It is deliberately **not** a tool for measuring the impact of a future
gate.

## Test coverage

Added/updated tests cover:

- Memory threshold enter/exit behavior and hysteresis.
- Gen2/sec threshold and rate behavior.
- Consecutive high/low cycle (debounce) behavior.
- Unavailable memory/GC signals → self-disable with `reason:no_signals`,
no further sampling.
- Provider exception handling → self-disable with `reason:error`, no
crash.
- Refresh overlap handling (non-blocking single writer) and dispose
during an in-flight refresh.
- Dispose/lifecycle behavior (no further sampling or emission after
dispose).
- Activity-driven stale refresh (no sampling while idle; samples only
when stale).
- Transition telemetry: enter emitted once, exit emitted once, severity
recorded on transition, duration recorded on exit, no repeat while state
is unchanged.
- `trigger` classification: `gen2` when only GC drives entry, `both`
when memory and GC cross together, `memory`/`none` on the enter/exit
pair.
- Extreme/edge configuration values are clamped to safe minimums.
- Windows `GlobalMemoryStatusEx` interop returns valid values.
- DI integration: the monitor is sampled only through the dedicated hook
and is disposed by `DynamicInstrumentation`.
- Telemetry aggregation: transitions tagged by `state`+`trigger`, the
`disabled` counter, and the three bucketed count metrics aggregate into
the expected series/tags.

## Other details

Initial thresholds are observation thresholds, not throttling
thresholds:

- Memory pressure threshold: `0.85`.
- Memory exit threshold with default hysteresis: `0.80`.
- Gen2 threshold: `2` collections/sec.
- Gen2 exit threshold with default hysteresis: `1` collection/sec.

These values are intentionally conservative starting points for data
collection and can be tuned after production telemetry is available.

This PR intentionally does not include an explicit/manual pressure event
signal. There is no concrete production caller or well-defined meaning
for that signal yet. If a future DI path has a specific condition, such
as snapshot capture exceeding a memory budget, it should add a named API
and metric for that scenario.

Any future DI throttling or blocking based on memory pressure should be
done in a separate PR after reviewing the collected telemetry.

## Note
Incidental DynamicInstrumentation lifecycle hardening (not
memory-pressure specific): Wiring the new monitor in as a disposable
owned by DynamicInstrumentation, exposed pre-existing races in the
start/subscribe/dispose paths. DynamicInstrumentation is disposed at
runtime via RCM, not just at shutdown. Since the monitor's lifecycle is
tied to those paths, we hardened them here.

---------

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: dudikeleti

tracer/src/Datadog.Trace/Debugger/Caching/DefaultMemoryChecker.cs

@@ -7,6 +7,7 @@
 
 using System;
 using System.Runtime.InteropServices;
+using Datadog.Trace.Debugger.RateLimiting;
 using Datadog.Trace.Logging;
 
 namespace Datadog.Trace.Debugger.Caching;
@@ -26,15 +27,10 @@ private DefaultMemoryChecker()
 
     public bool IsLowResourceEnvironment { get; }
 
-    [return: MarshalAs(UnmanagedType.Bool)]
-    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
-    private static extern bool GlobalMemoryStatusEx([In, Out] MEMORYSTATUSEX lpBuffer);
-
     private bool CheckLowResourceEnvironment()
     {
         try
         {
-            Logger.Debug("Checking if environment is low on resources");
             // Check if we're using more than 75% of available memory or there is less than 1GB of RAM available.
             return IsLowResourceEnvironmentGc() || IsLowResourceEnvironmentSystem();
         }
@@ -73,7 +69,7 @@ internal bool CheckWindowsMemory()
     {
         try
         {
-            if (MEMORYSTATUSEX.GetAvailablePhysicalMemory(out var availableMemory))
+            if (WindowsMemoryInfo.TryGetAvailablePhysicalMemory(out var availableMemory))
             {
                 // If less than 1GB of RAM is available, consider it a low-resource environment
                 return availableMemory < 1_073_741_824; // 1 GB in bytes
@@ -148,43 +144,4 @@ private ReadOnlySpan<char> ReadMemInfo()
 
         return value.Slice(0, spaceIndex);
     }
-
-    // Windows API for memory information
-    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
-    private sealed class MEMORYSTATUSEX
-    {
-#pragma warning disable IDE0044 // Add readonly modifier
-#pragma warning disable CS0169 // Field is never used
-        private uint dwLength;
-        private uint dwMemoryLoad;
-        private ulong ullTotalPhys;
-#pragma warning disable CS0649 // Field is never assigned to, and will always have its default value
-        private ulong ullAvailPhys;
-#pragma warning restore CS0649 // Field is never assigned to, and will always have its default value
-        private ulong ullTotalPageFile;
-        private ulong ullAvailPageFile;
-        private ulong ullTotalVirtual;
-        private ulong ullAvailVirtual;
-        private ulong ullAvailExtendedVirtual;
-#pragma warning restore CS0169 // Field is never used
-#pragma warning restore IDE0044 // Add readonly modifier
-
-        private MEMORYSTATUSEX()
-        {
-            dwLength = (uint)Marshal.SizeOf(typeof(MEMORYSTATUSEX));
-        }
-
-        internal static bool GetAvailablePhysicalMemory(out ulong availableMemory)
-        {
-            availableMemory = 0;
-            MEMORYSTATUSEX memStatus = new MEMORYSTATUSEX();
-            if (GlobalMemoryStatusEx(memStatus))
-            {
-                availableMemory = memStatus.ullAvailPhys;
-                return true;
-            }
-
-            return false;
-        }
-    }
 }

tracer/src/Datadog.Trace/Debugger/DebuggerFactory.cs

@@ -42,6 +42,7 @@ internal static DynamicInstrumentation CreateDynamicInstrumentation(IDiscoverySe
         var lineProbeResolver = LineProbeResolver.Create(debuggerSettings.ThirdPartyDetectionExcludes, debuggerSettings.ThirdPartyDetectionIncludes);
         var probeStatusPoller = ProbeStatusPoller.Create(diagnosticsSink, debuggerSettings);
         var configurationUpdater = ConfigurationUpdater.Create(tracerSettings.Manager.InitialMutableSettings.Environment, tracerSettings.Manager.InitialMutableSettings.ServiceVersion, debuggerSettings.MaxProbesPerType, globalRateLimiter);
+        var memoryPressureMonitor = new MemoryPressureMonitor(MemoryPressureConfig.Default);
 
         var statsd = GetDogStatsd(tracerSettings);
 
@@ -56,7 +57,8 @@ internal static DynamicInstrumentation CreateDynamicInstrumentation(IDiscoverySe
             probeStatusPoller: probeStatusPoller,
             configurationUpdater: configurationUpdater,
             dogStats: statsd,
-            globalRateLimiter: globalRateLimiter);
+            globalRateLimiter: globalRateLimiter,
+            memoryPressureMonitor: memoryPressureMonitor);
     }
 
     private static IDogStatsd GetDogStatsd(TracerSettings tracerSettings)

tracer/src/Datadog.Trace/Debugger/DynamicInstrumentation.cs

@@ -40,7 +40,9 @@ internal sealed class DynamicInstrumentation : IDisposable
     {
         private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(DynamicInstrumentation));
 
-        private readonly TaskCompletionSource<bool> _processExit;
+        // Completed when this DI instance is being disposed (runtime disable via remote config, or process shutdown).
+        // Used to abort in-flight initialization waits promptly.
+        private readonly TaskCompletionSource<bool> _disposalSignal;
         private readonly IDiscoveryService _discoveryService;
         private readonly IRcmSubscriptionManager _subscriptionManager;
         private readonly ISubscription _subscription;
@@ -53,6 +55,7 @@ internal sealed class DynamicInstrumentation : IDisposable
         private readonly IProbeStatusPoller _probeStatusPoller;
         private readonly ConfigurationUpdater _configurationUpdater;
         private readonly IDogStatsd _dogStats;
+        private readonly MemoryPressureMonitor _memoryPressureMonitor;
         private readonly DebuggerSettings _settings;
         private readonly NativeProbeInstrumentationRequester _instrumentProbes;
         private readonly object _instanceLock = new();
@@ -72,11 +75,12 @@ internal DynamicInstrumentation(
             ConfigurationUpdater configurationUpdater,
             IDogStatsd dogStats,
             IDebuggerGlobalRateLimiter? globalRateLimiter = null,
+            MemoryPressureMonitor? memoryPressureMonitor = null,
             NativeProbeInstrumentationRequester? instrumentProbes = null)
         {
             Log.Information("Initializing Dynamic Instrumentation");
             _settings = settings;
-            _processExit = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+            _disposalSignal = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
             _discoveryService = discoveryService;
             _lineProbeResolver = lineProbeResolver;
             _snapshotUploader = snapshotUploader;
@@ -87,6 +91,7 @@ internal DynamicInstrumentation(
             _configurationUpdater = configurationUpdater;
             _configurationUpdater.SetProbeInstrumentationHandlers(UpdateAddedProbeInstrumentations, UpdateRemovedProbeInstrumentations);
             _dogStats = dogStats;
+            _memoryPressureMonitor = memoryPressureMonitor ?? new MemoryPressureMonitor(MemoryPressureConfig.Default);
             _instrumentProbes = instrumentProbes ?? DebuggerNativeMethods.InstrumentProbes;
             _unboundProbes = new List<ProbeDefinition>();
             _lastReportedUnboundProbeErrors = new Dictionary<string, LineProbeResolveErrorKey>();
@@ -145,7 +150,7 @@ private async Task InitializeAsync()
                     hasFileProbes = _configurationUpdater.HasAnyEffectiveProbeForFile(probeConfiguration);
                     if (hasFileProbes)
                     {
-                        StartRuntimeIfNeeded();
+                        StartRuntimeIfNeeded(subscribeToRcm: false);
                     }
 
                     _configurationUpdater.AcceptFile(probeConfiguration);
@@ -154,8 +159,7 @@ private async Task InitializeAsync()
                 var isRcmAvailable = await rcmAvailabilityTask.ConfigureAwait(false);
                 if (isRcmAvailable)
                 {
-                    StartRuntimeIfNeeded();
-                    _subscriptionManager.SubscribeToChanges(_subscription);
+                    StartRuntimeIfNeeded(subscribeToRcm: true);
                 }
 
                 // Start background processing and register the assembly load callback if either:
@@ -184,16 +188,55 @@ private async Task InitializeAsync()
             }
         }
 
-        private void StartRuntimeIfNeeded()
+        /// <summary>
+        /// Starts the runtime (background processing + assembly-load callback) exactly once, and optionally
+        /// subscribes to RCM. Idempotent and safe to call from both the file-probe path (<paramref name="subscribeToRcm"/>
+        /// false) and the RCM-available path (<paramref name="subscribeToRcm"/> true).
+        /// </summary>
+        private void StartRuntimeIfNeeded(bool subscribeToRcm)
         {
-            if (IsInitialized || IsDisposed)
+            if (IsDisposed || (IsInitialized && !subscribeToRcm))
             {
                 return;
             }
 
-            AppDomain.CurrentDomain.AssemblyLoad += CheckUnboundProbes;
-            StartBackgroundProcess();
-            Volatile.Write(ref _initializationState, 2);
+            lock (_instanceLock)
+            {
+                if (IsDisposed)
+                {
+                    return;
+                }
+
+                // Start the runtime exactly once.
+                if (!IsInitialized)
+                {
+                    var assemblyLoadSubscribed = false;
+                    try
+                    {
+                        AppDomain.CurrentDomain.AssemblyLoad += CheckUnboundProbes;
+                        assemblyLoadSubscribed = true;
+                        StartBackgroundProcess();
+                        Volatile.Write(ref _initializationState, 2);
+                    }
+                    catch
+                    {
+                        if (assemblyLoadSubscribed)
+                        {
+                            AppDomain.CurrentDomain.AssemblyLoad -= CheckUnboundProbes;
+                        }
+
+                        throw;
+                    }
+                }
+
+                // Subscribe only on the RCM path, and only if a disable hasn't landed in the meantime.
+                // Best-effort: correctness against a leaked subscription is guaranteed by Dispose's Unsubscribe
+                // running under this same lock.
+                if (subscribeToRcm && !IsDisposed)
+                {
+                    _subscriptionManager.SubscribeToChanges(_subscription);
+                }
+            }
         }
 
         private void StartBackgroundProcess()
@@ -836,6 +879,16 @@ internal void AddLog(ProbeInfo probe, string log)
             SetProbeStatusToEmitting(probe);
         }
 
+        internal void RefreshMemoryPressureIfStale()
+        {
+            if (IsDisposed)
+            {
+                return;
+            }
+
+            _memoryPressureMonitor.RefreshIfStale();
+        }
+
         internal void SetProbeStatusToEmitting(ProbeInfo probe)
         {
             if (IsDisposed)
@@ -899,7 +952,7 @@ private async Task<bool> WaitForRcmAvailabilityAsync()
                 var rcmTimeout = TimeSpan.FromMinutes(5);
                 var timeoutTask = Task.Delay(rcmTimeout);
 
-                var completedTask = await Task.WhenAny(rcmAvailabilityTcs.Task, timeoutTask, _processExit.Task).ConfigureAwait(false);
+                var completedTask = await Task.WhenAny(rcmAvailabilityTcs.Task, timeoutTask, _disposalSignal.Task).ConfigureAwait(false);
                 if (completedTask == timeoutTask)
                 {
                     Log.Warning("Dynamic Instrumentation could not be enabled because Remote Configuration Management is not available after waiting {Timeout} seconds. Please note that Dynamic Instrumentation is not supported in all environments (e.g. AAS). Ensure that you are using datadog-agent version 7.41.1 or higher, and that Remote Configuration Management is enabled in datadog-agent's yaml configuration file.", rcmTimeout.TotalSeconds);
@@ -930,34 +983,34 @@ void DiscoveryCallback(AgentConfiguration x)
 
         public void Dispose()
         {
-            // Already disposed
             if (Interlocked.CompareExchange(ref _disposeState, 1, 0) != 0)
             {
                 return;
             }
 
-            if (_processExit.Task.IsCompleted)
-            {
-                return;
-            }
+            _disposalSignal.TrySetResult(true);
 
-            _processExit.TrySetResult(true);
-            AppDomain.CurrentDomain.AssemblyLoad -= CheckUnboundProbes;
             lock (_instanceLock)
             {
+                // Must stay under the lock: StartRuntimeIfNeeded subscribes AssemblyLoad under the same
+                // lock, so unsubscribing here is what prevents a subscribe-after-dispose handler leak.
+                AppDomain.CurrentDomain.AssemblyLoad -= CheckUnboundProbes;
+
                 SafeDisposal.New()
                             .Execute(() => _subscriptionManager.Unsubscribe(_subscription), "unsubscribing from RCM")
                             .Add(_snapshotUploader)
                             .Add(_logUploader)
                             .Add(_diagnosticsUploader)
                             .Add(_probeStatusPoller)
+                            .Add(_memoryPressureMonitor)
                             .DisposeAll();
             }
 
-            // Cannot await here because Dispose() is synchronous and callers hold locks.
-            // On master, _dogStats was disposed via SafeDisposal.Add() which called sync
-            // Dispose() — itself fire-and-forget internally via Task.Run().
-            _dogStats?.DisposeAsync().ContinueWith(t => Log.Error(t.Exception, "Error waiting for StatsD disposal"), TaskContinuationOptions.OnlyOnFaulted);
+            _dogStats?.DisposeAsync().ContinueWith(
+                t => Log.Error(t.Exception, "Error waiting for StatsD disposal"),
+                CancellationToken.None,
+                TaskContinuationOptions.OnlyOnFaulted,
+                TaskScheduler.Default);
         }
     }
 }

tracer/src/Datadog.Trace/Debugger/Expressions/ProbeProcessor.cs

@@ -106,6 +106,16 @@ private static CaptureLimitInfo ToCaptureLimitInfo(Capture? capture)
             return result.Count == 0 ? null : result.ToArray();
         }
 
+        private static bool ShouldRefreshMemoryPressureBeforeCapture(MethodState methodState)
+        {
+            return methodState is MethodState.BeginLine
+                or MethodState.BeginLineAsync
+                or MethodState.EntryStart
+                or MethodState.EntryAsync
+                or MethodState.ExitStart
+                or MethodState.ExitStartAsync;
+        }
+
         public bool TryBeginProcess(in ProbeData probeData, [NotNullWhen(true)] out IDebuggerSnapshotCreator? snapshotCreator)
         {
             var state = _state;
@@ -138,8 +148,13 @@ public bool Process<TCapture>(ref CaptureInfo<TCapture> info, IDebuggerSnapshotC
             }
 
             var probeInfo = state.ProbeInfo;
+            var dynamicInstrumentation = DebuggerManager.Instance.DynamicInstrumentation;
+            if (dynamicInstrumentation is not null && ShouldRefreshMemoryPressureBeforeCapture(info.MethodState))
+            {
+                dynamicInstrumentation.RefreshMemoryPressureIfStale();
+            }
 
-            if (DebuggerManager.Instance.DynamicInstrumentation?.IsInitialized == false)
+            if (dynamicInstrumentation?.IsInitialized == false)
             {
                 Log.Debug("Stop processing probe {ID} because Dynamic Instrumentation has not initialized yet or has been disabled, probably dynamically through Remote Config", probeData.ProbeId);
                 snapshotCreator.Stop();

tracer/src/Datadog.Trace/Debugger/RateLimiting/MemoryPressureConfig.cs

@@ -0,0 +1,65 @@
+// <copyright file="MemoryPressureConfig.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+#nullable enable
+
+using System;
+using System.Globalization;
+using Datadog.Trace.Util;
+
+namespace Datadog.Trace.Debugger.RateLimiting
+{
+    internal readonly struct MemoryPressureConfig
+    {
+        public static MemoryPressureConfig Default { get; } = new()
+        {
+            HighPressureThresholdRatio = 0.85,
+            MaxGen2PerSecond = 2,
+            MemoryExitMargin = 0.05,
+            Gen2ExitMargin = 1,
+            ConsecutiveHighToEnter = 1,
+            ConsecutiveLowToExit = 1,
+            RefreshInterval = TimeSpan.FromSeconds(1)
+        };
+
+        // Enter high pressure at this fraction (0.0–1.0) of available memory in use. Machine-wide on .NET Framework.
+        public double HighPressureThresholdRatio { get; init; }
+
+        public int MaxGen2PerSecond { get; init; }
+
+        public double MemoryExitMargin { get; init; }
+
+        public int Gen2ExitMargin { get; init; }
+
+        public int ConsecutiveHighToEnter { get; init; }
+
+        public int ConsecutiveLowToExit { get; init; }
+
+        public TimeSpan RefreshInterval { get; init; }
+
+        public override string ToString()
+        {
+            var culture = CultureInfo.InvariantCulture;
+            var sb = StringBuilderCache.Acquire();
+
+            sb.Append("Threshold=");
+            sb.Append(HighPressureThresholdRatio.ToString("F2", culture));
+            sb.Append(" (");
+            sb.Append((HighPressureThresholdRatio * 100).ToString("F1", culture));
+            sb.Append("%), MaxGen2=");
+            sb.Append(MaxGen2PerSecond.ToString(culture));
+            sb.Append("/s, ExitMargin=");
+            sb.Append(MemoryExitMargin.ToString("F2", culture));
+            sb.Append(", Gen2ExitMargin=");
+            sb.Append(Gen2ExitMargin.ToString(culture));
+            sb.Append(", HighToEnter=");
+            sb.Append(ConsecutiveHighToEnter.ToString(culture));
+            sb.Append(", LowToExit=");
+            sb.Append(ConsecutiveLowToExit.ToString(culture));
+
+            return StringBuilderCache.GetStringAndRelease(sb);
+        }
+    }
+}