/** * @param Run $whoops */ public function __construct(Run $whoops) { $this->whoops = $whoops; $this->whoops->allowQuit(false); $this->whoops->writeToOutput(false); $this->whoops->pushHandler(new PrettyPageHandler()); }
/** * Handle http exceptions * * @param UnknownHttpExceptionEvent $event */ public function onException(UnknownHttpExceptionEvent $event) { if (!$this->environment->equals(Environment::DEVELOPMENT)) { return; } $event->stopPropagation(); $this->whoops->writeToOutput(false); $this->whoops->allowQuit(false); $content = $this->whoops->handleException($event->getHttpException()); $event->getResponse()->setContent($content); }
/** * Convert the view to a rendered string. * * @return string A string of HTML, e.g. to be `echo`'d. */ public function __toString() { static $run, $handler; if (!isset($run, $handler)) { $run = new Run(); $handler = new PrettyPageHandler(); $handler->handleUnconditionally(true); $run->pushHandler($handler); $run->allowQuit(false); $run->writeToOutput(false); $run->register(); } // __toString cannot throw an exception, so we need to handle those // manually to prevent PHP from barfing: try { return $this->render(); } catch (Exception $e) { self::$didWhoops = true; if (!static::$swallowError) { return $run->handleException($e); } else { return static::$swallowError; } } }
/** * Saving Application instance for later use * * @param Container $container * @return void */ public function provideServices(Container $container) { $this->container = $container; /* * Creating and registering our error handler */ $whoops = new Run(); $whoops->register(); /** @var \Venta\Contracts\Kernel\Kernel $kernel */ $kernel = $container->get(Kernel::class); if ($kernel->isCli()) { // We don't need pretty pages in cli mode $whoops->allowQuit(true); $whoops->sendHttpCode(false); $whoops->writeToOutput(true); $whoops->pushHandler(new PlainTextHandler()); } else { // Push pretty page handler only for local environment $whoops->pushHandler($kernel->getEnvironment() === 'local' ? new PrettyPageHandler() : new PlainTextHandler()); } /** * Bind error handler */ $container->bindClass(RunInterface::class, $whoops, ['error_handler']); /* * Bind PSR-3 logger */ $container->share(\Monolog\Logger::class, function (Container $c) { $logger = new \Monolog\Logger('venta'); $handler = new \Monolog\Handler\StreamHandler(__DIR__ . '/../storage/logs/app.log'); $handler->pushProcessor(function ($record) use($c) { /** @var \Venta\Contracts\Kernel\Kernel $kernel */ $kernel = $c->get(Kernel::class); if ($kernel->isCli()) { // Add cli command related extra info /** @var \Symfony\Component\Console\Input\InputInterface $input */ $input = $c->get(InputInterface::class); $record['extra']['command'] = $input->getFirstArgument(); $record['extra']['arguments'] = $input->getArguments(); $record['extra']['options'] = $input->getOptions(); } else { // Add HTTP request related extra info /** @var \Psr\Http\Message\ServerRequestInterface $request */ $request = $c->get(ServerRequestInterface::class); $server = $request->getServerParams(); $record['extra']['url'] = $request->getUri()->getPath(); $record['extra']['http_method'] = $request->getMethod(); $record['extra']['host'] = $request->getUri()->getHost(); $record['extra']['referer'] = $request->getHeader('referer'); $record['extra']['user_agent'] = $request->getHeader('user-agent'); $record['extra']['ip'] = $server['REMOTE_ADDR'] ?? null; } return $record; }); $handler->setFormatter(new \Monolog\Formatter\LineFormatter()); $logger->pushHandler($handler); return $logger; }, ['logger', LoggerInterface::class]); }
/** * Returns the whoops instance. * * @return Whoops */ private function getWhoops() { $whoops = new Whoops(); $whoops->allowQuit(false); $whoops->writeToOutput(false); $whoops->pushHandler(new PrettyPageHandler()); return $whoops; }
protected function handleWithWhoops(Exception $exception) { $whoops = new Run(); $whoops->allowQuit(false); $whoops->writeToOutput(false); $whoops->pushHandler(new PrettyPageHandler()); return $whoops->handleException($exception); }
/** * Render an exception using Whoops. * * @param \Exception $e * @return \Illuminate\Http\Response */ protected function renderExceptionWithWhoops(Exception $e) { $whoops = new Whoops\Run(); $whoops->allowQuit(false); $whoops->writeToOutput(false); $whoops->pushHandler(new Whoops\Handler\PrettyPageHandler()); return response($whoops->handleException($e), 500); }
/** * Get the whoops instance. * * @return \Whoops\Run */ protected function whoops() { $whoops = new Whoops(); $whoops->allowQuit(false); $whoops->writeToOutput(false); $whoops->pushHandler(new Handler()); return $whoops; }
/** * Create and return an instance of the Whoops runner. * * @param ContainerInterface $container * @return Whoops */ public function __invoke(ContainerInterface $container) { $config = $container->has('config') ? $container->get('config') : []; $config = isset($config['whoops']) ? $config['whoops'] : []; $whoops = new Whoops(); $whoops->writeToOutput(false); $whoops->allowQuit(false); $whoops->pushHandler($container->get('Zend\\Expressive\\WhoopsPageHandler')); $this->registerJsonHandler($whoops, $config); $whoops->register(); return $whoops; }
/** * Register the Whoops error display service. * * @return void */ protected function registerWhoops() { $this->registerWhoopsHandler(); $this->app['whoops'] = $this->app->share(function ($app) { // We will instruct Whoops to not exit after it displays the exception as it // will otherwise run out before we can do anything else. We just want to // let the framework go ahead and finish a request on this end instead. with($whoops = new Run())->allowQuit(false); $whoops->writeToOutput(false); return $whoops->pushHandler($app['whoops.handler']); }); }
/** * Render an exception into an HTTP response. * * When debugging is enabled, we make the error pretty using Whoops * * @param \Illuminate\Http\Request $request * @param \Exception $e * @return \Illuminate\Http\Response */ public function render($request, Exception $e) { if ($this->isHttpException($e)) { return $this->renderHttpException($e); } if (config('app.debug')) { $whoops = new Run(); $whoops->pushHandler($request->ajax() ? new JsonResponseHandler() : new PrettyPageHandler()); $whoops->allowQuit(false); $whoops->writeToOutput(false); return response($whoops->handleException($e), $whoops->sendHttpCode()); } return parent::render($request, $e); }
public function handle(Request $request, $statusCode) { $runner = new Run(); $format = $request->getRequestFormat(); if ('html' == $format) { $handler = new PrettyPageHandler(); $handler->addDataTable('App', ['Controller' => $request->get('_controller'), 'Route' => $request->get('_route'), 'Session' => $request->hasSession(), 'Status' => $this->getCodeWithDescription($statusCode)]); } else { if ('json' == $format) { $handler = new JsonResponseHandler(); } else { $handler = new PlainTextHandler(); } } $runner->pushHandler($handler); $runner->writeToOutput(false); $runner->allowQuit(false); $runner->register(); return $runner; }
<?php include dirname(__DIR__) . '/vendor/autoload.php'; use lithium\core\ErrorHandler; use Whoops\Run; use Whoops\Handler\PrettyPageHandler; ErrorHandler::apply('lithium\\action\\Dispatcher::run', array(), function ($info, $params) { $run = new Run(); $handler = new PrettyPageHandler(); $jsonHandler = new \Whoops\Handler\JsonResponseHandler(); $jsonHandler->onlyForAjaxRequests(true); $run->pushHandler($handler); $run->pushHandler($jsonHandler); $request = $params['request']; $exception = $info['exception']; $handler->addDataTable('Request', array('URL' => $request->url, 'Query String' => isset($request->params['query']) ? $request->params['query'] : '<none>', 'HTTP Host' => $request->get('http:host'), 'HTTP Method' => $request->get('http:method'), 'Base Path' => $request->path, 'Scheme' => $request->scheme, 'Port' => $request->port, 'Host' => $request->host, 'Auth' => $request->auth, 'Username' => $request->username, 'Password' => $request->password, 'Protocol' => $request->protocol, 'Version' => $request->version)); $handler->addDataTable('Params', $request->params); $handler->addDataTable('Data', $request->data); $handler->addDataTable('Headers', $request->headers); $handler->addDataTable('Cookies', $request->cookies); $handler->addDataTable('Body', $request->body); $run->writeToOutput(false); return $run->handleException($exception); });
/** * Initializes the error handler. * @return ErrorHandler The initializes error handler */ private function initializeErrorHandler() : ErrorHandler { $errorHandler = new ErrorHandler(); $errorHandler->allowQuit(false); $errorHandler->writeToOutput(false); if ($this->errorLog !== null) { $logger = new PlainTextHandler($this->getErrorLogger()); $logger->loggerOnly(true); $errorHandler->pushHandler($logger); } if ($this->debug) { if ($this->jsonRequest) { $responseHandler = new JsonResponseHandler(); $responseHandler->addTraceToOutput(true); } else { $responseHandler = new PrettyPageHandler(); } $errorHandler->pushHandler($responseHandler); } return $errorHandler; }
/** * @param Whoops $whoops * * @return void */ public function prepareWhoops(Whoops $whoops) { set_error_handler([$whoops, Whoops::ERROR_HANDLER]); $whoops->writeToOutput(false); $whoops->allowQuit(false); }
<?php declare (strict_types=1); use function DI\get; use Interop\Container\ContainerInterface; use Psr\Log\LoggerInterface; use Psr\Log\NullLogger; use Stratify\ErrorHandlerModule\ErrorHandlerMiddleware; use Stratify\ErrorHandlerModule\ErrorResponder\ErrorResponder; use Stratify\ErrorHandlerModule\ErrorResponder\SimpleProductionResponder; use Stratify\ErrorHandlerModule\ErrorResponder\WhoopsResponder; use Whoops\Handler\PrettyPageHandler; use Whoops\Run; return [ErrorHandlerMiddleware::class => function (ContainerInterface $c) { $logger = $c->has(LoggerInterface::class) ? $c->get(LoggerInterface::class) : new NullLogger(); return new ErrorHandlerMiddleware($c->get(ErrorResponder::class), $logger); }, ErrorResponder::class => get(SimpleProductionResponder::class), WhoopsResponder::class => DI\object()->constructor(get('error_handler.whoops')), 'error_handler.whoops' => function () { $whoops = new Run(); $whoops->writeToOutput(false); $whoops->allowQuit(false); $handler = new PrettyPageHandler(); $handler->handleUnconditionally(true); $whoops->pushHandler($handler); return $whoops; }];
/** * Genera una respuesta con el mensaje de error * * @param Peticion $peticion * @param int $estadoHttp * @param \Throwable $error * * @return Respuesta */ public function generarRespuestaError(Peticion $peticion, $estadoHttp = 500, $error = null) { ob_end_clean(); // Preparamos respuesta a arrojar $respuesta = new Respuesta(); if (isset($this->erroresHttp[$estadoHttp])) { $respuesta->definirContenido('<h1>' . $this->erroresHttp[$estadoHttp] . '</h1>'); } $respuesta->definirEstadoHttp($estadoHttp); // Mostramos el detalle del error si el ambiente es desarrollo if ('desarrollo' == $this->ambiente) { $whoops = new Run(); $whoops_pph = new PrettyPageHandler(); if (isset($error) && get_class($error) == 'Armazon\\Nucleo\\Excepcion' && $error->tieneDetalle()) { $whoops_pph->addDataTable('Información de Excepción:', (array) $error->obtenerDetalle()); } $whoops_pph->addDataTable('Petición:', (array) $peticion); $whoops->pushHandler($whoops_pph); $whoops->writeToOutput(false); $whoops->allowQuit(false); $respuesta->definirContenido($whoops->handleException($error)); return $respuesta; } // Buscamos estado en las rutas $ruta = $this->enrutador->buscar($peticion->metodo, $estadoHttp); // Cambiamos la respuesta despachando ruta en caso de ser encontrada if ('estado_http' != $ruta->tipo && 404 != $ruta->estadoHttp) { $respuesta = $this->despacharRuta($peticion, $ruta, $estadoHttp); } return $respuesta; }
protected function getWhoops(ServerRequestInterface $request) { $whoops = new Run(); switch ($this->getAcceptType($request)) { case 'html': $whoops->pushHandler(new PrettyPageHandler()); break; case 'json': $whoops->pushHandler(new JsonResponseHandler()); break; default: $whoops->pushHandler(new PlainTextHandler()); } $whoops->allowQuit(false); $whoops->writeToOutput(false); $whoops->sendHttpCode(false); return $whoops; }