benchmarks: add diagnostics suite for #58

Author: rian-be

Benchmarks/Diagnostics/DiagnosticsOverheadBenchmarks.cs

@@ -0,0 +1,79 @@
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.DependencyInjection;
+using ModularityKit.Mutator.Abstractions.Audit;
+using ModularityKit.Mutator.Abstractions.Engine;
+using ModularityKit.Mutator.Abstractions.History;
+using ModularityKit.Mutator.Benchmarks.Diagnostics.Support;
+
+namespace ModularityKit.Mutator.Benchmarks.Diagnostics;
+
+/// <summary>
+/// Benchmarks audit, history, and logging-style overhead in the core mutation pipeline.
+/// </summary>
+[BenchmarkCategory("Diagnostics")]
+[MemoryDiagnoser]
+[InProcess]
+public class DiagnosticsOverheadBenchmarks
+{
+    private IMutationEngine _noDiagnosticsEngine = null!;
+    private IMutationEngine _auditHistoryEngine = null!;
+    private IMutationEngine _combinedDiagnosticsEngine = null!;
+    private DiagnosticsState _state = null!;
+    private DiagnosticsMutation _mutation = null!;
+
+    /// <summary>
+    /// Prepares baseline, audit-history, and combined observability benchmark engines.
+    /// </summary>
+    [GlobalSetup]
+    public void Setup()
+    {
+        _noDiagnosticsEngine = DiagnosticsBenchmarkScenario.BuildEngine(
+            services =>
+            {
+                services.AddSingleton<IMutationAuditor, NoOpAuditor>();
+                services.AddSingleton<IMutationHistoryStore, NoOpHistoryStore>();
+            });
+
+        _auditHistoryEngine = DiagnosticsBenchmarkScenario.BuildEngine();
+
+        _combinedDiagnosticsEngine = DiagnosticsBenchmarkScenario.BuildEngine(
+            configureEngine: engine =>
+            {
+                engine.RegisterInterceptor(new PassiveBenchmarkInterceptor());
+                engine.RegisterInterceptor(new FormattingLoggingInterceptor());
+            });
+
+        _state = new DiagnosticsState(42, "baseline");
+        _mutation = DiagnosticsBenchmarkScenario.CreateCommitMutation("diagnostics");
+    }
+
+    /// <summary>
+    /// Measures commit execution with observability paths disabled via no-op audit and history services.
+    /// </summary>
+    [Benchmark(Baseline = true)]
+    public async Task NoDiagnostics_Baseline()
+    {
+        var result = await _noDiagnosticsEngine.ExecuteAsync(_mutation, _state);
+        GC.KeepAlive(result);
+    }
+
+    /// <summary>
+    /// Measures commit execution with the default audit and history capture path enabled.
+    /// </summary>
+    [Benchmark]
+    public async Task AuditHistory_Enabled()
+    {
+        var result = await _auditHistoryEngine.ExecuteAsync(_mutation, _state);
+        GC.KeepAlive(result);
+    }
+
+    /// <summary>
+    /// Measures commit execution with audit/history capture plus interceptor and logging-style formatting enabled.
+    /// </summary>
+    [Benchmark]
+    public async Task CombinedInterceptionAndDiagnostics_Enabled()
+    {
+        var result = await _combinedDiagnosticsEngine.ExecuteAsync(_mutation, _state);
+        GC.KeepAlive(result);
+    }
+}

Benchmarks/Diagnostics/InterceptorOverheadBenchmarks.cs

@@ -0,0 +1,67 @@
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.DependencyInjection;
+using ModularityKit.Mutator.Abstractions.Audit;
+using ModularityKit.Mutator.Abstractions.Engine;
+using ModularityKit.Mutator.Abstractions.History;
+using ModularityKit.Mutator.Benchmarks.Diagnostics.Support;
+
+namespace ModularityKit.Mutator.Benchmarks.Diagnostics;
+
+/// <summary>
+/// Benchmarks interceptor overhead in the core mutation pipeline independently from audit and history storage.
+/// </summary>
+[BenchmarkCategory("Diagnostics")]
+[MemoryDiagnoser]
+[InProcess]
+public class InterceptorOverheadBenchmarks
+{
+    private IMutationEngine _baselineEngine = null!;
+    private IMutationEngine _interceptorEngine = null!;
+    private DiagnosticsState _state = null!;
+    private DiagnosticsMutation _mutation = null!;
+
+    /// <summary>
+    /// Prepares engines with and without a passive interceptor while disabling audit and history storage noise.
+    /// </summary>
+    [GlobalSetup]
+    public void Setup()
+    {
+        _baselineEngine = DiagnosticsBenchmarkScenario.BuildEngine(
+            services =>
+            {
+                services.AddSingleton<IMutationAuditor, NoOpAuditor>();
+                services.AddSingleton<IMutationHistoryStore, NoOpHistoryStore>();
+            });
+
+        _interceptorEngine = DiagnosticsBenchmarkScenario.BuildEngine(
+            services =>
+            {
+                services.AddSingleton<IMutationAuditor, NoOpAuditor>();
+                services.AddSingleton<IMutationHistoryStore, NoOpHistoryStore>();
+            },
+            engine => engine.RegisterInterceptor(new PassiveBenchmarkInterceptor()));
+
+        _state = new DiagnosticsState(42, "baseline");
+        _mutation = DiagnosticsBenchmarkScenario.CreateCommitMutation("interceptor");
+    }
+
+    /// <summary>
+    /// Measures the commit pipeline without interceptors, audit persistence, or history persistence.
+    /// </summary>
+    [Benchmark(Baseline = true)]
+    public async Task NoInterceptor_Baseline()
+    {
+        var result = await _baselineEngine.ExecuteAsync(_mutation, _state);
+        GC.KeepAlive(result);
+    }
+
+    /// <summary>
+    /// Measures the same commit pipeline with one passive interceptor enabled.
+    /// </summary>
+    [Benchmark]
+    public async Task PassiveInterceptor_Enabled()
+    {
+        var result = await _interceptorEngine.ExecuteAsync(_mutation, _state);
+        GC.KeepAlive(result);
+    }
+}

