Logger::isThrowable() - Code Metrics - Inspection of "Merge pull request #478 from geekwright/logandload" - XOOPS/XoopsCore - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cde499...a7c413 )

by Richard

created 2016-04-06 13:08 UTC

Logger::isThrowable() A

↳ Parent: Logger

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
c	1
b	1
f	0
dl	0
loc	5
ccs	0
cts	0
cp	0
rs	9.4285
cc	2
eloc	3
nc	2
nop	1
crap	6

<?php
/*
 You may not change or alter any portion of this comment or credits
 of supporting developers from this source code or any supporting source code
 which is considered copyrighted (c) material of the original comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/

namespace Xoops\Core;

use Psr\Log\LogLevel;
use Psr\Log\LoggerInterface;

/**
 * Xoops\Core\Logger - dispatch log requests to any registered loggers.
 *
 * No logging is done in this class, but any logger, implemented as a
 * module or extension, can register as a logger using the addLogger()
 * method. Multiple loggers can be registered, and each will be
 * invoked in turn for each log() call.
 *
 * Such loggers are expected to implement the PSR-3 LoggerInterface.
 * In addition, any logger that generates output as part of the XOOPS
 * delivered page should implement the quiet() method, to disable output.
 *
 * Loggers are managed this way so that any routine may easily add a
 * log entry without needing to know any details of the implementation.
 *
 * Not all events are published through this mechanism, only specific requests
 * to log() or related methods. Individual loggers may listen for events (i.e.
 * preloads) or other sources and gain access to detailed debugging information.
 *
 * @category  Xoops\Core\Logger
 * @package   Logger
 * @author    Richard Griffith <[email protected]>
 * @copyright 2013 XOOPS Project (http://xoops.org)
 * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 * @version   Release: 2.6.0
 * @link      http://xoops.org
 * @since     2.6.0
 */
class Logger implements LoggerInterface
{
    /**
     * @var LoggerInterface[] chain of PSR-3 compatible loggers to call
     */
    private $loggers = array();

    /**
     * @var boolean do we have active loggers?
     */
    private $logging_active = false;

    /**
     * @var boolean just to prevent fatal legacy errors. Does nothing. Stop it!
     */
    //public $activated = false;

    /**
     * Get the Xoops\Core\Logger instance
     *
     * @return Logger object
     */
    public static function getInstance()
    {
        static $instance;
        if (!isset($instance)) {
            $class = __CLASS__;
            $instance = new $class();
            // Always catch errors, for security reasons
            set_error_handler(array($instance, 'handleError'));
            // grab any uncaught exception
            set_exception_handler(array($instance, 'handleException'));
        }

        return $instance;
    }

