/**
* Add a filter to log/not log messages of a specific type.
* Fluent interface.
*
* @param string $type Filter type, action may be negated by prefixing it with '!'
* @param boolean $action Q\Log::FILTER_* constant
* @return Log
*/
public function setFilter($type, $action = LOG::FILTER_INCLUDE)
{
if ($type[0] == '!') {
$action = !$action;
$type = substr($type, 1);
}
if ($action == LOG::FILTER_EXCLUDE) {
trigger_error("Filters to exclude types aren't supported in Zend_Log.", E_USER_WARNING);
return;
}
$priority = isset($this->alias[$type]) ? $this->alias[$type] : $this->alias[null];
$filter = new \Zend_Log_Filter_Priority($priority);
$this->zendlog->addFilter($filter);
}
/**
* return Zend_Log
*/
protected function _getLogger()
{
if (!$this->_logger instanceof Zend_Log) {
$config = $this->_getConfig();
$this->_logger = new Zend_Log();
$this->_logger->addWriter(new Zend_Log_Writer_Stream($config->general->logfile ? $config->general->logfile : STDOUT));
$this->_logger->addFilter(new Zend_Log_Filter_Priority((int) $config->general->loglevel));
}
return $this->_logger;
}
function testShouldLogMissingSkuOncePerLine()
{
$importer = $this->mappingsImporterFromData('sku,make,model,year_range' . "\n" . 'sku1,honda,civic,2000-2001');
$writer = new Zend_Log_Writer_Mock();
$logger = new Zend_Log($writer);
$logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::NOTICE));
$importer->setLog($logger);
$importer->import();
$this->assertEquals(1, count($writer->events));
}
/**
* Factory to construct the Zend_Log and add writers based on the
* configuration
*
* $config can be an array of an instance of Zend_Config
*
* @param mixed $config Array or instance of Zend_Config
* @return Zend_Log
*/
public static function factory($config = array())
{
// check config param
if ($config instanceof Zend_Config) {
$config = $config->toArray();
} else {
if (!is_array($config)) {
throw new BazeZF_Framework_Log_Exception(sprintf('%s::%s first param must be an array or instance of Zend_Config', __CLASS__, __FUNC__));
}
}
// Do we have one or more writers configured?
if (!is_array(current($config))) {
$config = array($config);
}
$logger = new Zend_Log();
// load priority
if (isset($config['priorities'])) {
foreach ($config['priorities'] as $priorityName => $priority) {
// convert priority const has integer
if (!is_numeric($priority)) {
$priority = constant($priority);
}
$logger->addPriority($priorityName, (int) $priority);
}
}
// load writers
if (isset($config['writers'])) {
foreach ($config['writers'] as $writer) {
// skip disabled writer
if (isset($writer['enable']) && !$writer['enable']) {
continue;
}
$writerObj = self::_loadWriter($writer['writerName'], isset($writer['writerParams']) ? $writer['writerParams'] : array());
// load writer filters
if (isset($writer['filterName'])) {
$filterObj = self::_loadFilter($writer['filterName'], isset($writer['filterParams']) ? $writer['filterParams'] : array());
$writerObj->addFilter($filterObj);
}
$logger->addWriter($writerObj);
}
}
// load writer filters
if (isset($config['filters'])) {
foreach ($config['filters'] as $filter) {
$filterObj = self::_loadFilter($filter['filterName'], isset($filter['filterParams']) ? $filter['filterParams'] : array());
$logger->addFilter($filterObj);
}
}
// add default writer if no writer was added
if (!isset($writerObj)) {
$writer = new Zend_Log_Writer_Null();
$logger->addWriter($writer);
}
return $logger;
}
/**
* lees de opties uit application.ini en maak een log-object aan dat in de
* registry wordt gezet. Deze is vanuit de hele code te gebruiken voor debug-logging
* @return Zend_Log
*/
public function getLogger()
{
if (null === $this->_logger) {
$options = $this->getOptions();
if (!isset($options['debuglog'])) {
throw new Exception("Debug log path undefined in application.ini");
}
try {
$writer = new Zend_Log_Writer_Stream($options['debuglog']);
$this->_logger = new Zend_Log($writer);
} catch (Exception $e) {
$this->_logger = null;
}
if (isset($options['firebug']) && "1" == $options['firebug']) {
try {
$writer = new Zend_Log_Writer_Firebug();
if (null !== $this->_logger) {
$this->_logger->addWriter($writer);
} else {
$this->_logger = new Zend_Log($writer);
}
} catch (Exception $e) {
$this->_logger = null;
}
}
// voeg eventueel een uitvoer filter toe
if (null !== $this->_logger && isset($options['loglevel'])) {
try {
$loglevel = intVal($options['loglevel']);
$filter = new Zend_Log_Filter_Priority($loglevel);
$this->_logger->addFilter($filter);
} catch (Exception $e) {
}
}
}
// voeg toe aan de registry zodat we deze later eenvoudig kunnen gebruiken
if (null !== $this->_logger) {
$this->_logger->info('==========================================================');
Zend_Registry::set('logger', $this->_logger);
}
return $this->_logger;
}
function testShouldLogCorrectLineNumber()
{
$importer = $this->vehiclesListImporter('make,model,year' . "\n" . 'honda,civic,2000' . "\n" . 'honda,,2000');
$writer = new Zend_Log_Writer_Mock();
$logger = new Zend_Log($writer);
$logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::NOTICE));
$importer->setLog($logger);
$importer->import();
$event = $writer->events[0];
$this->assertEquals('Line(2) Blank Model', $event['message']);
}
function testShouldNotLogErrorsForUniversalRecord()
{
$importer = $this->mappingsImporterFromData('sku, make, model, year, universal
"sku","","","","1"');
$importer->import();
$writer = new Zend_Log_Writer_Mock();
$logger = new Zend_Log($writer);
$logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::NOTICE));
$importer->setLog($logger);
$importer->import();
$this->assertEquals(0, count($writer->events));
}
/**
* Setup the logging
*/
protected function _initLogging()
{
$this->bootstrap('frontController');
$logger = new Zend_Log();
$writer = 'production' == $this->getEnvironment() ? new Zend_Log_Writer_Stream(APPLICATION_PATH . '/../data/log/app.log') : new Zend_Log_Writer_Firebug();
$logger->addWriter($writer);
if ('production' == $this->getEnvironment()) {
$filter = new Zend_Log_Filter_Priority(Zend_Log::CRIT);
$logger->addFilter($filter);
}
$this->_logger = $logger;
Zend_Registry::set('log', $logger);
}
/**
* Sets up the fixture, for example, opens a network connection.
* This method is called before a test is executed.
*
* @access protected
*/
protected function setUp()
{
if (class_exists('Zend_Log') === false) {
$this->markTestSkipped('Class \\Zend_Log not found');
}
$writer = new \Zend_Log_Writer_Stream('error.log');
$formatter = new \Zend_Log_Formatter_Simple('log: %message%' . PHP_EOL);
$writer->setFormatter($formatter);
$logger = new \Zend_Log($writer);
$filter = new \Zend_Log_Filter_Priority(\Zend_Log::INFO);
$logger->addFilter($filter);
$this->object = new \Aimeos\MW\Logger\Zend($logger);
}
/**
* @return Esendex_Sms_Model_Logger_Logger
*/
public static function getInstance()
{
if (static::$logger) {
return static::$logger;
}
$file = sprintf('%s/%s', Mage::getBaseDir('log'), static::LOG_FILE);
$logger = new Zend_Log(new Zend_Log_Writer_Stream($file));
if (!Mage::getStoreConfig('esendex_sms/sms/debug_mode')) {
$logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::CRIT));
}
static::$logger = new Esendex_Sms_Model_Logger_Logger($logger);
return static::$logger;
}
/**
* init config
*/
protected function _initLogger()
{
$this->_logger = new Zend_Log();
if ($this->_config->logfile) {
$writer = new Zend_Log_Writer_Stream($this->_config->logfile);
} else {
$writer = new Zend_Log_Writer_Null();
}
$this->_logger->addWriter($writer);
if ($this->_config->loglevel) {
$filter = new Zend_Log_Filter_Priority($this->_config->loglevel);
$this->_logger->addFilter($filter);
}
}
/**
* Hook into the pimcore logger using the Pimcore\Console\Log\Writer
*
* @param int $filterPriority
*/
protected function initializePimcoreLogging($filterPriority = \Zend_Log::INFO)
{
$writer = new Writer($this->output);
$logger = new \Zend_Log($writer);
if ($this->output->isVerbose()) {
$filterPriority = null;
}
if (null !== $filterPriority) {
$logger->addFilter(new \Zend_Log_Filter_Priority($filterPriority));
}
// the filter handles verbosity
\Logger::setVerbosePriorities();
\Logger::addLogger($logger);
}
protected function _initMyLoggingSettings()
{
$logger = new Zend_Log();
$logger->addFilter(new Zend_Log_Filter_Priority((int) $this->_options["logging"]["level"]));
foreach ($this->_options["logging"]["writer"] as $wr) {
if ($wr == "Zend_Log_Writer_Stream") {
$w = new $wr($this->_options["logging"]["filename"]);
$logger->addWriter($w);
} else {
$logger->addWriter(new $wr());
}
}
Zend_Registry::set("logger", $logger);
}
/**
* test pw replacements
*/
public function testPWReplacements()
{
$config = Tinebase_Core::getConfig();
$logfile = tempnam(Tinebase_Core::getTempDir(), 'testlog');
$writer = new Zend_Log_Writer_Stream($logfile);
$formatter = new Tinebase_Log_Formatter();
$formatter->addReplacement($config->database->password);
$writer->setFormatter($formatter);
$this->_logger->addWriter($writer);
$filter = new Zend_Log_Filter_Priority(5);
$this->_logger->addFilter($filter);
$this->_logger->notice($config->database->password);
$loggerFile = file_get_contents($logfile);
$writer->shutdown();
unlink($logfile);
$this->assertFalse(strpos($loggerFile, $config->database->password), 'pw found!');
$this->assertContains('********', $loggerFile);
if ($config->logger->logruntime || $config->logger->logdifftime) {
$this->assertTrue(preg_match('/' . Tinebase_Core::getUser()->accountLoginName . ' \\d/', $loggerFile) === 1);
} else {
$this->assertContains(Tinebase_Core::getUser()->accountLoginName . ' - ', $loggerFile);
}
}
/**
* make new logger, configuration is taken from system_config, section $instanceName
* @param string $instanceName
* @param string $application
*/
protected function __construct($instanceName, $application = null)
{
if ($instanceName === null) {
throw new Exception(__METHOD__ . ': expected an instance name, got none');
}
$config = Config::getInstance(SYSTEM_CONFIG);
$log_config = $config->{$instanceName};
$this->log = new Zend_Log();
if (isset($log_config->file) && intval($log_config->file->enabled) !== 0) {
$file_logger = new Zend_Log_Writer_Stream($log_config->file->name);
/**
*
$format = Zend_Log_Formatter_Simple::DEFAULT_FORMAT;
$formatter = new Zend_Log_Formatter_Simple($format);
$file_logger->setFormatter($formatter);
*/
if (isset($application) && $application != '') {
$this->log->setEventItem('application', $application);
}
$formatter = new Zend_Log_Formatter_Simple('%syslog_time% %application%[%pid%]: %priorityName%: %message%' . PHP_EOL);
$file_logger->setFormatter($formatter);
$this->log->addWriter($file_logger);
}
if (isset($log_config->syslog) && intval($log_config->syslog->enabled) !== 0) {
$param = array('facility' => $log_config->syslog->facility);
if (isset($application) && $application != '') {
$param['application'] = $application;
}
$sys_logger = new Zend_Log_Writer_Syslog($param);
$formatter = new Zend_Log_Formatter_Simple('%priorityName%: %message%' . PHP_EOL);
$sys_logger->setFormatter($formatter);
$this->log->addWriter($sys_logger);
}
$filter = new Zend_Log_Filter_Priority(intval($log_config->priority));
$this->log->addFilter($filter);
}
/**
* Constructor. Sets writer and filter for log.
*/
function __construct()
{
if (Daiquiri_Config::getInstance()->core->log->enabled && php_sapi_name() !== 'cli') {
// configure formatter for log
$ip = Daiquiri_Auth::getInstance()->getRemoteAddr();
$username = Daiquiri_Auth::getInstance()->getCurrentUSername();
$formatstring = '%timestamp% ' . $ip . ' "' . $username . '" %priorityName% "%message%"' . PHP_EOL;
$formatter = new Zend_Log_Formatter_Simple($formatstring);
// open log file and get writer for log
$stream = @fopen(Daiquiri_Config::getInstance()->core->log->logfile, 'a', false);
if (!$stream) {
throw new Exception('Failed to open log file');
}
$writer = new Zend_Log_Writer_Stream($stream);
$writer->setFormatter($formatter);
// set loglevel
$loglevel = strtoupper(Daiquiri_Config::getInstance()->core->log->loglevel);
$filter = new Zend_Log_Filter_Priority(constant("Zend_Log::{$loglevel}"));
// configure log object
$this->_log = new Zend_Log();
$this->_log->addWriter($writer);
$this->_log->addFilter($filter);
}
}
/**
* Initialisiert bei jedem Request das Zend_Log Objekt
*/
public function bootstrap()
{
$configLog = new Dragon_Application_Config('dragonx/log/log');
$logger = new Zend_Log();
foreach ($configLog->eventitems as $name => $value) {
$logger->setEventItem($name, $value);
}
foreach ($configLog->writers as $writer) {
$logger->addWriter($writer);
}
foreach ($configLog->filters as $filter) {
$logger->addFilter($filter);
}
Zend_Registry::set('Zend_Log', $logger);
}
/**
* Constructor function.
*
* For all the defined filenames for log constant,
* will create a Zend_Log object
* with the path to the filename and a filter for these log.
*
* @param Zend_Config $config Object contain the user configuration.
*
* @return void
*/
public function __construct(Zend_Config $config)
{
parent::__construct();
$this->_loggers = array();
if (isset($config->log)) {
foreach ($config->log as $key => $val) {
$constant = "self::" . strtoupper($key);
if (defined($constant)) {
$priority = constant($constant);
$logger = new Zend_Log(new Zend_Log_Writer_Stream($val->filename));
$logger->addFilter(new Zend_Log_Filter_Priority($priority));
$this->_loggers[] = $logger;
}
}
}
}
protected function _initLogging()
{
// logging bootstrap resource depends on the front controller
$this->bootstrap('frontController');
// creating an instance of Zend_Log with set up of different environments
$logger = new Zend_Log();
$writer = 'production' == $this->getEnvironment() ? new Zend_Log_Writer_Stream(APPLICATION_PATH . '/../data/logs/app.log') : new Zend_Log_Writer_Firebug();
$logger->addWriter($writer);
// filtering for critial issues only under production environment
if ('production' == $this->getEnvironment()) {
$filter = new Zend_Log_Filter_Priority(Zend_Log::CRIT);
$logger->addFilter($filter);
}
// assigning the logger to a propected property of Bootstrap
$this->_logger = $logger;
Zend_Registry::set('log', $logger);
}
/**
* set logger
*/
protected function _setLog()
{
if (null === self::$_log) {
self::$_log = new SP_Log();
self::$_log->setEventItem('pid', getmypid());
$format = '%timestamp% pid(%pid%) %priorityName% (%priority%): %message%' . PHP_EOL;
$formatter = new Zend_Log_Formatter_Simple($format);
$log_file = SP_APP_PATH . DIRECTORY_SEPARATOR . 'log/log.txt';
$writer_file = new Zend_Log_Writer_Stream($log_file);
$writer_file->setFormatter($formatter);
$writer_firebug = new Zend_Log_Writer_Firebug();
self::$_log->addWriter($writer_file);
self::$_log->addWriter($writer_firebug);
self::$_log->addFilter(new Zend_Log_Filter_Priority(Zend_Log::INFO));
}
Zend_Registry::set('logger', self::$_log);
}
private static function _createLogger()
{
// get config
$config = MyProject::registry('config');
// disabled log
if (!$config->log->enable) {
return false;
}
// init logger
$logger = new Zend_Log();
// add default priority for
$dbProfilerLogPriority = 8;
$logger->addPriority('TABLE', $dbProfilerLogPriority);
// add priority per components
$componentsEnables = $config->log->components->toArray();
$components = array('DBCOLLECTION' => BaseZF_DbCollection::LOG_PRIORITY, 'DBITEM' => BaseZF_DbItem::LOG_PRIORITY, 'DBQUERY' => BaseZF_DbQuery::LOG_PRIORITY);
foreach ($components as $name => $priority) {
$logger->addPriority($name, $priority);
if (!$componentsEnables[strtolower($name)] && isset($componentsEnables[strtolower($name)])) {
$filter = new Zend_Log_Filter_Priority($priority, '!=');
$logger->addFilter($filter);
}
}
// add stream writer
if ($config->log->writers->stream->enable) {
$writer = new Zend_Log_Writer_Stream($config->log->writers->stream->path);
$logger->addWriter($writer);
}
// add firebug writer
if ($config->log->writers->firebug->enable) {
$writer = new Zend_Log_Writer_Firebug();
$writer->setPriorityStyle($dbProfilerLogPriority, 'TABLE');
$logger->addWriter($writer);
}
// add default writer if no writer was added
if (!isset($writer)) {
$writer = new Zend_Log_Writer_Null();
$logger->addWriter($writer);
}
return $logger;
}
/**
* Setup the logging
*/
protected function _initLogging()
{
$this->bootstrap('frontController');
$this->bootstrap('config');
$logger = new Zend_Log();
// $writer = 'production' == $this->getEnvironment() ?
// new Zend_Log_Writer_Stream(APPLICATION_PATH . '/../data/logs/app.log') :
// new Zend_Log_Writer_Firebug();
// $logger->addWriter($writer);
$config = $this->getResource('config');
$writer = new Zend_Log_Writer_Stream($config["log"]["file"]);
$writer->setFormatter(new Reg2_Log_Formatter($config["log"]["format"]));
$logger->addWriter($writer);
if ('production' == $this->getEnvironment()) {
$filter = new Zend_Log_Filter_Priority(Zend_Log::INFO);
$logger->addFilter($filter);
}
$this->_logger = $logger;
Zend_Registry::set('log', $logger);
$logger->debug("Start logging");
return $logger;
}
/**
* Returns a logger and ensure that there is only one instance created in the process
*
* @access public
* @static
* @param Zend_Log_Writer Child of Zend_Log_Writer
* @param boolean $isDefault Indicates if this logger is the default one to use
*
*/
public static function registerLogger($loggerName, $zendWriter = null, $zendFilter = null, $isDefault = false)
{
if (!isset(self::$instances[$loggerName])) {
$logger = new Zend_Log($zendWriter);
if ($zendFilter) {
$logger->addFilter($zendFilter);
}
self::$instances[$loggerName] = $logger;
//$filter = new Zend_Log_Filter_Priority(Zend_Log::CRIT);
//
}
// If we weren't told this is the default logger yet none exists then force it
if (!self::getDefaultLoggerName() and !$isDefault) {
$isDefault = true;
}
if ($isDefault) {
if (isset(self::$defaultLogger)) {
return;
//throw new Exception('Default logger is already defined');
}
self::$defaultLogger = $loggerName;
}
}
/**
* init logger
*
* @return void
*/
protected function _initLogger()
{
$writer = new Zend_Log_Writer_Stream(Zend_Registry::get('config')->logger->path);
$this->logger = new Zend_Log($writer);
// set priority
switch (strtoupper(Zend_Registry::get('config')->logger->level)) {
case 'EMERG':
$level = Zend_Log::EMERG;
break;
case 'ALERT':
$level = Zend_Log::ALERT;
break;
case 'CRIT':
$level = Zend_Log::CRIT;
break;
case 'ERR':
$level = Zend_Log::ERR;
break;
case 'WARN':
$level = Zend_Log::WARN;
break;
case 'NOTICE':
$level = Zend_Log::NOTICE;
break;
case 'INFO':
$level = Zend_Log::INFO;
break;
case 'DEBUG':
$level = Zend_Log::DEBUG;
break;
}
$this->logger->addFilter(new Zend_Log_Filter_Priority($level));
// save logger for further use
Zend_Registry::set('logger', $this->logger);
return $this->logger;
}
/**
* Make sure if we enable logging that the Zend_Log class
* is available.
* Create a default log object if none is set.
*
* @throws Zend_Cache_Exception
* @return void
*/
protected function _loggerSanity()
{
if (!isset($this->_directives['logging']) || !$this->_directives['logging']) {
return;
}
if (isset($this->_directives['logger'])) {
if ($this->_directives['logger'] instanceof Zend_Log) {
return;
}
Zend_Cache::throwException('Logger object is not an instance of Zend_Log class.');
}
// Create a default logger to the standard output stream
require_once 'Zend/Log.php';
require_once 'Zend/Log/Writer/Stream.php';
require_once 'Zend/Log/Filter/Priority.php';
$logger = new Zend_Log(new Zend_Log_Writer_Stream('php://output'));
$logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::WARN, '<='));
$this->_directives['logger'] = $logger;
}
/**
* Make sure if we enable logging that the Zend_Log class
* is available.
* Create a default log object if none is set.
*
* @throws Zend_Cache_Exception
* @return void
*/
protected function _loggerSanity()
{
if (!isset($this->_options['logging']) || !$this->_options['logging']) {
return;
}
if (isset($this->_options['logger']) && $this->_options['logger'] instanceof Zend_Log) {
return;
}
// Create a default logger to the standard output stream
require_once 'Zend/Log.php';
require_once 'Zend/Log/Writer/Stream.php';
require_once 'Zend/Log/Filter/Priority.php';
$logger = new Zend_Log(new Zend_Log_Writer_Stream('php://output'));
$logger->addFilter(new Zend_Log_Filter_Priority(Zend_Log::WARN, '<='));
$this->_options['logger'] = $logger;
}
/**
* Do general setup for a CLI script
* @param array $pa_additional_parameters Additional command line parameters. You don't have to add
* --log/-l for the log file and --log-level/-d for the Zend_Log log level. They're always set up automatically
* @return Zend_Console_Getopt
*/
function caSetupCLIScript($pa_additional_parameters)
{
require_once __CA_LIB_DIR__ . "/core/Zend/Console/Getopt.php";
require_once __CA_LIB_DIR__ . "/core/Zend/Log.php";
require_once __CA_LIB_DIR__ . "/core/Zend/Log/Writer/Stream.php";
require_once __CA_LIB_DIR__ . "/core/Zend/Log/Writer/Syslog.php";
require_once __CA_LIB_DIR__ . "/core/Zend/Log/Formatter/Simple.php";
$va_available_cli_opts = array_merge(array("log|l-s" => "Path to log file. If omitted, we log into the system log. Note that we don't log DEBUG messages into the system log, even when the log level is set to DEBUG.", "log-level|d-s" => "Log level"), $pa_additional_parameters);
try {
$o_opts = new Zend_Console_Getopt($va_available_cli_opts);
$o_opts->parse();
} catch (Exception $e) {
die("Invalid command line options: " . $e->getMessage() . PHP_EOL);
}
// set up logging
$o_writer = null;
if ($vs_log = $o_opts->getOption('log')) {
// log to file
try {
$o_writer = new Zend_Log_Writer_Stream($vs_log);
$o_writer->setFormatter(new Zend_Log_Formatter_Simple('%timestamp% %priorityName%: %message%' . PHP_EOL));
} catch (Zend_Log_Exception $e) {
// error while opening the file (usually permissions)
$o_writer = null;
print CLIUtils::textWithColor("Couldn't open log file. Now logging via system log.", "bold_red") . PHP_EOL . PHP_EOL;
}
}
// default: log everything to syslog
if (!$o_writer) {
$o_writer = new Zend_Log_Writer_Syslog(array('application' => 'CollectiveAccess CLI', 'facility' => LOG_USER));
// no need for timespamps in syslog ... the syslog itsself provides that
$o_writer->setFormatter(new Zend_Log_Formatter_Simple('%priorityName%: %message%' . PHP_EOL));
}
// was a loglevel set via command line? -> add filter to Zend logger, otherwise use WARN
$vs_level = $o_opts->getOption('log-level');
switch ($vs_level) {
case 'ERR':
$o_filter = new Zend_Log_Filter_Priority(Zend_Log::ERR);
break;
case 'DEBUG':
$o_filter = new Zend_Log_Filter_Priority(Zend_Log::DEBUG);
break;
case 'INFO':
$o_filter = new Zend_Log_Filter_Priority(Zend_Log::INFO);
break;
case 'WARN':
default:
$o_filter = new Zend_Log_Filter_Priority(Zend_Log::WARN);
break;
}
// set up global logger. can be used by importing 'global $g_logger' anywhere, but it's recommended to use the caCLILog() helper instead
global $g_logger;
$g_logger = new Zend_Log($o_writer);
$g_logger->setTimestampFormat('D Y-m-d H:i:s');
$g_logger->addFilter($o_filter);
return $o_opts;
}
/**
* Initialises the application
*
*/
public function init()
{
$__start = getmicrotime();
if (isset($this->config['log_file'])) {
$writer = new Zend_Log_Writer_Stream($this->config['log_file']);
$this->logger = new Zend_Log($writer);
if (isset($this->config['log_format'])) {
$formatter = new Zend_Log_Formatter_Simple($this->config['log_format']);
$writer->setFormatter($formatter);
}
// If not in debug mode, hide debug log messages
if (!ifset($this->config, 'debug', false)) {
$this->logger->addFilter(Zend_Log::NOTICE);
}
}
$this->recordStat('za::initlog', getmicrotime() - $__start);
$__start = getmicrotime();
$mailServer = $this->getConfig('smtp_server');
if (mb_strlen($mailServer)) {
ini_set('SMTP', $mailServer);
}
// Create a new view object.
$view = new CompositeView();
Zend_Registry::set(self::$ZEND_VIEW, $view);
/* @var Zend_Controller_Front $controller */
$this->frontController = Zend_Controller_Front::getInstance();
$this->frontController->setDispatcher(new InjectingDispatcher());
$this->frontController->addControllerDirectory($this->getConfig('controller_dir', 'controllers'), 'default');
$modules = ifset($this->config, 'modules', array());
foreach ($modules as $module) {
if (is_dir(APP_DIR . '/modules/' . $module)) {
$this->frontController->addControllerDirectory('modules/' . $module, $module);
}
}
$this->recordStat('za::initmodules', getmicrotime() - $__start);
$__start = getmicrotime();
$this->frontController->throwExceptions(ifset($this->config, 'debug', false) ? true : false);
if (isset($this->config['route_config']) && php_sapi_name() != 'cli') {
$router = $this->frontController->getRouter();
/* @var $router Zend_Controller_Router_Rewrite */
$config = new Zend_Config_Ini($this->config['route_config'], 'routes');
$router->addConfig($config, 'routes');
}
Zend_Controller_Action_HelperBroker::removeHelper('viewRenderer');
$this->frontController->setParam('noViewRenderer', true);
/**
* Set the session
*/
$session_name = str_replace(' ', '_', $this->config['name']);
Zend_Session::start(array('name' => $session_name));
$this->injector->addAutoProperty('log', $this->logger);
$__start = getmicrotime();
// $services = $this->loadDefaultServices();
$this->injector->addServiceDirectory(NOVEMBER_APP_DIR . '/services');
// $this->injector->loadServices($this->config['services']);
$this->recordStat('za::initdefaultservices', getmicrotime() - $__start);
$__start = getmicrotime();
//
// foreach ($services as $defaultService) {
// $this->injector->inject($defaultService);
// }
//
$this->recordStat('za::initinjectdefaultservices', getmicrotime() - $__start);
$__start = getmicrotime();
// Load extensions
$this->loadExtensions();
$this->injector->addServiceDirectory(ifset($this->config, 'services_dir', APP_DIR . '/services'));
$this->recordStat('za::initloadext', getmicrotime() - $__start);
$__start = getmicrotime();
$this->injector->loadServices($this->config['services']);
$this->recordStat('za::initloadservices', getmicrotime() - $__start);
$__start = getmicrotime();
// We know that there's definitely going to be an AuthService,
// so we can now go and load the user if there was one in
// the session.
$auth = $this->injector->getService('AuthService');
if (isset($this->getSession()->CURRENT_USER_TICKET) && mb_strlen($this->getSession()->CURRENT_USER_TICKET)) {
$auth->validateTicket($this->getSession()->CURRENT_USER_NAME, $this->getSession()->CURRENT_USER_TICKET);
}
$this->recordStat('za::initvalidateauth', getmicrotime() - $__start);
}
/**
* import from egroupware
*
* @param Zend_Console_Getopt $_opts
*/
public function importegw14($_opts)
{
$args = $_opts->getRemainingArgs();
if (count($args) < 1 || !is_readable($args[0])) {
echo "can not open config file \n";
echo "see tine20.org/wiki/EGW_Migration_Howto for details \n\n";
echo "usage: ./tine20.php --method=Appname.importegw14 /path/to/config.ini (see Tinebase/Setup/Import/Egw14/config.ini)\n\n";
exit(1);
}
try {
$config = new Zend_Config_Ini($args[0]);
if ($config->{strtolower($this->_applicationName)}) {
$config = $config->{strtolower($this->_applicationName)};
}
} catch (Zend_Config_Exception $e) {
fwrite(STDERR, "Error while parsing config file({$args['0']}) " . $e->getMessage() . PHP_EOL);
exit(1);
}
$writer = new Zend_Log_Writer_Stream('php://output');
$logger = new Zend_Log($writer);
$filter = new Zend_Log_Filter_Priority((int) $config->loglevel);
$logger->addFilter($filter);
$class_name = $this->_applicationName . '_Setup_Import_Egw14';
if (!class_exists($class_name)) {
$logger->ERR(__METHOD__ . '::' . __LINE__ . " no import for {$this->_applicationName} available");
exit(1);
}
try {
$importer = new $class_name($config, $logger);
$importer->import();
} catch (Exception $e) {
$logger->ERR(__METHOD__ . '::' . __LINE__ . " import for {$this->_applicationName} failed " . $e->getMessage());
}
}
/**
*
*/
protected function _getLoggerInstance()
{
static $logger;
if (!isset($logger)) {
$logger = new Zend_Log();
$formatter = new Zend_Log_Formatter_Simple("%timestamp% [" . getmypid() . "]: %priorityName% - %message%" . PHP_EOL);
// show errror only on quiet mode
if ($this->_isQuietMode()) {
$filter = new Zend_Log_Filter_Priority(Zend_Log::ERR, '=');
$logger->addFilter($filter);
}
// show debug only in debug mode
if (!$this->_isDebugMode()) {
$filter = new Zend_Log_Filter_Priority(Zend_Log::DEBUG, '!=');
$logger->addFilter($filter);
}
// show notice only in verbose
if (!$this->_isVerboseMode()) {
$filter = new Zend_Log_Filter_Priority(Zend_Log::NOTICE, '!=');
$logger->addFilter($filter);
}
// write on standart output
$writer = new Zend_Log_Writer_Stream('php://output');
$writer->setFormatter($formatter);
$logger->addWriter($writer);
// write on log file or syslog only if debug is disable
if (!$this->_isDebugMode()) {
// isset logFilePath write of specific file
if ($logFilePath = $this->_getLogFilePath()) {
$writer = new Zend_Log_Writer_Stream($logFilePath);
$writer->setFormatter($formatter);
$logger->addWriter($writer);
// else write on syslog
} else {
$writer = new Zend_Log_Writer_Syslog(array('application' => $this->_sctiptPath));
$writer->setFormatter($formatter);
$logger->addWriter($writer);
}
}
}
return $logger;
}
