added failed requests simulator

Author: rhamlett

src/PerfProblemSimulator/Controllers/FailedRequestController.cs

@@ -0,0 +1,135 @@
+using Microsoft.AspNetCore.Mvc;
+using PerfProblemSimulator.Models;
+using PerfProblemSimulator.Services;
+
+namespace PerfProblemSimulator.Controllers;
+
+/// <summary>
+/// Controller for generating failed HTTP requests (5xx responses).
+/// </summary>
+/// <remarks>
+/// <para>
+/// <strong>PURPOSE:</strong>
+/// This controller provides endpoints to generate HTTP 500 errors for testing
+/// Azure diagnostics tools like AppLens and Application Insights.
+/// </para>
+/// <para>
+/// <strong>USE CASES:</strong>
+/// <list type="bullet">
+/// <item>Testing AppLens error detection and analysis</item>
+/// <item>Validating Application Insights failure alerts</item>
+/// <item>Testing error rate based auto-scaling rules</item>
+/// <item>Training developers on error diagnosis in Azure</item>
+/// </list>
+/// </para>
+/// <para>
+/// <strong>HOW IT WORKS:</strong>
+/// The service makes HTTP requests to the /api/loadtest endpoint with parameters
+/// configured for guaranteed failure (100% error probability). The load test endpoint
+/// throws a random exception, resulting in an HTTP 500 response. Each request takes
+/// approximately 1.5 seconds, ensuring the failures appear in latency monitoring.
+/// </para>
+/// </remarks>
+[ApiController]
+[Route("api/[controller]")]
+[Produces("application/json")]
+[Tags("Failed Request Simulation")]
+public class FailedRequestController : ControllerBase
+{
+    private readonly IFailedRequestService _failedRequestService;
+    private readonly ILogger<FailedRequestController> _logger;
+
+    public FailedRequestController(
+        IFailedRequestService failedRequestService,
+        ILogger<FailedRequestController> logger)
+    {
+        _failedRequestService = failedRequestService ?? throw new ArgumentNullException(nameof(failedRequestService));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    /// <summary>
+    /// Starts generating failed HTTP requests.
+    /// </summary>
+    /// <param name="request">Configuration specifying how many failures to generate.</param>
+    /// <returns>Information about the started simulation.</returns>
+    /// <remarks>
+    /// <para>
+    /// This endpoint starts a background process that generates HTTP 500 errors.
+    /// Each failed request takes approximately 1.5 seconds and throws a random
+    /// exception type (TimeoutException, NullReferenceException, etc.).
+    /// </para>
+    /// <para>
+    /// <strong>Where to see the failures:</strong>
+    /// <list type="bullet">
+    /// <item>Azure Portal → App Service → Diagnose and Solve Problems → AppLens</item>
+    /// <item>Application Insights → Failures blade</item>
+    /// <item>Azure Monitor → Alerts (if error rate rules configured)</item>
+    /// </list>
+    /// </para>
+    /// </remarks>
+    /// <response code="200">Simulation started successfully</response>
+    [HttpPost("start")]
+    [ProducesResponseType(typeof(SimulationResult), StatusCodes.Status200OK)]
+    public IActionResult Start([FromBody] FailedRequestRequest? request)
+    {
+        var requestCount = request?.RequestCount ?? 10;
+
+        _logger.LogWarning(
+            "❌ Starting failed request simulation: Count={Count}",
+            requestCount);
+
+        var result = _failedRequestService.Start(requestCount);
+        return Ok(result);
+    }
+
+    /// <summary>
+    /// Stops the failed request simulation.
+    /// </summary>
+    /// <returns>Summary of the simulation run.</returns>
+    /// <remarks>
+    /// Stops generating new failed requests. Requests already in progress will complete.
+    /// </remarks>
+    /// <response code="200">Simulation stopped</response>
+    [HttpPost("stop")]
+    [ProducesResponseType(typeof(SimulationResult), StatusCodes.Status200OK)]
+    public IActionResult Stop()
+    {
+        _logger.LogInformation("🛑 Stopping failed request simulation");
+        var result = _failedRequestService.Stop();
+        return Ok(result);
+    }
+
+    /// <summary>
+    /// Gets the current status of the failed request simulation.
+    /// </summary>
+    /// <returns>Current simulation status including request counts.</returns>
+    /// <response code="200">Current status</response>
+    [HttpGet("status")]
+    [ProducesResponseType(typeof(FailedRequestStatus), StatusCodes.Status200OK)]
+    public IActionResult GetStatus()
+    {
+        var status = _failedRequestService.GetStatus();
+        return Ok(status);
+    }
+}
+
+/// <summary>
+/// Request model for starting a failed request simulation.
+/// </summary>
+public class FailedRequestRequest
+{
+    /// <summary>
+    /// Number of failed requests (HTTP 500s) to generate.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <strong>DEFAULT: 10</strong>
+    /// </para>
+    /// <para>
+    /// Each request takes approximately 1.5 seconds before failing.
+    /// Requests are spread out with a small delay between them to ensure
+    /// they appear as distinct data points in monitoring tools.
+    /// </para>
+    /// </remarks>
+    public int RequestCount { get; set; } = 10;
+}

src/PerfProblemSimulator/Controllers/ThreadBlockController.cs

@@ -33,16 +33,19 @@ namespace PerfProblemSimulator.Controllers;
 public class ThreadBlockController : ControllerBase
 {
     private readonly IThreadBlockService _threadBlockService;
+    private readonly ISimulationTracker _simulationTracker;
     private readonly ILogger<ThreadBlockController> _logger;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ThreadBlockController"/> class.
     /// </summary>
     public ThreadBlockController(
         IThreadBlockService threadBlockService,
+        ISimulationTracker simulationTracker,
         ILogger<ThreadBlockController> logger)
     {
         _threadBlockService = threadBlockService ?? throw new ArgumentNullException(nameof(threadBlockService));
+        _simulationTracker = simulationTracker ?? throw new ArgumentNullException(nameof(simulationTracker));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
     }
 
@@ -130,4 +133,32 @@ public async Task<IActionResult> TriggerSyncOverAsync(
                 ErrorResponse.SimulationError("Failed to start thread blocking simulation."));
         }
     }
