logging

<?php

/**
 * Interface for an object, that is able to log messages
 *
 * @package Nette\Logger
 * @version $id$
 * @copyright (c) 2009 Martin Pecka (Clevis)
 * @author Martin Pecka <martin.pecka@clevis.cz>
 * @license
 */
interface /*Nette\Logger\*/ILogger
{

    /**
     * Append the message to the log
     *
     * @param string $message The message to log
     * @param string|NULL $class Optional class (severity etc...) of the message
     * @return void
     */
    function logMessage($message, $class = NULL);

}

?>

<?php

/**
 * This is a logger that logs the messages into a file
 *
 * @package
 * @version $id$
 * @copyright (c) 2009 Martin Pecka (Clevis)
 * @author Martin Pecka <martin.pecka@clevis.cz>
 * @license
 */
class /*Nette\Logger\*/FileLogger extends /*Nette\*/Object implements /*Nette\Logger\*/ILogger
{

    /** @var string Name of the log file */
    protected $logFile;

    /** @var resource Handle of the log file */
    protected $logHandle = NULL;

    /** @var bool If true, log newer messages at the top of the file */
    protected $newerHigher;

    /**
     * Initialize the logger, setup the log file
     *
     * @param string $logFile The file we want to log into
     * @param bool $newerHigher Log newer messages at the beggining of the
     * file? BEWARE - this rapidly reduces performance!!!
     *
     * @return void
     */
    public function __construct($logFile, $newerHigher = FALSE)
    {
        if (!is_string($logFile))
            throw new InvalidArgumentException(
                'Argument 1 passed to FileLogger\'s constructor must be string');

        $this->logFile = $logFile;
        $this->newerHigher = $newerHigher;
    }

    /**
     * Close the log file if needed
     *
     * @return void
     */
    public function __destruct()
    {
        if ($this->logHandle !== NULL)
            fclose($this->logHandle);
    }

    /**
     * Log the message to file, with optional class
     *
     * @param string $message
     * @param string|NULL $class
     * @return void
     */
    public function logMessage($message, $class = NULL)
    {
        $message = date('Y-m-d H:i:s') . ': ' . $message . "\n\r";
        if ($class !== NULL)
            $message = "[$class] " . $message;

        $this->writeToFile($message);
    }

    /**
     * Physically write the message to the file using safestream
     *
     * If $newerHigher, write the message before the beginning
     *
     * @param mixed $message
     * @return void
     */
    protected function writeToFile($message)
    {
        if ($this->logHandle === NULL) {
            $this->openLogFile();
        }

        if ($this->newerHigher) {
            $contents = fread($this->logHandle, 1000000);
            $message .= $contents;
            rewind($this->logHandle);
        }

        fwrite($this->logHandle, $message);
    }

    /**
     * Open the file as safestream for appending
     *
     * If not newerHigher, move the cursor to the end
     *
     * @return void
     */
    protected function openLogFile()
    {
        SafeStream::register();

        //this is not stream safe, but will be called just once
        if (!file_exists($this->logFile))
            touch($this->logFile);

        if (($this->logHandle = @fopen('safe://' . $this->logFile, 'r+')) === FALSE) {
            throw new InvalidArgumentException('Cannot open logFile: ' . $this->logFile);
        }

        if (!$this->newerHigher) {
            //seek to the end of the file
            fseek($this->logHandle, -1, SEEK_END);
        }
    }

}

?>

<?php
Environment::getServiceLocator()->addService('ILogger',
  new FileLogger(APP_DIR . '/log/logfile.txt'));
Environment::setServiceAlias('ILogger', 'Logger');
?>

<?php
Environment::getLogger()->logMessage('Message');
Environment::getLogger()->logMessage('Mess', 'age');
?>

<?php
/**
 * Filesystem-based implementation of ILogger.
 * Slightly inspired by FileLogger by Martin Pecka <martin.pecka@clevis.cz>:
 *   https://forum.nette.org/cs/viewtopic.php?pid=19667#p19667
 *
 * @author     Jan Smitka <jan@smitka.org>
 * @copyright  Copyright (c) 2009 Jan Smitka
 */
class FileLogger extends Object implements ILogger
{
        /** @var string Mask of the log filename, can contain strftime formatting */
        private $filenameMask = 'log-%Y-%m-%d.log';

        /** @var string The directory where we save the logs */
        private $logDir = '%logDir%';

        /** @var string The log file path */
        private $file;

        /** @var int Maximum level of events logged */
        private $logLevel;

        /** @var int seconds If > 0, defines a time span used for one log
         *
         * eg. if you want to save two logs a day, you can define mask
         * "%Y-%m-%d-%H" and set this to half a day of seconds, so the logs
         * won't create each hour (as defined in the mask) */
        private $granularity = 0;

        /** @var string Log date format as in date() */
        private $dateFormat = 'r';



        /**
         * Just set member variables given as parameters
         *
         * @param string $filenameMask Mask of the log filename, can contain strftime formatting
         * @param int $logLevel One of the ILogger constants, maximum level of events logged
         * @param mixed $logDir Directory for saving the logs
         * @param int $granularity If > 0, defines a time span used for one log
         *
         * @return void
         */
        public function __construct($filenameMask = NULL, $logLevel = NULL, $logDir = NULL, $granularity = 0)
        {
                if ($logLevel === NULL)
                        $logLevel = Environment::isProduction() ? ILogger::INFO : ILogger::DEBUG;
                $this->setLogLevel($logLevel);

                if ($logDir !== NULL)
                        $this->logDir = $logDir;

                if ($filenameMask !== NULL)
                        $this->filenameMask = $filenameMask;

                $this->granularity = $granularity;
        }



