fix(application): log swallowed handler exceptions before wrapping in Result.Failure

[Pomdapis]

P0-02 — Dispatcher swallows handler exceptions silently

The Compendium command/query dispatchers convert any exception thrown inside a handler into
Result.Failure(Error.Failure("*.ExecutionFailed", ex.Message)) without logging the exception or
stack trace. In production this makes debugging blind: the only trace is on OTel spans
(exception.type / exception.message activity tags), which are not always sampled or retained.

Refs:

• Nexus bug inventory P0-02
• Memory note project_compendium_dispatcher_silent
• Nexus PR ci: switch to self-hosted ARC runners (runs-on: dotnet) #86 added an HTTP-layer ProblemDetailsLoggingFilter that only partially mitigated this (REST surface only — MCP, SDK, background/process-manager dispatch paths still went dark).

What changed

Three swallow points fixed (CommandDispatcher.DispatchAsync<TCommand>,
CommandDispatcher.DispatchAsync<TCommand,TResult>, QueryDispatcher.DispatchAsync<TQuery,TResult>):

1. Structured error logging before wrapping. Each catch block now calls
   _logger.LogError(ex, "...", commandOrQueryType, ...) — logging the full exception (with stack
   trace) at Error level before building the failure Result.
2. No public API break. Both dispatchers already receive IServiceProvider only. Rather than
   change the public single-argument constructor (which downstream consumers call directly — see the
   existing unit tests), the logger is resolved from the service provider with a
   NullLogger<T> fallback when no logging is configured. Binary- and source-compatible.
3. Non-breaking error enrichment. Error.Failure(...) already supports an optional metadata
   dictionary, so the failure error now carries { exceptionType } — letting consumers discriminate
   the underlying cause without string-parsing Error.Message.
4. Result contract preserved. Still returns Result.Failure, never rethrows.

The pre-existing LoggingBehavior<TRequest,TResponse> only logs when registered as a pipeline
behavior and rethrows; the dispatcher catch sits outside the behavior pipeline and is the final,
unconditional swallow point — which is exactly what this fixes.

Tests

Added to CommandDispatcherTests / QueryDispatcherTests (+ a tiny CapturingLogger<T> helper to
avoid a new Microsoft.Extensions.Diagnostics.Testing dependency):

• handler throws → Result.Failure returned AND logger received the exception at Error level
  AND exceptionType metadata present (command no-result, command-with-result, and query paths)
• no ILogger registered → falls back to NullLogger, still returns failure, does not throw
• success path → no Error-level log emitted

dotnet test Compendium.Application.Tests → 232 passed. Architecture tests → 37 passed.

Notes

• The legacy [Obsolete] SagaOrchestrator (slated for removal in v1.0) has similar catch-and-wrap
  blocks but is deprecated dead-path; intentionally out of scope for this focused P0 fix. The live
  choreography path (ChoreographyRouter) already aggregates handler errors with messages.

[Copilot]

Pull request overview

This PR addresses P0-02 by ensuring exceptions thrown by CQRS command/query handlers are no longer silently swallowed: the dispatchers now log the exception (including stack trace) before converting it into a Result.Failure, and they enrich the failure Error with exceptionType metadata without breaking public APIs.

Changes:

• Add ILogger<T> resolution (with NullLogger<T> fallback) to CommandDispatcher and QueryDispatcher without changing their public constructors.
• Log swallowed handler exceptions at Error level before returning Result.Failure(...), and attach { exceptionType } metadata to the failure error.
• Add unit tests (and a lightweight CapturingLogger<T>) to verify logging + metadata enrichment + null-logger fallback behavior.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
src/Application/Compendium.Application/CQRS/CommandDispatcher.cs	Resolve logger via IServiceProvider, log swallowed handler exceptions, and add exceptionType metadata on execution-failure results.
src/Application/Compendium.Application/CQRS/QueryDispatcher.cs	Same as command dispatcher: structured error log before wrapping, plus exceptionType metadata enrichment.
tests/Unit/Compendium.Application.Tests/CQRS/CapturingLogger.cs	Adds minimal in-memory ILogger<T> implementation for asserting logged entries without extra dependencies.
tests/Unit/Compendium.Application.Tests/CQRS/CommandDispatcherTests.cs	Adds coverage for logging-on-throw, null-logger fallback, and “no error logs on success” for command dispatch paths.
tests/Unit/Compendium.Application.Tests/CQRS/QueryDispatcherTests.cs	Adds coverage for logging-on-throw, null-logger fallback, and “no error logs on success” for query dispatch path.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.