[Debugger] Bound Dynamic Instrumentation probe expression evaluation with a time budget (#8806)

## Summary of changes

- Adds a cooperative **evaluation time budget** to Dynamic
Instrumentation (DI) probe expressions, so checkpointed generated
evaluation work stops when expiry is observed; regex additionally
receives a hard timeout.
- Introduces `EvaluationBudget` (a value type passed by `ref` through
compiled evaluation paths), `CompiledExpressionDelegate<T>` (delegate
signature now carries `ref EvaluationBudget`), and
`EvaluationTimeBudgetExceededException`.
- The parser injects lightweight budget checkpoints into the generated
expression tree at the points that can dominate runtime: the expression
root, generated collection and dump loops, selected string/comparison
operations, regex, and `instanceof` type resolution.
- A single active-time budget is shared across templates → condition →
metric → span decorations → capture expressions. It is paused before
deferred capture work and resumed after capture-expression compilation,
so intervening processing and compilation do not consume the remaining
allowance.
- Hand-rolls the enumerable `any`/`all`/`filter` loops (instead of LINQ)
so a checkpoint can be placed inside each iteration; uses a real `Regex`
timeout for pattern matching.
- Removes budget checkpoints from two paths where they add cost without
value: the `SafeEquals` binary path and member access, which is already
restricted to fields and auto-property backing fields.

## Reason for change

- DI probe expressions are authored remotely and compiled to delegates
that execute **in the customer's process, on the customer's thread**. A
pathological or accidentally expensive expression (large collections,
nested filters, complex predicates, catastrophic regex) could add
unbounded latency and degrade the host application.
- There was no evaluation time budget. This change makes supported
expensive paths self-limiting: once expiry is observed at a cooperative
checkpoint, evaluation aborts and surfaces an evaluation error; regex
also receives a hard timeout.

## Implementation details

### The budget (`EvaluationBudget`)

- Mutable value type passed by `ref` through compiled delegates and
evaluation helpers. Its state is deliberately copied when persisted
between the main and deferred-capture phases and when bridged through
type-resolution callbacks; the budget itself does not require a heap
allocation.
- `Create(maxMs)` records a deadline as `Stopwatch.GetTimestamp() +
duration` (with an overflow guard so very large values clamp to
`long.MaxValue`).
- `ThrowIfExceeded()` is the hot amortized checkpoint used in loops and
selected operations: reading the clock on every operation would be too
expensive, so it samples the clock once every
`OperationsBeforeTimeCheck` (32) calls.
- The hot checkpoint is marked `[MethodImpl(AggressiveInlining)]`; the
throw/clock helpers are `[NoInlining]` to keep the inlined path tiny.
- `ThrowIfExceededImmediately()` samples the clock at expression
roots/fallbacks and expensive type-resolution boundaries.
- `TimedOut` is sticky: once the deadline is hit, all later checkpoints
throw immediately.
- `GetRemainingTimeout()` converts the remaining budget into a
`TimeSpan` and is handed to `Regex.IsMatch(...)`. Regex can block for a
long time inside a single call, so it gets a real hard timeout; a
`RegexMatchTimeoutException` is converted into the budget exception (and
marks the budget timed out).
- `Pause()` stores the remaining stopwatch ticks instead of an absolute
deadline; `Resume()` rebases the deadline from that remaining
active-evaluation allowance.

```mermaid
flowchart TD
    Start["ThrowIfExceeded() — inlined into the hot path"] --> T{TimedOut?}
    T -- "yes (sticky)" --> Throw["ThrowTimedOut() [NoInlining]"]
    T -- no --> Dec["--operationsUntilTimeCheck"]
    Dec --> C{"> 0 ?"}
    C -- "yes (31 of 32 calls)" --> Ret["return — no clock read"]
    C -- "no (every 32nd call)" --> Clock["ThrowIfTimeExceeded() [NoInlining]<br/>reset counter to 32, read Stopwatch"]
    Clock --> D{"now >= deadline?"}
    D -- no --> Ret
    D -- yes --> Mark["MarkTimedOut() + throw EvaluationTimeBudgetExceededException"]
```

### Threading the budget through compiled expressions

- `CompiledExpressionDelegate<T>` adds a trailing `ref EvaluationBudget
budget` parameter; `CompiledExpression<T>.BudgetedDelegate` is the
compiled instance.
- The parser creates an `evaluationBudget` `ref` parameter for the
generated lambda and emits ordinary
`EvaluationBudget.ThrowIfExceeded(ref evaluationBudget)` checks
(`BudgetCheck()`) at strategic spots, with immediate checks at roots and
type-resolution boundaries.
- **One active-time budget per probe hit:**
`ProbeExpressionEvaluator.Evaluate` creates a budget after initial
expression compilation and passes the same `ref` to every
sub-expression. If deferred capture expressions are present, it pauses
and stores the budget on the (`ref struct`) result.
`EvaluateCaptureExpressions` compiles those expressions while the budget
is paused, then resumes and evaluates them with the same remaining
active-time allowance.

```mermaid
flowchart TD
    A["Probe hit → compile/cache initial expressions"] --> B["CreateBudget(): deadline = now + configured max"]
    B --> C["Templates(..., ref budget)"]
    C --> D["Condition(..., ref budget)"]
    D --> E["Metric(..., ref budget)"]
    E --> F["Span decorations(..., ref budget)"]
    F --> G["Pause budget and store remaining active time in result"]
    G --> H["Compile deferred capture expressions while paused"]
    H --> I["Resume and evaluate captures with remaining active-time budget"]
```

### Where checkpoints are injected (`BudgetCheck()`)

- **Root:** an immediate check at the top of every compiled expression
(including the fallback delegate) guarantees even a trivial expression
observes an already-exceeded budget.
- **Collection loops:** `any` / `all` / `filter` are hand-built loops
(`BuildEnumerableLoop`) with checkpoints before enumeration and at the
top of each iteration; enumerator disposal uses `Expression.TryFinally`.
The bounded capture-filter path checks once per item and passes the same
budget into the predicate so nested checkpointed operations share it.
- **String operations** that scale with input length: `Substring`,
`Contains` / `StartsWith` / `EndsWith`, `IsEmpty` (string and collection
length), and string lexicographic comparisons.
- **Dumps:** generated collection/dictionary dump loops.
- **Regex:** real `Regex.IsMatch` timeout via `GetRemainingTimeout()`.
- **`instanceof`:** immediate checks around loaded-assembly scans and
type-resolution callbacks.

### Checkpoints intentionally removed

- **`SafeEquals`:** equality only dispatches to an allowlisted set of
`Equals` implementations that are bounded and fast, so a per-comparison
checkpoint added overhead with no protective value.
- **Member access:** no per-access checkpoint is needed because the
current resolver emits fields or compiler-generated auto-property
backing fields, rejects side-effecting getters, and guards static
initialization. Removing the wrapping block also eliminated a stray
rendering artifact in the expression snapshots, so the affected
snapshots revert to their clean pre-budget form (no semantic change to
results/errors).

### Notes / risks

- **Behavior change:** expressions that exceed the budget now throw
`EvaluationTimeBudgetExceededException`, surfaced as an evaluation
error. As before, a condition that errors defaults to `true`.
- **Config:**
`DD_INTERNAL_DYNAMIC_INSTRUMENTATION_MAX_EVALUATION_TIME_MS` defaults to
50 ms and accepts values from 10–1000 ms; invalid or missing values use
the default. The configured value is propagated through probe processors
into their evaluators.
- **Trimming:** `Datadog.Trace.Trimming.xml` gains a
`System.Linq.Expressions.TryExpression` entry (auto-generated) because
the new enumerable loops use `Expression.TryFinally`.
- **Hot path:** ordinary checkpoints are aggressively inlined and sample
the clock only every 32 calls; roots and expensive type-resolution
boundaries check immediately, and throw/clock helpers remain
non-inlined.

## Test coverage

- `DebuggerExpressionLanguageTests` covers timeout propagation,
immediate root/fallback checks, pause/resume and shared capture-budget
behavior, regex timeout handling, and budgeted type resolution;
expression snapshots were regenerated for the new loop structure while
sanitizing budget plumbing from their rendered form.
- `DebuggerSettingsTests` covers the configured range/default behavior,
and `ProbeProcessorTests` covers propagation and updates of the
configured evaluation limit.

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: Andrew Lock <andrew.lock@datadoghq.com>

Author: 3 people

tracer/missing-nullability-files.csv

@@ -232,15 +232,13 @@ src/Datadog.Trace/DataStreamsMonitoring/Transport/DataStreamsTransportStrategy.c
 src/Datadog.Trace/DataStreamsMonitoring/Utils/BinaryPrimitivesHelper.cs
 src/Datadog.Trace/Debugger/Configurations/Trie.cs
 src/Datadog.Trace/Debugger/Expressions/CaptureInfo.cs
-src/Datadog.Trace/Debugger/Expressions/CompiledExpression.cs
 src/Datadog.Trace/Debugger/Expressions/Enums.cs
 src/Datadog.Trace/Debugger/Expressions/MethodScopeMembers.cs
 src/Datadog.Trace/Debugger/Expressions/ProbeExpressionParser.Binary.cs
 src/Datadog.Trace/Debugger/Expressions/ProbeExpressionParser.Collection.cs
 src/Datadog.Trace/Debugger/Expressions/ProbeExpressionParser.cs
 src/Datadog.Trace/Debugger/Expressions/ProbeExpressionParser.Dump.cs
 src/Datadog.Trace/Debugger/Expressions/ProbeExpressionParser.General.cs
-src/Datadog.Trace/Debugger/Expressions/ProbeExpressionParser.String.cs
 src/Datadog.Trace/Debugger/Expressions/ProbeExpressionParser.Unary.cs
 src/Datadog.Trace/Debugger/Expressions/ProbeExpressionParserHelper.cs
 src/Datadog.Trace/Debugger/Expressions/ProbeExpressionsProcessor.cs

tracer/src/Datadog.Trace.Trimming/build/Datadog.Trace.Trimming.xml

@@ -376,6 +376,7 @@
       <type fullname="System.Linq.Expressions.NewArrayExpression" />
       <type fullname="System.Linq.Expressions.NewExpression" />
       <type fullname="System.Linq.Expressions.ParameterExpression" />
+      <type fullname="System.Linq.Expressions.TryExpression" />
       <type fullname="System.Linq.Expressions.TypeBinaryExpression" />
       <type fullname="System.Linq.Expressions.UnaryExpression" />
       <type fullname="System.Runtime.CompilerServices.CallSite" />

tracer/src/Datadog.Trace/Configuration/supported-configurations.yaml

@@ -831,6 +831,16 @@ supportedConfigurations:
     documentation: |-
       Configuration key for enabling or disabling Dynamic Instrumentation.
       Default value is false (disabled).
+  DD_DYNAMIC_INSTRUMENTATION_EVALUATION_TIMEOUT_MS:
+  - implementation: A
+    scope: managed
+    type: int
+    default: '50'
+    product: Debugger
+    const_name: EvaluationTimeoutMs
+    documentation: |-
+      Configuration key for the maximum elapsed time, in milliseconds, allowed for evaluating probe expressions.
+      Values from <c>10</c> to <c>1000</c> are accepted. Default value is <c>50</c>.
   DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE:
   - implementation: B
     scope: managed

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

@@ -21,11 +21,14 @@ internal sealed record DebuggerSettings
         public const string DebuggerMetricPrefix = "dynamic.instrumentation.metric.probe";
         public const int DefaultMaxDepthToSerialize = 3;
         public const int DefaultMaxSerializationTimeInMilliseconds = 200;
+        public const int DefaultMaxEvaluationTimeInMilliseconds = 50;
         public const int DefaultMaxNumberOfItemsInCollectionToCopy = 100;
         public const int DefaultMaxNumberOfFieldsToCopy = 20;
         public const int DefaultMaxStringLength = 1000;
         public const int DefaultMaxProbesPerType = 0;
 
+        private const int MinAllowedEvaluationTimeInMilliseconds = 10;
+        private const int MaxAllowedEvaluationTimeInMilliseconds = 1000;
         private const int DefaultUploadBatchSize = 100;
         public const int DefaultSymbolBatchSizeInBytes = 1 * 1024 * 1024; // 1 MB
         private const int DefaultDiagnosticsIntervalSeconds = 60 * 60; // 1 hour
@@ -55,6 +58,13 @@ public DebuggerSettings(IConfigurationSource? source, IConfigurationTelemetry te
                                                      serializationTimeThreshold => serializationTimeThreshold > 0)
                                                 .Value;
 
+            MaxEvaluationTimeInMilliseconds = config
+                                             .WithKeys(ConfigurationKeys.Debugger.EvaluationTimeoutMs)
+                                             .AsInt32(
+                                                  DefaultMaxEvaluationTimeInMilliseconds,
+                                                  evaluationTimeThreshold => evaluationTimeThreshold is >= MinAllowedEvaluationTimeInMilliseconds and <= MaxAllowedEvaluationTimeInMilliseconds)
+                                             .Value;
+
             UploadBatchSize = config
                              .WithKeys(ConfigurationKeys.Debugger.UploadBatchSize)
                              .AsInt32(DefaultUploadBatchSize, batchSize => batchSize > 0)
@@ -168,6 +178,8 @@ public DebuggerSettings(IConfigurationSource? source, IConfigurationTelemetry te
 
         public int MaxSerializationTimeInMilliseconds { get; }
 
+        public int MaxEvaluationTimeInMilliseconds { get; }
+
         public int MaximumDepthOfMembersToCopy { get; }
 
         public int UploadBatchSize { get; }

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

@@ -312,7 +312,7 @@ private void StartBackgroundProcess()
                                             lineProbes.Add(new NativeLineProbeDefinition(location!.ProbeDefinition.Id, location.Mvid, location.MethodToken, (int)location.BytecodeOffset, location.LineNumber, location.ProbeDefinition.Where.SourceFile));
                                             fetchProbeStatus.Add(new FetchProbeStatus(addedProbe.Id, addedProbe.Version ?? 0));
                                             _lastReportedUnboundProbeErrors.Remove(addedProbe.Id);
-                                            ProbeExpressionsProcessor.Instance.AddProbeProcessor(addedProbe);
+                                            ProbeExpressionsProcessor.Instance.AddProbeProcessor(addedProbe, _settings.MaxEvaluationTimeInMilliseconds);
                                             SetRateLimit(addedProbe);
                                             break;
                                         case LiveProbeResolveStatus.Unbound:
@@ -351,7 +351,7 @@ private void StartBackgroundProcess()
                                     {
                                         var nativeDefinition = new NativeMethodProbeDefinition(addedProbe.Id, addedProbe.Where.TypeName, addedProbe.Where.MethodName, signature);
                                         methodProbes.Add(nativeDefinition);
-                                        ProbeExpressionsProcessor.Instance.AddProbeProcessor(addedProbe);
+                                        ProbeExpressionsProcessor.Instance.AddProbeProcessor(addedProbe, _settings.MaxEvaluationTimeInMilliseconds);
                                         SetRateLimit(addedProbe);
                                     }
 
@@ -692,7 +692,7 @@ private void CheckUnboundProbes(object? sender, AssemblyLoadEventArgs args)
                     // configured rate would never take effect for that probe.
                     foreach (var boundProbe in boundProbes)
                     {
-                        ProbeExpressionsProcessor.Instance.AddProbeProcessor(boundProbe);
+                        ProbeExpressionsProcessor.Instance.AddProbeProcessor(boundProbe, _settings.MaxEvaluationTimeInMilliseconds);
                         SetRateLimit(boundProbe);
                     }
 

tracer/src/Datadog.Trace/Debugger/ExceptionAutoInstrumentation/ExceptionReplayProcessor.cs

@@ -253,7 +253,7 @@ public void LogException(Exception ex, IDebuggerSnapshotCreator inSnapshotCreato
             shadowStack.Leave(snapshotCreator.TrackedStackFrameNode);
         }
 
-        public IProbeProcessor UpdateProbeProcessor(ProbeDefinition probe)
+        public IProbeProcessor UpdateProbeProcessor(ProbeDefinition probe, int maxEvaluationTimeInMilliseconds)
         {
             return this;
         }

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

@@ -3,7 +3,8 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
 // </copyright>
 
-using System;
+#nullable enable
+
 using System.Linq.Expressions;
 using Datadog.Trace.Debugger.Models;
 
@@ -12,23 +13,23 @@ namespace Datadog.Trace.Debugger.Expressions
     internal readonly record struct CompiledExpression<T>
     {
         internal CompiledExpression(
-            Func<ScopeMember, ScopeMember, ScopeMember, Exception, ScopeMember[], T> @delegate,
-            Expression parsedExpression,
-            string rawExpression,
-            EvaluationError[] errors)
+            CompiledExpressionDelegate<T>? @delegate,
+            Expression? parsedExpression,
+            string? rawExpression,
+            EvaluationError[]? errors)
         {
-            Delegate = @delegate;
+            BudgetedDelegate = @delegate;
             ParsedExpression = parsedExpression;
             RawExpression = rawExpression;
             Errors = errors;
         }
 
-        internal Func<ScopeMember, ScopeMember, ScopeMember, Exception, ScopeMember[], T> Delegate { get; }
+        internal CompiledExpressionDelegate<T>? BudgetedDelegate { get; }
 
-        internal Expression ParsedExpression { get; }
+        internal Expression? ParsedExpression { get; }
 
-        internal string RawExpression { get; }
+        internal string? RawExpression { get; }
 
-        internal EvaluationError[] Errors { get; }
+        internal EvaluationError[]? Errors { get; }
     }
 }

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

