Updates to crash generation to bypass ANCM interception.

Author: rhamlett_microsoft

src/PerfProblemSimulator/Models/CrashRequest.cs

@@ -37,17 +37,17 @@ public class CrashRequest
 
     /// <summary>
     /// If true, crash happens during the HTTP request (no response sent).
-    /// This is more likely to be captured by Azure Crash Monitoring.
-    /// Default: false (crash after response for better UX)
+    /// This is required for Azure Crash Monitoring to capture the crash.
+    /// Default: true (optimized for Azure Crash Monitoring)
     /// </summary>
     /// <remarks>
     /// <para>
-    /// <strong>Azure Crash Monitoring Note:</strong> Set this to true for Azure Crash Monitoring
+    /// <strong>Azure Crash Monitoring Note:</strong> This must be true for Azure Crash Monitoring
     /// to properly capture the crash. When false, the crash happens on a background thread
     /// after the HTTP response is sent, which Azure may not associate with a request.
     /// </para>
     /// </remarks>
-    public bool Synchronous { get; set; } = false;
+    public bool Synchronous { get; set; } = true;
 }
 
 /// <summary>
@@ -84,5 +84,12 @@ public enum CrashType
     /// Allocates memory until the process runs out and crashes.
     /// Different from memory pressure - this is meant to be fatal.
     /// </summary>
-    OutOfMemory = 4
+    OutOfMemory = 4,
+
+    /// <summary>
+    /// Uses RtlFailFast to trigger an unbypassable native crash.
+    /// This bypasses all .NET and ANCM exception handlers and guarantees
+    /// a Windows Error Report is generated. Best option for Azure Crash Monitoring.
+    /// </summary>
+    NativeCrash = 5
 }

src/PerfProblemSimulator/Services/CrashService.cs

@@ -117,6 +117,10 @@ private void ExecuteCrash(CrashType crashType, string message)
                 ExecuteOutOfMemory();
                 break;
 
+            case CrashType.NativeCrash:
+                ExecuteNativeCrash();
+                break;
+
             default:
                 throw new ArgumentOutOfRangeException(nameof(crashType), crashType, "Unknown crash type");
         }
@@ -232,6 +236,38 @@ private void ExecuteAccessViolation()
     [DllImport("kernel32.dll", SetLastError = true)]
     private static extern void RaiseException(uint dwExceptionCode, uint dwExceptionFlags, uint nNumberOfArguments, IntPtr lpArguments);
 
+    /// <summary>
+    /// Uses RtlFailFast to trigger an unbypassable crash that guarantees WER capture.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <strong>Educational Note:</strong> RtlFailFast (the underlying implementation of __fastfail)
+    /// is the nuclear option for crash generation. It:
+    /// </para>
+    /// <list type="bullet">
+    /// <item>Bypasses ALL exception handlers (including ANCM in IIS InProcess mode)</item>
+    /// <item>Generates a Windows Error Report that Crash Monitoring can capture</item>
+    /// <item>Cannot be caught, filtered, or intercepted by any managed or unmanaged code</item>
+    /// <item>Is what the CLR itself uses for internal fatal errors</item>
+    /// </list>
+    /// <para>
+    /// Use this crash type if other crash types are not being captured by Azure Crash Monitoring.
+    /// The error code 7 (FAST_FAIL_FATAL_APP_EXIT) is specifically designed for application crashes.
+    /// </para>
+    /// </remarks>
+    private void ExecuteNativeCrash()
+    {
+        _logger.LogCritical("Triggering RtlFailFast - this will bypass all exception handlers!");
+        
+        // FAST_FAIL_FATAL_APP_EXIT (7) - Indicates a fatal application error
+        // This generates an unbypassable crash that Windows Error Reporting will capture
+        const uint FAST_FAIL_FATAL_APP_EXIT = 7;
+        RtlFailFast(FAST_FAIL_FATAL_APP_EXIT);
+    }
+
+    [DllImport("ntdll.dll")]
+    private static extern void RtlFailFast(uint Code);
+
     /// <summary>
     /// Allocates memory until the process runs out and crashes.
     /// </summary>
@@ -311,7 +347,8 @@ public Dictionary<CrashType, string> GetCrashTypeDescriptions()
             [CrashType.StackOverflow] = "Triggers StackOverflowException via infinite recursion. Cannot be caught. Creates interesting stack traces for analysis.",
             [CrashType.UnhandledException] = "Throws an unhandled exception on a background thread, demonstrating the importance of proper exception handling.",
             [CrashType.AccessViolation] = "Writes to invalid memory (null pointer). Demonstrates native-level crashes common in P/Invoke or unsafe code bugs.",
-            [CrashType.OutOfMemory] = "Allocates memory until the process crashes. Useful for learning memory dump analysis techniques."
+            [CrashType.OutOfMemory] = "Allocates memory until the process crashes. Useful for learning memory dump analysis techniques.",
+            [CrashType.NativeCrash] = "Uses RtlFailFast to bypass ALL exception handlers including ANCM. Guarantees WER capture - use this if other types aren't detected by Azure Crash Monitoring."
         };
     }
 }