public function __construct($name = 'PHPUnit', $level = 'debug') { /** * Filter growl notifications and send only * - test failures ($handerLevel = Logger::NOTICE; see GrowlHandler constructor) * - summary of test suites (message "Results OK ...", or "Results KO ..." */ $filters = array(function ($record, $handlerLevel) { if ($record['level'] > $handlerLevel) { return true; } return preg_match('/^Results/', $record['message']) === 1; }); $stream = new RotatingFileHandler(__DIR__ . DIRECTORY_SEPARATOR . 'monologTestListener.log', 0, Logger::toMonologLevel($level)); $stream->setFilenameFormat('{filename}-{date}', 'Ymd'); $handlers = array($stream); try { // be notified only for test suites and test failures $growl = new GrowlHandler(array(), Logger::NOTICE); $handlers[] = new CallbackFilterHandler($growl, $filters); } catch (\Exception $e) { // Growl server is probably not started echo $e->getMessage(), PHP_EOL, PHP_EOL; } parent::__construct($name, $handlers); }
public function __construct($level = Logger::DEBUG, array $skipClassesPartials = array(), array $skipFunctions = array(), $skipStackFramesCount = 0) { $this->level = Logger::toMonologLevel($level); $this->skipClassesPartials = array_merge(array('Monolog\\'), $skipClassesPartials); $this->skipFunctions = array_merge($this->skipFunctions, $skipFunctions); $this->skipStackFramesCount = $skipStackFramesCount; }
/** * @param HandlerInterface $handler Handler. * @param string $deduplicationStore The file/path where the deduplication log should be kept * @param int $deduplicationLevel The minimum logging level for log records to be looked at for deduplication purposes * @param int $time The period (in seconds) during which duplicate entries should be suppressed after a given log is sent through * @param Boolean $bubble Whether the messages that are handled can bubble up the stack or not */ public function __construct(HandlerInterface $handler, $deduplicationStore = null, $deduplicationLevel = Logger::ERROR, $time = 60, $bubble = true) { parent::__construct($handler, 0, Logger::DEBUG, $bubble, false); $this->deduplicationStore = $deduplicationStore === null ? sys_get_temp_dir() . '/monolog-dedup-' . substr(md5(__FILE__), 0, 20) . '.log' : $deduplicationStore; $this->deduplicationLevel = Logger::toMonologLevel($deduplicationLevel); $this->time = $time; }
public function register(Application $app) { // System log $app['logger.system'] = $app->share(function ($app) { $log = new Logger('logger.system'); $log->pushHandler($app['monolog.handler']); $log->pushHandler(new SystemHandler($app, Logger::INFO)); return $log; }); // Changelog $app['logger.change'] = $app->share(function ($app) { $log = new Logger('logger.change'); $log->pushHandler(new RecordChangeHandler($app)); return $log; }); // Firebug $app['logger.firebug'] = $app->share(function ($app) { $log = new Logger('logger.firebug'); $handler = new FirePHPHandler(); $handler->setFormatter(new WildfireFormatter()); $log->pushHandler($handler); return $log; }); // System log $app['logger.flash'] = $app->share(function ($app) { $log = new FlashLogger(); return $log; }); // Manager $app['logger.manager'] = $app->share(function ($app) { $changeRepository = $app['storage']->getRepository('Bolt\\Storage\\Entity\\LogChange'); $systemRepository = $app['storage']->getRepository('Bolt\\Storage\\Entity\\LogSystem'); $mgr = new Manager($app, $changeRepository, $systemRepository); return $mgr; }); $app->register(new MonologServiceProvider(), ['monolog.name' => 'bolt']); $app['monolog.level'] = function ($app) { return Logger::toMonologLevel($app['config']->get('general/debuglog/level')); }; $app['monolog.logfile'] = function ($app) { return $app['resources']->getPath('cache') . '/' . $app['config']->get('general/debuglog/filename'); }; $app['monolog.handler'] = $app->extend('monolog.handler', function ($handler, $app) { // If we're not debugging, just send to /dev/null if (!$app['config']->get('general/debuglog/enabled')) { return new NullHandler(); } return $handler; }); // If we're not debugging, just send to /dev/null if (!$app['config']->get('general/debuglog/enabled')) { $app['monolog.handler'] = function () { return new NullHandler(); }; } $app['logger.debug'] = function () use($app) { return $app['monolog']; }; }
/** * Get log level. * * @return int * * @author Wuhsien Yu <*****@*****.**> * * @since 2016/03/12 */ protected static function getLevel() { $level = Logger::toMonologLevel(Config::get('log.level')); if (!in_array($level, Logger::getLevels())) { $level = Logger::INFO; } return $level; }
/** * @covers Monolog\Logger::toMonologLevel */ public function testConvertPSR3ToMonologLevel() { $this->assertEquals(Logger::toMonologLevel('debug'), 100); $this->assertEquals(Logger::toMonologLevel('info'), 200); $this->assertEquals(Logger::toMonologLevel('notice'), 250); $this->assertEquals(Logger::toMonologLevel('warning'), 300); $this->assertEquals(Logger::toMonologLevel('error'), 400); $this->assertEquals(Logger::toMonologLevel('critical'), 500); $this->assertEquals(Logger::toMonologLevel('alert'), 550); $this->assertEquals(Logger::toMonologLevel('emergency'), 600); }
public static function factory(array $config, array $handlers, $debug) { $config = self::validateAndNormaliseConfig($config); if (!isset($handlers[$config['handler']])) { throw new InvalidConfigurationException(sprintf("No handler with name '%s' defined. Did you define it before this handler?", $config['handler'])); } if ($debug) { // When debug is enabled, do not buffer messages, but let them be handled our delegate handler. return $handlers[$config['handler']]; } return new FingersCrossedHandler($handlers[$config['handler']], $config['activation_strategy']['factory']::factory($config['activation_strategy']['conf']), 0, true, true, Logger::toMonologLevel($config['passthru_level'])); }
/** * @param string $token Pushover api token * @param string|array $users Pushover user id or array of ids the message will be sent to * @param string $title Title sent to the Pushover API * @param integer $level The minimum logging level at which this handler will be triggered * @param Boolean $bubble Whether the messages that are handled can bubble up the stack or not * @param Boolean $useSSL Whether to connect via SSL. Required when pushing messages to users that are not * the pushover.net app owner. OpenSSL is required for this option. * @param integer $highPriorityLevel The minimum logging level at which this handler will start * sending "high priority" requests to the Pushover API * @param integer $emergencyLevel The minimum logging level at which this handler will start * sending "emergency" requests to the Pushover API * @param integer $retry The retry parameter specifies how often (in seconds) the Pushover servers will send the same notification to the user. * @param integer $expire The expire parameter specifies how many seconds your notification will continue to be retried for (every retry seconds). */ public function __construct($token, $users, $title = null, $level = Logger::CRITICAL, $bubble = true, $useSSL = true, $highPriorityLevel = Logger::CRITICAL, $emergencyLevel = Logger::EMERGENCY, $retry = 30, $expire = 25200) { $connectionString = $useSSL ? 'ssl://api.pushover.net:443' : 'api.pushover.net:80'; parent::__construct($connectionString, $level, $bubble); $this->token = $token; $this->users = (array) $users; $this->title = $title ?: gethostname(); $this->highPriorityLevel = Logger::toMonologLevel($highPriorityLevel); $this->emergencyLevel = Logger::toMonologLevel($emergencyLevel); $this->retry = $retry; $this->expire = $expire; }
/** * {@inheritdoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); // Converts PSR-3 levels to Monolog ones if necessary $config['level'] = Logger::toMonologLevel($config['level']); $container->setParameter('ae_monolog_fluentd.host', $config['host']); $container->setParameter('ae_monolog_fluentd.port', $config['port']); $container->setParameter('ae_monolog_fluentd.options', $config['options']); $container->setParameter('ae_monolog_fluentd.level', $config['level']); $loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.xml'); }
/** * * @param int|array $minLevelOrList * A list of levels to accept or a minimum level if maxLevel is provided * @param int $maxLevel * Maximum level to accept, only used if $minLevelOrList is not an array */ public function setAcceptedLevels($minLevelOrList = Logger::DEBUG, $maxLevel = Logger::EMERGENCY) { if (is_array($minLevelOrList)) { $acceptedLevels = array_map('Monolog\\Logger::toMonologLevel', $minLevelOrList); } else { $minLevelOrList = Logger::toMonologLevel($minLevelOrList); $maxLevel = Logger::toMonologLevel($maxLevel); $acceptedLevels = array_values(array_filter(Logger::getLevels(), function ($level) use($minLevelOrList, $maxLevel) { return $level >= $minLevelOrList && $level <= $maxLevel; })); } $this->acceptedLevels = array_flip($acceptedLevels); }
public function register(App $glue) { #if (!$glue->config->exists('monolog.path')) { # // No log path set # return; #} $glue->singleton('Monolog\\Logger', function ($glue) { $logLevel = $glue->config->get('monolog.level', Logger::ERROR); $logLevel = Logger::toMonologLevel($logLevel); $folder = $glue->config->get('monolog.folder'); $filename = $glue->config->get('monolog.file', 'app.log'); // create a log channel $log = new Logger($glue->config->get('monolog.name', 'glue')); $log->pushHandler(new StreamHandler($folder . '/' . $filename, $logLevel)); return $log; }); $glue->singleton('Psr\\Log\\LoggerInterface', 'Monolog\\Logger'); $glue->alias('Monolog\\Logger', 'log'); }
/** * @param callable|HandlerInterface $handler Handler or factory callable($record, $fingersCrossedHandler). * @param int|ActivationStrategyInterface $activationStrategy Strategy which determines when this handler takes action * @param int $bufferSize How many entries should be buffered at most, beyond that the oldest items are removed from the buffer. * @param Boolean $bubble Whether the messages that are handled can bubble up the stack or not * @param Boolean $stopBuffering Whether the handler should stop buffering after being triggered (default true) * @param int $passthruLevel Minimum level to always flush to handler on close, even if strategy not triggered */ public function __construct($handler, $activationStrategy = null, $bufferSize = 0, $bubble = true, $stopBuffering = true, $passthruLevel = null) { if (null === $activationStrategy) { $activationStrategy = new ErrorLevelActivationStrategy(Logger::WARNING); } // convert simple int activationStrategy to an object if (!$activationStrategy instanceof ActivationStrategyInterface) { $activationStrategy = new ErrorLevelActivationStrategy($activationStrategy); } $this->handler = $handler; $this->activationStrategy = $activationStrategy; $this->bufferSize = $bufferSize; $this->bubble = $bubble; $this->stopBuffering = $stopBuffering; if ($passthruLevel !== null) { $this->passthruLevel = Logger::toMonologLevel($passthruLevel); } if (!$this->handler instanceof HandlerInterface && !is_callable($this->handler)) { throw new \RuntimeException("The given handler (" . json_encode($this->handler) . ") is not a callable nor a Monolog\\Handler\\HandlerInterface object"); } }
public function __construct($actionLevel, array $ignore) { $this->actionLevel = \Monolog\Logger::toMonologLevel($actionLevel); $this->ignore = $ignore; }
public function __construct($level = Logger::DEBUG, $backtraceLevel = 8) { $this->level = Logger::toMonologLevel($level); $this->backtraceLevel = $backtraceLevel; }
/** * Register a rotating file log handler. * * @param string $level * @param string $path * @return void */ public function useRotatingFiles($level = 'debug', $path = null) { $path || ($path = $this->settings['directory']); $this->monolog->pushHandler($handler = new Handler\RotatingFileHandler($path, 5, Logger::toMonologLevel($level))); $handler->setFormatter($this->getDefaultFormatter()); return $this; }
public function __construct($level = Logger::DEBUG, array $skipClassesPartials = array('Monolog\\')) { $this->level = Logger::toMonologLevel($level); $this->skipClassesPartials = $skipClassesPartials; }
/** * Init the Logger */ protected function initLogger() { $this->logger = new Logger(__CLASS__); $log_level = Logger::INFO; if (isset($this->config['log_level']) && !empty($this->config['log_level'])) { $log_level = Logger::toMonologLevel($this->config['log_level']); } if (isset($this->config['log_file'])) { $handler = new StreamHandler($this->config['log_file'], $log_level); $this->logger->pushHandler($handler); } }
// // Logger initialization // //------------------------------------------------------------------------------ /*! Note @ 7 Aug, 2015 * Here we started to make use of the Psr\Log interface and Seldaek\Monolog, * digging the original Log class empty as a wrapper to LoggerInterface, and * moved the backtrace and session info into separate processors in monolog. * * Specifically, backtrace context like file, subject and action are moved to * the BacktraceProcessor class, while session info is moved to the * SessionProcessor class. * * Node::set() invoke is migrated into NodeHandler class. */ Log::setLogger(new Logger('default')); // Log enabled if (conf::get('system::log.enabled', true)) { $level = Logger::toMonologLevel(conf::get('system::log.level', 'debug')); Log::getLogger()->pushProcessor(new BacktraceProcessor($level))->pushProcessor(new SessionProcessor($level))->pushProcessor(new ProcessProcessor($level))->pushHandler(new NodeHandler($level)); unset($level); } else { // This should not be necessary, no handlers will run nothing. Log::getLogger()->pushHandler(new NullHandler()); } //------------------------------------------------------------------------------ // // System shims // //------------------------------------------------------------------------------ require_once __DIR__ . '/framework/environment.php';
public function __construct($level = Logger::DEBUG) { $this->level = Logger::toMonologLevel($level); }
/** * Sets minimum logging level at which this handler will be triggered. * * @param int $level * @return self */ public function setLevel($level) { $this->level = Logger::toMonologLevel($level); return $this; }
$path = $settings['view']['template_path'] ?? '../templates'; $twig_settings = $settings['view']['twig'] ?? $default_config; // Create Twig object and add Slim extensions $view = new \Slim\Views\Twig($path, $twig_settings); $view->addExtension(new Slim\Views\TwigExtension($c->router, $c->request->getUri())); $view->addExtension(new Twig_Extension_Debug()); return $view; }; // Monolog logging service: https://github.com/Seldaek/monolog $container['logger'] = function ($c) use($settings) { $name = $settings['logger']['name'] ?? __FILE__; $location = $settings['logger']['path'] ?? '../logs/application.log'; $log_level = $settings['logger']['level'] ?? 'DEBUG'; $logger = new \Monolog\Logger($name); $logger->pushProcessor(new \Monolog\Processor\UidProcessor()); $logger->pushHandler(new \Monolog\Handler\StreamHandler($location, \Monolog\Logger::toMonologLevel($log_level))); return $logger; }; /** * ----------------------------------------------------------------------------- * Service Layer * ----------------------------------------------------------------------------- * * These classes provide the business logic to interact with services and build the information necessary for * views. View routes.php to see how these classes are mapped to URLs */ $container['myService'] = function ($c) { return new \USF\IdM\SlimSkeleton\Service\ExampleService($c->logger, $c->settings); }; /** * -----------------------------------------------------------------------------
/** * @param int $defaultActionLevel The default action level to be used if the record's category doesn't match any * @param array $channelToActionLevel An array that maps channel names to action levels. */ public function __construct($defaultActionLevel, $channelToActionLevel = array()) { $this->defaultActionLevel = Logger::toMonologLevel($defaultActionLevel); $this->channelToActionLevel = array_map('Monolog\\Logger::toMonologLevel', $channelToActionLevel); }
/** * Converts PSR-3 levels to Monolog ones if necessary * * @param string|int Level number (monolog) or name (PSR-3) * @return int * @static */ public static function toMonologLevel($level) { return \Monolog\Logger::toMonologLevel($level); }
public function __construct($actionLevel) { $this->actionLevel = Logger::toMonologLevel($actionLevel); }
public function build(ContainerBuilder $builder) { $builder->bind(LoggerInterface::class)->scoped(new Singleton())->to(function (TestSystem $system) { $handler = new ErrorLogHandler(ErrorLogHandler::SAPI, Logger::toMonologLevel(strtolower($system->getLogLevel()))); $handler->pushProcessor(new PsrLogMessageProcessor()); $monolog = new Logger('System'); $monolog->pushHandler($handler); return $monolog; }); }