@@ -0,0 +1,19 @@
+// <copyright file="CompiledExpressionDelegate.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 Datadog.Trace.Debugger.Models;
+
+namespace Datadog.Trace.Debugger.Expressions;
+
+internal delegate T CompiledExpressionDelegate<T>(
+    ScopeMember invocationTarget,
+    ScopeMember returnValue,
+    ScopeMember duration,
+    Exception exception,
+    ScopeMember[] members,
+    ref EvaluationBudget budget);

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

@@ -0,0 +1,171 @@
+// <copyright file="EvaluationBudget.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.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace Datadog.Trace.Debugger.Expressions;
+
+internal struct EvaluationBudget
+{
+    private const int OperationsBeforeTimeCheck = 32;
+    private static readonly double StopwatchTicksPerMillisecond = Stopwatch.Frequency / 1000.0;
+
+    // Stores an absolute deadline while running and remaining ticks while paused.
+    // Reusing one field keeps this hot-path struct compact.
+    private long _deadlineOrRemainingStopwatchTicks;
+    private int _operationsUntilTimeCheck;
+    private EvaluationBudgetState _state;
+
+    private EvaluationBudget(long deadlineTimestamp)
+    {
+        _deadlineOrRemainingStopwatchTicks = deadlineTimestamp;
+        _operationsUntilTimeCheck = OperationsBeforeTimeCheck;
+        _state = EvaluationBudgetState.Running;
+    }
+
+    private enum EvaluationBudgetState : byte
+    {
+        Uninitialized,
+        Running,
+        Paused,
+        TimedOut
+    }
+
+    internal readonly bool IsInitialized => _state != EvaluationBudgetState.Uninitialized;
+
+    internal readonly bool IsPaused => _state == EvaluationBudgetState.Paused;
+
+    internal readonly bool TimedOut => _state == EvaluationBudgetState.TimedOut;
+
+    internal static EvaluationBudget Create(int maxEvaluationTimeInMilliseconds)
+    {
+        var now = Stopwatch.GetTimestamp();
+        var duration = ToStopwatchTicks(maxEvaluationTimeInMilliseconds);
+        var deadline = long.MaxValue - now <= duration ? long.MaxValue : now + duration;
+        return new EvaluationBudget(deadline);
+    }
+
+    internal static void ThrowIfExceeded(ref EvaluationBudget budget)
+    {
+        budget.ThrowIfExceeded();
+    }
+
+    internal static void ThrowIfExceededImmediately(ref EvaluationBudget budget)
+    {
+        budget.ThrowIfExceededImmediately();
+    }
+
+    private static long ToStopwatchTicks(int milliseconds)
+    {
+        if (milliseconds <= 0)
+        {
+            return 0;
+        }
+
+        return (long)(milliseconds * StopwatchTicksPerMillisecond);
+    }
+
+    [DoesNotReturn]
+    private static void ThrowTimedOut()
+    {
+        throw new EvaluationTimeBudgetExceededException();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void ThrowIfExceeded()
+    {
+        if (_state != EvaluationBudgetState.Running)
+        {
+            MarkTimedOutAndThrow();
+        }
+
+        if (--_operationsUntilTimeCheck > 0)
+        {
+            return;
+        }
+
+        ThrowIfTimeExceeded();
+    }
+
+    internal void ThrowIfExceededImmediately()
+    {
+        ThrowIfTimeExceeded();
+    }
+
+    internal void Pause()
+    {
+        if (_state != EvaluationBudgetState.Running)
+        {
+            return;
+        }
+
+        _deadlineOrRemainingStopwatchTicks -= Stopwatch.GetTimestamp();
+        _state = EvaluationBudgetState.Paused;
+    }
+
+    internal void Resume()
+    {
+        if (_state != EvaluationBudgetState.Paused)
+        {
+            return;
+        }
+
+        var remainingStopwatchTicks = _deadlineOrRemainingStopwatchTicks;
+        var now = Stopwatch.GetTimestamp();
+        _deadlineOrRemainingStopwatchTicks =
+            remainingStopwatchTicks <= 0
+                ? now
+                : long.MaxValue - now <= remainingStopwatchTicks
+                    ? long.MaxValue
+                    : now + remainingStopwatchTicks;
+        _state = EvaluationBudgetState.Running;
+    }
+
+    internal TimeSpan GetRemainingTimeout()
+    {
+        ThrowIfTimeExceeded();
+
+        var remainingStopwatchTicks = _deadlineOrRemainingStopwatchTicks - Stopwatch.GetTimestamp();
+        if (remainingStopwatchTicks <= 0)
+        {
+            MarkTimedOutAndThrow();
+        }
+
+        var milliseconds = Math.Max(1, (int)(remainingStopwatchTicks / StopwatchTicksPerMillisecond));
+        return TimeSpan.FromMilliseconds(milliseconds);
+    }
+
+    internal void MarkTimedOut()
+    {
+        _state = EvaluationBudgetState.TimedOut;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void ThrowIfTimeExceeded()
+    {
+        if (_state != EvaluationBudgetState.Running)
+        {
+            MarkTimedOutAndThrow();
+        }
+
+        _operationsUntilTimeCheck = OperationsBeforeTimeCheck;
+        if (Stopwatch.GetTimestamp() >= _deadlineOrRemainingStopwatchTicks)
+        {
+            MarkTimedOutAndThrow();
+        }
+    }
+
+    [DoesNotReturn]
+    private void MarkTimedOutAndThrow()
+    {
+        _state = EvaluationBudgetState.TimedOut;
+        ThrowTimedOut();
+    }
+}

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

@@ -0,0 +1,16 @@
+// <copyright file="EvaluationTimeBudgetExceededException.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;
+
+namespace Datadog.Trace.Debugger.Expressions;
+
+internal sealed class EvaluationTimeBudgetExceededException(Exception? innerException = null)
+    : Exception(ErrorMessage, innerException)
+{
+    internal const string ErrorMessage = "Expression evaluation timed out";
+}