/** * @see Silex\ServiceProviderInterface::register * @param Silex\Application $app */ public function register(Application $app) { // There's only ever going to be one error page...right? $app['whoops.error_page_handler'] = $app->share(function () { return new PrettyPageHandler(); }); // Retrieves info on the Silex environment and ships it off // to the PrettyPageHandler's data tables: // This works by adding a new handler to the stack that runs // before the error page, retrieving the shared page handler // instance, and working with it to add new data tables $app['whoops.silex_info_handler'] = $app->protect(function () use($app) { try { $request = $app['request']; } catch (RuntimeException $e) { // This error occurred too early in the application's life // and the request instance is not yet available. return; } // General application info: $app['whoops.error_page_handler']->addDataTable('Silex Application', array('Charset' => $app['charset'], 'Locale' => $app['locale'], 'Route Class' => $app['route_class'], 'Dispatcher Class' => $app['dispatcher_class'], 'Application Class' => get_class($app))); // Request info: $app['whoops.error_page_handler']->addDataTable('Silex Application (Request)', array('URI' => $request->getUri(), 'Request URI' => $request->getRequestUri(), 'Path Info' => $request->getPathInfo(), 'Query String' => $request->getQueryString() ?: '<none>', 'HTTP Method' => $request->getMethod(), 'Script Name' => $request->getScriptName(), 'Base Path' => $request->getBasePath(), 'Base URL' => $request->getBaseUrl(), 'Scheme' => $request->getScheme(), 'Port' => $request->getPort(), 'Host' => $request->getHost())); }); $app['whoops'] = $app->share(function () use($app) { $run = new Run(); $run->pushHandler($app['whoops.error_page_handler']); $run->pushHandler($app['whoops.silex_info_handler']); return $run; }); $app->error(array($app['whoops'], Run::EXCEPTION_HANDLER)); $app['whoops']->register(); }
/** * registerWhoops * * @return void */ public static function registerWhoops() { self::$whoops = new Run(); self::$handler = new PrettyPageHandler(); self::$whoops->pushHandler(self::$handler); self::$whoops->register(); }
public function __invoke($request, $response, $next) { $app = $next; $container = $app->getContainer(); $settings = $container['settings']; if (isset($settings['debug']) === true && $settings['debug'] === true) { // Enable PrettyPageHandler with editor options $prettyPageHandler = new PrettyPageHandler(); if (empty($settings['whoops.editor']) === false) { $prettyPageHandler->setEditor($settings['whoops.editor']); } // Enable JsonResponseHandler when request is AJAX $jsonResponseHandler = new JsonResponseHandler(); $jsonResponseHandler->onlyForAjaxRequests(true); // Add more information to the PrettyPageHandler $prettyPageHandler->addDataTable('Slim Application', ['Application Class' => get_class($app), 'Script Name' => $app->environment->get('SCRIPT_NAME'), 'Request URI' => $app->environment->get('PATH_INFO') ?: '<none>']); $prettyPageHandler->addDataTable('Slim Application (Request)', array('Accept Charset' => $app->request->getHeader('ACCEPT_CHARSET') ?: '<none>', 'Content Charset' => $app->request->getContentCharset() ?: '<none>', 'Path' => $app->request->getUri()->getPath(), 'Query String' => $app->request->getUri()->getQuery() ?: '<none>', 'HTTP Method' => $app->request->getMethod(), 'Base URL' => (string) $app->request->getUri(), 'Scheme' => $app->request->getUri()->getScheme(), 'Port' => $app->request->getUri()->getPort(), 'Host' => $app->request->getUri()->getHost())); // Set Whoops to default exception handler $whoops = new \Whoops\Run(); $whoops->pushHandler($prettyPageHandler); $whoops->pushHandler($jsonResponseHandler); $whoops->register(); $container['errorHandler'] = function ($c) use($whoops) { return new WhoopsErrorHandler($whoops); }; // $container['whoops'] = $whoops; } return $app($request, $response); }
public function __invoke($request, $response, $next) { $container = $this->app->getContainer(); $settings = DotArray::newDotArray($container['settings']); if ($settings['app.debug'] === true) { // Enable PrettyPageHandler with editor options $prettyPageHandler = new PrettyPageHandler(); if ($settings->has('whoops.editor')) { $prettyPageHandler->setEditor($settings['whoops.editor']); } // Enable JsonResponseHandler when request is AJAX $jsonResponseHandler = new JsonResponseHandler(); $jsonResponseHandler->onlyForAjaxRequests(true); // Add more information to the PrettyPageHandler $prettyPageHandler->addDataTable('Slim Application', ['Application Class' => get_class($this->app), 'Script Name' => $this->app->environment->get('SCRIPT_NAME'), 'Request URI' => $this->app->environment->get('PATH_INFO') ?: '<none>']); $prettyPageHandler->addDataTable('Slim Application (Request)', ['Accept Charset' => $this->app->request->getHeader('ACCEPT_CHARSET') ?: '<none>', 'Content Charset' => $this->app->request->getContentCharset() ?: '<none>', 'Path' => $this->app->request->getUri()->getPath(), 'Query String' => $this->app->request->getUri()->getQuery() ?: '<none>', 'HTTP Method' => $this->app->request->getMethod(), 'Base URL' => (string) $this->app->request->getUri(), 'Scheme' => $this->app->request->getUri()->getScheme(), 'Port' => $this->app->request->getUri()->getPort(), 'Host' => $this->app->request->getUri()->getHost()]); $prettyPageHandler->addDataTable('SlimFastShake Settings', $settings->flatten()); // Set Whoops to default exception handler $whoops = new \Whoops\Run(); $whoops->pushHandler($prettyPageHandler); $whoops->pushHandler($jsonResponseHandler); if (isset($container['logger'])) { $logger = $container['logger']; $whoops->pushHandler(function ($exception, $inspector, $run) use($logger) { $logger->critical('Whoops: ' . $exception->getMessage()); }); } $whoops->register(); $container['errorHandler'] = function ($c) use($whoops) { return new WhoopsErrorHandler($whoops); }; $container['whoops'] = $whoops; } return $next($request, $response); }
public function register() { $error_page = new PrettyPageHandler(); $error_page->setEditor('sublime'); $this->whoops->pushHandler($error_page); $this->whoops->register(); }
/** * @param ServerRequestInterface $request * @param ResponseInterface $response * @param callable $next * * @return ResponseInterface */ public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next) { try { return $next($request, $response); } catch (Exception $e) { if ($this->logger) { $this->logger->error($e->getMessage(), ['exception' => $e]); } $type = $this->type($request); $response = $response->withHeader('Content-Type', $type); try { if (method_exists($e, 'getHttpStatus')) { $code = $e->getHttpStatus(); } else { $code = $e->getCode(); } $response = $response->withStatus($code); } catch (InvalidArgumentException $_) { // Exception did not contain a valid code $response = $response->withStatus(500); } if ($e instanceof HttpException) { $response = $e->withResponse($response); } $handler = $this->handler($type); $this->whoops->pushHandler($handler); $body = $this->whoops->handleException($e); $response->getBody()->write($body); $this->whoops->popHandler(); return $response; } }
/** * @param Phalcon\DI $di */ public function __construct(DI $di = null) { if (!$di) { $di = DI::getDefault(); } // There's only ever going to be one error page...right? $di->setShared('whoops.error_page_handler', function () { return new PrettyPageHandler(); }); // Retrieves info on the Phalcon environment and ships it off // to the PrettyPageHandler's data tables: // This works by adding a new handler to the stack that runs // before the error page, retrieving the shared page handler // instance, and working with it to add new data tables $phalcon_info_handler = function () use($di) { try { $request = $di['request']; } catch (Exception $e) { // This error occurred too early in the application's life // and the request instance is not yet available. return; } // Request info: $di['whoops.error_page_handler']->addDataTable('Phalcon Application (Request)', array('URI' => $request->getScheme() . '://' . $request->getServer('HTTP_HOST') . $request->getServer('REQUEST_URI'), 'Request URI' => $request->getServer('REQUEST_URI'), 'Path Info' => $request->getServer('PATH_INFO'), 'Query String' => $request->getServer('QUERY_STRING') ?: '<none>', 'HTTP Method' => $request->getMethod(), 'Script Name' => $request->getServer('SCRIPT_NAME'), 'Scheme' => $request->getScheme(), 'Port' => $request->getServer('SERVER_PORT'), 'Host' => $request->getServerName())); }; $di->setShared('whoops', function () use($di, $phalcon_info_handler) { $run = new Run(); $run->pushHandler($di['whoops.error_page_handler']); $run->pushHandler($phalcon_info_handler); return $run; }); $di['whoops']->register(); }
/** * @param DI $di */ public function __construct(DI $di = null) { if (!class_exists('\\Whoops\\Run')) { return; } if (!$di) { $di = DI::getDefault(); } // There's only ever going to be one error page...right? $di->setShared('whoops.pretty_page_handler', function () use($di) { return (new DebugbarHandler())->setDi($di); }); // There's only ever going to be one error page...right? $di->setShared('whoops.json_response_handler', function () { $jsonHandler = new JsonResponseHandler(); $jsonHandler->onlyForAjaxRequests(true); return $jsonHandler; }); $di->setShared('whoops', function () use($di) { $run = new Run(); $run->silenceErrorsInPaths(array('/phalcon-debugbar/'), E_ALL); $run->pushHandler($di['whoops.pretty_page_handler']); $run->pushHandler($di['whoops.json_response_handler']); return $run; }); $di['whoops']->register(); }
/** * Handle an exception. * * Calls on prepareWhoopsHandler() to inject additional data tables into * the generated payload, and then injects the response with the result * of whoops handling the exception. * * @param \Exception $exception * @param Request $request * @param Response $response * @return Response */ protected function handleException(\Exception $exception, Request $request, Response $response) { $this->prepareWhoopsHandler($request); $this->whoops->pushHandler($this->whoopsHandler); $response->getBody()->write($this->whoops->handleException($exception)); return $response; }
/** * Add JSON handler to Whoops if Ajax request * * @param GetResponseEvent $event */ public function onRequest(GetResponseEvent $event) { if (!$event->isMasterRequest() || !$event->getRequest()->isXmlHttpRequest()) { return; } $this->whoops->pushHandler(new JsonResponseHandler()); }
/** * @param Run $whoops */ public function __construct(Run $whoops) { $this->whoops = $whoops; $this->whoops->allowQuit(false); $this->whoops->writeToOutput(false); $this->whoops->pushHandler(new PrettyPageHandler()); }
protected static function registerWhoops() { $app = Slim::getInstance(); $app->container->singleton('whoopsPrettyPageHandler', function () { return new PrettyPageHandler(); }); $app->whoopsSlimInfoHandler = $app->container->protect(function () use($app) { try { $request = $app->request(); } catch (\RuntimeException $e) { return; } $current_route = $app->router()->getCurrentRoute(); $route_details = array(); if ($current_route !== null) { $route_details = array('Route Name' => $current_route->getName() ?: '<none>', 'Route Pattern' => $current_route->getPattern() ?: '<none>', 'Route Middleware' => $current_route->getMiddleware() ?: '<none>'); } $app->whoopsPrettyPageHandler->addDataTable('Slim Application', array_merge(array('Charset' => $request->headers('ACCEPT_CHARSET'), 'Locale' => $request->getContentCharset() ?: '<none>', 'Application Class' => get_class($app)), $route_details)); $app->whoopsPrettyPageHandler->addDataTable('Slim Application (Request)', array('URI' => $request->getRootUri(), 'Request URI' => $request->getResourceUri(), 'Path' => $request->getPath(), 'Query String' => $request->params() ?: '<none>', 'HTTP Method' => $request->getMethod(), 'Script Name' => $request->getScriptName(), 'Base URL' => $request->getUrl(), 'Scheme' => $request->getScheme(), 'Port' => $request->getPort(), 'Host' => $request->getHost())); }); // Open with editor if editor is set $whoops_editor = $app->config('whoops.editor'); if ($whoops_editor !== null) { $app->whoopsPrettyPageHandler->setEditor($whoops_editor); } $app->container->singleton('whoops', function () use($app) { $run = new Run(); $run->pushHandler($app->whoopsPrettyPageHandler); $run->pushHandler($app->whoopsSlimInfoHandler); return $run; }); }
private static function getWhoopsInstance(ServerRequestInterface $request) { $whoops = new Run(); if (php_sapi_name() === 'cli') { $whoops->pushHandler(new PlainTextHandler()); return $whoops; } $format = FormatNegotiator::getPreferredFormat($request); switch ($format) { case 'json': $handler = new JsonResponseHandler(); $handler->addTraceToOutput(true); break; case 'html': $handler = new PrettyPageHandler(); break; case 'txt': $handler = new PlainTextHandler(); $handler->addTraceToOutput(true); break; case 'xml': $handler = new XmlResponseHandler(); $handler->addTraceToOutput(true); break; default: if (empty($format)) { $handler = new PrettyPageHandler(); } else { $handler = new PlainTextHandler(); $handler->addTraceToOutput(true); } } $whoops->pushHandler($handler); return $whoops; }
/** * 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]); }
/** * Class constructor * * @param integer $iDebug debug level */ public function __construct($iDebug = 0) { parent::__construct($iDebug); if ($this->showExtendedExceptionInfo()) { $this->whoops = new Whoops\Run(); $this->whoops->pushHandler(new Whoops\Handler\PrettyPageHandler()); $this->whoops->register(); } }
/** * Render an exception using Whoops. * * @param $request * @param \Exception $e * @return Response */ protected function renderExceptionWithWhoops($request, Exception $e) { $whoops = new Whoops\Run(); if ($request->ajax()) { $whoops->pushHandler(new Whoops\Handler\JsonResponseHandler()); } else { $whoops->pushHandler(new Whoops\Handler\PrettyPageHandler()); } return new Response($whoops->handleException($e), $e->getStatusCode(), $e->getHeaders()); }
/** * 激活调试器 */ public static function enable() { if (self::$enabled) { return; } self::$_debugger = new Run(); self::$_debugger->pushHandler(new PrettyPageHandler()); self::$_debugger->register(); self::$enabled = true; }
public static function register(Application $app) { $whoops = new Run(); if (ConfigManager::exists('app.display_errors') && ConfigManager::get('app.display_errors')) { $whoops->pushHandler(new PrettyPageHandler()); } else { $whoops->pushHandler(new ProdHandler($app)); } $whoops->register(); }
/** * Render an exception using Whoops. * * @param \Exception $e The Exception object * @param string $json Whether to use the JsonResponseHandler instead * of the PrettyPageHandler. * @return \Illuminate\Http\Response */ protected function renderExceptionWithWhoops(Exception $e, $json = false) { $whoops = new Whoops(); if ($json) { $whoops->pushHandler(new JsonResponseHandler()); } else { $whoops->pushHandler(new PrettyPageHandler()); } return new Response($whoops->handleException($e), $e->getStatusCode(), $e->getHeaders()); }
/** * @param \Illuminate\Http\Request $request * @param \Exception $e * * @return \Illuminate\Contracts\Routing\ResponseFactory|\Symfony\Component\HttpFoundation\Response */ public function renderExceptionWithWhoops($request, Exception $e) { $whoops = new Run(); if ($request->ajax() || $request->wantsJson()) { $whoops->pushHandler(new JsonResponseHandler()); } else { $whoops->pushHandler(new PrettyPageHandler()); } return response($whoops->handleException($e), $e->getStatusCode(), $e->getHeaders()); }
/** * Register error handler. */ public function registerErrorHandler() { $environment = getenv('ENVIRONMENT'); $whoops = new Whoops(); if ($environment !== 'production') { $whoops->pushHandler(new PrettyPageHandler()); } else { // @todo: This should display a pretty error page instead. $whoops->pushHandler(new Whoops\Handler\PrettyPageHandler()); } $whoops->register(); }
/** * @param Request $request * @param Exception $exception * @return Response * @throws \InvalidArgumentException */ protected function renderExceptionWithWhoops(Request $request, Exception $exception) { $whoops = new Whoops(); if ($request->isJson() || $request->wantsJson()) { $whoops->pushHandler(new JsonResponseHandler()); } else { $whoops->pushHandler(new PrettyPageHandler()); } $code = $exception instanceof HttpException ? $exception->getStatusCode() : 500; $headers = $exception instanceof HttpException ? $exception->getHeaders() : []; return new Response($whoops->handleException($exception), $code, $headers); }
/** * @param Application $app */ public function register(Application $app) { // There's only ever going to be one error page...right? $app['whoops.error_page_handler'] = $app->share(function () { if (PHP_SAPI === 'cli') { return new PlainTextHandler(); } else { return new PrettyPageHandler(); } }); // Retrieves info on the Silex environment and ships it off // to the PrettyPageHandler's data tables: // This works by adding a new handler to the stack that runs // before the error page, retrieving the shared page handler // instance, and working with it to add new data tables $app['whoops.silex_info_handler'] = $app->protect(function () use($app) { try { /** @var Request $request */ $request = $app['request']; } catch (RuntimeException $e) { // This error occurred too early in the application's life // and the request instance is not yet available. return; } /** @var Handler $errorPageHandler */ $errorPageHandler = $app["whoops.error_page_handler"]; if ($errorPageHandler instanceof PrettyPageHandler) { /** @var PrettyPageHandler $errorPageHandler */ // General application info: $errorPageHandler->addDataTable('Silex Application', array('Charset' => $app['charset'], 'Locale' => $app['locale'], 'Route Class' => $app['route_class'], 'Dispatcher Class' => $app['dispatcher_class'], 'Application Class' => get_class($app))); // Request info: $errorPageHandler->addDataTable('Silex Application (Request)', array('URI' => $request->getUri(), 'Request URI' => $request->getRequestUri(), 'Path Info' => $request->getPathInfo(), 'Query String' => $request->getQueryString() ?: '<none>', 'HTTP Method' => $request->getMethod(), 'Script Name' => $request->getScriptName(), 'Base Path' => $request->getBasePath(), 'Base URL' => $request->getBaseUrl(), 'Scheme' => $request->getScheme(), 'Port' => $request->getPort(), 'Host' => $request->getHost())); } }); $app['whoops'] = $app->share(function () use($app) { $run = new Run(); $run->allowQuit(false); $run->pushHandler($app['whoops.error_page_handler']); $run->pushHandler($app['whoops.silex_info_handler']); return $run; }); $app->error(function ($e) use($app) { $method = Run::EXCEPTION_HANDLER; ob_start(); $app['whoops']->{$method}($e); $response = ob_get_clean(); $code = $e instanceof HttpException ? $e->getStatusCode() : 500; return new Response($response, $code); }); $app['whoops']->register(); }
/** * @param array $values Optional arguments for container. */ public function __construct($values = array()) { $defaults = array(); $defaults['tables'] = array('$wp' => function () { global $wp; if (!$wp instanceof \WP) { return array(); } $output = get_object_vars($wp); unset($output['private_query_vars']); unset($output['public_query_vars']); return array_filter($output); }, '$wp_query' => function () { global $wp_query; if (!$wp_query instanceof \WP_Query) { return array(); } $output = get_object_vars($wp_query); $output['query_vars'] = array_filter($output['query_vars']); unset($output['posts']); unset($output['post']); return array_filter($output); }, '$post' => function () { $post = get_post(); if (!$post instanceof \WP_Post) { return array(); } return get_object_vars($post); }); $defaults['handler.pretty'] = function ($plugin) { $handler = new PrettyPageHandler(); foreach ($plugin['tables'] as $name => $callback) { $handler->addDataTableCallback($name, $callback); } // Requires Remote Call plugin. $handler->addEditor('phpstorm-remote-call', 'http://localhost:8091?message=%file:%line'); return $handler; }; $defaults['handler.json'] = function () { $handler = new Admin_Ajax_Handler(); $handler->addTraceToOutput(true); return $handler; }; $defaults['run'] = function ($plugin) { $run = new Run(); $run->pushHandler($plugin['handler.pretty']); $run->pushHandler($plugin['handler.json']); return $run; }; parent::__construct(array_merge($defaults, $values)); }
/** * {@inheritDoc} */ public function onBootstrap(EventInterface $e) { $config = $e->getTarget()->getServiceManager()->get('Config'); $config = isset($config['view_manager']) ? $config['view_manager'] : array(); if ($e->getRequest() instanceof ConsoleRequest || empty($config['display_exceptions'])) { return; } $this->run = new Run(); $this->run->register(); // set up whoops config $prettyPageHandler = new PrettyPageHandler(); if (isset($config['editor'])) { if ($config['editor'] == 'phpStorm') { $localPath = null; if (isset($config['local_path'])) { $localPath = $config['local_path']; } $prettyPageHandler->setEditor(function ($file, $line) use($localPath) { if ($localPath) { // if your development server is not local it's good to map remote files to local $translations = array('^' . __DIR__ => $config['editor_path']); // change to your path foreach ($translations as $from => $to) { $file = preg_replace('#' . $from . '#', $to, $file, 1); } } return "pstorm://{$file}:{$line}"; }); } else { $prettyPageHandler->setEditor($config['editor']); } } if (!empty($config['json_exceptions']['display'])) { $jsonHandler = new JsonResponseHandler(); if (!empty($config['json_exceptions']['show_trace'])) { $jsonHandler->addTraceToOutput(true); } if (!empty($config['json_exceptions']['ajax_only'])) { $jsonHandler->onlyForAjaxRequests(true); } $this->run->pushHandler($jsonHandler); } if (!empty($config['whoops_no_catch'])) { $this->noCatchExceptions = $config['whoops_no_catch']; } $this->run->pushHandler($prettyPageHandler); $eventManager = $e->getTarget()->getEventManager(); $eventManager->attach(MvcEvent::EVENT_RENDER_ERROR, array($this, 'prepareException')); $eventManager->attach(MvcEvent::EVENT_DISPATCH_ERROR, array($this, 'prepareException')); }
/** * Set the proper Error Handler based on the Output of the page * * @param string $output */ public function setHandler($output = null) { $this->_whoops->popHandler(); if ($output == Output::JSON) { $this->_handler = new JsonResponseHandler(); } else { if ($output == Output::XML) { $this->_handler = new XmlResponseHandler(); } else { $this->_handler = new PlainResponseHandler(); } } $this->_whoops->pushHandler($this->_handler); }
public function register(App $glue) { $whoops = new Run(); $logger = $glue->bound('Psr\\Log\\LoggerInterface') ? $glue->make('Psr\\Log\\LoggerInterface') : null; $whoops->pushHandler(new PlainTextHandler($logger)); if ($glue->config->get('debug', false) !== true) { $whoops->pushHandler(new ProductionHandler($logger)); } else { $whoops->pushHandler(new PrettyPageHandler($logger)); } $whoops->register(); $glue->singleton('Whoops\\Run', function () use($whoops) { return $whoops; }); }
private function errors() { if ($this->environment == 'production') { return; } $run = new Whoops\Run(); $handler = new Whoops\Handler\PrettyPageHandler(); $run->pushHandler($handler); $run->pushHandler(function ($exception, $inspector, $run) { $inspector->getFrames()->map(function ($frame) { return $frame; }); }); $run->register(); }
public function register() { if (function_exists('ini_set')) { ini_set('display_errors', 0); } $run = new Run(); $handler = new ErrorHandler(); $json_handler = new JsonErrorHandler(); $cli_handler = new PlainTextHandler(); $cli_handler->onlyForCommandLine(true); $run->pushHandler($handler); $run->pushHandler($json_handler); $run->pushHandler($cli_handler); $run->register(); }
public function onBootstrap(EventInterface $e) { $this->serviceLocator = $e->getTarget()->getServiceManager(); $config = $e->getTarget()->getServiceManager()->get('Config'); $this->whoopsConfig = $config['arilas']['whoops']; if ($this->whoopsConfig['disabled']) { return; } $this->run = new Run(); $this->run->register(); $this->run->pushHandler($this->getHandler()); $eventManager = $e->getTarget()->getEventManager(); $eventManager->attach(MvcEvent::EVENT_RENDER_ERROR, array($this, 'prepareException')); $eventManager->attach(MvcEvent::EVENT_DISPATCH_ERROR, array($this, 'prepareException')); }