+
+    /// <summary>
+    /// Stops all active thread pool starvation simulations.
+    /// </summary>
+    /// <returns>Number of simulations that were stopped.</returns>
+    /// <remarks>
+    /// <para>
+    /// This endpoint cancels all active thread blocking simulations. Already-blocked threads
+    /// will eventually complete their current delay, but no new blocking operations will start.
+    /// </para>
+    /// </remarks>
+    /// <response code="200">Thread blocking simulations stopped.</response>
+    [HttpPost("stop")]
+    [ProducesResponseType(typeof(object), StatusCodes.Status200OK)]
+    public IActionResult Stop()
+    {
+        _logger.LogInformation("Stopping all thread blocking simulations");
+        
+        var cancelled = _simulationTracker.CancelByType(SimulationType.ThreadBlock);
+        
+        _logger.LogInformation("Stopped {Count} thread blocking simulations", cancelled);
+        
+        return Ok(new 
+        { 
+            message = $"Stopped {cancelled} thread blocking simulation(s)",
+            cancelledCount = cancelled
+        });
+    }
 }

src/PerfProblemSimulator/Models/SimulationType.cs

@@ -74,5 +74,13 @@ public enum SimulationType
     /// Designed to eventually trigger 230s Azure App Service timeout under extreme load.
     /// Diagnosis tools: Azure Load Testing, Application Insights, Azure Monitor.
     /// </summary>
-    LoadTest
+    LoadTest,
+
+    /// <summary>
+    /// Failed request simulation that generates HTTP 5xx responses.
+    /// Uses the load test endpoint with 100% error probability to create guaranteed failures.
+    /// Designed to produce HTTP 500 errors visible in AppLens and Application Insights.
+    /// Diagnosis tools: AppLens, Application Insights failures blade, Azure Monitor alerts.
+    /// </summary>
+    FailedRequest
 }

src/PerfProblemSimulator/Program.cs

@@ -202,6 +202,18 @@
 // causing immediate problems.
 builder.Services.AddSingleton<ILoadTestService, LoadTestService>();
 
+// FailedRequestService - Singleton service for generating HTTP 5xx errors
+// Educational Note: Singleton lifetime is required because the service maintains
+// state about running simulations. This service generates failed requests by calling
+// the load test endpoint with 100% error probability, producing HTTP 500 errors that
+// appear in AppLens and Application Insights for training on error diagnosis.
+builder.Services.AddHttpClient("FailedRequest")
+    .ConfigurePrimaryHttpMessageHandler(() => new SocketsHttpHandler
+    {
+        ConnectTimeout = TimeSpan.FromSeconds(60)
+    });
+builder.Services.AddSingleton<IFailedRequestService, FailedRequestService>();
+
 // MetricsCollector - Singleton service for collecting system metrics
 // Educational Note: This service runs on a DEDICATED THREAD (not the thread pool)
 // so it remains responsive even during thread pool starvation scenarios.