Perf: Eliminate audit and history entry allocations when auditor/store is disabled

[rian-be]

Problem Statement

Every mutation execution allocated MutationAuditEntry and MutationHistoryEntry objects unconditionally, even when the registered IMutationAuditor and IMutationHistoryStore implementations discarded them immediately. The factory ran first, allocated, then passed the result to a consumer that ignored it pure waste on every call.

Additionally, CreateHistoryEntry called result.SideEffects.ToList() on every commit mutation, allocating redundant defensive copy of an already-read-only collection.

---

Solution Overview

1. Default Interface Method: IsEnabled

public interface IMutationAuditor
{
    bool IsEnabled => true;
    Task AuditAsync(MutationAuditEntry entry);
    // ...
}

• Additive default interface property no breaking changes
• Existing implementors use default (true), no source changes required
• NoOp implementations override to false

2. Guard OutcomeProcessor Before Factory Calls

private async Task AuditSuccessAsync(...)
{
    if (!_auditor.IsEnabled)
        return;                    // skip factory entirely
    var entry = MutationAuditEntryFactory.CreateSuccess(...);
    await _auditor.AuditAsync(entry);
}

• Check happens before factory is called
• Eliminates MutationAuditEntry, MutationHistoryEntry, and all intermediate allocations when auditor/store is disabled
• Same pattern for AuditFailureAsync and StoreInHistoryAsync

3. Remove Redundant Defensive Copy

// Before: SideEffects = result.SideEffects.ToList()
// After:  SideEffects = result.SideEffects

• MutationHistoryEntry.SideEffects already accepts IReadOnlyList<SideEffect>, so no additional copy is required
• Saves one List<SideEffect> allocation per commit mutation

---

Performance Impact

Benchmark Results

Benchmark	Before	After	Delta
NoDiagnostics_Baseline	2.237 us	1.430 us	-36.1%
AuditHistory_Enabled	4.974 us	3.660 us	-26.4%
CombinedInterceptionAndDiagnostics_Enabled	5.653 us / 4.01 KB	3.966 us / 3.52 KB	-29.8% / -12.2%

Optimized Path Analysis

Path	Before	After
NoOpAuditor + NoOpHistoryStore	Audit + History entry allocated, then discarded	Factory skipped entirely 0 bytes allocated for audit/history entry creation
InMemoryAuditor + InMemoryHistoryStore	Entry allocated + stored	Same (consumer needs data)
Any path with side effects	.ToList() defensive copy	Direct reference, no copy

---

Key Design Decisions

Why default interface method instead of separate `INoOpAuditor` interface?

Every auditor can explicitly declare whether it consumes audit entries. A separate marker interface would require runtime type checks (is INoOpAuditor) at the call site and couple the runtime to specific no op implementations. A default interface member keeps the capability part of the existing abstraction and preserves compatibility with existing implementations.

Why check in OutcomeProcessor instead of the factory?

The factory job is to create entries. Adding a bool create parameter would leak infrastructure concerns into the factory. Checking at the call site (OutcomeProcessor) keeps the factory pure and lets the caller decide the same pattern used throughout the pipeline for policy evaluation and interception.

Why not pass raw data to the auditor and let it create the entry?

That would require new method on IMutationAuditor (breaking change) and couple the audit entry schema to the interface. The current approach keeps the existing factory and audit entry schema while avoiding any breaking API changes.

Why not remove factory calls at the engine level?

The engine doesn't know which auditor/store implementation is registered. Only the OutcomeProcessor, which holds the concrete references, can make the decision. Centralizing the check there avoids leaking implementation awareness upward.

---

Files Changed

IMutationAuditor.cs

• Added bool IsEnabled => true; — default interface method

IMutationHistoryStore.cs

• Added bool IsEnabled => true; — default interface method

MutationExecutionOutcomeProcessor.cs

• Guarded AuditSuccessAsync/AuditFailureAsync with if (!_auditor.IsEnabled) return;
• Guarded StoreInHistoryAsync with if (!_historyStore.IsEnabled) return;

MutationAuditEntryFactory.cs

• Replaced result.SideEffects.ToList() with result.SideEffects

NoOpAuditor.cs / NoOpHistoryStore.cs

• Added bool IsEnabled => false; override

---

Migration

Note

No migration steps required. IsEnabled is additive with default true. Existing IMutationAuditor and IMutationHistoryStore implementations continue to work without modification. Implementations that do not consume entries (such as NoOpAuditor) can override the property to false to enable the allocation free fast path.