Removed safety limits from configuration files.

Author: rhamlett_microsoft

src/PerfProblemSimulator/Models/ProblemSimulatorOptions.cs

@@ -4,65 +4,13 @@ namespace PerfProblemSimulator.Models;
 /// Configuration options for the Performance Problem Simulator.
 /// Loaded from the "ProblemSimulator" section of appsettings.json.
 /// </summary>
-/// <remarks>
-/// <para>
-/// <strong>Educational Note:</strong> These limits are crucial for preventing the simulator
-/// from accidentally causing permanent damage to the host system. In production applications,
-/// similar limits should be applied to any resource-intensive operations.
-/// </para>
-/// <para>
-/// The options pattern (<c>IOptions&lt;ProblemSimulatorOptions&gt;</c>) allows these values
-/// to be easily overridden per environment (development vs production) and supports
-/// hot reloading via <c>IOptionsMonitor&lt;T&gt;</c>.
-/// </para>
-/// </remarks>
 public class ProblemSimulatorOptions
 {
     /// <summary>
     /// Configuration section name in appsettings.json.
     /// </summary>
     public const string SectionName = "ProblemSimulator";
 
-    /// <summary>
-    /// Maximum duration in seconds for CPU stress simulation.
-    /// Prevents runaway CPU consumption.
-    /// </summary>
-    /// <remarks>
-    /// Default: 300 seconds (5 minutes). This provides enough time to observe metrics
-    /// and practice diagnosis without risking long-term system instability.
-    /// </remarks>
-    public int MaxCpuDurationSeconds { get; set; } = 300;
-
-    /// <summary>
-    /// Maximum memory that can be allocated in megabytes.
-    /// Prevents the application from consuming all available system memory.
-    /// </summary>
-    /// <remarks>
-    /// Default: 1024 MB (1 GB). This is enough to cause visible memory pressure
-    /// on most systems without triggering out-of-memory conditions.
-    /// </remarks>
-    public int MaxMemoryAllocationMb { get; set; } = 1024;
-
-    /// <summary>
-    /// Maximum delay in milliseconds for thread blocking simulation.
-    /// Limits how long individual threads can be blocked.
-    /// </summary>
-    /// <remarks>
-    /// Default: 30000 ms (30 seconds). Long enough to demonstrate thread pool
-    /// starvation effects without permanently blocking threads.
-    /// </remarks>
-    public int MaxThreadBlockDelayMs { get; set; } = 30000;
-
-    /// <summary>
-    /// Maximum number of concurrent blocking requests.
-    /// Limits thread pool exhaustion severity.
-    /// </summary>
-    /// <remarks>
-    /// Default: 200. This is typically enough to exhaust the default thread pool
-    /// on most systems while remaining manageable.
-    /// </remarks>
-    public int MaxConcurrentBlockingRequests { get; set; } = 200;
-
     /// <summary>
     /// How often the metrics collector should sample system metrics in milliseconds.
     /// </summary>
@@ -71,13 +19,4 @@ public class ProblemSimulatorOptions
     /// dashboard updates but consumes more resources.
     /// </remarks>
     public int MetricsCollectionIntervalMs { get; set; } = 1000;
-
-    /// <summary>
-    /// Whether to log detailed information about simulation requests.
-    /// </summary>
-    /// <remarks>
-    /// Default: true. Useful for understanding what's happening during simulations.
-    /// May be disabled in production-like testing scenarios for performance.
-    /// </remarks>
-    public bool EnableRequestLogging { get; set; } = true;
 }

src/PerfProblemSimulator/Services/CpuStressService.cs

@@ -1,4 +1,3 @@
-using Microsoft.Extensions.Options;
 using PerfProblemSimulator.Models;
 using System.Diagnostics;
 