    /**
     * Error handling callback.
     *
     * This will
     *
     * @param integer $errorNumber error number
     * @param string  $errorString error message
     * @param string  $errorFile   file
     * @param integer $errorLine   line number
     *
     * @return void
     */
    public function handleError($errorNumber, $errorString, $errorFile, $errorLine)
    {
        if ($this->logging_active && ($errorNumber & error_reporting())) {

            // if an error occurs before a locale is established,
            // we still need messages, so check and deal with it

            $msg = ': ' . sprintf(
                (class_exists('\XoopsLocale', false) ? \XoopsLocale::EF_LOGGER_FILELINE : "%s in file %s line %s"),
                $this->sanitizePath($errorString),
                $this->sanitizePath($errorFile),
                $errorLine
            );

            switch ($errorNumber) {
                case E_USER_NOTICE:
                    $msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_ERROR : '*Error:') . $msg;
                    $this->log(LogLevel::NOTICE, $msg);
                    break;
                case E_NOTICE:
                    $msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_NOTICE : '*Notice:') . $msg;
                    $this->log(LogLevel::NOTICE, $msg);
                    break;
                case E_WARNING:
                    $msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_WARNING : '*Warning:') . $msg;
                    $this->log(LogLevel::WARNING, $msg);
                    break;
                case E_STRICT:
                    $msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_STRICT : '*Strict:') . $msg;
                    $this->log(LogLevel::WARNING, $msg);
                    break;
                case E_USER_ERROR:
                    $msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_ERROR : '*Error:') . $msg;
                    @$this->log(LogLevel::CRITICAL, $msg);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
                    break;
                default:
                    $msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_UNKNOWN : '*Unknown:') . $msg;
                    $this->log(LogLevel::ERROR, $msg);
                    break;
            }
        }

        if ($errorNumber == E_USER_ERROR) {
            $trace = true;
            if (substr($errorString, 0, '8') === 'notrace:') {
                $trace = false;
                $errorString = substr($errorString, 8);
            }
            $this->reportFatalError($errorString);
            if ($trace) {
                $trace = debug_backtrace();
                array_shift($trace);
                if ('cli' === php_sapi_name()) {
                    foreach ($trace as $step) {
                        if (isset($step['file'])) {
                            fprintf(STDERR, "%s (%d)\n", $this->sanitizePath($step['file']), $step['line']);
                        }
                    }
                } else {
                    echo "<div style='color:#f0f0f0;background-color:#f0f0f0'>" . _XOOPS_FATAL_BACKTRACE . ":<br />";
                    foreach ($trace as $step) {
                        if (isset($step['file'])) {
                            printf("%s (%d)\n<br />", $this->sanitizePath($step['file']), $step['line']);
                        }
                    }
                    echo '</div>';
                }
            }
            exit();

        }
    }

    /**
     * Exception handling callback.
     *
     * @param \Exception|\Throwable $e uncaught Exception or Error
     *
     * @return void
     */
    public function handleException($e)
    {
        if ($this->isThrowable($e)) {
            $msg = $e->getMessage();
            $this->reportFatalError($msg);
        }
    }

    /**
     * Determine if an object implements Throwable (or is an Exception that would under PHP 7.)
     *
     * @param mixed $e Expected to be an object related to Exception or Throwable
     *
     * @return bool true if related to Throwable or Exception, otherwise false
     */
    protected function isThrowable($e)
    {
        $type = interface_exists('\Throwable', false) ? '\Throwable' : '\Exception';
        return $e instanceof $type;
    }

    /**
     * Announce fatal error, attempt to log
     *
     * @param string $msg error message to report
     *
     * @return void
     */
    private function reportFatalError($msg)
    {
        $msg=$this->sanitizePath($msg);
        if ('cli' === php_sapi_name()) {
            fprintf(STDERR, "\nError : %s\n", $msg);
        } else {
            printf(_XOOPS_FATAL_MESSAGE, XOOPS_URL, $msg);
        }
        @$this->log(LogLevel::CRITICAL, $msg);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
    }

    /**
     * clean a path to remove sensitive details
     *
     * @param string $message text to sanitize
     *
     * @return string sanitized message
     */
    public function sanitizePath($message)
    {
        $cleaners = [
            ['\\', '/',],
            [\XoopsBaseConfig::get('var-path'), 'VAR',],
            [str_replace('\\', '/', realpath(\XoopsBaseConfig::get('var-path'))), 'VAR',],
            [\XoopsBaseConfig::get('lib-path'), 'LIB',],
            [str_replace('\\', '/', realpath(\XoopsBaseConfig::get('lib-path'))), 'LIB',],
            [\XoopsBaseConfig::get('root-path'), 'ROOT',],
            [str_replace('\\', '/', realpath(\XoopsBaseConfig::get('root-path'))), 'ROOT',],
            [\XoopsBaseConfig::get('db-name') . '.', '',],
            [\XoopsBaseConfig::get('db-name'), '',],
            [\XoopsBaseConfig::get('db-prefix') . '_', '',],
            [\XoopsBaseConfig::get('db-user'), '***',],
            [\XoopsBaseConfig::get('db-pass'), '***',],
        ];
        $stringsToClean = array_column($cleaners, 0);
        $replacementStings = array_column($cleaners, 1);

        $message = str_replace($stringsToClean, $replacementStings, $message);

        return $message;
    }

    /**
     * add a PSR-3 compatible logger to the chain
     *
     * @param object $logger a PSR-3 compatible logger object
     *
     * @return void
     */
    public function addLogger($logger)
    {
        if (is_object($logger) && method_exists($logger, 'log')) {
                $this->loggers[] = $logger;
                $this->logging_active = true;
        }
    }

    /**
     * System is unusable.
     *
     * @param string $message message
     * @param array  $context array of context data for this log entry
     *
     * @return void
     */
    public function emergency($message, array $context = array())
    {
        $this->log(LogLevel::EMERGENCY, $message, $context);
    }

    /**
     * Action must be taken immediately.
     *
     * Example: Entire website down, database unavailable, etc. This should
     * trigger the SMS alerts and wake you up.
     *
     * @param string $message message
     * @param array  $context array of context data for this log entry
     *
     * @return void
     */
    public function alert($message, array $context = array())
    {
        $this->log(LogLevel::ALERT, $message, $context);
    }

    /**
     * Critical conditions.
     *
     * Example: Application component unavailable, unexpected exception.
     *
     * @param string $message message
     * @param array  $context array of context data for this log entry
     *
     * @return void
     */
    public function critical($message, array $context = array())
    {
        $this->log(LogLevel::CRITICAL, $message, $context);
    }

    /**
     * Runtime errors that do not require immediate action but should typically
     * be logged and monitored.
     *
     * @param string $message message
     * @param array  $context array of context data for this log entry
     *
     * @return void
     */
    public function error($message, array $context = array())
    {
        $this->log(LogLevel::ERROR, $message, $context);
    }

    /**
     * Exceptional occurrences that are not errors.
     *
     * Example: Use of deprecated APIs, poor use of an API, undesirable things
     * that are not necessarily wrong.
     *
     * @param string $message message
     * @param array  $context array of context data for this log entry
     *
     * @return void
     */
    public function warning($message, array $context = array())
    {
        $this->log(LogLevel::WARNING, $message, $context);
    }

    /**
     * Normal but significant events.
     *
     * @param string $message message
     * @param array  $context array of context data for this log entry
     *
     * @return void
     */
    public function notice($message, array $context = array())
    {
        $this->log(LogLevel::NOTICE, $message, $context);
    }

    /**
     * Interesting events.
     *
     * Example: User logs in, SQL logs.
     *
     * @param string $message message
     * @param array  $context array of context data for this log entry
     *
     * @return void
     */
    public function info($message, array $context = array())
    {
        $this->log(LogLevel::INFO, $message, $context);
    }

    /**
     * Detailed debug information.
     *
     * @param string $message message
     * @param array  $context array of context data for this log entry
     *
     * @return void
     */
    public function debug($message, array $context = array())
    {
        $this->log(LogLevel::DEBUG, $message, $context);
    }

    /**
     * Logs with an arbitrary level.
     *
     * @param mixed  $level   PSR-3 LogLevel constant
     * @param string $message message
     * @param array  $context array of context data for this log entry
     *
     * @return void
     */
    public function log($level, $message, array $context = array())
    {
        if (!empty($this->loggers)) {
            foreach ($this->loggers as $logger) {
                if (is_object($logger)) {
                    try {
                        $logger->log($level, $message, $context);
                    } catch (\Exception $e) {
                        // just ignore, as we can't do anything, not even log it.
                    }
                }
            }
        }
    }

    /**
     * quiet - turn off output if output is rendered in XOOPS page output.
     * This is intended to assist ajax code that may fail with any extra
     * content the logger may introduce.
     *
     * It should have no effect on loggers using other methods, such a write
     * to file.
     *
     * @return void
     */
    public function quiet()
    {
        if (!empty($this->loggers)) {
            foreach ($this->loggers as $logger) {
                if (is_object($logger) && method_exists($logger, 'quiet')) {
                    try {
                        $logger->quiet();
                    } catch (\Exception $e) {
                        // just ignore, as we can't do anything, not even log it.
                    }
                }
            }
        }
    }

    // Deprecated uses

    /**
     * Keep deprecated calls from failing
     *
     * @param string $var property
     * @param string $val value
     *
     * @return void
     *
     * @deprecated
     */
    public function __set($var, $val)
    {
        $this->deprecatedMessage();
        // legacy compatibility: turn off logger display for $xoopsLogger->activated = false; usage
        if ($var==='activated' && !$val) {
            $this->quiet();
        }

    }

    /**
     * Keep deprecated calls from failing
     *
     * @param string $var property
     *
     * @return void
     *
     * @deprecated
     */
    public function __get($var)
    {
        $this->deprecatedMessage();
    }

    /**
     * Keep deprecated calls from failing
     *
     * @param string $method method
     * @param string $args   arguments
     *
     * @return void
     *
     * @deprecated
    */
    public function __call($method, $args)
    {
        $this->deprecatedMessage();
    }

    /**
     * issue a deprecated warning
     *
     * @return void
     */
    private function deprecatedMessage()
    {
        $xoops = \Xoops::getInstance();
        $xoops->deprecated('This use of XoopsLogger is deprecated since 2.6.0.');
    }
}


