A structured roadmap for evolving DebugProbe from a lightweight request inspector into a production-friendly debugging and observability toolkit for ASP.NET Core applications.
DebugProbe aims to provide developers with a lightweight, embedded debugging experience for inspecting HTTP traffic inside ASP.NET Core applications — without requiring external infrastructure or heavyweight observability platforms.
The long-term direction is to keep DebugProbe:
- Lightweight
- Developer-first
- Easy to install
- Safe for internal environments
- Useful for distributed API debugging
- Extensible without becoming overly complex
- Incoming request capture
- Response capture
- Request body inspection
- Response body inspection
- Header inspection
- Timing and duration tracking
/debugdashboard- Request details page
- Compare view between environments
- Embedded static assets
- Remote trace comparison
- Environment metadata support
- Minimal dependencies
- Simple setup
- In-memory bounded storage
- Easy ASP.NET Core integration
The roadmap focuses on 5 major areas:
- Security & Safety
- Outgoing HTTP Visibility
- Performance & Storage
- Observability & Metrics
- Developer Experience & UI
Goal: Make DebugProbe safer and more production-friendly.
Capture and display response headers alongside requests.
- Easier CORS debugging
- Cache inspection
- Authentication troubleshooting
- Better environment comparison
Protect debug endpoints with configurable authentication.
- ASP.NET Core authorization policy
- Token-based access
- Environment-based enable/disable
- IP allowlist support
- Safer staging deployments
- Prevent accidental exposure
- Production-readiness
Improve out-of-box configuration.
- Ignore
/swagger - Ignore
/health - Ignore static assets
- Disable body capture in Production
Prevent excessive memory usage.
MaxBodyBytes,MaxStoredEntries,CaptureBodies,CaptureResponseHeaders
- Better stability
- Lower memory pressure
- Safer large payload handling
Built-in redaction system.
- Authorization headers
- Cookies
- API keys
- Password fields
- Sensitive JSON fields
options.RedactHeaders = ["Authorization", "Cookie"];
options.RedactJsonFields = ["password", "token"];Goal: Add visibility into external API calls and downstream services.
Add automatic outgoing HTTP capture using DelegatingHandler.
- URL
- Method
- Status code
- Duration
- Request headers
- Response headers
- Request body
- Response body
- Exceptions
Link incoming requests with outgoing calls.
- Trace ID propagation
- Request chain visibility
- End-to-end debugging
Incoming Request
├── External API Call #1
├── External API Call #2
└── Database/API latency timeline
New UI section for external calls.
- Recent outgoing requests
- Filter by host
- Error highlighting
- Latency sorting
- Group by service
Aggregate metrics by destination host.
- Average latency
- Failure rate
- Request count
- Slowest services
Goal: Move beyond temporary in-memory debugging.
Introduce sink/provider architecture.
IDebugProbeSinkCurrent implementation.
- JSON-based storage
- Rolling files
- Lightweight persistence
- Searchable local history
- Structured querying
- Better retention support
- Centralized debugging
- Multi-instance aggregation
- Shared environments
Allow traces to be shared and archived.
- JSON
- CSV
- ZIP export bundles
Automatic cleanup rules.
- Maximum age
- Maximum size
- Maximum entries
Goal: Add lightweight operational insights.
Aggregate request statistics.
- Request count
- Error rate
- Median latency
- P95 latency
- Slowest endpoints
Analyze downstream services.
- Top external hosts
- Failed services
- Timeout rates
- Latency distribution
Embedded lightweight charts.
- Request timeline
- Latency graphs
- Error trends
- Throughput graphs
Improve debugging workflow.
- Path
- Method
- Status code
- Host
- Trace ID
- Duration range
Goal: Make DebugProbe easier and faster to use.
Smarter request diffing.
- JSON field diff
- Highlighted changes
- Header comparison
- Timing comparison
Improve readability and usability.
- Better layout
- Responsive UI
- Dark mode
- Faster rendering
- Cleaner navigation
Global search across captured entries.
- Headers
- Bodies
- URLs
- Trace IDs
Replay captured requests.
- Reproduce bugs
- Regression testing
- API debugging
Allow custom integrations.
- Custom sinks
- Custom redactors
- Custom exporters
- Custom UI tabs
Goal: Expand into distributed debugging scenarios.
Collect traces across multiple services.
Optional interoperability with OTEL.
- Trace export
- Activity integration
- Span correlation
Centralized debugging service.
- Multi-instance deployments
- Kubernetes environments
- Shared QA systems
Potential long-term additions.
- Shared trace links
- Saved sessions
- Trace annotations
DebugProbe should remain simple to install and remove.
Prefer built-in ASP.NET Core features where possible.
Security and redaction should be first-class concerns.
New features should support modular extension points.
- Authentication
- Redaction
- Body size limits
- Response headers
- Outgoing HTTP capture
- Persistence
- Metrics dashboard
- Filtering/search
- Export/import
- Distributed tracing
- OpenTelemetry
- Remote collectors
- Replay tooling
- Response header capture
- RequireAuth option
- Redaction support
- MaxBodyBytes
- Outgoing HTTP capture
- Outgoing requests UI tab
- Persistence providers
- Metrics dashboard
- Filtering/search
- Export/import
- Distributed tracing
- Remote collector
- OpenTelemetry integration
DebugProbe should become:
The easiest way to inspect and compare HTTP behavior inside ASP.NET Core applications.
While still remaining:
- lightweight
- embeddable
- developer-friendly
- infrastructure-optional
- safe for internal environments