@@ -65,7 +64,6 @@ public class CpuStressService : ICpuStressService
 {
     private readonly ISimulationTracker _simulationTracker;
     private readonly ILogger<CpuStressService> _logger;
-    private readonly ProblemSimulatorOptions _options;
 
     /// <summary>
     /// Default duration in seconds when not specified or invalid.
@@ -77,30 +75,23 @@ public class CpuStressService : ICpuStressService
     /// </summary>
     /// <param name="simulationTracker">Service for tracking active simulations.</param>
     /// <param name="logger">Logger for diagnostic information.</param>
-    /// <param name="options">Configuration options containing limits.</param>
     public CpuStressService(
         ISimulationTracker simulationTracker,
-        ILogger<CpuStressService> logger,
-        IOptions<ProblemSimulatorOptions> options)
+        ILogger<CpuStressService> logger)
     {
         _simulationTracker = simulationTracker ?? throw new ArgumentNullException(nameof(simulationTracker));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
     }
 
     /// <inheritdoc />
     public Task<SimulationResult> TriggerCpuStressAsync(int durationSeconds, CancellationToken cancellationToken)
     {
         // ==========================================================================
-        // STEP 1: Validate and cap the duration
+        // STEP 1: Validate the duration (no upper limits - app is meant to break)
         // ==========================================================================
-        // We apply defensive programming here - never trust input, always validate.
-        // This prevents users from accidentally (or intentionally) causing harm by
-        // requesting extremely long durations.
-
         var actualDuration = durationSeconds <= 0
             ? DefaultDurationSeconds
-            : Math.Min(durationSeconds, _options.MaxCpuDurationSeconds);
+            : durationSeconds;
 
         var simulationId = Guid.NewGuid();
         var startedAt = DateTimeOffset.UtcNow;

src/PerfProblemSimulator/Services/MemoryPressureService.cs

@@ -1,4 +1,3 @@
-using Microsoft.Extensions.Options;
 using PerfProblemSimulator.Models;
 using System.Runtime.InteropServices;
 
@@ -63,7 +62,6 @@ public class MemoryPressureService : IMemoryPressureService
 {
     private readonly ISimulationTracker _simulationTracker;
     private readonly ILogger<MemoryPressureService> _logger;
-    private readonly ProblemSimulatorOptions _options;
 
     /// <summary>
     /// Thread-safe list holding all allocated memory blocks.
@@ -96,67 +94,34 @@ public class MemoryPressureService : IMemoryPressureService
     /// </summary>
     /// <param name="simulationTracker">Service for tracking active simulations.</param>
     /// <param name="logger">Logger for diagnostic information.</param>
-    /// <param name="options">Configuration options containing limits.</param>
     public MemoryPressureService(
         ISimulationTracker simulationTracker,
-        ILogger<MemoryPressureService> logger,
-        IOptions<ProblemSimulatorOptions> options)
+        ILogger<MemoryPressureService> logger)
     {
         _simulationTracker = simulationTracker ?? throw new ArgumentNullException(nameof(simulationTracker));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
     }
 
     /// <inheritdoc />
     public SimulationResult AllocateMemory(int sizeMegabytes)
     {
         // ==========================================================================
-        // STEP 1: Validate and constrain the allocation size
+        // STEP 1: Validate the allocation size (no upper limits - app is meant to break)
         // ==========================================================================
         var actualSize = sizeMegabytes <= 0
             ? DefaultSizeMegabytes
             : Math.Max(MinimumSizeMegabytes, sizeMegabytes);
 
-        // Check against remaining capacity
         long currentAllocatedBytes;
         lock (_lock)
         {
             currentAllocatedBytes = _allocatedBlocks.Sum(b => b.SizeBytes);
         }
 
-        var maxBytes = (long)_options.MaxMemoryAllocationMb * 1024 * 1024;
-        var remainingCapacity = maxBytes - currentAllocatedBytes;
-        var requestedBytes = (long)actualSize * 1024 * 1024;
-
-        if (requestedBytes > remainingCapacity)
-        {
-            // Cap to remaining capacity (minimum 10MB if any space left)
-            actualSize = (int)(remainingCapacity / (1024 * 1024));
-            if (actualSize < MinimumSizeMegabytes)
-            {
-                actualSize = 0; // Not enough space for minimum allocation
-            }
-        }
-
-        if (actualSize <= 0)
-        {
-            return new SimulationResult
-            {
-                SimulationId = Guid.Empty,
-                Type = SimulationType.Memory,
-                Status = "Failed",
-                Message = $"Cannot allocate memory: Maximum allocation limit ({_options.MaxMemoryAllocationMb} MB) reached. " +
-                          "Release existing allocations first with POST /api/memory/release-memory.",
-                ActualParameters = new Dictionary<string, object>
-                {
-                    ["RequestedSizeMegabytes"] = sizeMegabytes,
-                    ["CurrentAllocatedMegabytes"] = currentAllocatedBytes / (1024.0 * 1024.0),
-                    ["MaxAllowedMegabytes"] = _options.MaxMemoryAllocationMb
-                },
-                StartedAt = DateTimeOffset.UtcNow,
-                EstimatedEndAt = null
-            };
-        }
+        _logger.LogInformation(
+            "Allocating {Size} MB. Current total: {Current} MB",
+            actualSize,
+            currentAllocatedBytes / (1024.0 * 1024.0));
 
         var simulationId = Guid.NewGuid();
         var startedAt = DateTimeOffset.UtcNow;

src/PerfProblemSimulator/Services/ThreadBlockService.cs

@@ -1,4 +1,3 @@
-using Microsoft.Extensions.Options;
 using PerfProblemSimulator.Models;
 
 namespace PerfProblemSimulator.Services;
@@ -88,7 +87,6 @@ public class ThreadBlockService : IThreadBlockService
 {
     private readonly ISimulationTracker _simulationTracker;
     private readonly ILogger<ThreadBlockService> _logger;
-    private readonly ProblemSimulatorOptions _options;
 
     /// <summary>
     /// Default delay in milliseconds when not specified or invalid.
@@ -110,12 +108,10 @@ public class ThreadBlockService : IThreadBlockService
     /// </summary>
     public ThreadBlockService(
         ISimulationTracker simulationTracker,
-        ILogger<ThreadBlockService> logger,
-        IOptions<ProblemSimulatorOptions> options)
+        ILogger<ThreadBlockService> logger)
     {
         _simulationTracker = simulationTracker ?? throw new ArgumentNullException(nameof(simulationTracker));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
     }
 
     /// <inheritdoc />
@@ -125,15 +121,15 @@ public Task<SimulationResult> TriggerSyncOverAsyncAsync(
         CancellationToken cancellationToken)
     {
         // ==========================================================================
-        // STEP 1: Validate and constrain parameters
+        // STEP 1: Validate parameters (no upper limits - app is meant to break)
         // ==========================================================================
         var actualDelay = delayMilliseconds <= 0
             ? DefaultDelayMs
-            : Math.Max(MinimumDelayMs, Math.Min(delayMilliseconds, _options.MaxThreadBlockDelayMs));
+            : Math.Max(MinimumDelayMs, delayMilliseconds);
 
         var actualConcurrent = concurrentRequests <= 0
             ? DefaultConcurrentRequests
-            : Math.Min(concurrentRequests, _options.MaxConcurrentBlockingRequests);
+            : concurrentRequests;
 
         var simulationId = Guid.NewGuid();
         var startedAt = DateTimeOffset.UtcNow;

src/PerfProblemSimulator/appsettings.Development.json

@@ -8,11 +8,6 @@
     }
   },
   "ProblemSimulator": {
-    "MaxCpuDurationSeconds": 60,
-    "MaxMemoryAllocationMb": 512,
-    "MaxThreadBlockDelayMs": 10000,
-    "MaxConcurrentBlockingRequests": 50,
-    "MetricsCollectionIntervalMs": 500,
-    "EnableRequestLogging": true
+    "MetricsCollectionIntervalMs": 500
   }
 }

