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

Completed

Push — master ( fe4c2e...b05117 )

by Michael

created 2016-03-22 03:26 UTC

Logger::__call() A

↳ Parent: Logger

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Metric	Value
dl	0
loc	4
rs	10
ccs	3
cts	3
cp	1
cc	1
eloc	2
nc	1
nop	2
crap	1

<?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.
     *
     * This will
     *
     * @param \Exception|\Throwable $e uncaught Exception or Error
     *
     * @return void
     */
    public function handleException($e)
    {
        $msg = $e->getMessage();
        $this->reportFatalError($msg);
    }

    /**
     * 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	55		public function handleError($errorNumber, $errorString, $errorFile, $errorLine)
95			{
96	55		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	55		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	55		}
165
166			/**
167			* Exception handling callback.
168			*
169			* This will
170			*
171			* @param \Exception\|\Throwable $e uncaught Exception or Error
172			*
173			* @return void
174			*/
175			public function handleException($e)
176			{
177			$msg = $e->getMessage();
178			$this->reportFatalError($msg);
179			}
180
181			/**
182			* Announce fatal error, attempt to log
183			*
184			* @param string $msg error message to report
185			*
186			* @return void
187			*/
188			private function reportFatalError($msg)
189			{
190			$msg=$this->sanitizePath($msg);
191			if ('cli' === php_sapi_name()) {
192			fprintf(STDERR, "\nError : %s\n", $msg);
193			} else {
194			printf(_XOOPS_FATAL_MESSAGE, XOOPS_URL, $msg);
195			}
196			@$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...
197			}
198
199			/**
200			* clean a path to remove sensitive details
201			*
202			* @param string $message text to sanitize
203			*
204			* @return string sanitized message
205			*/
206	21		public function sanitizePath($message)
207			{
208			$cleaners = [
209	21		['\\', '/',],
210	21		[\XoopsBaseConfig::get('var-path'), 'VAR',],
211	21		[str_replace('\\', '/', realpath(\XoopsBaseConfig::get('var-path'))), 'VAR',],
212	21		[\XoopsBaseConfig::get('lib-path'), 'LIB',],
213	21		[str_replace('\\', '/', realpath(\XoopsBaseConfig::get('lib-path'))), 'LIB',],
214	21		[\XoopsBaseConfig::get('root-path'), 'ROOT',],
215	21		[str_replace('\\', '/', realpath(\XoopsBaseConfig::get('root-path'))), 'ROOT',],
216	21		[\XoopsBaseConfig::get('db-name') . '.', '',],
217	21		[\XoopsBaseConfig::get('db-name'), '',],
218	21		[\XoopsBaseConfig::get('db-prefix') . '_', '',],
219	21		[\XoopsBaseConfig::get('db-user'), '***',],
220	21		[\XoopsBaseConfig::get('db-pass'), '***',],
221			];
222	21		$stringsToClean = array_column($cleaners, 0);
223	21		$replacementStings = array_column($cleaners, 1);
224
225	21		$message = str_replace($stringsToClean, $replacementStings, $message);
226
227	21		return $message;
228			}
229
230			/**
231			* add a PSR-3 compatible logger to the chain
232			*
233			* @param object $logger a PSR-3 compatible logger object
234			*
235			* @return void
236			*/
237	22		public function addLogger($logger)
238			{
239	22		if (is_object($logger) && method_exists($logger, 'log')) {
240	22		$this->loggers[] = $logger;
241	22		$this->logging_active = true;
242			}
243	22		}
244
245			/**
246			* System is unusable.
247			*
248			* @param string $message message
249			* @param array $context array of context data for this log entry
250			*
251			* @return void
252			*/
253	1		public function emergency($message, array $context = array())
254			{
255	1		$this->log(LogLevel::EMERGENCY, $message, $context);
256	1		}
257
258			/**
259			* Action must be taken immediately.
260			*
261			* Example: Entire website down, database unavailable, etc. This should
262			* trigger the SMS alerts and wake you up.
263			*
264			* @param string $message message
265			* @param array $context array of context data for this log entry
266			*
267			* @return void
268			*/
269	1		public function alert($message, array $context = array())
270			{
271	1		$this->log(LogLevel::ALERT, $message, $context);
272	1		}
273
274			/**
275			* Critical conditions.
276			*
277			* Example: Application component unavailable, unexpected exception.
278			*
279			* @param string $message message
280			* @param array $context array of context data for this log entry
281			*
282			* @return void
283			*/
284	1		public function critical($message, array $context = array())
285			{
286	1		$this->log(LogLevel::CRITICAL, $message, $context);
287	1		}
288
289			/**
290			* Runtime errors that do not require immediate action but should typically
291			* be logged and monitored.
292			*
293			* @param string $message message
294			* @param array $context array of context data for this log entry
295			*
296			* @return void
297			*/
298	1		public function error($message, array $context = array())
299			{
300	1		$this->log(LogLevel::ERROR, $message, $context);
301	1		}
302
303			/**
304			* Exceptional occurrences that are not errors.
305			*
306			* Example: Use of deprecated APIs, poor use of an API, undesirable things
307			* that are not necessarily wrong.
308			*
309			* @param string $message message
310			* @param array $context array of context data for this log entry
311			*
312			* @return void
313			*/
314	1		public function warning($message, array $context = array())
315			{
316	1		$this->log(LogLevel::WARNING, $message, $context);
317	1		}
318
319			/**
320			* Normal but significant events.
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 notice($message, array $context = array())
328			{
329	1		$this->log(LogLevel::NOTICE, $message, $context);
330	1		}
331
332			/**
333			* Interesting events.
334			*
335			* Example: User logs in, SQL logs.
336			*
337			* @param string $message message
338			* @param array $context array of context data for this log entry
339			*
340			* @return void
341			*/
342	1		public function info($message, array $context = array())
343			{
344	1		$this->log(LogLevel::INFO, $message, $context);
345	1		}
346
347			/**
348			* Detailed debug information.
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 debug($message, array $context = array())
356			{
357	1		$this->log(LogLevel::DEBUG, $message, $context);
358	1		}
359
360			/**
361			* Logs with an arbitrary level.
362			*
363			* @param mixed $level PSR-3 LogLevel constant
364			* @param string $message message
365			* @param array $context array of context data for this log entry
366			*
367			* @return void
368			*/
369	14		public function log($level, $message, array $context = array())
370			{
371	14		if (!empty($this->loggers)) {
372	13		foreach ($this->loggers as $logger) {
373	13		if (is_object($logger)) {
374			try {
375	13		$logger->log($level, $message, $context);
376	13		} catch (\Exception $e) {
377			// just ignore, as we can't do anything, not even log it.
378			}
379			}
380			}
381			}
382	14		}
383
384			/**
385			* quiet - turn off output if output is rendered in XOOPS page output.
386			* This is intended to assist ajax code that may fail with any extra
387			* content the logger may introduce.
388			*
389			* It should have no effect on loggers using other methods, such a write
390			* to file.
391			*
392			* @return void
393			*/
394	2		public function quiet()
395			{
396	2		if (!empty($this->loggers)) {
397	2		foreach ($this->loggers as $logger) {
398	2		if (is_object($logger) && method_exists($logger, 'quiet')) {
399			try {
400	2		$logger->quiet();
401	2		} catch (\Exception $e) {
402			// just ignore, as we can't do anything, not even log it.
403			}
404			}
405			}
406			}
407	2		}
408
409			// Deprecated uses
410
411			/**
412			* Keep deprecated calls from failing
413			*
414			* @param string $var property
415			* @param string $val value
416			*
417			* @return void
418			*
419			* @deprecated
420			*/
421	1		public function __set($var, $val)
422			{
423	1		$this->deprecatedMessage();
424			// legacy compatibility: turn off logger display for $xoopsLogger->activated = false; usage
425	1		if ($var==='activated' && !$val) {
426	1		$this->quiet();
427			}
428
429	1		}
430
431			/**
432			* Keep deprecated calls from failing
433			*
434			* @param string $var property
435			*
436			* @return void
437			*
438			* @deprecated
439			*/
440	1		public function __get($var)
441			{
442	1		$this->deprecatedMessage();
443	1		}
444
445			/**
446			* Keep deprecated calls from failing
447			*
448			* @param string $method method
449			* @param string $args arguments
450			*
451			* @return void
452			*
453			* @deprecated
454			*/
455	1		public function __call($method, $args)
456			{
457	1		$this->deprecatedMessage();
458	1		}
459
460			/**
461			* issue a deprecated warning
462			*
463			* @return void
464			*/
465	3		private function deprecatedMessage()
466			{
467	3		$xoops = \Xoops::getInstance();
468	3		$xoops->deprecated('This use of XoopsLogger is deprecated since 2.6.0.');
469	3		}
470			}
471

XOOPS / XoopsCore

Push — master ( fe4c2e...b05117 )

Logger::__call() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like