Log::debug() - Code Metrics - Inspection of "Merge pull request #9177 from nextcloud/log-except..." - nextcloud/server - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 42b7df...991790 )

by Robin

created 2018-04-17 13:26 UTC

Log::debug() A

↳ Parent: Log

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	2
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php
declare(strict_types=1);
/**
 * @copyright Copyright (c) 2016, ownCloud, Inc.
 *
 * @author Arthur Schiwon <[email protected]>
 * @author Bart Visscher <[email protected]>
 * @author Bernhard Posselt <[email protected]>
 * @author Joas Schilling <[email protected]>
 * @author Johannes Schlichenmaier <[email protected]>
 * @author Juan Pablo Villafáñez <[email protected]>
 * @author Lukas Reschke <[email protected]>
 * @author Morris Jobke <[email protected]>
 * @author Olivier Paroz <[email protected]>
 * @author Robin Appelman <[email protected]>
 * @author Thomas Müller <[email protected]>
 * @author Thomas Pulzer <[email protected]>
 * @author Victor Dubiniuk <[email protected]>
 *
 * @license AGPL-3.0
 *
 * This code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License, version 3,
 * as published by the Free Software Foundation.
 *
 * 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. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License, version 3,
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 *
 */

namespace OC;

use InterfaSys\LogNormalizer\Normalizer;

use OC\Log\ExceptionSerializer;
use OC\Log\File;
use OCP\ILogger;
use OCP\Support\CrashReport\IRegistry;
use OCP\Util;

/**
 * logging utilities
 *
 * This is a stand in, this should be replaced by a Psr\Log\LoggerInterface
 * compatible logger. See https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md
 * for the full interface specification.
 *
 * MonoLog is an example implementing this interface.
 */
class Log implements ILogger {

	/** @var string */
	private $logger;

	/** @var SystemConfig */
	private $config;

	/** @var boolean|null cache the result of the log condition check for the request */
	private $logConditionSatisfied = null;

	/** @var Normalizer */
	private $normalizer;

	/** @var IRegistry */
	private $crashReporters;

	/**
	 * @param string $logger The logger that should be used
	 * @param SystemConfig $config the system config object
	 * @param Normalizer|null $normalizer
	 * @param IRegistry|null $registry
	 */
	public function __construct($logger = null, SystemConfig $config = null, $normalizer = null, IRegistry $registry = null) {
		// FIXME: Add this for backwards compatibility, should be fixed at some point probably
		if ($config === null) {
			$config = \OC::$server->getSystemConfig();
		}

		$this->config = $config;

		// FIXME: Add this for backwards compatibility, should be fixed at some point probably
		if ($logger === null) {
			$logType = $this->config->getValue('log_type', 'file');
			$this->logger = static::getLogClass($logType);
			call_user_func([$this->logger, 'init']);
		} else {
			$this->logger = $logger;
		}
		if ($normalizer === null) {
			$this->normalizer = new Normalizer();
		} else {
			$this->normalizer = $normalizer;
		}
		$this->crashReporters = $registry;
	}