src/PerfProblemSimulator/appsettings.json

@@ -8,11 +8,6 @@
   },
   "AllowedHosts": "*",
   "ProblemSimulator": {
-    "MaxCpuDurationSeconds": 300,
-    "MaxMemoryAllocationMb": 512,
-    "MaxThreadBlockDelayMs": 30000,
-    "MaxConcurrentBlockingRequests": 1000,
-    "MetricsCollectionIntervalMs": 1000,
-    "EnableRequestLogging": true
+    "MetricsCollectionIntervalMs": 1000
   }
 }

tests/PerfProblemSimulator.Tests/Integration/CpuEndpointTests.cs

@@ -68,7 +68,7 @@ public async Task TriggerHighCpu_WithDefaultValues_UsesDefaults()
     }
 
     [Fact]
-    public async Task TriggerHighCpu_WithExcessiveDuration_CapsToMaximum()
+    public async Task TriggerHighCpu_WithLargeDuration_UsesRequestedDuration()
     {
         // Arrange
         var request = new { DurationSeconds = 9999 };
@@ -86,7 +86,7 @@ public async Task TriggerHighCpu_WithExcessiveDuration_CapsToMaximum()
         var result = await response.Content.ReadFromJsonAsync<JsonElement>(_jsonOptions);
         var actualParams = result.GetProperty("actualParameters");
         var actualDuration = actualParams.GetProperty("durationSeconds").GetInt32();
-        Assert.True(actualDuration <= 300, $"Duration should be capped to max (300), was {actualDuration}");
+        Assert.Equal(9999, actualDuration); // No limits, uses requested value
     }
 
     [Fact]

