Unable to block error traces in a Symfony 3 controller - php

Question

I am studying the Symfony\Component\Debug\Debug.
As far as I know the AppKernel's constructor can accept a second argument to define whether to use the debug modality or not (true/false).
What I actually don't understand is the usage and complementarity of Debug::enable() as it is indicated in the app_dev.php on the official Symfony Github's repository.
For example I tried to throw an Exception on a Controller in order to see the effect and I commented Debug::enable(); within app_dev.php but I always see the error page.
Why am I still seeing error traces in spite of commenting out Debug::enable();?

Answer 1

Short explanation
The Debug::enable() method registers a fallback error handler, which will be called if your application failed to handle an error.
The error page you see when kernel is booted with the $debug flag set to true, is a result of your application error handling (implemented by an exception listener). Set the flag to false to disable stack traces. If you're only after testing you can also disable error pages in development.
The page shown by the Debug component is not as nice as the one provided by the exception listener, but it's nicer than the PHP one.
Detailed explanation
The front controller calls your application kernel:
$kernel = new AppKernel('dev', true);
$response = $kernel->handle(Request::createFromGlobals());
The application kernel boots itself, creates the container and calls the http kernel to handle the request:
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
if (false === $this->booted) {
$this->boot();
}
return $this->getHttpKernel()->handle($request, $type, $catch);
}
The http kernel will use the event dispatcher to trigger certain events (kernel.request, kernel.response, kernel.exception etc). When an exception is thrown while handling the request, the http kernel will catch it and trigger the kernel.exception event:
// the following code is simplified to show the point
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
try {
return $this->handleRaw($request, $type);
} catch (\Exception $e) {
return $this->handleException($e, $request, $type);
}
}
private function handleException(\Exception $e, $request, $type)
{
$event = new GetResponseForExceptionEvent($this, $request, $type, $e);
$this->dispatcher->dispatch(KernelEvents::EXCEPTION, $event);
// ...
}
One of the listeners registered by default in the Symfony Standard Edition is the Symfony\Component\HttpKernel\EventListener\ExceptionListener. It's responsible for rendering nice error pages.
However, it will only handle exceptions thrown while handling a request in the http kernel. So if anything goes wrong outside of this call, it won't be handled (have a look at the catch blog in the previous code example).
This is where the Debug component comes in. The Debug::enable() method registers an error handler, an exception handler and a special class loader. You can use it in any PHP project without the http kernel. It is sort of a fallback error handler which will be called if your application failed to handle an error. It has no relation to the $debug constructor argument in the kernel.