Benchmarks/Diagnostics/Support/DiagnosticsBenchmarkScenario.cs

@@ -0,0 +1,58 @@
+using Microsoft.Extensions.DependencyInjection;
+using ModularityKit.Mutator.Abstractions;
+using ModularityKit.Mutator.Abstractions.Context;
+using ModularityKit.Mutator.Abstractions.Engine;
+using ModularityKit.Mutator.Runtime;
+
+namespace ModularityKit.Mutator.Benchmarks.Diagnostics.Support;
+
+/// <summary>
+/// Creates repeatable diagnostics benchmark scenarios and engine instances.
+/// </summary>
+internal static class DiagnosticsBenchmarkScenario
+{
+    /// <summary>
+    /// Gets the shared state identifier used by diagnostics benchmark cases.
+    /// </summary>
+    public const string StateId = "diagnostics-benchmark-state";
+
+    /// <summary>
+    /// Builds performance oriented mutation engine for diagnostics benchmark scenarios.
+    /// </summary>
+    /// <param name="configureServices">Optional service registrations overriding default runtime services.</param>
+    /// <param name="configureEngine">Optional engine configuration executed after engine resolution.</param>
+    /// <returns>A configured mutation engine instance.</returns>
+    public static IMutationEngine BuildEngine(
+        Action<IServiceCollection>? configureServices = null,
+        Action<IMutationEngine>? configureEngine = null)
+    {
+        var services = new ServiceCollection();
+        services.AddMutators(MutationEngineOptions.Performance);
+
+        configureServices?.Invoke(services);
+
+        var engine = services
+            .BuildServiceProvider()
+            .GetRequiredService<IMutationEngine>();
+
+        configureEngine?.Invoke(engine);
+        return engine;
+    }
+
+    /// <summary>
+    /// Creates a minimal commit mutation instance bound to the shared diagnostics benchmark state.
+    /// </summary>
+    /// <param name="operationSuffix">The operation suffix used to build a stable correlation identifier.</param>
+    /// <returns>A diagnostics mutation configured for commit execution.</returns>
+    public static DiagnosticsMutation CreateCommitMutation(string operationSuffix)
+    {
+        var context = MutationContext.System("diagnostics-benchmark") with
+        {
+            StateId = StateId,
+            Mode = MutationMode.Commit,
+            CorrelationId = $"{StateId}:{operationSuffix}"
+        };
+
+        return new DiagnosticsMutation(context);
+    }
+}

Benchmarks/Diagnostics/Support/DiagnosticsMutation.cs