	/**
	 * System is unusable.
	 *
	 * @param string $message
	 * @param array $context
	 * @return void
	 */
	public function emergency(string $message, array $context = []) {
		$this->log(Util::FATAL, $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
	 * @param array $context
	 * @return void
	 */
	public function alert(string $message, array $context = []) {
		$this->log(Util::ERROR, $message, $context);
	}

	/**
	 * Critical conditions.
	 *
	 * Example: Application component unavailable, unexpected exception.
	 *
	 * @param string $message
	 * @param array $context
	 * @return void
	 */
	public function critical(string $message, array $context = []) {
		$this->log(Util::ERROR, $message, $context);
	}

	/**
	 * Runtime errors that do not require immediate action but should typically
	 * be logged and monitored.
	 *
	 * @param string $message
	 * @param array $context
	 * @return void
	 */
	public function error(string $message, array $context = []) {
		$this->log(Util::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
	 * @param array $context
	 * @return void
	 */
	public function warning(string $message, array $context = []) {
		$this->log(Util::WARN, $message, $context);
	}

	/**
	 * Normal but significant events.
	 *
	 * @param string $message
	 * @param array $context
	 * @return void
	 */
	public function notice(string $message, array $context = []) {
		$this->log(Util::INFO, $message, $context);
	}

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

	/**
	 * Detailed debug information.
	 *
	 * @param string $message
	 * @param array $context
	 * @return void
	 */
	public function debug(string $message, array $context = []) {
		$this->log(Util::DEBUG, $message, $context);
	}


	/**
	 * Logs with an arbitrary level.
	 *
	 * @param int $level
	 * @param string $message
	 * @param array $context
	 * @return void
	 */
	public function log(int $level, string $message, array $context = []) {
		$minLevel = $this->getLogLevel($context);

		array_walk($context, [$this->normalizer, 'format']);

		$app = $context['app'] ?? 'no app in context';

		// interpolate $message as defined in PSR-3
		$replace = [];
		foreach ($context as $key => $val) {
			$replace['{' . $key . '}'] = $val;
		}
		$message = strtr($message, $replace);

		if ($level >= $minLevel) {
			$this->writeLog($app, $message, $level);
		}
	}

	private function getLogLevel($context) {
		/**
		 * check for a special log condition - this enables an increased log on
		 * a per request/user base
		 */
		if ($this->logConditionSatisfied === null) {
			// default to false to just process this once per request
			$this->logConditionSatisfied = false;
			if (!empty($logCondition)) {


				// check for secret token in the request
				if (isset($logCondition['shared_secret'])) {
					$request = \OC::$server->getRequest();

					// if token is found in the request change set the log condition to satisfied
					if ($request && hash_equals($logCondition['shared_secret'], $request->getParam('log_secret', ''))) {
						$this->logConditionSatisfied = true;
					}
				}

				// check for user
				if (isset($logCondition['users'])) {
					$user = \OC::$server->getUserSession()->getUser();

					// if the user matches set the log condition to satisfied
					if ($user !== null && in_array($user->getUID(), $logCondition['users'], true)) {
						$this->logConditionSatisfied = true;
					}
				}
			}
		}

		// if log condition is satisfied change the required log level to DEBUG
		if ($this->logConditionSatisfied) {
			return Util::DEBUG;
		}

		if (isset($context['app'])) {
			$logCondition = $this->config->getValue('log.condition', []);
			$app = $context['app'];

			/**
			 * check log condition based on the context of each log message
			 * once this is met -> change the required log level to debug
			 */
			if (!empty($logCondition)
				&& isset($logCondition['apps'])
				&& in_array($app, $logCondition['apps'], true)) {
				return Util::DEBUG;
			}
		}

		return min($this->config->getValue('loglevel', Util::WARN), Util::FATAL);
	}

	/**
	 * Logs an exception very detailed
	 *
	 * @param \Exception|\Throwable $exception
	 * @param array $context
	 * @return void
	 * @since 8.2.0
	 */
	public function logException(\Throwable $exception, array $context = []) {
		$app = $context['app'] ?? 'no app in context';
		$level = $context['level'] ?? Util::ERROR;

		$serializer = new ExceptionSerializer();
		$data = $serializer->serializeException($exception);
		$data['CustomMessage'] = $context['message'] ?? '--';

		$minLevel = $this->getLogLevel($context);

		array_walk($context, [$this->normalizer, 'format']);

		if ($level >= $minLevel) {
			if ($this->logger !== File::class) {
				$data = json_encode($data, JSON_PARTIAL_OUTPUT_ON_ERROR);
			}
			$this->writeLog($app, $data, $level);
		}

		$context['level'] = $level;
		if (!is_null($this->crashReporters)) {
			$this->crashReporters->delegateReport($exception, $context);
		}
	}

	/**
	 * @param string $app
	 * @param string|array $entry
	 * @param int $level
	 */
	protected function writeLog(string $app, $entry, int $level) {
		call_user_func([$this->logger, 'write'], $app, $entry, $level);
	}

	/**
	 * @param string $logType
	 * @return string
	 * @internal
	 */
	public static function getLogClass(string $logType): string {
		switch (strtolower($logType)) {
			case 'errorlog':
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
				return \OC\Log\Errorlog::class;
			case 'syslog':
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
				return \OC\Log\Syslog::class;
			case 'file':
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
				return \OC\Log\File::class;

			// Backwards compatibility for old and fallback for unknown log types
			case 'owncloud':
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
			case 'nextcloud':
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
			default:
switch ($expr) {
    default: { //wrong
        doSomething();
        break;
    }
}

switch ($expr) {
    default: //right
        doSomething();
        break;
}
				return \OC\Log\File::class;
		}
	}
}


1			<?php
2			declare(strict_types=1);
3			/**
4			* @copyright Copyright (c) 2016, ownCloud, Inc.
5			*
6			* @author Arthur Schiwon <[email protected]>
7			* @author Bart Visscher <[email protected]>
8			* @author Bernhard Posselt <[email protected]>
9			* @author Joas Schilling <[email protected]>
10			* @author Johannes Schlichenmaier <[email protected]>
11			* @author Juan Pablo Villafáñez <[email protected]>
12			* @author Lukas Reschke <[email protected]>
13			* @author Morris Jobke <[email protected]>
14			* @author Olivier Paroz <[email protected]>
15			* @author Robin Appelman <[email protected]>
16			* @author Thomas Müller <[email protected]>
17			* @author Thomas Pulzer <[email protected]>
18			* @author Victor Dubiniuk <[email protected]>
19			*
20			* @license AGPL-3.0
21			*
22			* This code is free software: you can redistribute it and/or modify
23			* it under the terms of the GNU Affero General Public License, version 3,
24			* as published by the Free Software Foundation.
25			*
26			* This program is distributed in the hope that it will be useful,
27			* but WITHOUT ANY WARRANTY; without even the implied warranty of
28			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29			* GNU Affero General Public License for more details.
30			*
31			* You should have received a copy of the GNU Affero General Public License, version 3,
32			* along with this program. If not, see <http://www.gnu.org/licenses/>
33			*
34			*/
35
36			namespace OC;
37
38			use InterfaSys\LogNormalizer\Normalizer;
39
40			use OC\Log\ExceptionSerializer;
41			use OC\Log\File;
42			use OCP\ILogger;
43			use OCP\Support\CrashReport\IRegistry;
44			use OCP\Util;
45
46			/**
47			* logging utilities
48			*
49			* This is a stand in, this should be replaced by a Psr\Log\LoggerInterface
50			* compatible logger. See https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md
51			* for the full interface specification.
52			*
53			* MonoLog is an example implementing this interface.
54			*/
55			class Log implements ILogger {
56
57			/** @var string */
58			private $logger;
59
60			/** @var SystemConfig */
61			private $config;
62
63			/** @var boolean\|null cache the result of the log condition check for the request */
64			private $logConditionSatisfied = null;
65
66			/** @var Normalizer */
67			private $normalizer;
68
69			/** @var IRegistry */
70			private $crashReporters;
71
72			/**
73			* @param string $logger The logger that should be used
74			* @param SystemConfig $config the system config object
75			* @param Normalizer\|null $normalizer
76			* @param IRegistry\|null $registry
77			*/
78			public function __construct($logger = null, SystemConfig $config = null, $normalizer = null, IRegistry $registry = null) {
79			// FIXME: Add this for backwards compatibility, should be fixed at some point probably
80			if ($config === null) {
81			$config = \OC::$server->getSystemConfig();
82			}
83
84			$this->config = $config;
85
86			// FIXME: Add this for backwards compatibility, should be fixed at some point probably
87			if ($logger === null) {
88			$logType = $this->config->getValue('log_type', 'file');
89			$this->logger = static::getLogClass($logType);
90			call_user_func([$this->logger, 'init']);
91			} else {
92			$this->logger = $logger;
93			}
94			if ($normalizer === null) {
95			$this->normalizer = new Normalizer();
96			} else {
97			$this->normalizer = $normalizer;
98			}
99			$this->crashReporters = $registry;
100			}
101
102			/**
103			* System is unusable.
104			*
105			* @param string $message
106			* @param array $context
107			* @return void
108			*/
109			public function emergency(string $message, array $context = []) {
110			$this->log(Util::FATAL, $message, $context);
111			}
112
113			/**
114			* Action must be taken immediately.
115			*
116			* Example: Entire website down, database unavailable, etc. This should
117			* trigger the SMS alerts and wake you up.
118			*
119			* @param string $message
120			* @param array $context
121			* @return void
122			*/
123			public function alert(string $message, array $context = []) {
124			$this->log(Util::ERROR, $message, $context);
125			}
126
127			/**
128			* Critical conditions.
129			*
130			* Example: Application component unavailable, unexpected exception.
131			*
132			* @param string $message
133			* @param array $context
134			* @return void
135			*/
136			public function critical(string $message, array $context = []) {
137			$this->log(Util::ERROR, $message, $context);
138			}
139
140			/**
141			* Runtime errors that do not require immediate action but should typically
142			* be logged and monitored.
143			*
144			* @param string $message
145			* @param array $context
146			* @return void
147			*/
148			public function error(string $message, array $context = []) {
149			$this->log(Util::ERROR, $message, $context);
150			}
151
152			/**
153			* Exceptional occurrences that are not errors.
154			*
155			* Example: Use of deprecated APIs, poor use of an API, undesirable things
156			* that are not necessarily wrong.
157			*
158			* @param string $message
159			* @param array $context
160			* @return void
161			*/
162			public function warning(string $message, array $context = []) {
163			$this->log(Util::WARN, $message, $context);
164			}
165
166			/**
167			* Normal but significant events.
168			*
169			* @param string $message
170			* @param array $context
171			* @return void
172			*/
173			public function notice(string $message, array $context = []) {
174			$this->log(Util::INFO, $message, $context);
175			}
176
177			/**
178			* Interesting events.
179			*
180			* Example: User logs in, SQL logs.
181			*
182			* @param string $message
183			* @param array $context
184			* @return void
185			*/
186			public function info(string $message, array $context = []) {
187			$this->log(Util::INFO, $message, $context);
188			}
189
190			/**
191			* Detailed debug information.
192			*
193			* @param string $message
194			* @param array $context
195			* @return void
196			*/
197			public function debug(string $message, array $context = []) {
198			$this->log(Util::DEBUG, $message, $context);
199			}
200
201
202			/**
203			* Logs with an arbitrary level.
204			*
205			* @param int $level
206			* @param string $message
207			* @param array $context
208			* @return void
209			*/
210			public function log(int $level, string $message, array $context = []) {
211			$minLevel = $this->getLogLevel($context);
212
213			array_walk($context, [$this->normalizer, 'format']);
214
215			$app = $context['app'] ?? 'no app in context';
216
217			// interpolate $message as defined in PSR-3
218			$replace = [];
219			foreach ($context as $key => $val) {
220			$replace['{' . $key . '}'] = $val;
221			}
222			$message = strtr($message, $replace);
223
224			if ($level >= $minLevel) {
225			$this->writeLog($app, $message, $level);
226			}
227			}
228
229			private function getLogLevel($context) {
230			/**
231			* check for a special log condition - this enables an increased log on
232			* a per request/user base
233			*/
234			if ($this->logConditionSatisfied === null) {
235			// default to false to just process this once per request
236			$this->logConditionSatisfied = false;
237			if (!empty($logCondition)) {
			0 ignored issues – show Bug introduced 2018-03-22 16:12 UTC by Report Bug Copy Issue Report The variable `$logCondition` seems only to be defined at a later point. As such the call to `empty()` seems to always evaluate to `true`. This check marks calls to `isset(...)` or `empty(...)` that are found before the variable itself is defined. These will always have the same result. This is likely the result of code being shifted around. Consider removing these calls. Loading history...
238
239			// check for secret token in the request
240			if (isset($logCondition['shared_secret'])) {
241			$request = \OC::$server->getRequest();
242
243			// if token is found in the request change set the log condition to satisfied
244			if ($request && hash_equals($logCondition['shared_secret'], $request->getParam('log_secret', ''))) {
245			$this->logConditionSatisfied = true;
246			}
247			}
248
249			// check for user
250			if (isset($logCondition['users'])) {
251			$user = \OC::$server->getUserSession()->getUser();
252
253			// if the user matches set the log condition to satisfied
254			if ($user !== null && in_array($user->getUID(), $logCondition['users'], true)) {
255			$this->logConditionSatisfied = true;
256			}
257			}
258			}
259			}
260
261			// if log condition is satisfied change the required log level to DEBUG
262			if ($this->logConditionSatisfied) {
263			return Util::DEBUG;
264			}
265
266			if (isset($context['app'])) {
267			$logCondition = $this->config->getValue('log.condition', []);
268			$app = $context['app'];
269
270			/**
271			* check log condition based on the context of each log message
272			* once this is met -> change the required log level to debug
273			*/
274			if (!empty($logCondition)
275			&& isset($logCondition['apps'])
276			&& in_array($app, $logCondition['apps'], true)) {
277			return Util::DEBUG;
278			}
279			}
280
281			return min($this->config->getValue('loglevel', Util::WARN), Util::FATAL);
282			}
283
284			/**
285			* Logs an exception very detailed
286			*
287			* @param \Exception\|\Throwable $exception
288			* @param array $context
289			* @return void
290			* @since 8.2.0
291			*/
292			public function logException(\Throwable $exception, array $context = []) {
293			$app = $context['app'] ?? 'no app in context';
294			$level = $context['level'] ?? Util::ERROR;
295
296			$serializer = new ExceptionSerializer();
297			$data = $serializer->serializeException($exception);
298			$data['CustomMessage'] = $context['message'] ?? '--';
299
300			$minLevel = $this->getLogLevel($context);
301
302			array_walk($context, [$this->normalizer, 'format']);
303
304			if ($level >= $minLevel) {
305			if ($this->logger !== File::class) {
306			$data = json_encode($data, JSON_PARTIAL_OUTPUT_ON_ERROR);
307			}
308			$this->writeLog($app, $data, $level);
309			}
310
311			$context['level'] = $level;
312			if (!is_null($this->crashReporters)) {
313			$this->crashReporters->delegateReport($exception, $context);
314			}
315			}
316
317			/**
318			* @param string $app
319			* @param string\|array $entry
320			* @param int $level
321			*/
322			protected function writeLog(string $app, $entry, int $level) {
323			call_user_func([$this->logger, 'write'], $app, $entry, $level);
324			}
325
326			/**
327			* @param string $logType
328			* @return string
329			* @internal
330			*/
331			public static function getLogClass(string $logType): string {
332			switch (strtolower($logType)) {
333			case 'errorlog':
			0 ignored issues – show Coding Style introduced 2018-04-10 10:09 UTC by Report Bug Copy Issue Report `case` statements should be defined using a colon. As per the PSR-2 coding standard, case statements should not be wrapped in curly braces. There is no need for braces, since each case is terminated by the next `break`. There is also the option to use a semicolon instead of a colon, this is discouraged because many programmers do not even know it works and the colon is universal between programming languages. switch ($expr) { case "A": { //wrong doSomething(); break; } case "B"; //wrong doSomething(); break; case "C": //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
334			return \OC\Log\Errorlog::class;
335			case 'syslog':
			0 ignored issues – show Coding Style introduced 2018-04-10 10:09 UTC by Report Bug Copy Issue Report `case` statements should be defined using a colon. As per the PSR-2 coding standard, case statements should not be wrapped in curly braces. There is no need for braces, since each case is terminated by the next `break`. There is also the option to use a semicolon instead of a colon, this is discouraged because many programmers do not even know it works and the colon is universal between programming languages. switch ($expr) { case "A": { //wrong doSomething(); break; } case "B"; //wrong doSomething(); break; case "C": //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
336			return \OC\Log\Syslog::class;
337			case 'file':
			0 ignored issues – show Coding Style introduced 2018-04-10 10:09 UTC by Report Bug Copy Issue Report `case` statements should be defined using a colon. As per the PSR-2 coding standard, case statements should not be wrapped in curly braces. There is no need for braces, since each case is terminated by the next `break`. There is also the option to use a semicolon instead of a colon, this is discouraged because many programmers do not even know it works and the colon is universal between programming languages. switch ($expr) { case "A": { //wrong doSomething(); break; } case "B"; //wrong doSomething(); break; case "C": //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
338			return \OC\Log\File::class;
339
340			// Backwards compatibility for old and fallback for unknown log types
341			case 'owncloud':
			0 ignored issues – show Coding Style introduced 2018-04-10 10:09 UTC by Report Bug Copy Issue Report `case` statements should be defined using a colon. As per the PSR-2 coding standard, case statements should not be wrapped in curly braces. There is no need for braces, since each case is terminated by the next `break`. There is also the option to use a semicolon instead of a colon, this is discouraged because many programmers do not even know it works and the colon is universal between programming languages. switch ($expr) { case "A": { //wrong doSomething(); break; } case "B"; //wrong doSomething(); break; case "C": //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
342			case 'nextcloud':
			0 ignored issues – show Coding Style introduced 2018-04-10 10:09 UTC by Report Bug Copy Issue Report `case` statements should be defined using a colon. As per the PSR-2 coding standard, case statements should not be wrapped in curly braces. There is no need for braces, since each case is terminated by the next `break`. There is also the option to use a semicolon instead of a colon, this is discouraged because many programmers do not even know it works and the colon is universal between programming languages. switch ($expr) { case "A": { //wrong doSomething(); break; } case "B"; //wrong doSomething(); break; case "C": //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
343			default:
			0 ignored issues – show Coding Style introduced 2018-04-10 10:09 UTC by Report Bug Copy Issue Report DEFAULT statements must be defined using a colon As per the PSR-2 coding standard, default statements should not be wrapped in curly braces. switch ($expr) { default: { //wrong doSomething(); break; } } switch ($expr) { default: //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
344			return \OC\Log\File::class;
345			}
346			}
347			}
348

nextcloud / server

Push — master ( 42b7df...991790 )

Log::debug() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like