/**
*
*/
public function buildLogger($channel, $handlers = null)
{
// Create a new logger
$logger = new \Monolog\Logger($channel);
// Setup processors
$logger->pushProcessor(new \Monolog\Processor\IntrospectionProcessor());
$logger->pushProcessor(new \Monolog\Processor\ProcessIdProcessor());
$logger->pushProcessor(new \Monolog\Processor\WebProcessor());
// Are we in CLI/verbose mode?
if (\z\app()->isCli() === true) {
// Define the level
if (\z\app()->isVerbose() === true) {
$level = \Monolog\Logger::DEBUG;
} else {
$level = \Monolog\Logger::INFO;
}
// Redirect to standard output
$handler = new \Monolog\Handler\StreamHandler('php://stdout', $level);
// Format for CLI
$handler->setFormatter(new \fbenard\Zero\Services\Formatters\CliLogFormatter());
} else {
// Redirect to /dev/null
$handler = new \Monolog\Handler\NullHandler();
}
// Push the handler
$logger->pushHandler($handler);
// Parse each handler
if (is_array($handlers) === true) {
foreach ($handlers as $handler) {
// Push the handler
$logger->pushHandler($handler);
}
}
return $logger;
}
/**
* Add processors to the Logger
*
* @param callable[] Array of Monolog processors
*/
private function addProcessors(array $processors)
{
// We need to reverse the array because Monolog "pushes" processors to top of the stack
foreach (array_reverse($processors) as $processor) {
$this->logger->pushProcessor($processor);
}
}
protected function log($message)
{
$tz = new \DateTimeZone('UTC');
$log = new \Monolog\Logger(__NAMESPACE__);
$log->setTimezone($tz);
$error_handler = new \Monolog\Handler\ErrorLogHandler();
$log->pushHandler($error_handler);
// adds url,client ip,http_method,server and referrer to each log
$web_processor = new \Monolog\Processor\WebProcessor();
$log->pushProcessor($web_processor);
// adds a unique identifier to each log
// e.g. "uid":"0ce8d6d"
$uid_processor = new \Monolog\Processor\UidProcessor();
$log->pushProcessor($uid_processor);
$log->info(get_called_class() . ' ' . $message, $this->getContext());
}
/**
* Registers services on the given container.
*
* This method should only be used to configure services and parameters.
* It should not get services.
*
* @param Container|ContainerInterface $pimple A container instance
*
* @return PhpRenderer
*/
public function register(Container $pimple)
{
$settings = $pimple->get('settings')['logger'];
$logger = new \Monolog\Logger($settings['name']);
$logger->pushProcessor(new \Monolog\Processor\UidProcessor());
$logger->pushHandler(new \Monolog\Handler\StreamHandler($settings['path'], \Monolog\Logger::DEBUG));
$pimple['logger'] = $logger;
}
public function bootMonolog()
{
$container = $this->app->getContainer();
$container['logger'] = function ($c) {
$settings = DotArray::newDotArray($c['settings']);
$logger = new \Monolog\Logger($settings['app.name'] . 'Log');
$logger->pushProcessor(new \Monolog\Processor\WebProcessor());
$logger->pushProcessor(new \Monolog\Processor\UidProcessor());
$logger->pushProcessor(new \Monolog\Processor\GitProcessor());
$logger->pushHandler(new \Monolog\Handler\RotatingFileHandler(join(DIRECTORY_SEPARATOR, [$settings['paths.log'], date('Y-m-d') . '.log']), $settings['logger.max_files'], \Monolog\Logger::DEBUG));
if ($settings['app.debug']) {
$logger->pushHandler(new \Monolog\Handler\BrowserConsoleHandler());
}
if ($settings['features.error.slack'] && $settings->has('slack')) {
$logger->pushHandler(new \Monolog\Handler\SlackHandler($settings['slack.token'], $settings['slack.channel'], $settings['slack.username']));
}
return $logger;
};
}
/**
* Bootstrap the application.
*/
protected function bootstrap()
{
// Read all config files
$config = new Repository($this->loadConfigFiles());
// Register the configuration instance for later use.
// Note that Slim framework already used a service key named 'settings' for
// accessing the framework settings. Here, we will use a separate key for
// the application configurations. If you want to reuse the service key,
// you should merge the framework settings with the application configurations.
$container = $this->getContainer();
$container['config'] = function () use($config) {
return $config;
};
date_default_timezone_set($config['app.timezone']);
mb_internal_encoding('UTF-8');
// Register route handler strategy
$container['foundHandler'] = function () {
return new \Slim\Handlers\Strategies\RequestResponseArgs();
};
// Register a logger used in the application
$container['logger'] = function () use($container) {
$logger = new \Monolog\Logger('logger');
$logger->pushProcessor(new \Monolog\Processor\WebProcessor());
$logger->pushHandler(new \Monolog\Handler\StreamHandler($container['path.storage'] . 'logs' . DIRECTORY_SEPARATOR . 'error.log'));
return $logger;
};
// Register 500 System Error handler
$container['errorHandler'] = function () use($container) {
$errorHandler = new \Core\Handlers\Error($container['config']['app.debug']);
if (isset($container['logger'])) {
$errorHandler->setLogger($container['logger']);
}
return $errorHandler;
};
// Register 404 Not Found handler
$container['notFoundHandler'] = function () {
return new \Core\Handlers\NotFound();
};
// Register 405 Method Not Allowed handler
$container['notAllowedHandler'] = function () {
return new \Core\Handlers\NotAllowed();
};
// Register the specified providers.
$providers = $config['app.providers'];
foreach ($providers as $provider) {
$container->register(new $provider());
}
// Register facades which are shortcuts
// for accessing registered services.
Facade::setContainer($container);
}
protected function configureContainer(ContainerBuilder $builder)
{
//$builder->useAutowiring(false);
$builder->addDefinitions(__DIR__ . '/settings.php');
// Services
$services = [\Doctrine\DBAL\Connection::class => function (ContainerInterface $container) {
$config = new \Doctrine\DBAL\Configuration();
$connectionParams = array('dbname' => $container->get('db.name'), 'user' => $container->get('db.user'), 'password' => $container->get('db.pass'), 'host' => $container->get('db.host'), 'port' => $container->get('db.port'), 'charset' => 'utf8', 'driver' => 'pdo_mysql');
$dbh = \Doctrine\DBAL\DriverManager::getConnection($connectionParams, $config);
return $dbh;
}, \Psr\Log\LoggerInterface::class => function (ContainerInterface $container) {
$name = $container->get('logger.name');
$filepath = $container->get('logger.path');
$logger = new \Monolog\Logger($name);
$logger->pushProcessor(new \Monolog\Processor\UidProcessor());
$logger->pushHandler(new \Monolog\Handler\StreamHandler($filepath, \Monolog\Logger::DEBUG));
return $logger;
}];
$builder->addDefinitions($services);
}
$settings = $c->get('settings')['view'];
$view = new \Slim\Views\Twig($settings['template_path'], ['debug' => $settings['debug'], 'cache' => $settings['cache_path']]);
// Add extensions
$view->addExtension(new \Slim\Views\TwigExtension($c['router'], $c['request']->getUri()));
$view->addExtension(new Twig_Extension_Debug());
return $view;
};
// Flash messages
$container['flash'] = function ($c) {
return new \Slim\Flash\Messages();
};
// monolog
$container['logger'] = function ($c) {
$settings = $c->get('settings')['logger'];
$logger = new Monolog\Logger($settings['name']);
$logger->pushProcessor(new Monolog\Processor\UidProcessor());
$logger->pushHandler(new Monolog\Handler\StreamHandler($settings['path'], Monolog\Logger::DEBUG));
return $logger;
};
$container['facebook'] = function ($c) {
$settings = $c->get('settings')['facebook'];
$fb = new Facebook\Facebook(['app_id' => $settings['app_id'], 'app_secret' => $settings['app_secret'], 'default_graph_version' => $settings['default_graph_version']]);
return $fb;
};
// error handle
$container['errorHandler'] = function ($c) {
return function ($request, $response, $exception) use($c) {
$data = ['code' => $exception->getCode(), 'message' => $exception->getMessage(), 'file' => $exception->getFile(), 'line' => $exception->getLine(), 'trace' => explode("\n", $exception->getTraceAsString())];
return $c->get('response')->withStatus(500)->withHeader('Content-Type', 'application/json')->write(json_encode($data));
};
};
/**
* @return $this
*/
public function init()
{
$that = $this;
$dispatcher = $this->app->getDispatcher();
$monitor = $dispatcher->getMonitor();
// Configuration
$this->app->getConfig()->load($this->getPath() . '/config/settings.php')->load($this->getPath() . '/config/' . $this->app->getEnvironment() . '/settings.php');
// Auth
$this->app->single('core.auth', function () use($that) {
$em = $that->getApp()->get('core.entity.manager');
$session = $that->getApp()->get('core.session');
$space = new Session\Space($session, 'core.auth');
$auth = new Acl($em, $space);
$that->app->getConfig()->grab('auth')->inject($auth);
return $auth;
});
// Data cache
$this->app->single('core.cache.data', function () use($that) {
$config = $that->getApp()->getConfig()->grab('cache.data');
$cache = $that->getCache($config);
return $cache;
});
// Accelerator cache
$this->app->single('core.cache.accelerator', function () use($that) {
$config = $that->getApp()->getConfig()->grab('cache.accelerator');
$cache = $that->getCache($config);
return $cache;
});
// Entity manager
$this->app->single('core.entity.manager', function () use($that) {
$config = $that->getApp()->getConfig();
$dataCache = $that->getApp()->get('core.cache.data');
$acceleratorCache = $that->getApp()->get('core.cache.accelerator');
$cfg = new \Doctrine\ORM\Configuration();
$cfg->setResultCacheImpl($dataCache);
$cfg->setMetadataCacheImpl($acceleratorCache);
$cfg->setQueryCacheImpl($acceleratorCache);
$cfg->setProxyDir($config->get('cache.proxyDir'));
$cfg->setProxyNamespace('Proxies');
$cfg->setSQLLogger(new \Doctrine\DBAL\Logging\DebugStack());
$paths = $that->getApp()->findPaths('Entity');
$driverImpl = $cfg->newDefaultAnnotationDriver($paths);
$cfg->setMetadataDriverImpl($driverImpl);
$conn = \Doctrine\DBAL\DriverManager::getConnection($config->get('db')->getData(), $cfg, new \Doctrine\Common\EventManager());
$em = new Entity\Manager($that->getApp(), $conn, $cfg, $conn->getEventManager());
return $em;
});
// Session
$this->app->single('core.session', function () use($that) {
$session = new Session();
$that->getApp()->getConfig()->grab('session')->inject($session);
return $session;
});
// Resource manager
$this->app->single('core.resource.manager', function () use($that) {
$rm = new Resource\Manager();
$that->getApp()->getConfig()->grab('resource.manager')->inject($rm);
return $rm;
});
// Asset manager
$this->app->single('core.am', function () use($that) {
$am = new Asset\Manager($that->getApp());
$that->getApp()->getConfig()->grab('asset.manager')->inject($am);
return $am;
});
// Browser console output
$this->app->single('core.console', function () {
$log = new \Monolog\Logger('console');
$log->pushHandler(new \Monolog\Handler\ChromePHPHandler());
$log->pushHandler(new \Monolog\Handler\FirePHPHandler());
return $log;
});
// Request tracker
$this->app->single('core.tracker', function () use($that) {
$request = $that->getApp()->getRequest();
$session = $that->getApp()->get('core.session');
$space = new Session\Space($session, 'core.tracker');
$tracker = new Tracker($space, $request);
$that->getApp()->getConfig()->grab('tracker')->inject($tracker);
return $tracker;
});
// Logger
$this->app->single('core.log', function () use($that) {
$config = $that->getApp()->getConfig();
$env = $that->getApp()->getEnvironment();
$log = new \Monolog\Logger('log');
$log->pushHandler(new \Monolog\Handler\StreamHandler($config->get('log.app')));
$log->pushProcessor(new \Monolog\Processor\WebProcessor());
$log->pushProcessor(new \Monolog\Processor\MemoryUsageProcessor());
$log->pushProcessor(new \Monolog\Processor\IntrospectionProcessor());
if (in_array($env, array(App::DEVELOPMENT))) {
$log->pushHandler(new \Monolog\Handler\ChromePHPHandler());
$log->pushHandler(new \Monolog\Handler\FirePHPHandler());
}
return $log;
});
// Locale
$this->app->set('core.locale', function () use($that) {
$code = $that->getApp()->getContext()->getLocale()->getActive();
$locale = $that->getApp()->get('core.entity.manager')->getRepository('Cms\\Entity\\System\\Locale')->findOneByCode($code);
return $locale;
});
$this->app->set('core.locale.switcher', function () use($that) {
$locale = $that->getApp()->getContext()->getLocale();
$session = $that->getApp()->get('core.session');
$space = new Session\Space($session, 'core.locale.switcher');
$switcher = new Switcher($locale, $space);
$that->getApp()->getConfig()->grab('locale.switcher')->inject($switcher);
return $switcher;
});
// Dispatcher events
$monitor->listen(Dispatcher::STARTED, function () use($that) {
$switcher = $that->getApp()->get('core.locale.switcher');
$switcher->remember();
});
$monitor->listen(Dispatcher::ROUTE_FOUND, function () use($that) {
$dispatcher = $that->getApp()->getDispatcher();
$route = $dispatcher->getRoute();
$auth = $that->getApp()->get('core.auth');
if (!$auth->isAccessible($route)) {
$dispatcher->forceRoute('site-error-unauthorized');
}
});
$monitor->listen(Dispatcher::ENDED, function () use($that) {
$app = $that->getApp();
$tracker = $that->getApp()->get('core.tracker');
$tracker->track();
if ($that->getApp()->getEnvironment() == App::DEVELOPMENT) {
$em = $app->get('core.entity.manager');
$console = $app->get('core.console');
$sql = $em->getConfiguration()->getSQLLogger();
foreach ($sql->queries as $query) {
$data = array('params' => $query['params'], 'types' => $query['types']);
$console->debug($query['sql'], $data);
}
}
});
return $this;
}
/**
* Push the log message and context information into Mongo
*
* @param string $level Logging level (ex. info, debug, notice...)
* @param string $message Log message
* @param array $context Extra context information
* @return boolean Success/fail of logging
*/
public function log($level, $message, array $context = array())
{
$logger = new \Monolog\Logger('audit');
try {
$handler = new \Monolog\Handler\MongoDBHandler(new \Mongo($this->getConnectString()), $this->getDbName(), $this->getDbCollection());
} catch (\MongoConnectionException $e) {
throw new \Exception('Cannot connect to Mongo - please check your server');
}
$logger->pushHandler($handler);
$logger->pushProcessor(function ($record) {
$record['datetime'] = $record['datetime']->format('U');
return $record;
});
return $logger->{$level}($message, $context);
}
return Utils::createClassInstance($class, $params);
};
}
foreach ($app->config['monolog.processors'] as $name => $params) {
$services["app.monolog.processors.{$name}"][] = function () use($name, $params, $app) {
$class = array_shift($params);
if (strpos($class, '\\') === false) {
$class = "Monolog\\Processor\\{$class}Processor";
}
return Utils::createClassInstance($class, $params);
};
}
foreach ($app->config['monolog.loggers'] as $name => $log_config) {
$services["app.monolog.{$name}"][] = function () use($name, $log_config, $app) {
$log_config += array('handlers' => array(), 'processors' => array());
$log = new \Monolog\Logger($name);
foreach ($log_config['handlers'] as $handler) {
$log->pushHandler($app["monolog.handlers.{$handler}"]);
}
foreach ($log_config['processors'] as $processor) {
$log->pushProcessor($app["monolog.processors.{$processor}"]);
}
return $log;
};
}
};
$hooks['app.exception'][0][] = function (ExceptionHandler $handler, \Exception $ex, App $app) {
if ($app->config['monolog.logExceptions']) {
$app->monolog__main->addError($ex);
}
};
/**
* Возвращает инстанс по имени
*
* @param string $sInstance
*
* @return mixed
* @throws Exception
*/
public function GetInstance($sInstance)
{
if (!isset($this->aInstances[$sInstance])) {
/**
* Создаем новый инстанс
*/
$aConfig = Config::Get('sys.logs.instances.' . $sInstance);
if (!$aConfig) {
throw new Exception("Log instance '{$sInstance}' not available");
}
$oInstance = new \Monolog\Logger($sInstance);
/**
* Список обработчиков
*/
foreach ($aConfig['handlers'] as $sHandler => $aParams) {
/**
* Формируем список параметром инициализации хендлера, учитываем только числовые ключи
*/
$aParamsInit = array();
foreach ($aParams as $k => $v) {
if (is_int($k)) {
if (in_array($v, $this->aLevels)) {
$v = $this->ConvertLevel($v);
}
$aParamsInit[] = $v;
}
}
$sHandler = ucfirst($sHandler);
$oRefClass = new ReflectionClass("Monolog\\Handler\\{$sHandler}Handler");
$oHandler = $oRefClass->newInstanceArgs($aParamsInit);
$oInstance->pushHandler($oHandler);
/**
* Устанавливаем формат логов
*/
if (isset($aParams['formatter'])) {
$aFormatter = $aParams['formatter'];
$sFormatterName = ucfirst(array_shift($aFormatter));
$oRefClass = new ReflectionClass("Monolog\\Formatter\\{$sFormatterName}Formatter");
$oFormatter = $oRefClass->newInstanceArgs($aFormatter);
$oHandler->setFormatter($oFormatter);
}
}
/**
* Список пре-обработчиков
*/
if (isset($aConfig['processors'])) {
foreach ($aConfig['processors'] as $sProcessors => $aParams) {
if (is_int($sProcessors)) {
$sProcessors = $aParams;
$aParams = array();
}
$sProcessors = ucfirst($sProcessors);
$sClass = "Monolog\\Processor\\{$sProcessors}Processor";
if ($aParams) {
$oRefClass = new ReflectionClass($sClass);
$oProcessors = $oRefClass->newInstanceArgs($aParams);
} else {
// for bug PHP 5.3.3 https://bugs.php.net/bug.php?id=52854
$oProcessors = new $sClass();
}
$oInstance->pushProcessor($oProcessors);
}
}
$this->aInstances[$sInstance] = $oInstance;
}
return $this->aInstances[$sInstance];
}
<?php
/********************************************************************
* File to place other service providers of 3rd party dependencies. *
********************************************************************/
// register monolog dependency for logging
$app->singleton('logger', function ($app) {
extract($app->getConfig('logging'));
$logger = new \Monolog\Logger($channel);
// push each assigned handler
foreach ($handlers as $handler) {
$logger->pushHandler($handler);
}
// push each assigned processor
foreach ($processors as $processor) {
$logger->pushProcessor($handler);
}
return $logger;
});
<?php
// DIC configuration
$container = $app->getContainer();
// -----------------------------------------------------------------------------
// Service providers
// -----------------------------------------------------------------------------
// php-view
$container['view'] = function ($c) {
return new Slim\Views\PhpRenderer($c['settings']['view']['template_path']);
};
// monolog
$container['logger'] = function ($c) {
$logger = new Monolog\Logger($c['settings']['logger']['name']);
$logger->pushProcessor(new Monolog\Processor\MemoryPeakUsageProcessor());
$logger->pushProcessor(new Monolog\Processor\WebProcessor());
$handler = new Monolog\Handler\StreamHandler($c['settings']['logger']['path'], \Monolog\Logger::DEBUG);
$handler->setFormatter(new Monolog\Formatter\JsonFormatter());
$logger->pushHandler($handler);
$logger->pushHandler(new Monolog\Handler\ErrorLogHandler());
return $logger;
};
// error handler
$container['errorHandler'] = function ($c) {
return new Lib\ApiError($c['logger']);
};
// not found handler
$container['notFoundHandler'] = function ($c) {
return new Lib\ApiNotFound($c['logger']);
};
// not allowed handler
}
closedir($handle);
}
*/
session_start();
//подключаем локализацию
//$lang = \ZippyERP\System\System::getLang();
//require_once _ZIPPY ."lang/{$lang}.php";
/*
foreach ($modules as $module) {
$file = $modulespath .$module ."/lang/{$lang}.php";
if(file_exists($file)){
require_once $file;
}
}
*/
// логгер
$logger = new \Monolog\Logger("main");
$dateFormat = "Y n j, g:i a";
//$output = "%datetime% > %level_name% > %message% %context% %extra%\n";
$output = "%datetime% %level_name% : %message% \n";
$formatter = new \Monolog\Formatter\LineFormatter($output, $dateFormat);
$h1 = new \Monolog\Handler\RotatingFileHandler(_ROOT . "logs/app.log", 10, $_config['common']['loglevel']);
$h2 = new \Monolog\Handler\RotatingFileHandler(_ROOT . "logs/error.log", 10, 400);
$h1->setFormatter($formatter);
$h2->setFormatter($formatter);
$logger->pushHandler($h1);
$logger->pushHandler($h2);
$logger->pushProcessor(new \Monolog\Processor\IntrospectionProcessor());
@mkdir(_ROOT . "logs");
/**
*
*/
private function initLoggers()
{
$logger = new \Monolog\Logger(self::$logger);
if (WP_DEBUG) {
$logger->pushHandler(new \Monolog\Handler\StreamHandler(self::$logDir . '/jigoshop.debug.log', \Monolog\Logger::DEBUG));
}
$logger->pushHandler(new \Monolog\Handler\StreamHandler(self::$logDir . '/jigoshop.log', \Monolog\Logger::WARNING));
$logger->pushProcessor(new \Monolog\Processor\IntrospectionProcessor());
$logger->pushProcessor(new \Monolog\Processor\WebProcessor());
\Monolog\Registry::addLogger($logger);
}
