/**
* {@inheritDoc}
*/
public function register(Container $container)
{
// Append custom settings with missing params from default settings
$container['settings']['logger'] = self::mergeWithDefaultSettings($container['settings']['logger']);
/**
* Add dependency (DI).
*
* @param Container $c
*
* @return Logger
*/
$container['logger'] = function (Container $c) {
$settings = $c['settings']['logger'];
$loggerFormat = "[%datetime%] %level_name% %message% %context% %extra%\n";
$loggerTimeFormat = "Y-m-d H:i:s";
$loggerTimeZone = new DateTimeZone('Europe/Berlin');
$logger = new Logger($settings['name']);
if ($settings['color']) {
$logger->pushProcessor(new ConsoleColorProcessor());
}
$logger->pushProcessor(new CleanupProcessor($settings['trimPaths']));
$logger->pushProcessor(new IntrospectionProcessor(Logger::WARNING));
$logger->pushProcessor(new ProcessIdProcessor());
$logger->pushProcessor(new PsrLogMessageProcessor());
$logger->setTimezone($loggerTimeZone);
$logger->useMicrosecondTimestamps(false);
// Using microseconds is buggy (2016-08-04)
$formatter = new LineFormatter($loggerFormat, $loggerTimeFormat);
$formatter->ignoreEmptyContextAndExtra(true);
$defaultHandler = new StreamHandler('php://stdout', $settings['level'], $bubble = false);
$defaultHandler->setFormatter($formatter);
$logger->pushHandler($defaultHandler);
$errorHandler = new StreamHandler('php://stderr', Logger::ERROR, $bubble = false);
$errorHandler->setFormatter($formatter);
$logger->pushHandler($errorHandler);
// Register logger as default PHP error, exception and shutdown handler
// Note: Make sure only this handler handles errors (set $callPrevious to false)
$errorHandler = ErrorHandler::register($logger, $errorLevelMap = false, $exceptionLevelMap = false);
$errorHandler->registerErrorHandler($levelMap = [], $callPrevious = false);
$errorHandler->registerExceptionHandler($levelMap = [], $callPrevious = false);
return $logger;
};
}
/**
* Processes the error, fatal and exceptions
*/
protected function report()
{
# - let monolog handle the logging in the errors,
# unless you want it to, you can refer to method
# handleExceptionError()
MonologErrorHandler::register(di()->get('log'));
# - register all the the loggers we have
register_shutdown_function([$this, 'handleFatalError']);
set_error_handler([$this, 'handleError']);
set_exception_handler([$this, 'handleExceptionError']);
}
/**
* Perform extra chores on boot
*
* @param Application $app
*/
public function boot(Application $app)
{
// Register Monolog error handler for fatal errors here because Symfony's handler overrides it
$monologErrorHandler = new MonologErrorHandler($app['log']);
$monologErrorHandler->registerErrorHandler();
$monologErrorHandler->registerFatalHandler();
}
public function testHandleError()
{
$logger = new Logger('test', array($handler = new TestHandler()));
$errHandler = new ErrorHandler($logger);
$errHandler->registerErrorHandler(array(E_USER_NOTICE => Logger::EMERGENCY), false);
trigger_error('Foo', E_USER_ERROR);
$this->assertCount(1, $handler->getRecords());
$this->assertTrue($handler->hasErrorRecords());
trigger_error('Foo', E_USER_NOTICE);
$this->assertCount(2, $handler->getRecords());
$this->assertTrue($handler->hasEmergencyRecords());
}
function start()
{
if (!$this->logger) {
throw new \InvalidArgumentException("No Logger property passed to MonologErrorHandler." . "Is your Injector config correct?");
}
ErrorHandler::register($this->logger);
}
/**
*注册Monolog框架
*/
public static function registerMonolog()
{
self::$logger = new \Monolog\Logger('inc');
\Monolog\ErrorHandler::register(self::$logger);
self::$logHandler = new \Monolog\Handler\StreamHandler(self::$logPath . '/log_debug.log', \Monolog\Logger::DEBUG);
self::$logger->pushHandler(self::$logHandler);
}
/**
* @param InputInterface $input
* @param OutputInterface $output
*
* @return int|null
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$stopwatch = new Stopwatch();
$stopwatch->start('dbBackup');
$dumpedFiles = [];
$encryptedFiles = [];
$config = ConfigLoader::loadConfig($input->getOption('config_file') ?: 'config.yml');
$logger = LoggerFactory::getLogger($config, $output);
ErrorHandler::register($logger);
try {
// dump
foreach ($config['connections'] as $connection) {
$dumper = DatabaseDumperFactory::getDumper($connection, $logger);
$dumpedFiles = array_merge($dumpedFiles, $dumper->dump($connection['databases']));
}
// encrypt
$encrypter = FileEncrypterFactory::getEncrypter($config['encryption'], $logger);
$encryptedFiles = $encrypter->encrypt($dumpedFiles);
// store
// todo: add factory?
$store = new S3StorageAdapter($config['s3'], $logger);
$store->store($encryptedFiles);
// rotate
//$rotator = new BackupRotator($config['rotation']);
//$rotator->rotate($store);
} catch (\Exception $e) {
$logger->error('Unhandled exception: ' . $e->getMessage());
}
// cleanup
FileWiper::wipe($dumpedFiles, $logger);
FileWiper::wipe($encryptedFiles, $logger);
$logger->notice('Completed backup in ' . (string) $stopwatch->stop('dbBackup'));
// todo: return non-zero if any errors
return 0;
}
/**
* @Route("/admin/")
* @Route("/admin/{rest}", requirements={"rest" = ".+"})
* @Route("/")
* @Route("/{rest}", requirements={"rest" = ".+"})
*/
public function indexAction(Request $request)
{
// don't render page on tinymce files
$specialfiles = array('js/tinymce/plugins/campsiteimage/popup.php', 'js/tinymce/plugins/campsiteimage/images.php', 'js/tinymce/plugins/campsiteattachment/popup.php', 'js/tinymce/plugins/campsiteattachment/attachments.php', 'js/tinymce/plugins/campsiteinternallink/link.php', 'js/tinymce/plugins/campsitemedia/popup.php', 'js/tinymce/plugins/campsitemedia/attachments.php', 'bin/events-notifier', 'bin/newscoop-autopublish', 'bin/newscoop-indexer', 'bin/newscoop-statistics');
foreach ($specialfiles as $file) {
if (strpos($request->server->get('SCRIPT_FILENAME'), $file) !== false) {
return new Response();
}
}
$logger = $this->container->get('monolog.logger.sentry');
\Monolog\ErrorHandler::register($logger);
$application = \Zend_Registry::get('zend_application');
$bootstrap = $application->getBootstrap();
$front = $bootstrap->getResource('FrontController');
$front->setDefaultControllerName('legacy');
$front->returnResponse(true);
$default = $front->getDefaultModule();
if (null === $front->getControllerDirectory($default)) {
throw new \Zend_Application_Bootstrap_Exception('No default controller directory registered with front controller');
}
$front->setParam('bootstrap', $bootstrap);
$front->setBaseUrl('/');
$response = $front->dispatch();
//copy headers
$symfonyHeaders = array();
foreach ($response->getHeaders() as $key => $header) {
$symfonyHeaders[$header['name']] = $header['value'];
}
return new Response($response, $response->getHttpResponseCode(), $symfonyHeaders);
}
public function onKernelException(GetResponseForExceptionEvent $e)
{
$ex = $e->getException();
$response = new Response();
if ($ex instanceof NotFoundHttpException) {
$response->setContent($this->view->render('error/404'));
$e->setResponse($response);
return;
}
if ($this->debugMode) {
\Symfony\Component\Debug\ExceptionHandler::register();
throw $ex;
}
$response->setContent($this->view->render('error/exception'));
$e->setResponse($response);
$this->logger->handleException($ex);
}
/**
* Инициализация модуля
*/
public function Init()
{
/**
* Подключаем логирование всех PHP ошибок
*/
if (Config::Get('sys.logs.php')) {
\Monolog\ErrorHandler::register($this->GetInstance($this->sInstanceForPHPError));
}
}
public function __construct($app)
{
// Install the PHP error handler now only if logging
// is enabled. Otherwise we don't need to instantiate the
// logger until it has been requested through the DI container.
if ($this->hasLogging($app)) {
ErrorHandler::register($this->getLogger($app));
}
}
public static function init()
{
$logConfig = Config::get('log');
$logName = $logConfig['path'] . '/' . date('y_m_d') . '.log';
$logger = new Logger('run_logger');
$stream = new StreamHandler($logName, Logger::DEBUG);
$logger->pushHandler(new BufferHandler($stream, 10, Logger::DEBUG, true, true));
//用BufferHandler设置同一请求下日志数达到10条再写一次文件
ErrorHandler::register($logger);
}
/**
* Handles an exception
*
* @param \Exception $e The exception to handle
*/
public function handleException(\Exception $e)
{
if ($e instanceof ValidatorException) {
$this->logger->log($this->uncaughtExceptionLevel === null ? LogLevel::ERROR : $this->uncaughtExceptionLevel, $e->getMessage(), []);
} else {
$this->monologHandler->handleException($e);
}
if ($this->previousExceptionHandler) {
call_user_func($this->previousExceptionHandler, $e);
}
}
public function setServicesOptional()
{
$this->services['ErrorHandler'] = function ($services) {
$config = $services['Config'];
$log = new \Monolog\Logger('system');
if ($config->getSetting('core.displayErrors')) {
// ini_set('display_errors', 1);
// ini_set('display_startup_errors', 1);
// error_reporting(E_ALL);
$log->pushHandler(new \Monolog\Handler\BrowserConsoleHandler());
}
$log->pushHandler(new \Monolog\Handler\StreamHandler($services['ProjectPath'] . 'error.txt', \Monolog\Logger::DEBUG));
return $log;
};
\Monolog\ErrorHandler::register($this->services['ErrorHandler']);
$this->services['ModelFactory'] = function ($services) {
$config = $services['Config'];
$modelFactory = new \Mwyatt\Core\Factory\Model();
$modelFactory->setDefaultNamespace($config->getSetting('projectBaseNamespace') . 'Model\\');
return $modelFactory;
};
$this->services['IteratorFactory'] = function ($services) {
$config = $services['Config'];
$iteratorFactory = new \Mwyatt\Core\Factory\Iterator();
$iteratorFactory->setDefaultNamespace($config->getSetting('projectBaseNamespace') . 'Iterator\\');
return $iteratorFactory;
};
$this->services['MapperFactory'] = function ($services) {
$config = $services['Config'];
$mapperFactory = new \Mwyatt\Core\Factory\Mapper($services['Database'], $services['ModelFactory'], $services['IteratorFactory']);
$mapperFactory->setDefaultNamespace($config->getSetting('projectBaseNamespace') . 'Mapper\\');
return $mapperFactory;
};
$this->services['RepositoryFactory'] = function ($services) {
$config = $services['Config'];
$repositoryFactory = new \Mwyatt\Core\Factory\Repository($services['MapperFactory']);
$repositoryFactory->setDefaultNamespace($config->getSetting('projectBaseNamespace') . 'Repository\\');
return $repositoryFactory;
};
$this->services['Mail'] = function ($services) {
$config = $services['Config'];
$transport = \Swift_SmtpTransport::newInstance($config->getSetting('mail.host'), $config->getSetting('mail.port'), $config->getSetting('mail.security'));
$transport->setUsername($config->getSetting('mail.username'));
$transport->setPassword($config->getSetting('mail.appPassword'));
$swiftMailer = \Swift_Mailer::newInstance($transport);
return new \Mwyatt\Core\Mail($swiftMailer);
};
$this->services['Database'] = function ($services) {
$config = $services['Config'];
$database = new \Mwyatt\Core\Database\Pdo();
$database->connect($config->getSetting('database.host'), $config->getSetting('database.basename'), $config->getSetting('database.username'), $config->getSetting('database.password'));
return $database;
};
}
public static function getFileAndMailLogger($logFile, $fileLevel, $mailTo, $mailLevel)
{
$monolog = new Monolog('f&mLog');
$streamHandler = new StreamHandler($logFile, $fileLevel);
$mailHandler = new NativeMailerHandler($mailTo, date("Y-m-d H:i:s") . ' - e7Bot error ', "e7bot", $fileLevel, true, 300);
$mailHandler->setFormatter(new LineFormatter(self::LOG_FORMAT, null, true));
$streamHandler->setFormatter(new LineFormatter(self::LOG_FORMAT, null, true));
$monolog->pushHandler($streamHandler);
$monolog->pushHandler($mailHandler);
ErrorHandler::register($monolog);
return new Logger($monolog, $logFile);
}
/**
* Returns an instance of Monolog with all configured handlers
* added. The Monolog instance will be given $name.
* @param $name
* @return Logger
*/
public function getFor($name)
{
if (isset($this->cache[$name])) {
return $this->cache[$name];
}
$handlers = $this->getHandlers(self::KEY_ALWAYS_LOADED);
if ($name !== self::KEY_ALWAYS_LOADED) {
$handlers = array_merge($handlers, $this->getHandlers($name));
}
$logger = new Logger($name, $handlers);
ErrorHandler::register($logger);
$this->cache[$name] = $logger;
return $logger;
}
/**
* @param MvcEvent $e
*/
public function onBootstrap(MvcEvent $e)
{
$serviceManager = $e->getApplication()->getServiceManager();
$options = $serviceManager->get('Config');
$options = isset($options['monolog_error_handler']) ? $options['monolog_error_handler'] : null;
$options = new ErrorHandlerOptions($options);
if (!$options->getEnabled()) {
return;
}
$logger = $options->getLogger();
if (is_string($logger)) {
$logger = $serviceManager->get("monolog.logger.{$logger}");
}
ErrorHandler::register($logger, $options->getErrorLevelMap(), $options->getExceptionLevel(), $options->getFatalLevel());
}
public function routerStartup(Yaf\Request_Abstract $request, Yaf\Response_Abstract $response)
{
error_reporting(E_ERROR | E_PARSE);
ini_set('display_errors', true);
/**
* whoops调试输出， 需要安装whoops
*/
// $run = new \Whoops\Run();
// $handler = new \Whoops\Handler\PrettyPageHandler();
// $run->pushHandler($handler);
// $run->register();
/**
* phpConsole调试(需要安装google扩展)
* 可以直接调用phpConsole客户端，或者monolog也封装了客户端
* phpConsole php client: https://github.com/barbushin/php-console/wiki/PHP-Console-extension-features
* monolog phpConsole client:https://github.com/Seldaek/monolog/blob/master/src/Monolog/Handler/PHPConsoleHandler.php
*/
$logger = new \Monolog\Logger('all', array(new \Monolog\Handler\PHPConsoleHandler()));
//TODO::找到关闭气泡弹窗方法。
\Monolog\ErrorHandler::register($logger);
}
/**
* prepare logging environment with configuration variables
*/
public function __construct()
{
// copied functionality from system/core/Common.php, as the whole CI infrastructure is not available yet
if (!defined('ENVIRONMENT') or !file_exists($file_path = APPPATH . 'config/' . ENVIRONMENT . '/monolog.php')) {
$file_path = APPPATH . 'config/monolog.php';
}
// Fetch the config file
if (file_exists($file_path)) {
require $file_path;
} else {
exit('monolog.php config does not exist');
}
// make $config from config/monolog.php accessible to $this->write_log()
$this->config = $config;
$this->log = new Logger($this->config['channel']);
// detect and register all PHP errors in this log hence forth
ErrorHandler::register($this->log);
if ($this->config['introspection_processor']) {
// add controller and line number info to each log message
$this->log->pushProcessor(new IntrospectionProcessor());
}
// decide which handler(s) to use
foreach ($this->config['handlers'] as $value) {
switch ($value) {
case 'file':
$handler = new RotatingFileHandler($this->config['file_logfile']);
break;
case 'new_relic':
$handler = new NewRelicHandler(Logger::ERROR, true, $this->config['new_relic_app_name']);
break;
case 'hipchat':
$handler = new HipChatHandler($config['hipchat_app_token'], $config['hipchat_app_room_id'], $config['hipchat_app_notification_name'], $config['hipchat_app_notify'], $config['hipchat_app_loglevel']);
break;
default:
exit('log handler not supported: ' . $this->config['handler']);
}
$this->log->pushHandler($handler);
}
$this->write_log('DEBUG', 'Monolog replacement logger initialized');
}
/**
* Application constructor.
*
* @param object $loader The autoloader instance.
* @param array $config The custom configuration of the application.
* @param string $appPath The application absolute path.
* @param array $classesMap The custom classes map of the application.
*/
public function __construct($loader, array $config = [], $appPath = null, array $classesMap = [])
{
# Utilities
$this->utilities = new Utilities($this);
# Register start time
$this->utilities->registerStartTime();
# Store application path
$this->utilities->setApplicationPath($appPath);
# Store classes map
$this['class'] = $this->utilities->setClassesMap($classesMap);
# Call container constructor
parent::__construct($this->utilities->setConfiguration($config));
# Register core services providers
$this->register(new FilesystemServiceProvider());
$this->register(new FinderServiceProvider());
$this->register(new HttpServiceProvider());
$this->register(new LoggerServiceProvider());
$this->register(new MessagesServiceProvider());
$this->register(new RouterServiceProvider());
$this->register(new SupportServiceProvider());
$this->register(new TemplatingServiceProvider());
$this->register(new TriggersServiceProvider());
# Enables the portablity layer and configures PHP for UTF-8
Utf8Bootup::initAll();
# Redirects to an UTF-8 encoded URL if it's not already the case
Utf8Bootup::filterRequestUri();
# Normalizes HTTP inputs to UTF-8 NFC
Utf8Bootup::filterRequestInputs();
# Print errors in debug mode
if ($this['debug']) {
$whoops = new WhoopsRun();
$whoops->pushHandler(new WhoopsHandler());
$whoops->register();
} else {
ErrorHandler::register($this['phpLogger']);
}
# Only enable Kint in debug mode
\Kint::enabled($this['debug']);
}
/**
* @param array $config
* @throws Exception\FacadeAlreadyInitializedException
*/
private function setOptions(array $config)
{
foreach ($config['handlers'] as $name => $handler) {
$this->setHandlerFromConfig($name, $handler);
}
if (false === empty($config['registerErrorHandler'])) {
MonologErrorHandler::register($this->logger);
}
if (false === empty($config['ignoredExceptionClasses'])) {
$this->ignoredExceptions = $config['ignoredExceptionClasses'];
}
if (isset($config['useIgnoreLogic'])) {
$this->useIgnoreLogic = (bool) $config['useIgnoreLogic'];
}
if (false === empty($config['useFacade'])) {
LoggerFacade::setLogger($this);
}
if (false === empty($config['exceptionFormatterCallback']) && is_callable($config['exceptionFormatterCallback'])) {
$this->exceptionFormatterCallback = $config['exceptionFormatterCallback'];
} elseif (false === empty($config['messageFormatter'])) {
$this->messageFormatter = $config['messageFormatter'];
}
}
/**
* creates a \Monolog\Logger instance
*
* @param bool $debug If true the debug logging mode will be enabled
*
* @return \Monolog\Logger
*/
public function create($debug = false)
{
$logger = new Logger('browscap');
if ($debug) {
$stream = new StreamHandler('php://output', Logger::DEBUG);
$stream->setFormatter(new LineFormatter('[%datetime%] %channel%.%level_name%: %message% %extra%' . "\n"));
/** @var callable $memoryProcessor */
$memoryProcessor = new MemoryUsageProcessor(true);
$logger->pushProcessor($memoryProcessor);
/** @var callable $peakMemoryProcessor */
$peakMemoryProcessor = new MemoryPeakUsageProcessor(true);
$logger->pushProcessor($peakMemoryProcessor);
} else {
$stream = new StreamHandler('php://output', Logger::INFO);
$stream->setFormatter(new LineFormatter('[%datetime%] %message% %extra%' . "\n"));
/** @var callable $peakMemoryProcessor */
$peakMemoryProcessor = new MemoryPeakUsageProcessor(true);
$logger->pushProcessor($peakMemoryProcessor);
}
$logger->pushHandler($stream);
$logger->pushHandler(new ErrorLogHandler(ErrorLogHandler::OPERATING_SYSTEM, Logger::NOTICE));
ErrorHandler::register($logger);
return $logger;
}
public static function init()
{
date_default_timezone_set('UTC');
$dir = str_replace("\\", '/', __DIR__);
self::$serverRoot = implode('/', array_slice(explode('/', $dir), 0, -1));
self::$autoloader = (require self::path('vendor/autoload.php'));
self::$logger = new Logger('logger');
self::$logger->pushHandler(new ErrorLogHandler(ErrorLogHandler::OPERATING_SYSTEM, Logger::NOTICE));
ErrorHandler::register(self::$logger);
self::$configDir = self::path('config');
self::$config = new \Mesamatrix\Config(self::$configDir);
// attempt to create the private dir
$privateDir = self::path(self::$config->getValue('info', 'private_dir'));
if (!is_dir($privateDir)) {
mkdir($privateDir);
}
// register the log file
$logLevel = self::$config->getValue('info', 'log_level', Logger::WARNING);
$logPath = $privateDir . '/mesamatrix.log';
if (!file_exists($logPath) && is_dir($privateDir)) {
touch($logPath);
}
if (is_writable($logPath)) {
self::$logger->popHandler();
self::$logger->pushHandler(new StreamHandler($logPath, $logLevel));
} else {
self::$logger->error('Error log ' . $logPath . ' is not writable!');
}
if ($logLevel < Logger::INFO) {
ini_set('error_reporting', E_ALL);
ini_set('display_errors', 1);
}
// initialise request
self::$request = HTTPRequest::createFromGlobals();
self::$logger->debug('Base initialisation complete');
}
}
if (!is_writable($logpath)) {
chmod($logfile, 0777);
}
if (!file_exists($logfile)) {
file_put_contents($logfile, '');
}
umask($old);
$log = new \Monolog\Logger(strtoupper($app->request->getHost()));
$log->pushHandler(new \Monolog\Handler\StreamHandler($logfile, \Monolog\Logger::DEBUG, true, 0777));
return $log;
});
/**
* Register handlers
*/
\Monolog\ErrorHandler::register($app->log);
/**
* Error handle
*/
$app->error(function (\Exception $e) use($app) {
$app->applyHook('log.request.info', $e->getMessage());
$app->log->error($e);
$app->render('error.php');
});
$app->notFound(function () use($app) {
$app->applyHook('log.request.info', 'Page not found');
$app->render('404.php');
});
// throw new \Exception('test error');
/**
* Define hooks
$te->addGlobal('username', $shared['user']->username);
}
if (isset($_SESSION['superuser'])) {
$te->addGlobal('super', $_SESSION['superuser']);
}
if ($flash->hasMessages()) {
$te->addGlobal('flashes', $flash->display());
}
return $te;
}, 'glide' => require_once __DIR__ . '/shared/glide.php', ClientInterface::class => function () {
$client = new Client();
return $client;
}, Flash::class => function () {
return new Flash(TemplateFactory::create(Templates::SEMANTIC_2));
}, 'User' => function () use($shared) {
return $shared['user'];
}, 'rauth' => function () {
$rauth = new Rauth();
// Add cache at some point
return $rauth;
}, Logger::class => function () use($shared) {
$logger = new \Monolog\Logger('nofwlog');
$logger->pushHandler(new StreamHandler($shared['site']['logFolder'] . '/all.log'));
$logger->pushHandler(new StreamHandler($shared['site']['logFolder'] . '/error.log', \Monolog\Logger::NOTICE));
if ($shared['site']['env'] == 'dev') {
$logger->pushHandler(new BrowserConsoleHandler());
}
ErrorHandler::register($logger);
$logger->info('Logging set up');
return $logger;
}];
/**
* Adds a logging provider to the container of phpDocumentor.
*
* @return void
*/
protected function addLogging()
{
$this->register(new MonologServiceProvider(), array('monolog.name' => 'phpDocumentor', 'monolog.logfile' => sys_get_temp_dir() . '/phpdoc.log', 'monolog.debugfile' => sys_get_temp_dir() . '/phpdoc.debug.log', 'monolog.level' => Logger::INFO));
$app = $this;
/** @var Configuration $configuration */
$configuration = $this['config'];
$this['monolog.configure'] = $this->protect(function ($log) use($app, $configuration) {
$paths = $configuration->getLogging()->getPaths();
$logLevel = $configuration->getLogging()->getLevel();
$app->configureLogger($log, $logLevel, $paths['default'], $paths['errors']);
});
$this->extend('console', function (ConsoleApplication $console) use($configuration) {
$console->getHelperSet()->set(new LoggerHelper());
$console->getHelperSet()->set(new ConfigurationHelper($configuration));
return $console;
});
ErrorHandler::register($this['monolog']);
}
/**
* @return ErrorHandler
*/
public function buildAndRegister()
{
return ErrorHandler::register($this->getLogger() ?: $this->getDefaultLogger(), $this->getErrorLevelMap(), $this->getExceptionLevel(), $this->getFatalLevel());
}
public function boot(Application $app)
{
if ($app['monolog.use_error_handler']) {
ErrorHandler::register($app['monolog']);
}
if (isset($app['monolog.listener'])) {
$app['dispatcher']->addSubscriber($app['monolog.listener']);
}
}
/**
* Adds a logging provider to the container of phpDocumentor.
*
* @return void
*/
protected function addLogging()
{
$this->register(new MonologServiceProvider(), array('monolog.name' => 'phpDocumentor', 'monolog.logfile' => sys_get_temp_dir() . '/phpdoc.log', 'monolog.debugfile' => sys_get_temp_dir() . '/phpdoc.debug.log', 'monolog.level' => Logger::INFO));
$app = $this;
$this['monolog.configure'] = $this->protect(function ($log) use($app) {
$level = (string) $app['config']->logging->level;
// null means the default is used
$logPath = isset($app['config']->logging->paths->default) ? (string) $app['config']->logging->paths->default : null;
// null means the default is used
$debugPath = isset($app['config']->logging->paths->errors) ? (string) $app['config']->logging->paths->errors : null;
$app->configureLogger($log, $level, $logPath, $debugPath);
});
ErrorHandler::register($this['monolog']);
}
public function testError($classesPartialsTraceIgnore = null)
{
$code = E_USER_NOTICE;
$message = 'message';
$file = __FILE__;
$line = __LINE__;
$this->errorDispatcher->expects($this->once())->method('dispatchError')->with($this->equalTo($code), $this->equalTo($message), $this->equalTo($file), $this->equalTo($line), $classesPartialsTraceIgnore ?: $this->equalTo($this->getHandlerDefaultOption('classesPartialsTraceIgnore')));
$errorHandler = ErrorHandler::register($this->initLogger($classesPartialsTraceIgnore ? array('classesPartialsTraceIgnore' => $classesPartialsTraceIgnore) : array()), false);
$errorHandler->registerErrorHandler(array(), false, E_USER_WARNING);
$errorHandler->handleError($code, $message, $file, $line);
}
