[Summary view] [Print] [Text view]

   1  <?php
   2  /**

   3   * $Id: Logger.class.php 10 2007-05-27 10:55:12Z spocke $

   4   *

   5   * @package MCFileManager.filesystems

   6   * @author Moxiecode

   7   * @copyright Copyright © 2005, Moxiecode Systems AB, All rights reserved.

   8   */
   9  
  10  // File type contstants

  11  define('MC_LOGGER_DEBUG', 0);
  12  define('MC_LOGGER_INFO', 10);
  13  define('MC_LOGGER_WARN', 20);
  14  define('MC_LOGGER_ERROR', 30);
  15  define('MC_LOGGER_FATAL', 40);
  16  
  17  /**

  18   * Logging utility class. This class handles basic logging with levels, log rotation and custom log formats. It's

  19   * designed to be compact but still powerful and flexible.

  20   */
  21  class Moxiecode_Logger {
  22      // Private fields

  23      var $_path;
  24      var $_filename;
  25      var $_maxSize;
  26      var $_maxFiles;
  27      var $_maxSizeBytes;
  28      var $_level;
  29      var $_format;
  30  
  31      /**

  32       * Constructs a new logger instance.

  33       */
  34  	public function __construct() {
  35          $this->_path = "";
  36          $this->_filename = "{level}.log";
  37          $this->setMaxSize("100k");
  38          $this->_maxFiles = 10;
  39          $this->_level = MC_LOGGER_DEBUG;
  40          $this->_format = "[{time}] [{level}] {message}";
  41      }
  42  
  43      /**

  44       * Old syntax of class constructor. Deprecated in PHP7.

  45       *

  46       * @deprecated since Moodle 3.1

  47       */
  48      public function Moxiecode_Logger() {
  49          debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER);
  50          self::__construct();
  51      }
  52  
  53      /**

  54       * Sets the current log level, use the MC_LOGGER constants.

  55       *

  56       * @param int $level Log level instance for example MC_LOGGER_DEBUG.

  57       */
  58  	function setLevel($level) {
  59          if (is_string($level)) {
  60              switch (strtolower($level)) {
  61                  case "debug":
  62                      $level = MC_LOGGER_DEBUG;
  63                      break;
  64  
  65                  case "info":
  66                      $level = MC_LOGGER_INFO;
  67                      break;
  68  
  69                  case "warn":
  70                  case "warning":
  71                      $level = MC_LOGGER_WARN;
  72                      break;
  73  
  74                  case "error":
  75                      $level = MC_LOGGER_ERROR;
  76                      break;
  77  
  78                  case "fatal":
  79                      $level = MC_LOGGER_FATAL;
  80                      break;
  81  
  82                  default:
  83                      $level = MC_LOGGER_FATAL;
  84              }
  85          }
  86  
  87          $this->_level = $level;
  88      }
  89  
  90      /**

  91       * Returns the current log level for example MC_LOGGER_DEBUG.

  92       *

  93       * @return int Current log level for example MC_LOGGER_DEBUG.

  94       */
  95  	function getLevel() {
  96          return $this->_level;
  97      }
  98  
  99  	function setPath($path) {
 100          $this->_path = $path;
 101      }
 102  
 103  	function getPath() {
 104          return $this->_path;
 105      }
 106  
 107  	function setFileName($file_name) {
 108          $this->_filename = $file_name;
 109      }
 110  
 111  	function getFileName() {
 112          return $this->_filename;
 113      }
 114  
 115  	function setFormat($format) {
 116          $this->_format = $format;
 117      }
 118  
 119  	function getFormat() {
 120          return $this->_format;
 121      }
 122  
 123  	function setMaxSize($size) {
 124          // Fix log max size

 125          $logMaxSizeBytes = intval(preg_replace("/[^0-9]/", "", $size));
 126  
 127          // Is KB

 128          if (strpos((strtolower($size)), "k") > 0)
 129              $logMaxSizeBytes *= 1024;
 130  
 131          // Is MB

 132          if (strpos((strtolower($size)), "m") > 0)
 133              $logMaxSizeBytes *= (1024 * 1024);
 134  
 135          $this->_maxSizeBytes = $logMaxSizeBytes;
 136          $this->_maxSize = $size;
 137      }
 138  
 139  	function getMaxSize() {
 140          return $this->_maxSize;
 141      }
 142  
 143  	function setMaxFiles($max_files) {
 144          $this->_maxFiles = $max_files;
 145      }
 146  
 147  	function getMaxFiles() {
 148          return $this->_maxFiles;
 149      }
 150  
 151  	function debug($msg) {
 152          $args = func_get_args();
 153          $this->_logMsg(MC_LOGGER_DEBUG, implode(', ', $args));
 154      }
 155  
 156  	function info($msg) {
 157          $args = func_get_args();
 158          $this->_logMsg(MC_LOGGER_INFO, implode(', ', $args));
 159      }
 160  
 161  	function warn($msg) {
 162          $args = func_get_args();
 163          $this->_logMsg(MC_LOGGER_WARN, implode(', ', $args));
 164      }
 165  
 166  	function error($msg) {
 167          $args = func_get_args();
 168          $this->_logMsg(MC_LOGGER_ERROR, implode(', ', $args));
 169      }
 170  
 171  	function fatal($msg) {
 172          $args = func_get_args();
 173          $this->_logMsg(MC_LOGGER_FATAL, implode(', ', $args));
 174      }
 175  
 176  	function isDebugEnabled() {
 177          return $this->_level >= MC_LOGGER_DEBUG;
 178      }
 179  
 180  	function isInfoEnabled() {
 181          return $this->_level >= MC_LOGGER_INFO;
 182      }
 183  
 184  	function isWarnEnabled() {
 185          return $this->_level >= MC_LOGGER_WARN;
 186      }
 187  
 188  	function isErrorEnabled() {
 189          return $this->_level >= MC_LOGGER_ERROR;
 190      }
 191  
 192  	function isFatalEnabled() {
 193          return $this->_level >= MC_LOGGER_FATAL;
 194      }
 195  
 196  	function _logMsg($level, $message) {
 197          $roll = false;
 198  
 199          if ($level < $this->_level)
 200              return;
 201  
 202          $logFile = $this->toOSPath($this->_path . "/" . $this->_filename);
 203  
 204          switch ($level) {
 205              case MC_LOGGER_DEBUG:
 206                  $levelName = "DEBUG";
 207                  break;
 208  
 209              case MC_LOGGER_INFO:
 210                  $levelName = "INFO";
 211                  break;
 212  
 213              case MC_LOGGER_WARN:
 214                  $levelName = "WARN";
 215                  break;
 216  
 217              case MC_LOGGER_ERROR:
 218                  $levelName = "ERROR";
 219                  break;
 220  
 221              case MC_LOGGER_FATAL:
 222                  $levelName = "FATAL";
 223                  break;
 224          }
 225  
 226          $logFile = str_replace('{level}', strtolower($levelName), $logFile);
 227  
 228          $text = $this->_format;
 229          $text = str_replace('{time}', date("Y-m-d H:i:s"), $text);
 230          $text = str_replace('{level}', strtolower($levelName), $text);
 231          $text = str_replace('{message}', $message, $text);
 232          $message = $text . "\r\n";
 233  
 234          // Check filesize

 235          if (file_exists($logFile)) {
 236              $size = @filesize($logFile);
 237  
 238              if ($size + strlen($message) > $this->_maxSizeBytes)
 239                  $roll = true;
 240          }
 241  
 242          // Roll if the size is right

 243          if ($roll) {
 244              for ($i=$this->_maxFiles-1; $i>=1; $i--) {
 245                  $rfile = $this->toOSPath($logFile . "." . $i);
 246                  $nfile = $this->toOSPath($logFile . "." . ($i+1));
 247  
 248                  if (@file_exists($rfile))
 249                      @rename($rfile, $nfile);
 250              }
 251  
 252              @rename($logFile, $this->toOSPath($logFile . ".1"));
 253  
 254              // Delete last logfile

 255              $delfile = $this->toOSPath($logFile . "." . ($this->_maxFiles + 1));
 256              if (@file_exists($delfile))
 257                  @unlink($delfile);
 258          }
 259  
 260          // Append log line

 261          if (($fp = @fopen($logFile, "a")) != null) {
 262              @fputs($fp, $message);
 263              @fflush($fp);
 264              @fclose($fp);
 265          }
 266      }
 267  
 268      /**

 269       * Converts a Unix path to OS specific path.

 270       *

 271       * @param String $path Unix path to convert.

 272       */
 273  	function toOSPath($path) {
 274          return str_replace("/", DIRECTORY_SEPARATOR, $path);
 275      }
 276  }
 277  
 278  ?>