@@ -0,0 +1,66 @@
+using ModularityKit.Mutator.Abstractions;
+using ModularityKit.Mutator.Abstractions.Changes;
+using ModularityKit.Mutator.Abstractions.Context;
+using ModularityKit.Mutator.Abstractions.Engine;
+using ModularityKit.Mutator.Abstractions.Intent;
+using ModularityKit.Mutator.Abstractions.Results;
+
+namespace ModularityKit.Mutator.Benchmarks.Diagnostics.Support;
+
+/// <summary>
+/// Minimal commit mutation used to measure diagnostics and interception overhead.
+/// </summary>
+internal sealed class DiagnosticsMutation(MutationContext context) : IMutation<DiagnosticsState>
+{
+    /// <summary>
+    /// Gets the benchmark mutation intent metadata.
+    /// </summary>
+    public MutationIntent Intent { get; } = new()
+    {
+        OperationName = "DiagnosticsMutation",
+        Category = "Benchmark",
+        Description = "Minimal commit mutation used to measure interception and diagnostics overhead.",
+        RiskLevel = MutationRiskLevel.Low,
+        IsReversible = true
+    };
+
+    /// <summary>
+    /// Gets the execution context bound to the benchmark mutation instance.
+    /// </summary>
+    public MutationContext Context { get; } = context;
+
+    /// <summary>
+    /// Applies the benchmark mutation to the provided state.
+    /// </summary>
+    /// <param name="state">The input state.</param>
+    /// <returns>The successful mutation result containing the updated state and changes.</returns>
+    public MutationResult<DiagnosticsState> Apply(DiagnosticsState state)
+    {
+        var nextState = state with
+        {
+            Counter = state.Counter + 1,
+            LastOperation = Context.CorrelationId ?? string.Empty
+        };
+
+        return MutationResult<DiagnosticsState>.Success(
+            nextState,
+            ChangeSet.FromChanges(
+                StateChange.Modified(nameof(DiagnosticsState.Counter), state.Counter, nextState.Counter),
+                StateChange.Modified(nameof(DiagnosticsState.LastOperation), state.LastOperation, nextState.LastOperation)
+            ));
+    }
+
+    /// <summary>
+    /// Validates the provided state before mutation execution.
+    /// </summary>
+    /// <param name="state">The input state.</param>
+    /// <returns>A successful validation result.</returns>
+    public ValidationResult Validate(DiagnosticsState state) => ValidationResult.Success();
+
+    /// <summary>
+    /// Simulates the benchmark mutation using the same state transition as commit execution.
+    /// </summary>
+    /// <param name="state">The input state.</param>
+    /// <returns>The simulated mutation result.</returns>
+    public MutationResult<DiagnosticsState> Simulate(DiagnosticsState state) => Apply(state);
+}

Benchmarks/Diagnostics/Support/DiagnosticsState.cs

@@ -0,0 +1,8 @@
+namespace ModularityKit.Mutator.Benchmarks.Diagnostics.Support;
+
+/// <summary>
+/// Minimal state used by diagnostics benchmark scenarios.
+/// </summary>
+/// <param name="Counter">The mutable numeric field exercised by the benchmark mutation.</param>
+/// <param name="LastOperation">The last logical operation label written by the mutation.</param>
+public sealed record DiagnosticsState(int Counter, string LastOperation);

Benchmarks/Diagnostics/Support/FormattingLoggingInterceptor.cs

@@ -0,0 +1,67 @@
+using ModularityKit.Mutator.Abstractions.Changes;
+using ModularityKit.Mutator.Abstractions.Context;
+using ModularityKit.Mutator.Abstractions.Intent;
+using ModularityKit.Mutator.Runtime.Interception;
+
+namespace ModularityKit.Mutator.Benchmarks.Diagnostics.Support;
+
+/// <summary>
+/// Logging style interceptor that formats lifecycle messages and writes them to a sink.
+/// </summary>
+internal sealed class FormattingLoggingInterceptor : MutationInterceptorBase
+{
+    private readonly TextWriter _sink = TextWriter.Null;
+
+    /// <summary>
+    /// Gets the interceptor name used in benchmark scenarios.
+    /// </summary>
+    public override string Name => nameof(FormattingLoggingInterceptor);
+
+    /// <summary>
+    /// Formats and writes pre mutation log line to the configured sink.
+    /// </summary>
+    /// <param name="intent">The mutation intent.</param>
+    /// <param name="context">The mutation context.</param>
+    /// <param name="state">The current state.</param>
+    /// <param name="executionId">The execution identifier.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A completed task.</returns>
+    public override Task OnBeforeMutationAsync(
+        MutationIntent intent,
+        MutationContext context,
+        object state,
+        string executionId,
+        CancellationToken cancellationToken = default)
+    {
+        _sink.WriteLine($"[Before] {intent.OperationName} by {context.ActorId} (ExecutionId: {executionId})");
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Formats and writes post mutation log lines, including the generated change set, to the configured sink.
+    /// </summary>
+    /// <param name="intent">The mutation intent.</param>
+    /// <param name="context">The mutation context.</param>
+    /// <param name="oldState">The state before mutation execution.</param>
+    /// <param name="newState">The state after mutation execution.</param>
+    /// <param name="changes">The generated change set.</param>
+    /// <param name="executionId">The execution identifier.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A completed task.</returns>
+    public override Task OnAfterMutationAsync(
+        MutationIntent intent,
+        MutationContext context,
+        object? oldState,
+        object? newState,
+        ChangeSet changes,
+        string executionId,
+        CancellationToken cancellationToken = default)
+    {
+        _sink.WriteLine($"[After] {intent.OperationName}, changes: {changes.Changes.Count} (ExecutionId: {executionId})");
+
+        foreach (var change in changes.Changes)
+            _sink.WriteLine($"  - {change.Path}: {change.OldValue} -> {change.NewValue}");
+
+        return Task.CompletedTask;
+    }
+}