Source for file Logger.php

Documentation is available at Logger.php

  1. <?php
  2. /**
  3.  * Logger.php
  4.  *
  5.  * PHP version 5
  6.  *
  7.  * LICENSE: This program is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU General Public License as published
  9.  * by the Free Software Foundation.
  10.  *
  11.  * @package                     FreeNAC
  12.  * @author                      Hector Ortiz (FreeNAC Core Team)
  13.  * @copyright                   2007 FreeNAC
  14.  * @license                     http://www.gnu.org/copyleft/gpl.html   GNU Public License Version 2
  15.  * @version                     SVN: $Id$
  16. */
  17.  
  18. /**
  19. * Define the Logger class which is a Singleton which provides for logging facilities.
  20. *
  21. * This class uses the constants defined by Syslog, which are listed as follows:
  22. *   - LOG_EMERG   0       System is unusable
  23. *   - LOG_ALERT   1       Action must be taken immediately
  24. *   - LOG_CRIT    2       Critical conditions
  25. *   - LOG_ERR   3       Error conditions
  26. *   - LOG_WARNING 4       Warning conditions
  27. *   - LOG_NOTICE  5       Normal, but significant condition
  28. *   - LOG_INFO    6       Informational message
  29. *   - LOG_DEBUG   7       Debug-level-message
  30. *
  31. * Example usage:
  32. *   - $logger=Logger::getInstance();        Needed, before other lines
  33. *   - $logger->setDebugLevel(3);        Log debug1,2,3 (default is only 1)
  34. *   - $logger->setLogToStdErr();        If you don't want to use syslog
  35. *   - $logger->logit("Hello world");        Will appear in syslog or stderr
  36. *   - $logger->debug("Hello debug world");    Will be prefixed "debug1"
  37. *   - $logger->debug("Hello debug world",3);    Will be prefixed "debug3"
  38. *    
  39. */
  40.  
  41. /* Define some other values for the facility to open
  42.  * The ones defined by default are:
  43.  * LOG_AUTH     32
  44.  * LOG_AUTHPRIV    80
  45.  * LOG_CRON    72
  46.  * LOG_DAEMON    24    
  47.  * LOG_KERN    0
  48.  * LOG_LOCAL0    128
  49.  * LOG_LOCAL1    136
  50.  * LOG_LOCAL2    144
  51.  * LOG_LOCAL3    152
  52.  * LOG_LOCAL4    160
  53.  * LOG_LOCAL5    168
  54.  * LOG_LOCAL6    176
  55.  * LOG_LOCAL7    184
  56.  * LOG_LPR    48
  57.  * LOG_MAIL    16
  58.  * LOG_NEWS    56
  59.  * LOG_SYSLOG    40
  60.  * LOG_USER    8
  61.  * LOG_UUCP    64
  62. */
  63. define('WEB',500);
  64.  
  65. final class Logger
  66. {
  67.    /**
  68.    * Maximum debugging level
  69.    */
  70.    const MAX_DEBUG_LEVEL=3;                
  71.    private $debug_level=NULL;            //Current debugging level
  72.    private static $instance=NULL;        //Instance of this class
  73.    private $identifier=NULL;
  74.    private $facility=NULL;
  75.    private $stderr=false;
  76.    private $stdout=false;
  77.    private $stdout_stream = NULL;
  78.    private $stderr_stream = NULL;
  79.    private $httpd_log=false;            //Log to webserver log?
  80.    private $email_alert=false;            //Send Err or higher via email
  81.    
  82.    /**
  83.    * Open logging facilities and start output buffering
  84.    */
  85.    private function __construct($facility=LOG_DAEMON)  
  86.    {
  87.       define_syslog_variables();
  88.       ob_start();
  89.       $this->identifier=basename($_SERVER['SCRIPT_FILENAME']); #Get script's name as identifier
  90.       $this->openFacility($facility);           #Open logging facilities
  91.    }
  92.  
  93.    /**
  94.    * Close logging facilities and flush output buffering
  95.    */
  96.    public function __destruct()        
  97.    {
  98.       ob_end_flush();
  99.       closelog();
  100.    }
  101.  
  102.    /**
  103.    * Divert logging to Email
  104.    * @param boolean $var        Activate or deactivate LogToEmail logging. Default is to activate ($var=true)
  105.    * @return boolean        True if successful, false otherwise
  106.    */
  107.    public function setLogToEmail($var=true)
  108.    {
  109.       if (is_bool($var) && ($var===true))
  110.       {
  111.          $this->email_alert=true;
  112.       }
  113.       else
  114.       {
  115.          $this->email_alert=false;
  116.       }
  117.    }
  118.  
  119.    /**
  120.    * Divert logging to httpd
  121.    * @param boolean $var        Activate or deactivate httpd logging. Default is to activate ($var=true)
  122.    */
  123.    public function setLogToHttpd($var=true)
  124.    {
  125.       if (is_bool($var) && ($var===true))
  126.       {
  127.          $this->httpd_log=true;
  128.       }
  129.       else
  130.       {
  131.          $this->httpd_log=false;
  132.       }
  133.    }
  134.  
  135.    /**
  136.    * Divert logging to StdErr
  137.    * @param boolean $var    Activate or deactivate StdErr logging. Default is to activate ($var=true)
  138.    */
  139.    public function setLogToStdErr($var=true)    //Redirect logging to stderr
  140.    {
  141.       if (is_bool($var) && ($var===true))
  142.       {
  143.          closelog();        #Close syslog
  144.          $this->stderr=true;
  145.       }
  146.       else
  147.       {
  148.          $this->stderr=false;
  149.       }
  150.    }
  151.  
  152.    /**
  153.    * Divert logging to StdOut
  154.    * @param boolean $var        Activate or deactivate StdOut logging. Default is to activate ($var=true)
  155.    */
  156.    public function setLogToStdOut($var=true)    //Redirect logging to stderr
  157.    {
  158.       if (is_bool($var) && ($var===true))
  159.       {
  160.          closelog();            #Close syslog
  161.          $this->stdout=true;
  162.       }
  163.       else
  164.       {
  165.          $this->stdout=false;
  166.       }
  167.    }
  168.  
  169.    /**
  170.    * Set the script name which will be displayed in syslog
  171.    * @param mixed $name        Name to set to
  172.    * @return boolean        True if successful, false otherwise
  173.    */
  174.    public function setIdentifier($name=NULL)    
  175.    {
  176.       if ($name != NULL)
  177.       {   
  178.          closelog();
  179.          $this->identifier=$name;
  180.          return true;
  181.       }
  182.       else 
  183.       {
  184.          return false;
  185.       }
  186.    }
  187.   
  188.    /**
  189.    * The name displayed in syslog
  190.    * @return mixed         Name
  191.    */
  192.    public function getIdentifier()    
  193.    {
  194.       return $this->identifier;
  195.    }
  196.  
  197.    /**
  198.    * Get instance of this class
  199.    * @return object    Current instance
  200.    */
  201.    public static function getInstance($facility=LOG_DAEMON)
  202.    {
  203.       if (empty(self::$instance))               //Is there an instance of this class?
  204.          self::$instance=new Logger($facility);        //No, then create it
  205.       return self::$instance;                   //Yes, return it
  206.    }
  207.  
  208.    /**
  209.    * Prevent clonning the instance
  210.    * @throws    Exception indicating that copy can't be performed
  211.    */
  212.    public function __clone()                   
  213.    {
  214.       throw new Exception("Cannot clone the SysLogger object");
  215.    }
  216.  
  217.    /**
  218.    * Log a message to the HTTPD log
  219.    * This method is a wrapper around the error_log function
  220.    * @return boolean        True if successful, false otherwise
  221.    */
  222.    public function loghttpd($message='')
  223.    {
  224.       return error_log($message,0);
  225.    }
  226.    
  227.    /**
  228.    * Log a message.
  229.    * @param mixed $message        Message to log
  230.    * @param integer $criticality     How critical is this message? Default is informational
  231.    * @return boolean            True if successful, false otherwise
  232.    */
  233.    public function logit($message='',$criticality=LOG_INFO)
  234.    {
  235.       define_syslog_variables();
  236.       if (($criticality<0) || ($criticality > 7))    #Sanity check, defaults to LOG_INFO if user entered an invalid value
  237.          $criticality=LOG_INFO;
  238.       if ($criticality == LOG_ERR)
  239.          $message="ERROR: $message";
  240.       else if ($criticality == LOG_WARNING)
  241.          $message="WARNING: $message";
  242.       if (is_string($message)&&(strlen($message)>0))
  243.       {
  244.          if ($this->stderr)                #Should we log to stderr?
  245.          {
  246.             $message=trim($message);
  247.             $message.="\n";
  248.             if ($this->facility == WEB )
  249.             {
  250.                $fd = fopen($this->stderr_stream,'w');
  251.                fputs($fd, $message);
  252.                fclose($fd);
  253.             }
  254.             else
  255.             {  
  256.                fputs(STDERR, $message);   
  257.                ob_flush();
  258.             }
  259.          }
  260.          else if ($this->stdout)
  261.          {
  262.             $message=trim($message);
  263.             if ($this->facility == WEB )
  264.             {
  265.                $message.="<br />\n";
  266.                $fd = fopen($this->stdout_stream,'w');
  267.                fputs($fd, $message);
  268.                fclose($fd);
  269.             }
  270.             else
  271.             {
  272.                $message.="\n";
  273.                fputs(STDOUT, $message);
  274.                ob_flush();
  275.             }
  276.          }
  277.          else
  278.          {
  279.             syslog((int)$criticality,$message);         #Log it through syslog
  280.             ob_flush();
  281.          }
  282.          if ($this->httpd_log)
  283.          {
  284.             $this->loghttpd($message);            #Should we log to Weblog?
  285.          }
  286.          if ($this->email_alert)
  287.          {
  288.             error_log($message,1,"root");        #TBD: Use a variable for email?
  289.          }
  290.          #if ($this->file_log)
  291.          #{
  292.          #   error_log($message,3,"/var/log/mylog");    #TBD: Use a ariable for mail?
  293.          #}
  294.          return true;
  295.       }
  296.       else
  297.       { 
  298.          return false;
  299.       }
  300.    }
  301.  
  302.    /**
  303.    * Send an email to root
  304.    * This is a wrapper around the php mail function
  305.    * @return boolean            True is mail successfully sent, false otherwise
  306.    */
  307.    public function mailit($subject,$message,$to='root')
  308.    {
  309.       if (strlen($message) > 0)
  310.       {
  311.          return mail($to, $subject, $message);
  312.       }
  313.       else
  314.       {
  315.          return false;
  316.       }
  317.    }
  318.  
  319.    /**
  320.    * Wrapper around the logit method. Log a message only if the specified level for this function
  321.    * is less or equal than the current debugging level.
  322.    * @param mixed $msg            Message to log
  323.    * @param integer $to_level        Debug level where this message should be displayed. Default 1.
  324.    * @return boolean            True if successful, false otherwise
  325.    */
  326.    public function debug($msg,$to_level=1)
  327.    {
  328.       if (is_int($to_level)&&is_string($msg))
  329.       {
  330.          #Perform sanity checks to see if both the current debugging level and the specified level are valid values 
  331.          #according to MAX_DEBUG_LEVEL
  332.  
  333.          #Lower bound
  334.          if ($to_level <= 0)
  335.             $to_level=NULL;
  336.          if ($this->debug_level <= 0)
  337.             $this->debug_level=NULL;
  338.  
  339.          #Upper bound
  340.          if ($this->debug_level > self::MAX_DEBUG_LEVEL)
  341.             $this->debug_level=self::MAX_DEBUG_LEVEL;
  342.          if ($to_level > self::MAX_DEBUG_LEVEL)
  343.             $to_level=self::MAX_DEBUG_LEVEL;
  344.  
  345.          #The specified level falls within our current debugging level?
  346.          if ($this->debug_level && ($to_level<=$this->debug_level) && (strlen($msg)>0))
  347.          {
  348.             $mymsg="Debug$to_level: $msg";    #Include debugging level in the message
  349.             $this->logit($mymsg,LOG_DEBUG);    #Log it
  350.             return true;
  351.          }
  352.          else 
  353.          {
  354.             return false;
  355.          }
  356.       }
  357.       else 
  358.       {
  359.          return false;
  360.       }
  361.    }
  362.  
  363.    /**
  364.    * Get the current debugging level.
  365.    * @return integer        Current debug level
  366.    */
  367.    public function getDebugLevel()
  368.    {
  369.       return $this->debug_level;
  370.    }
  371.  
  372.    /**
  373.    * Set debugging level. It will cause to print all debugging messages less or equal than the value we specify in this function.
  374.    * @param integer $var    Debug level. Default 1. 0 means no debugging
  375.    * @return boolean        True if successful, false otherwise
  376.    */
  377.    public function setDebugLevel($var=1)
  378.    {
  379.       if (is_int($var))
  380.       {
  381.          $this->debug_level=$var;
  382.          return true;
  383.       }
  384.       else
  385.       {
  386.          $this->logit("Value passed to setDebugLevel is not an integer",LOG_WARNING);
  387.          return false;
  388.       }
  389.    }
  390.  
  391.    /**
  392.    * Wrapper around the logit method.
  393.    * This method logs by default to the stdout stream defined by the chosen facility
  394.    * @param mixed $error        The error message to display
  395.    * @return boolean            True if successful, false otherwise
  396.    */
  397.    public function showMessage($message=NULL)
  398.    {
  399.       if (strlen($message) > 0)
  400.       {
  401.          $this->setLogToStdOut(true);
  402.          $this->logit($message);
  403.          $this->setLogToStdOut(false);
  404.          return true;
  405.       }
  406.       else
  407.          return false;
  408.    }
  409.  
  410.    /**
  411.    * Wrapper around the logit method.
  412.    * This method logs by default to the stderr stream defined by the chosen facility
  413.    * @param mixed $error    The error message to display
  414.    * @return boolean        True if successful, false otherwise
  415.    */
  416.    public function showError($error=NULL)
  417.    {
  418.       if (strlen($error) > 0)
  419.       {
  420.          $this->setLogToStdErr(true);
  421.          $this->logit($error, LOG_ERR);
  422.          $this->setLogToStdErr(false);
  423.          return true;
  424.       }
  425.       else
  426.          return false;
  427.    }
  428.  
  429.    /**
  430.    * Open logging facility specified for the user
  431.    * @param integer $facility    Facility to open. Default is LOG_DAEMON
  432.    * @return boolean        True if successful, false otherwise
  433.    */
  434.    public function openFacility($facility=LOG_DAEMON)
  435.    {
  436.       if (is_integer($facility))
  437.       {
  438.          switch($facility)                    #Sanity checks
  439.          {
  440.             case LOG_AUTH:
  441.             case LOG_AUTHPRIV:
  442.             case LOG_CRON:
  443.             case LOG_DAEMON:
  444.             case LOG_KERN:
  445.             case LOG_LOCAL0:
  446.             case LOG_LOCAL1:
  447.             case LOG_LOCAL2:
  448.             case LOG_LOCAL3:
  449.             case LOG_LOCAL4:
  450.             case LOG_LOCAL5:
  451.             case LOG_LOCAL6:
  452.             case LOG_LOCAL7:
  453.             case LOG_LPR:
  454.             case LOG_MAIL:
  455.             case LOG_NEWS:
  456.             case LOG_SYSLOG:
  457.             case LOG_USER:
  458.             case LOG_UUCP:
  459.                {
  460.                   closelog();
  461.                   $this->facility=$facility;
  462.                   $this->stdout_stream = STDOUT;
  463.                   $this->stderr_stream = STDERR; 
  464.                   return openlog($this->identifier,LOG_CONS | LOG_NDELAY | LOG_PID, $this->facility);
  465.                }
  466.             case WEB:
  467.                {
  468.                   closelog();
  469.                   $this->facility=$facility;
  470.                   $this->stdout_stream = "php://output";
  471.                   $this->stderr_stream = "php://stderr";
  472.                   return openlog($this->identifier,LOG_CONS | LOG_NDELAY | LOG_PID, $this->facility);
  473.                }
  474.             default:
  475.                return false;
  476.          }
  477.       }
  478.       else
  479.       {
  480.          $this->logit("Value passed to openFacility is not recognized",LOG_WARNING);
  481.          return false;
  482.       }
  483.    }
  484. }

Documentation generated on Mon, 17 Nov 2008 01:10:40 +0100 by phpDocumentor 1.4.0