tests/PerfProblemSimulator.Tests/Integration/MemoryEndpointTests.cs

@@ -166,7 +166,7 @@ public async Task ReleaseMemory_WhenNothingAllocated_ReturnsZeroCount()
     }
 
     [Fact]
-    public async Task AllocateMemory_WithExcessiveSize_CapsToMaximum()
+    public async Task AllocateMemory_WithLargeSize_UsesRequestedSize()
     {
         // Arrange
         var request = new { SizeMegabytes = 9999 };
@@ -184,6 +184,6 @@ public async Task AllocateMemory_WithExcessiveSize_CapsToMaximum()
         var result = await response.Content.ReadFromJsonAsync<JsonElement>(_jsonOptions);
         var actualParams = result.GetProperty("actualParameters");
         var actualSize = actualParams.GetProperty("sizeMegabytes").GetInt32();
-        Assert.True(actualSize <= 1024, $"Size should be capped to max (1024), was {actualSize}");
+        Assert.Equal(9999, actualSize); // No limits, uses requested value
     }
 }

tests/PerfProblemSimulator.Tests/Integration/ThreadBlockEndpointTests.cs

@@ -117,7 +117,7 @@ public async Task TriggerSyncOverAsync_IncludesEstimatedEndTime()
     }
 
     [Fact]
-    public async Task TriggerSyncOverAsync_WithExcessiveDelay_CapsToMaximum()
+    public async Task TriggerSyncOverAsync_WithLargeDelay_UsesRequestedDelay()
     {
         // Arrange
         var request = new { DelayMilliseconds = 999999 };
@@ -135,11 +135,11 @@ public async Task TriggerSyncOverAsync_WithExcessiveDelay_CapsToMaximum()
         var result = await response.Content.ReadFromJsonAsync<JsonElement>(_jsonOptions);
         var actualParams = result.GetProperty("actualParameters");
         var actualDelay = actualParams.GetProperty("delayMilliseconds").GetInt32();
-        Assert.True(actualDelay <= 30000, $"Delay should be capped to max (30000), was {actualDelay}");
+        Assert.Equal(999999, actualDelay); // No limits, uses requested value
     }
 
     [Fact]
-    public async Task TriggerSyncOverAsync_WithExcessiveConcurrency_CapsToMaximum()
+    public async Task TriggerSyncOverAsync_WithLargeConcurrency_UsesRequestedConcurrency()
     {
         // Arrange
         var request = new { ConcurrentRequests = 9999 };
@@ -157,6 +157,6 @@ public async Task TriggerSyncOverAsync_WithExcessiveConcurrency_CapsToMaximum()
         var result = await response.Content.ReadFromJsonAsync<JsonElement>(_jsonOptions);
         var actualParams = result.GetProperty("actualParameters");
         var actualConcurrent = actualParams.GetProperty("concurrentRequests").GetInt32();
-        Assert.True(actualConcurrent <= 200, $"Concurrency should be capped to max (200), was {actualConcurrent}");
+        Assert.Equal(9999, actualConcurrent); // No limits, uses requested value
     }
 }