21    private static $loggingHandler = 
null;
 
   26    private static $logLevel = 
null;
 
   31    private static $captureLog = 
false;
 
   36    private static $capturedLog = array();
 
   43    private static $earlyLog = array();
 
   52    private static $logLevelStack = array();
 
   61    private static $logMask = 0;
 
   68    const NO_TRACKID = 
'_NOTRACKIDYET_';
 
   74    private static $trackid = self::NO_TRACKID;
 
  104    private static $format = 
'%date{%b %d %H:%M:%S} %process %level %stat[%trackid] %msg';
 
  111    private static $shutdownRegistered = 
false;
 
  118    private static $shuttingDown = 
false;
 
  137        self::log(self::EMERG, $string);
 
  148        self::log(self::CRIT, $string);
 
  157    public static function alert($string)
 
  159        self::log(self::ALERT, $string);
 
  168    public static function error($string)
 
  170        self::log(self::ERR, $string);
 
  181        self::log(self::WARNING, $string);
 
  192        self::log(self::NOTICE, $string);
 
  201    public static function info($string)
 
  203        self::log(self::INFO, $string);
 
  213    public static function debug($string)
 
  224    public static function stats($string)
 
  226        self::log(self::NOTICE, $string, 
true);
 
  237        self::$captureLog = $val;
 
  246        return self::$capturedLog;
 
  257        self::$trackid = $trackId;
 
  272        } 
catch (\Exception $e) {
 
  274            self::error(
'Cannot load or create session: '.$e->getMessage());
 
  277        self::$trackid = 
$s->getTrackID();
 
  279        self::$shuttingDown = 
true;
 
  280        foreach (self::$earlyLog as $msg) {
 
  281            self::log($msg[
'level'], $msg[
'string'], $msg[
'statsLog']);
 
  295        return ($errno & self::$logMask) || !($errno & error_reporting());
 
  308        assert(
'is_int($mask)');
 
  310        $currentEnabled = error_reporting();
 
  311        self::$logLevelStack[] = array($currentEnabled, self::$logMask);
 
  313        $currentEnabled &= ~$mask;
 
  314        error_reporting($currentEnabled);
 
  315        self::$logMask |= 
$mask;
 
  326        $lastMask = array_pop(self::$logLevelStack);
 
  327        error_reporting($lastMask[0]);
 
  328        self::$logMask = $lastMask[1];
 
  342        self::$earlyLog[] = array(
'level' => $level, 
'string' => 
$message, 
'statsLog' => 
$stats);
 
  345        if (!self::$shutdownRegistered) {
 
  346            register_shutdown_function(array(
'SimpleSAML\Logger', 
'flush'));
 
  347            self::$shutdownRegistered = 
true;
 
  355        self::$loggingHandler = 
false;
 
  358        $known_handlers = array(
 
  359            'syslog'   => 
'SimpleSAML\Logger\SyslogLoggingHandler',
 
  360            'file'     => 
'SimpleSAML\Logger\FileLoggingHandler',
 
  361            'errorlog' => 
'SimpleSAML\Logger\ErrorLogLoggingHandler',
 
  369        self::$logLevel = 
$config->getInteger(
'logging.level', self::INFO);
 
  376        if (!array_key_exists(
$handler, $known_handlers) && class_exists(
$handler)) {
 
  377            if (!in_array(
'SimpleSAML\Logger\LoggingHandlerInterface', class_implements(
$handler), 
true)) {
 
  378                throw new \Exception(
"The logging handler '$handler' is invalid.");
 
  382            if (!array_key_exists(
$handler, $known_handlers)) {
 
  383                throw new \Exception(
 
  384                    "Invalid value for the 'logging.handler' configuration option. Unknown handler '".
$handler.
"''." 
  396    private static function log($level, $string, $statsLog = 
false)
 
  398        if (self::$loggingHandler === 
false) {
 
  400            self::defer($level, $string, $statsLog);
 
  402        } elseif (php_sapi_name() === 
'cli' || 
defined(
'STDIN')) {
 
  404            if (is_null(self::$loggingHandler)) {
 
  405                self::createLoggingHandler(
'SimpleSAML\Logger\StandardErrorLoggingHandler');
 
  408            if (self::$trackid === self::NO_TRACKID) {
 
  409                self::$trackid = 
'CL'.bin2hex(openssl_random_pseudo_bytes(4));
 
  411        } elseif (self::$loggingHandler === 
null) {
 
  413            self::createLoggingHandler();
 
  415            if (!empty(self::$earlyLog)) {
 
  417                foreach (self::$earlyLog as $msg) {
 
  418                    self::log($msg[
'level'], $msg[
'string'], $msg[
'statsLog']);
 
  423        if (self::$captureLog) {
 
  424            $ts = microtime(
true);
 
  425            $msecs = (int) (($ts - (
int) $ts) * 1000);
 
  426            $ts = gmdate(
'H:i:s', $ts).sprintf(
'.%03d', $msecs).
'Z';
 
  427            self::$capturedLog[] = $ts.
' '.$string;
 
  430        if (self::$logLevel >= $level || $statsLog) {
 
  431            if (is_array($string)) {
 
  432                $string = implode(
",", $string);
 
  435            $formats = array(
'%trackid', 
'%msg', 
'%srcip', 
'%stat');
 
  436            $replacements = array(self::$trackid, $string, 
$_SERVER[
'REMOTE_ADDR']);
 
  442            array_push($replacements, $stat);
 
  444            if (self::$trackid === self::NO_TRACKID && !self::$shuttingDown) {
 
  446                self::defer($level, $string, $statsLog);
 
  448            } elseif (self::$trackid === self::NO_TRACKID) {
 
  450                array_shift($replacements);
 
  451                array_unshift($replacements, 
'N/A');
 
  456            self::$loggingHandler->log($level, $string);
 
An exception for terminatinating execution or to throw for unit testing.
static getCapturedLog()
Get the captured log.
static isErrorMasked($errno)
Evaluate whether errors of a certain error level are masked or not.
static setCaptureLog($val=true)
static log($level, $string, $statsLog=false)
static emergency($string)
static setTrackId($trackId)
Set the track identifier to use in all logs.
static createLoggingHandler($handler=null)
static defer($level, $message, $stats)
Defer a message for later logging.
static popErrorMask()
Pop an error mask.
static flush()
Flush any pending log messages to the logging handler.
static maskErrors($mask)
Disable error reporting for the given log levels.
static getInstance($instancename='simplesaml')
Get a configuration file by its instance name.
static getSessionFromRequest()
Retrieves the current session.
error($a_errmsg)
set error message @access public
catch(Exception $e) $message
Attribute-related utility methods.
defined( 'APPLICATION_ENV')||define( 'APPLICATION_ENV'
if((!isset($_SERVER['DOCUMENT_ROOT'])) OR(empty($_SERVER['DOCUMENT_ROOT']))) $_SERVER['DOCUMENT_ROOT']