Logger.class.php

Go to the documentation of this file.

<?php
class spunQ_Logger {

    const VERBOSE_DEBUG = 0;

    const VDEBUG = 0;

    const DEBUG = 10;

    const INFO = 20;

    const WARNING = 30;

    const ERROR = 40;

    const CRITICAL = 50;

    const MAX_STACK_SIZE = 10;

    private static $instance = NULL;

    public static function getInstance() {
        if (self::$instance === NULL) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    private $rules = array();

    private $lowestPriorityRule = 100;

    protected $messageStack = 0;

    protected function __construct() {
        return NULL;
    }

    public function vdebug($message) {
        return $this->logMessage(self::VDEBUG, $message);
    }

    public function debug($message) {
        return $this->logMessage(self::DEBUG, $message);
    }

    public function info($message) {
        return $this->logMessage(self::INFO, $message);
    }

    public function warning($message) {
        return $this->logMessage(self::WARNING, $message);
    }

    public function error($message) {
        return $this->logMessage(self::ERROR, $message);
    }

    public function critical($message) {
        return $this->logMessage(self::CRITICAL, $message);
    }

    public function logMessage($priority, $message) {
        if ($priority < $this->lowestPriorityRule) {
            return;
        }
        if ($this->messageStack >= self::MAX_STACK_SIZE) {
            return;
        }
        $this->messageStack++;
        $caller = $this->getCaller();
        $path = $this->fileToPath($caller['file'], $caller['function']);
        $rules = $this->getLoggingRules($path, $priority);
        $usedTargets = array();
        foreach ($rules as $rule) {
            if (in_array($rule->getLogTarget(), $usedTargets)) {
                continue;
            }
            $rule->getLogTarget()->logMessage($path, $priority, $message, $caller['file'], $caller['line']);
            $usedTargets[] = $rule->getLogTarget();
        }
        $this->messageStack--;
        return NULL;
    }

    private function fileToPath($file, $function = NULL) {
        $functionString = $function === NULL ? '' : (':' . $function . '()');
        $alias = NULL;
        if (spunQ::isInitialized()) {
            $alias = spunQ_Module::fileToAlias($file);
        }
        if ($alias === NULL) {
            $alias = $file;
        }
        return $alias . $functionString;
    }

    private function formatFileToPath($folder, $file) {
        $imploded = implode('/', $folder->getBreadcrumbsTo($file));
        $withoutExtension = (preg_replace('!\.[^/]*$!', '', $imploded));
        return str_replace('/', '.', $withoutExtension);
    }

    public function addRule(spunQ_LoggerRule $rule) {
        if ($rule->getPriority() < $this->lowestPriorityRule) {
            $this->lowestPriorityRule = $rule->getPriority();
        }
        $this->rules[] = $rule;
        return $rule;
    }

    public function removeRule(spunQ_LoggerRule $rule) {
        if (($key = array_search($rule, $this->rules, true)) !== FALSE) {
            $removed = array_splice($this->rules, $key, 1);
            $this->setLowestPriority();
            return $removed;
        }
        return $this;
    }

    private function setLowestPriority(){
        $priorites = array();
        if (empty($this->rules)) {
            $this->lowestPriorityRule = 100;
            return NULL;
        }
        foreach ($this->rules as $rule) {
            $priorites[] = $rule->getPriority();
        }
        $this->lowestPriorityRule = min($priorities);
        return NULL;
    }

    private function getCaller() {
        $trace = new spunQ_Backtrace();
        $file = NULL;
        $line = NULL;
        $function = NULL;
        foreach ($trace->getSlices() as $slice) {
            if (!preg_match('/(Logger|LogTarget)\.class\.php$/', $slice->getFile())) {
                $file = $slice->getFile();
                $line = $slice->getLine();
                $function = $slice->getScopingFunction();
                break;
            }
        }
        return array('file' => $file, 'line' => $line, 'function' => $function);
    }

    private function getLoggingRules($path, $priority) {
        $rules = array();
        foreach ($this->rules as $rule) {
            $search = array('.', '*', '?', '(', ')');
            $replace = array('\.', '.*', '.', '\(', '\)');
            if ($rule->getPriority() <= $priority && ($rule->getPath() == NULL || preg_match('!' . str_replace($search, $replace, $rule->getPath()) . '.*!', $path))) {
                $rules[] = $rule;
            }
        }
        return $rules;
    }

    public function clearAllRules() {
        $this->rules = array();
        $this->lowestPriorityRule = self::ERROR + 1;
        return NULL;
    }

}

function vd($message) {
    return vdebug($message);
}

function vdebug($message) {
    spunQ_Logger::getInstance()->vdebug($message);
    return $message;
}

function debug($message) {
    spunQ_Logger::getInstance()->debug($message);
    return $message;
}

function info($message) {
    spunQ_Logger::getInstance()->info($message);
    return $message;
}

function warning($message) {
    spunQ_Logger::getInstance()->warning($message);
    return $message;
}

function error($message) {
    spunQ_Logger::getInstance()->error($message);
    return $message;
}

function critical($message) {
    spunQ_Logger::getInstance()->critical($message);
    return $message;
}

---