1			<?php
2			/*
3			You may not change or alter any portion of this comment or credits
4			of supporting developers from this source code or any supporting source code
5			which is considered copyrighted (c) material of the original comment or credit authors.
6
7			This program is distributed in the hope that it will be useful,
8			but WITHOUT ANY WARRANTY; without even the implied warranty of
9			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10			*/
11
12			namespace Xoops\Core;
13
14			use Psr\Log\LogLevel;
15			use Psr\Log\LoggerInterface;
16
17			/**
18			* Xoops\Core\Logger - dispatch log requests to any registered loggers.
19			*
20			* No logging is done in this class, but any logger, implemented as a
21			* module or extension, can register as a logger using the addLogger()
22			* method. Multiple loggers can be registered, and each will be
23			* invoked in turn for each log() call.
24			*
25			* Such loggers are expected to implement the PSR-3 LoggerInterface.
26			* In addition, any logger that generates output as part of the XOOPS
27			* delivered page should implement the quiet() method, to disable output.
28			*
29			* Loggers are managed this way so that any routine may easily add a
30			* log entry without needing to know any details of the implementation.
31			*
32			* Not all events are published through this mechanism, only specific requests
33			* to log() or related methods. Individual loggers may listen for events (i.e.
34			* preloads) or other sources and gain access to detailed debugging information.
35			*
36			* @category Xoops\Core\Logger
37			* @package Logger
38			* @author Richard Griffith <[email protected]>
39			* @copyright 2013 XOOPS Project (http://xoops.org)
40			* @license GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
41			* @version Release: 2.6.0
42			* @link http://xoops.org
43			* @since 2.6.0
44			*/
45			class Logger implements LoggerInterface
46			{
47			/**
48			* @var LoggerInterface[] chain of PSR-3 compatible loggers to call
49			*/
50			private $loggers = array();
51
52			/**
53			* @var boolean do we have active loggers?
54			*/
55			private $logging_active = false;
56
57			/**
58			* @var boolean just to prevent fatal legacy errors. Does nothing. Stop it!
59			*/
60			//public $activated = false;
61
62			/**
63			* Get the Xoops\Core\Logger instance
64			*
65			* @return Logger object
66			*/
67	18		public static function getInstance()
68			{
69	18		static $instance;
70	18		if (!isset($instance)) {
71			$class = __CLASS__;
72			$instance = new $class();
73			// Always catch errors, for security reasons
74			set_error_handler(array($instance, 'handleError'));
75			// grab any uncaught exception
76			set_exception_handler(array($instance, 'handleException'));
77			}
78
79	18		return $instance;
80			}
81
82			/**
83			* Error handling callback.
84			*
85			* This will
86			*
87			* @param integer $errorNumber error number
88			* @param string $errorString error message
89			* @param string $errorFile file
90			* @param integer $errorLine line number
91			*
92			* @return void
93			*/
94	53		public function handleError($errorNumber, $errorString, $errorFile, $errorLine)
95			{
96	53		if ($this->logging_active && ($errorNumber & error_reporting())) {
97
98			// if an error occurs before a locale is established,
99			// we still need messages, so check and deal with it
100
101	5		$msg = ': ' . sprintf(
102	5		(class_exists('\XoopsLocale', false) ? \XoopsLocale::EF_LOGGER_FILELINE : "%s in file %s line %s"),
103	5		$this->sanitizePath($errorString),
104	5		$this->sanitizePath($errorFile),
105			$errorLine
106			);
107
108			switch ($errorNumber) {
109	5	View Code Duplication	case E_USER_NOTICE:
110	1		$msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_ERROR : '*Error:') . $msg;
111	1		$this->log(LogLevel::NOTICE, $msg);
112	1		break;
113	4	View Code Duplication	case E_NOTICE:
114	1		$msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_NOTICE : '*Notice:') . $msg;
115	1		$this->log(LogLevel::NOTICE, $msg);
116	1		break;
117	3	View Code Duplication	case E_WARNING:
118	1		$msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_WARNING : '*Warning:') . $msg;
119	1		$this->log(LogLevel::WARNING, $msg);
120	1		break;
121	2	View Code Duplication	case E_STRICT:
122	1		$msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_STRICT : '*Strict:') . $msg;
123	1		$this->log(LogLevel::WARNING, $msg);
124	1		break;
125	1	View Code Duplication	case E_USER_ERROR:
126			$msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_ERROR : '*Error:') . $msg;
127			@$this->log(LogLevel::CRITICAL, $msg);
			0 ignored issues – show Security Best Practice introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
