374 lines
8.9 KiB
PHP
Executable File
374 lines
8.9 KiB
PHP
Executable File
<?php
|
|
// {{{ICINGA_LICENSE_HEADER}}}
|
|
/**
|
|
* This file is part of Icinga 2 Web.
|
|
*
|
|
* Icinga 2 Web - Head for multiple monitoring backends.
|
|
* Copyright (C) 2013 Icinga Development Team
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* @copyright 2013 Icinga Development Team <info@icinga.org>
|
|
* @license http://www.gnu.org/licenses/gpl-2.0.txt GPL, version 2
|
|
* @author Icinga Development Team <info@icinga.org>
|
|
*/
|
|
// {{{ICINGA_LICENSE_HEADER}}}
|
|
|
|
namespace Icinga\Application;
|
|
|
|
use Icinga\Protocol\Ldap\Exception;
|
|
use \Zend_Config;
|
|
use \Zend_Log;
|
|
use \Zend_Log_Filter_Priority;
|
|
use \Zend_Log_Writer_Abstract;
|
|
use \Zend_Log_Exception;
|
|
use \Icinga\Exception\ConfigurationError;
|
|
|
|
/**
|
|
* Singleton logger
|
|
*/
|
|
final class Logger
|
|
{
|
|
/**
|
|
* Default log type
|
|
*/
|
|
const DEFAULT_LOG_TYPE = "stream";
|
|
|
|
/**
|
|
* Default log target
|
|
*/
|
|
const DEFAULT_LOG_TARGET = "./var/log/icinga.log";
|
|
|
|
/**
|
|
* Default debug target
|
|
*/
|
|
const DEFAULT_DEBUG_TARGET = "./var/log/icinga.debug.log";
|
|
|
|
/**
|
|
* Array of writers
|
|
*
|
|
* @var array
|
|
*/
|
|
private $writers = array();
|
|
|
|
/**
|
|
* Instance of Zend_Log
|
|
*
|
|
* @var Zend_Log
|
|
*/
|
|
private $logger;
|
|
|
|
/**
|
|
* Singleton instance
|
|
*
|
|
* @var Logger
|
|
*/
|
|
private static $instance;
|
|
|
|
/**
|
|
* Queue of unwritten messages
|
|
*
|
|
* @var array
|
|
*/
|
|
private static $queue = array();
|
|
|
|
/**
|
|
* Flag indicate that errors occurred in the past
|
|
*
|
|
* @var bool
|
|
*/
|
|
private static $errorsOccurred = false;
|
|
|
|
/**
|
|
* Create a new logger object
|
|
*
|
|
* @param Zend_Config $config
|
|
*/
|
|
public function __construct(Zend_Config $config)
|
|
{
|
|
$this->overwrite($config);
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getWriters()
|
|
{
|
|
return $this->writers;
|
|
}
|
|
|
|
/**
|
|
* Overwrite config to initiated logger
|
|
*
|
|
* @param Zend_Config $config
|
|
*
|
|
* @return self
|
|
*/
|
|
public function overwrite(Zend_Config $config)
|
|
{
|
|
$this->clearLog();
|
|
try {
|
|
if ($config->debug && $config->debug->enable == '1') {
|
|
$this->setupDebugLog($config);
|
|
}
|
|
} catch (ConfigurationError $e) {
|
|
$this->warn('Could not create debug log: ' . $e->getMessage());
|
|
}
|
|
if ($config->get('enable', '1') != '0') {
|
|
$this->setupLog($config);
|
|
}
|
|
$this->flushQueue();
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Configure debug log
|
|
*
|
|
* @param Zend_Config $config
|
|
*/
|
|
private function setupDebugLog(Zend_Config $config)
|
|
{
|
|
$type = $config->debug->get("type", self::DEFAULT_LOG_TYPE);
|
|
$target = $config->debug->get("target", self::DEFAULT_LOG_TARGET);
|
|
if ($target == self::DEFAULT_LOG_TARGET) {
|
|
$type = self::DEFAULT_LOG_TYPE;
|
|
}
|
|
$this->addWriter($type, $target, Zend_Log::DEBUG);
|
|
}
|
|
|
|
/**
|
|
* Configure log
|
|
*
|
|
* @param Zend_Config $config
|
|
*/
|
|
private function setupLog(Zend_Config $config)
|
|
{
|
|
$type = $config->get("type", self::DEFAULT_LOG_TYPE);
|
|
$target = $config->get("target", self::DEFAULT_DEBUG_TARGET);
|
|
if ($target == self::DEFAULT_DEBUG_TARGET) {
|
|
$type = self::DEFAULT_LOG_TYPE;
|
|
}
|
|
$level = Zend_Log::WARN;
|
|
if ($config->get("verbose", 0) == 1) {
|
|
$level = Zend_Log::INFO;
|
|
}
|
|
$this->addWriter($type, $target, $level);
|
|
}
|
|
|
|
/**
|
|
* Add writer to log instance
|
|
*
|
|
* @param string $type Type, e.g. stream
|
|
* @param string $target Target, e.g. filename
|
|
* @param int $priority Value of Zend::* constant
|
|
* @throws ConfigurationError
|
|
*/
|
|
private function addWriter($type, $target, $priority)
|
|
{
|
|
$type[0] = strtoupper($type[0]);
|
|
$writerClass = "Zend_Log_Writer_" . $type;
|
|
|
|
if (!@class_exists($writerClass)) {
|
|
self::fatal(
|
|
'Could not add log writer of type "%s". Type does not exist.',
|
|
$type
|
|
);
|
|
return;
|
|
}
|
|
try {
|
|
|
|
$target = Config::resolvePath($target);
|
|
$writer = new $writerClass($target);
|
|
$writer->addFilter(new Zend_Log_Filter_Priority($priority));
|
|
// Make sure the permissions for log target file are correct
|
|
if ($type === 'Stream' && !file_exists($target)) {
|
|
touch($target);
|
|
chmod($target, 0664);
|
|
}
|
|
|
|
$this->logger->addWriter($writer);
|
|
$this->writers[] = $writer;
|
|
} catch (Zend_Log_Exception $e) {
|
|
self::fatal(
|
|
'Could not add log writer of type %s. An exception was thrown: %s',
|
|
$type,
|
|
$e->getMessage()
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flush pending messages to writer
|
|
*/
|
|
public function flushQueue()
|
|
{
|
|
try {
|
|
foreach (self::$queue as $msgTypePair) {
|
|
$this->logger->log($msgTypePair[0], $msgTypePair[1]);
|
|
}
|
|
} catch (Zend_Log_Exception $e) {
|
|
self::fatal(
|
|
'Could not flush logs to output. An exception was thrown: %s',
|
|
$e->getMessage()
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Format output message
|
|
*
|
|
* @param array $argv
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function formatMessage(array $argv)
|
|
{
|
|
if (count($argv) == 1) {
|
|
$format = $argv[0];
|
|
} else {
|
|
$format = array_shift($argv);
|
|
}
|
|
if (!is_string($format)) {
|
|
$format = json_encode($format);
|
|
}
|
|
foreach ($argv as &$arg) {
|
|
if (!is_string($arg)) {
|
|
$arg = json_encode($arg);
|
|
}
|
|
}
|
|
|
|
return @vsprintf($format, $argv);
|
|
}
|
|
|
|
/**
|
|
* Reset object configuration
|
|
*/
|
|
public function clearLog()
|
|
{
|
|
$this->logger = null;
|
|
$this->writers = array();
|
|
$this->logger = new Zend_Log();
|
|
}
|
|
|
|
/**
|
|
* Create an instance
|
|
*
|
|
* @param Zend_Config $config
|
|
*
|
|
* @return Logger
|
|
*/
|
|
public static function create(Zend_Config $config)
|
|
{
|
|
if (self::$instance) {
|
|
return self::$instance->overwrite($config);
|
|
}
|
|
return self::$instance = new Logger($config);
|
|
}
|
|
|
|
/**
|
|
* Log message with severity debug
|
|
*/
|
|
public static function debug()
|
|
{
|
|
self::log(self::formatMessage(func_get_args()), Zend_Log::DEBUG);
|
|
}
|
|
|
|
/**
|
|
* Log message with severity warn
|
|
*/
|
|
public static function warn()
|
|
{
|
|
self::log(self::formatMessage(func_get_args()), Zend_Log::WARN);
|
|
}
|
|
|
|
/**
|
|
* Log message with severity info
|
|
*/
|
|
public static function info()
|
|
{
|
|
self::log(self::formatMessage(func_get_args()), Zend_Log::INFO);
|
|
}
|
|
|
|
/**
|
|
* Log message with severity error
|
|
*/
|
|
public static function error()
|
|
{
|
|
self::log(self::formatMessage(func_get_args()), Zend_Log::ERR);
|
|
}
|
|
|
|
/**
|
|
* Log message with severity fatal
|
|
*/
|
|
public static function fatal()
|
|
{
|
|
self::log(self::formatMessage(func_get_args()), Zend_Log::EMERG);
|
|
}
|
|
|
|
/**
|
|
* Log message
|
|
*
|
|
* @param string $msg Message
|
|
* @param int $level Log level
|
|
*/
|
|
private static function log($msg, $level = Zend_Log::INFO)
|
|
{
|
|
$logger = self::$instance;
|
|
|
|
if ($level < Zend_Log::WARN && self::$errorsOccurred === false) {
|
|
self::$errorsOccurred =true;
|
|
}
|
|
|
|
if (!$logger || !count($logger->getWriters())) {
|
|
array_push(self::$queue, array($msg, $level));
|
|
return;
|
|
}
|
|
|
|
$logger->logger->log($msg, $level);
|
|
}
|
|
|
|
/**
|
|
* Flag if messages > warning occurred
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function hasErrorsOccurred()
|
|
{
|
|
return self::$errorsOccurred;
|
|
}
|
|
|
|
/**
|
|
* Access the log queue
|
|
*
|
|
* The log queue holds messages that could not be written to output
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function getQueue()
|
|
{
|
|
return self::$queue;
|
|
}
|
|
|
|
/**
|
|
* Reset object state
|
|
*/
|
|
public static function reset()
|
|
{
|
|
self::$queue = array();
|
|
self::$instance = null;
|
|
}
|
|
}
|