        /**
         * Returns the logger verbosity.
         *
         * @return int
         */
        public function getLogLevel()
        {
                return $this->logLevel;
        }

        /**
         * Sets the logger verbosity.
         * @param int $level one of the ILogger severity constants
         *
         * @return void
         *
         * @throws InvalidArgumentException If the given level is not one of
         * ILogger's constants
         */
        public function setLogLevel($level)
        {
                if ($level > ILogger::DEBUG || $level < ILogger::NONE)
                        throw new InvalidArgumentException('Log level must be one of the ILogger severity constants.');
                $this->logLevel = $level;
        }



        /**
         * Returns the filename mask of log file.
         *
         * @return string
         */
        public function getFilenameMask()
        {
                return $this->filenameMask;
        }

        /**
         * Sets the filename mask for log files.
         * You can use the strftime specifiers.
         *
         * @param string $filenameMask
         *
         * @return void
         *
         * @see strftime()
         */
        public function setFilenameMask($filenameMask)
        {
                $this->filenameMask = $filenameMask;
                $this->file = NULL;
        }



        /**
         * Returns the directory path where log files reside.
         *
         * @return string with untranslated environment variables
         */
        public function getLogDir()
        {
                return $this->logDir;
        }

        /**
         * Sets the directory path where log files reside.
         * You can use environment variables.
         *
         * @param string $logDir
         *
         * @return void
         *
         * @see Environment::expand()
         */
        public function setLogDir($logDir)
        {
                $this->logDir = $logDir;
                $this->file = NULL;
        }



        /**
         * Returns log files granularity.
         *
         * @return int in seconds
         */
        public function getGranularity()
        {
                return $this->granularity;
        }

        /**
         * Sets log files granularity.
         * Please note that real granularity is also determined by filename mask.
         *
         * @param int $granularity
         *
         * @return void
         *
         * @throws InvalidArgumentException If the grannularity is not non-negative number
         */
        public function setGranularity($granularity)
        {
                if ($granularity < 0)
                        throw new InvalidArgumentException('Granularity must be greater than or equal to 0.');

                $this->granularity = $granularity;
                $this->file = NULL;
        }



        /**
         * Returns the date format used inside log files.
         *
         * @return string
         */
        public function getDateFormat()
        {
                return $this->dateFormat;
        }

        /**
         * Sets the date format used inside log files.
         * Format is the same as used by date() function.
         *
         * @param string $dateFormat
         *
         * @return void
         *
         * @see date()
         */
        public function setDateFormat($dateFormat)
        {
                $this->dateFormat = $dateFormat;
        }





        /**
         * Returns the full path to the current log file.
         *
         * @return string
         *
         * @throws InvalidStateException
         */
        public function getFile()
        {
                if ($this->file === NULL) {
                        // granularity calculations
                        if ($this->granularity > 1) {
                                $offset = 345600 - (int) date('Z');
                                $timestamp = $offset + floor((time() - $offset) / $this->granularity) * $this->granularity;
                        } else
                                $timestamp = time();

                        $this->file = ($path = Environment::expand($this->logDir))
                                    . (String::endsWith($path, '/') ? '' : '/')
                                    . strftime($this->filenameMask, $timestamp);
                }

                return $this->file;
        }



         /**
         * Log a message.
         *
         * The message can be formatted as in printf
         *
         * @param string $message The message to log
         * @param int $level Severity of the message
         * @param mixed $args Following arguments are interpreted as printf arguments
         *
         * @throws InvalidArgumentException If the given level is not one of
         * the interfaces' constants
         * @throws InvalidStateException If file operation failed
         */
        public function logMessage($message, $level = ILogger::INFO)
        {
                if ($level > ILogger::DEBUG || $level <= ILogger::NONE)
                        throw new InvalidArgumentException('Log level must be one of the ILogger severity constants except ILogger::NONE.');

                //had the user passed some printf arguments?
                if (func_num_args() > 2) {
                        $args = func_get_args();
                        array_shift($args);
                        array_shift($args);

                        $message = vsprintf($message, $args);
                }

                if ($level <= $this->logLevel) {
                        $message = sprintf("%s %s: %s\r\n", date($this->dateFormat), $this->logLevelToString($level), $message);
                        file_put_contents($this->getFile(), $message, FILE_APPEND);
                        // Please note that FILE_APPEND operation is atomic (tested):
                        // http://us2.php.net/manual/en/function.file-put-contents.php
                }
        }



        /**
         * Translate log severity level into a readable string.
         *
         * @param int $level One of ILogger's constants
         *
         * @return void
         *
         * @throws InvalidArgumentException If the level is unknown
         */
        protected function logLevelToString($level)
        {
                switch ($level) {
                case ILogger::ERROR:
                        return 'ERROR';

                case ILogger::WARNING:
                        return 'WARNING';

                case ILogger::INFO:
                        return 'INFO';

                case ILogger::DEBUG:
                        return 'DEBUG';

                default:
                        throw new InvalidArgumentException('Unknown severity level.');
                }
        }
}

?>