128			break;
129		View Code Duplication	default:
130	1		$msg = (class_exists('\XoopsLocale', false) ? \XoopsLocale::E_LOGGER_UNKNOWN : '*Unknown:') . $msg;
131	1		$this->log(LogLevel::ERROR, $msg);
132	1		break;
133			}
134			}
135
136	53		if ($errorNumber == E_USER_ERROR) {
137			$trace = true;
138			if (substr($errorString, 0, '8') === 'notrace:') {
139			$trace = false;
140			$errorString = substr($errorString, 8);
141			}
142			$this->reportFatalError($errorString);
143			if ($trace) {
144			$trace = debug_backtrace();
145			array_shift($trace);
146			if ('cli' === php_sapi_name()) {
147			foreach ($trace as $step) {
148			if (isset($step['file'])) {
149			fprintf(STDERR, "%s (%d)\n", $this->sanitizePath($step['file']), $step['line']);
150			}
151			}
152			} else {
153			echo "<div style='color:#f0f0f0;background-color:#f0f0f0'>" . _XOOPS_FATAL_BACKTRACE . ":<br />";
154			foreach ($trace as $step) {
155			if (isset($step['file'])) {
156			printf("%s (%d)\n<br />", $this->sanitizePath($step['file']), $step['line']);
157			}
158			}
159			echo '</div>';
160			}
161			}
162			exit();
			0 ignored issues – show Coding Style Compatibility introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The method `handleError()` contains an exit expression. An exit expression should only be used in rare cases. For example, if you write a short command line script. In most cases however, using an `exit` expression makes the code untestable and often causes incompatibilities with other libraries. Thus, unless you are absolutely sure it is required here, we recommend to refactor your code to avoid its usage. Loading history...
163			}
164	53		}
165
166			/**
167			* Exception handling callback.
168			*
169			* @param \Exception\|\Throwable $e uncaught Exception or Error
170			*
171			* @return void
172			*/
173			public function handleException($e)
174			{
175			if ($this->isThrowable($e)) {
176			$msg = $e->getMessage();
177			$this->reportFatalError($msg);
178			}
179			}
180
181			/**
182			* Determine if an object implements Throwable (or is an Exception that would under PHP 7.)
183			*
184			* @param mixed $e Expected to be an object related to Exception or Throwable
185			*
186			* @return bool true if related to Throwable or Exception, otherwise false
187			*/
188			protected function isThrowable($e)
189			{
190			$type = interface_exists('\Throwable', false) ? '\Throwable' : '\Exception';
191			return $e instanceof $type;
192			}
193
194			/**
195			* Announce fatal error, attempt to log
196			*
197			* @param string $msg error message to report
198			*
199			* @return void
200			*/
201			private function reportFatalError($msg)
202			{
203			$msg=$this->sanitizePath($msg);
204			if ('cli' === php_sapi_name()) {
205			fprintf(STDERR, "\nError : %s\n", $msg);
206			} else {
207			printf(_XOOPS_FATAL_MESSAGE, XOOPS_URL, $msg);
208			}
209			@$this->log(LogLevel::CRITICAL, $msg);
			0 ignored issues – show Security Best Practice introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
210			}
211
212			/**
213			* clean a path to remove sensitive details
214			*
215			* @param string $message text to sanitize
216			*
217			* @return string sanitized message
218			*/
219	21		public function sanitizePath($message)
220			{
221			$cleaners = [
222	21		['\\', '/',],
223	21		[\XoopsBaseConfig::get('var-path'), 'VAR',],
224	21		[str_replace('\\', '/', realpath(\XoopsBaseConfig::get('var-path'))), 'VAR',],
225	21		[\XoopsBaseConfig::get('lib-path'), 'LIB',],
226	21		[str_replace('\\', '/', realpath(\XoopsBaseConfig::get('lib-path'))), 'LIB',],
227	21		[\XoopsBaseConfig::get('root-path'), 'ROOT',],
228	21		[str_replace('\\', '/', realpath(\XoopsBaseConfig::get('root-path'))), 'ROOT',],
229	21		[\XoopsBaseConfig::get('db-name') . '.', '',],
230	21		[\XoopsBaseConfig::get('db-name'), '',],
231	21		[\XoopsBaseConfig::get('db-prefix') . '_', '',],
232	21		[\XoopsBaseConfig::get('db-user'), '***',],
233	21		[\XoopsBaseConfig::get('db-pass'), '***',],
234			];
235	21		$stringsToClean = array_column($cleaners, 0);
236	21		$replacementStings = array_column($cleaners, 1);
237
238	21		$message = str_replace($stringsToClean, $replacementStings, $message);
239
240	21		return $message;
241			}
242
243			/**
244			* add a PSR-3 compatible logger to the chain
245			*
246			* @param object $logger a PSR-3 compatible logger object
247			*
248			* @return void
249			*/
250	22		public function addLogger($logger)
251			{
252	22		if (is_object($logger) && method_exists($logger, 'log')) {
253	22		$this->loggers[] = $logger;
254	22		$this->logging_active = true;
255			}
256	22		}
257
258			/**
259			* System is unusable.
260			*
261			* @param string $message message
262			* @param array $context array of context data for this log entry
263			*
264			* @return void
265			*/
266	1		public function emergency($message, array $context = array())
267			{
268	1		$this->log(LogLevel::EMERGENCY, $message, $context);
269	1		}
270
271			/**
272			* Action must be taken immediately.
273			*
274			* Example: Entire website down, database unavailable, etc. This should
275			* trigger the SMS alerts and wake you up.
276			*
277			* @param string $message message
278			* @param array $context array of context data for this log entry
279			*
280			* @return void
281			*/
282	1		public function alert($message, array $context = array())
283			{
284	1		$this->log(LogLevel::ALERT, $message, $context);
285	1		}
286
287			/**
288			* Critical conditions.
289			*
290			* Example: Application component unavailable, unexpected exception.
291			*
292			* @param string $message message
293			* @param array $context array of context data for this log entry
294			*
295			* @return void
296			*/
297	1		public function critical($message, array $context = array())
298			{
299	1		$this->log(LogLevel::CRITICAL, $message, $context);
300	1		}
301
302			/**
303			* Runtime errors that do not require immediate action but should typically
304			* be logged and monitored.
305			*
306			* @param string $message message
307			* @param array $context array of context data for this log entry
308			*
309			* @return void
310			*/
311	1		public function error($message, array $context = array())
312			{
313	1		$this->log(LogLevel::ERROR, $message, $context);
314	1		}
315
316			/**
317			* Exceptional occurrences that are not errors.
318			*
319			* Example: Use of deprecated APIs, poor use of an API, undesirable things
320			* that are not necessarily wrong.
321			*
322			* @param string $message message
323			* @param array $context array of context data for this log entry
324			*
325			* @return void
326			*/
327	1		public function warning($message, array $context = array())
328			{
329	1		$this->log(LogLevel::WARNING, $message, $context);
330	1		}
331
332			/**
333			* Normal but significant events.
334			*
335			* @param string $message message
336			* @param array $context array of context data for this log entry
337			*
338			* @return void
339			*/
340	1		public function notice($message, array $context = array())
341			{
342	1		$this->log(LogLevel::NOTICE, $message, $context);
343	1		}
344
345			/**
346			* Interesting events.
347			*
348			* Example: User logs in, SQL logs.
349			*
350			* @param string $message message
351			* @param array $context array of context data for this log entry
352			*
353			* @return void
354			*/
355	1		public function info($message, array $context = array())
356			{
357	1		$this->log(LogLevel::INFO, $message, $context);
358	1		}
359
360			/**
361			* Detailed debug information.
362			*
363			* @param string $message message
364			* @param array $context array of context data for this log entry
365			*
366			* @return void
367			*/
368	1		public function debug($message, array $context = array())
369			{
370	1		$this->log(LogLevel::DEBUG, $message, $context);
371	1		}
372
373			/**
374			* Logs with an arbitrary level.
375			*
376			* @param mixed $level PSR-3 LogLevel constant
377			* @param string $message message
378			* @param array $context array of context data for this log entry
379			*
380			* @return void
381			*/
382	14		public function log($level, $message, array $context = array())
383			{
384	14		if (!empty($this->loggers)) {
385	13		foreach ($this->loggers as $logger) {
386	13		if (is_object($logger)) {
387			try {
388	13		$logger->log($level, $message, $context);
389	13		} catch (\Exception $e) {
390			// just ignore, as we can't do anything, not even log it.
391			}
392			}
393			}
394			}
395	14		}
396
397			/**
398			* quiet - turn off output if output is rendered in XOOPS page output.
399			* This is intended to assist ajax code that may fail with any extra
400			* content the logger may introduce.
401			*
402			* It should have no effect on loggers using other methods, such a write
403			* to file.
404			*
405			* @return void
406			*/
407	2		public function quiet()
408			{
409	2		if (!empty($this->loggers)) {
410	2		foreach ($this->loggers as $logger) {
411	2		if (is_object($logger) && method_exists($logger, 'quiet')) {
412			try {
413	2		$logger->quiet();
414	2		} catch (\Exception $e) {
415			// just ignore, as we can't do anything, not even log it.
416			}
417			}
418			}
419			}
420	2		}
421
422			// Deprecated uses
423
424			/**
425			* Keep deprecated calls from failing
426			*
427			* @param string $var property
428			* @param string $val value
429			*
430			* @return void
431			*
432			* @deprecated
433			*/
434	1		public function __set($var, $val)
435			{
436	1		$this->deprecatedMessage();
437			// legacy compatibility: turn off logger display for $xoopsLogger->activated = false; usage
438	1		if ($var==='activated' && !$val) {
439	1		$this->quiet();
440			}
441
442	1		}
443
444			/**
445			* Keep deprecated calls from failing
446			*
447			* @param string $var property
448			*
449			* @return void
450			*
451			* @deprecated
452			*/
453	1		public function __get($var)
454			{
455	1		$this->deprecatedMessage();
456	1		}
457
458			/**
459			* Keep deprecated calls from failing
460			*
461			* @param string $method method
462			* @param string $args arguments
463			*
464			* @return void
465			*
466			* @deprecated
467			*/
468	1		public function __call($method, $args)
469			{
470	1		$this->deprecatedMessage();
471	1		}
472
473			/**
474			* issue a deprecated warning
475			*
476			* @return void
477			*/
478	3		private function deprecatedMessage()
479			{
480	3		$xoops = \Xoops::getInstance();
481	3		$xoops->deprecated('This use of XoopsLogger is deprecated since 2.6.0.');
482	3		}
483			}
484

XOOPS / XoopsCore

Push — master ( cde499...a7c413 )

Logger::isThrowable() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like