filp/whoops
Whoops
Whoops is a PHP debugging tool and error handler designed to intercept and visualize exceptions and stack traces during application development. It functions as an exception renderer that converts errors into human-readable web pages or machine-readable responses.
The project differentiates itself by providing a visual debugging interface with line-highlighted code views and a stack trace visualizer that links directly to source files in a local text editor or IDE. It employs environment-aware response resolution to automatically select between HTML, JSON, XML, or plain text output based on the request type.
The system manages the error lifecycle through a pipeline of configurable handlers and middleware, allowing for custom error processing logic and the injection of request-specific metadata into stack trace frames. It includes capabilities for stack trace inspection, API error formatting, and execution environment detection to identify AJAX calls or command-line executions.
Features
- Debugging Tools - Provides a visual debugging environment with line-highlighted code views to resolve errors during development.
- PHP Exception Handlers - Intercepts PHP errors and exceptions to display them in a formatted interface for faster troubleshooting.
- Exception Renderers - A system for converting PHP errors into human-readable web pages or machine-readable JSON and XML responses.
- Application Debugging - Visualizes stack traces and environment data on a web page to quickly identify causes of application failures.
- Visual Debugging Environments - Renders formatted error pages that visualize failure states, system internals, and line-highlighted code.
- PHP Error Handlers - Intercepts PHP exceptions to provide a formatted visual interface for faster troubleshooting.
- Error Tracking and Exception Handling - Implements a sequence of handlers and middleware to manage and report PHP exceptions.
- Error Handling - Allows defining custom processing behavior via handler interfaces to manage how exceptions are intercepted.
- Exception Handling Pipelines - Processes errors through a configurable stack of handlers that intercept and modify exception data before rendering.
- Frame Analyzers - Extracts and analyzes frames from an exception stack trace to retrieve context, file names, and line numbers.
- Frame Extractors - Parses PHP exception traces into structured frame objects to retrieve file paths and surrounding source code.
- External Command Integrations - Maps error report file paths to system commands that open specific files and lines in a local IDE.
- IDE Integrations - Connects error report stack traces to local IDEs to facilitate rapid navigation to problematic source files.
- Error Handling Middleware - Implements a configurable pipeline of handlers to intercept and process exceptions before rendering.
- Error Contextualization - Injects custom middleware to enrich error output with request-specific information and frame comments.
- Pipeline Management - Organizes a pipeline of custom or built-in handlers to process exceptions and trace data.
- Format Error Translators - Converts PHP exceptions into structured JSON or XML responses for AJAX and API clients.
- Handler Interfaces - Uses handler interfaces and closures to allow developers to override default error-processing behavior.
- Runtime Context Injection - Enables plugins to attach real-time request metadata and custom information to stack trace frames.
- Stack Trace Hierarchy Visualizers - Renders interactive visualizations of exception frames and provides direct links to source files in local editors.
- Local Development Editors - Links error trace references directly to local development editors to open the exact line of a failure.
- Debugging And Profiling - Displays pretty error pages for development.
