Added app crash simulator

Author: rhamlett_microsoft

src/PerfProblemSimulator/Controllers/CrashController.cs

@@ -0,0 +1,212 @@
+using Microsoft.AspNetCore.Mvc;
+using PerfProblemSimulator.Models;
+using PerfProblemSimulator.Services;
+
+namespace PerfProblemSimulator.Controllers;
+
+/// <summary>
+/// Controller for triggering intentional application crashes.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <strong>Educational Note:</strong> This controller provides endpoints to intentionally
+/// crash the application in various ways. This is useful for learning:
+/// </para>
+/// <list type="bullet">
+/// <item>How to configure Azure App Service crash monitoring</item>
+/// <item>How to collect and analyze crash dumps</item>
+/// <item>Understanding different types of fatal errors in .NET</item>
+/// <item>Practicing crash dump analysis with WinDbg or Visual Studio</item>
+/// </list>
+/// <para>
+/// <strong>WARNING:</strong> These endpoints will terminate the application!
+/// Azure App Service will automatically restart the application after a crash.
+/// </para>
+/// </remarks>
+[ApiController]
+[Route("api/[controller]")]
+[Produces("application/json")]
+[Tags("Crash Simulation")]
+public class CrashController : ControllerBase
+{
+    private readonly ICrashService _crashService;
+    private readonly ILogger<CrashController> _logger;
+
+    public CrashController(ICrashService crashService, ILogger<CrashController> logger)
+    {
+        _crashService = crashService ?? throw new ArgumentNullException(nameof(crashService));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    /// <summary>
+    /// Triggers an application crash of the specified type.
+    /// </summary>
+    /// <param name="request">The crash configuration.</param>
+    /// <returns>Confirmation that the crash has been scheduled (response sent before crash occurs).</returns>
+    /// <remarks>
+    /// <para>
+    /// <strong>WARNING:</strong> This endpoint will TERMINATE the application!
+    /// </para>
+    /// <para>
+    /// The response is sent before the crash occurs, so you will receive a 200 OK
+    /// indicating the crash has been scheduled. The actual crash happens shortly after.
+    /// </para>
+    /// <para>
+    /// <strong>Azure Crash Monitoring Setup:</strong>
+    /// </para>
+    /// <list type="number">
+    /// <item>In Azure Portal, go to your App Service</item>
+    /// <item>Navigate to "Diagnose and solve problems"</item>
+    /// <item>Search for "Crash Monitoring"</item>
+    /// <item>Enable crash monitoring with "Collect Memory Dump"</item>
+    /// <item>Call this endpoint to trigger a crash</item>
+    /// <item>Download the crash dump from the Azure portal</item>
+    /// </list>
+    /// </remarks>
+    /// <response code="200">Crash has been scheduled</response>
+    /// <response code="400">Invalid crash configuration</response>
+    /// <response code="503">Problem endpoints are disabled</response>
+    [HttpPost("trigger")]
+    [ProducesResponseType(typeof(SimulationResult), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status503ServiceUnavailable)]
+    public IActionResult TriggerCrash([FromBody] CrashRequest? request)
+    {
+        request ??= new CrashRequest();
+
+        // Validate delay
+        if (request.DelaySeconds < 0 || request.DelaySeconds > 60)
+        {
+            return BadRequest(new ErrorResponse
+            {
+                Error = "INVALID_DELAY",
+                Message = "DelaySeconds must be between 0 and 60"
+            });
+        }
+
+        _logger.LogCritical(
+            "🚨 CRASH REQUESTED: Type={CrashType}, Delay={DelaySeconds}s",
+            request.CrashType, request.DelaySeconds);
+
+        // Trigger the crash
+        _crashService.TriggerCrash(request.CrashType, request.DelaySeconds, request.Message);
+
+        var crashMessage = $"💥 {request.CrashType} crash scheduled! " +
+                      (request.DelaySeconds > 0 
+                          ? $"Crash will occur in {request.DelaySeconds} seconds." 
+                          : "Crash will occur in ~100ms (after this response is sent).");
+
+        return Ok(new SimulationResult
+        {
+            SimulationId = Guid.NewGuid(),
+            Type = SimulationType.Crash,
+            Status = "Scheduled",
+            Message = crashMessage,
+            ActualParameters = new Dictionary<string, object>
+            {
+                ["CrashType"] = request.CrashType.ToString(),
+                ["DelaySeconds"] = request.DelaySeconds
+            }
+        });
+    }
+
+    /// <summary>
+    /// Gets information about available crash types.
+    /// </summary>
+    /// <returns>A dictionary of crash types and their descriptions.</returns>
+    /// <remarks>
+    /// Use this endpoint to understand what each crash type does before triggering it.
+    /// </remarks>
+    /// <response code="200">List of crash types and descriptions</response>
+    [HttpGet("types")]
+    [ProducesResponseType(typeof(Dictionary<string, CrashTypeInfo>), StatusCodes.Status200OK)]
+    public IActionResult GetCrashTypes()
+    {
+        var descriptions = _crashService.GetCrashTypeDescriptions();
+        
+        var result = descriptions.ToDictionary(
+            kvp => kvp.Key.ToString(),
+            kvp => new CrashTypeInfo
+            {
+                Name = kvp.Key.ToString(),
+                Value = (int)kvp.Key,
+                Description = kvp.Value,
+                RecommendedForAzure = kvp.Key == CrashType.FailFast || kvp.Key == CrashType.StackOverflow
+            });
+
+        return Ok(result);
+    }
+
+    /// <summary>
+    /// Triggers a FailFast crash (most common for Azure crash monitoring).
+    /// </summary>
+    /// <param name="delaySeconds">Optional delay before crash (0-60 seconds).</param>
+    /// <returns>Confirmation that the crash has been scheduled.</returns>
+    /// <remarks>
+    /// This is a convenience endpoint for the most commonly used crash type.
+    /// Environment.FailFast is the recommended method for testing Azure crash monitoring.
+    /// </remarks>
+    /// <response code="200">Crash has been scheduled</response>
+    /// <response code="503">Problem endpoints are disabled</response>
+    [HttpPost("failfast")]
+    [ProducesResponseType(typeof(SimulationResult), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status503ServiceUnavailable)]
+    public IActionResult TriggerFailFast([FromQuery] int delaySeconds = 0)
+    {
+        return TriggerCrash(new CrashRequest
+        {
+            CrashType = CrashType.FailFast,
+            DelaySeconds = Math.Clamp(delaySeconds, 0, 60),
+            Message = "FailFast triggered via /api/crash/failfast endpoint"
+        });
+    }
+
+    /// <summary>
+    /// Triggers a StackOverflow crash.
+    /// </summary>
+    /// <param name="delaySeconds">Optional delay before crash (0-60 seconds).</param>
+    /// <returns>Confirmation that the crash has been scheduled.</returns>
+    /// <remarks>
+    /// Creates interesting stack traces for analysis. The crash dump will show
+    /// repeated calls to the same method, demonstrating infinite recursion.
+    /// </remarks>
+    /// <response code="200">Crash has been scheduled</response>
+    /// <response code="503">Problem endpoints are disabled</response>
+    [HttpPost("stackoverflow")]
+    [ProducesResponseType(typeof(SimulationResult), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status503ServiceUnavailable)]
+    public IActionResult TriggerStackOverflow([FromQuery] int delaySeconds = 0)
+    {
+        return TriggerCrash(new CrashRequest
+        {
+            CrashType = CrashType.StackOverflow,
+            DelaySeconds = Math.Clamp(delaySeconds, 0, 60)
+        });
+    }
+}
+
+/// <summary>
+/// Information about a crash type.
+/// </summary>
+public class CrashTypeInfo
+{
+    /// <summary>
+    /// Name of the crash type.
+    /// </summary>
+    public required string Name { get; set; }
+
+    /// <summary>
+    /// Numeric value for the crash type enum.
+    /// </summary>
+    public int Value { get; set; }
+
+    /// <summary>
+    /// Detailed description of what this crash type does.
+    /// </summary>
+    public required string Description { get; set; }
+
+    /// <summary>
+    /// Whether this crash type is recommended for Azure crash monitoring.
+    /// </summary>
+    public bool RecommendedForAzure { get; set; }
+}

src/PerfProblemSimulator/Models/CrashRequest.cs

@@ -0,0 +1,71 @@
+namespace PerfProblemSimulator.Models;
+
+/// <summary>
+/// Request model for triggering application crashes.
+/// </summary>
+/// <remarks>
+/// <para>
+/// <strong>Educational Note:</strong> This request triggers intentional application crashes
+/// for learning how to use Azure crash monitoring and memory dump collection.
+/// </para>
+/// <para>
+/// <strong>WARNING:</strong> These operations will terminate the application process!
+/// The application will need to be restarted (Azure App Service does this automatically).
+/// </para>
+/// </remarks>
+public class CrashRequest
+{
+    /// <summary>
+    /// The type of crash to trigger.
+    /// </summary>
+    public CrashType CrashType { get; set; } = CrashType.FailFast;
+
+    /// <summary>
+    /// Optional delay in seconds before the crash occurs.
+    /// Allows time to observe the application state before crash.
+    /// Default: 0 (immediate)
+    /// </summary>
+    public int DelaySeconds { get; set; } = 0;
+
+    /// <summary>
+    /// Custom message to include in the crash (for FailFast and UnhandledException types).
+    /// </summary>
+    public string? Message { get; set; }
+}
+
+/// <summary>
+/// Types of crashes that can be triggered.
+/// </summary>
+public enum CrashType
+{
+    /// <summary>
+    /// Calls Environment.FailFast() which immediately terminates the process.
+    /// Creates a Windows Error Report and crash dump if configured.
+    /// </summary>
+    FailFast = 0,
+
+    /// <summary>
+    /// Triggers a StackOverflowException via infinite recursion.
+    /// Cannot be caught and immediately terminates the process.
+    /// Creates interesting stack traces for analysis.
+    /// </summary>
+    StackOverflow = 1,
+
+    /// <summary>
+    /// Throws an unhandled exception on a background thread.
+    /// Terminates the process if unhandled exception policy is set to terminate.
+    /// </summary>
+    UnhandledException = 2,
+
+    /// <summary>
+    /// Triggers an access violation by writing to protected memory.
+    /// Requires unsafe code and demonstrates native-level crashes.
+    /// </summary>
+    AccessViolation = 3,
+
+    /// <summary>
+    /// Allocates memory until the process runs out and crashes.
+    /// Different from memory pressure - this is meant to be fatal.
+    /// </summary>
+    OutOfMemory = 4
+}

src/PerfProblemSimulator/Models/SimulationType.cs

@@ -52,5 +52,11 @@ public enum SimulationType
     /// Thread pool starvation simulation using sync-over-async anti-patterns.
     /// Diagnosis tools: ThreadPool.GetAvailableThreads(), dotnet-counters, Application Insights request queuing.
     /// </summary>
-    ThreadBlock
+    ThreadBlock,
+
+    /// <summary>
+    /// Application crash simulation that terminates the process.
+    /// Diagnosis tools: Azure Crash Monitoring, Windows Error Reporting, crash dump analysis with WinDbg.
+    /// </summary>
+    Crash
 }

src/PerfProblemSimulator/PerfProblemSimulator.csproj

@@ -5,6 +5,11 @@
     Common properties (TargetFramework, Nullable, ImplicitUsings) are inherited from Directory.Build.props
   -->
 
+  <PropertyGroup>
+    <!-- Enable unsafe code for AccessViolation crash simulation -->
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.0" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="10.1.0" />

src/PerfProblemSimulator/Program.cs

@@ -108,6 +108,11 @@
 // its own simulation, and state is tracked by the singleton SimulationTracker.
 builder.Services.AddTransient<IThreadBlockService, ThreadBlockService>();
 
+// CrashService - Transient service for triggering intentional application crashes
+// Educational Note: This service demonstrates various crash scenarios for learning
+// how to use Azure crash monitoring and memory dump collection.
+builder.Services.AddTransient<ICrashService, CrashService>();
+
 // 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.