You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

381 lines
10 KiB

3 years ago
  1. <?php
  2. declare(strict_types=1);
  3. /**
  4. * @copyright Copyright (c) 2016, ownCloud, Inc.
  5. *
  6. * @author Arthur Schiwon <blizzz@arthur-schiwon.de>
  7. * @author Bart Visscher <bartv@thisnet.nl>
  8. * @author Bernhard Posselt <dev@bernhard-posselt.com>
  9. * @author Christoph Wurst <christoph@winzerhof-wurst.at>
  10. * @author Joas Schilling <coding@schilljs.com>
  11. * @author Julius Härtl <jus@bitgrid.net>
  12. * @author Morris Jobke <hey@morrisjobke.de>
  13. * @author Olivier Paroz <github@oparoz.com>
  14. * @author Robin Appelman <robin@icewind.nl>
  15. * @author Roeland Jago Douma <roeland@famdouma.nl>
  16. * @author Thomas Müller <thomas.mueller@tmit.eu>
  17. * @author Victor Dubiniuk <dubiniuk@owncloud.com>
  18. *
  19. * @license AGPL-3.0
  20. *
  21. * This code is free software: you can redistribute it and/or modify
  22. * it under the terms of the GNU Affero General Public License, version 3,
  23. * as published by the Free Software Foundation.
  24. *
  25. * This program is distributed in the hope that it will be useful,
  26. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  28. * GNU Affero General Public License for more details.
  29. *
  30. * You should have received a copy of the GNU Affero General Public License, version 3,
  31. * along with this program. If not, see <http://www.gnu.org/licenses/>
  32. *
  33. */
  34. namespace OC;
  35. use OCP\Log\IDataLogger;
  36. use function array_merge;
  37. use InterfaSys\LogNormalizer\Normalizer;
  38. use OC\Log\ExceptionSerializer;
  39. use OCP\ILogger;
  40. use OCP\Log\IFileBased;
  41. use OCP\Log\IWriter;
  42. use OCP\Support\CrashReport\IRegistry;
  43. /**
  44. * logging utilities
  45. *
  46. * This is a stand in, this should be replaced by a Psr\Log\LoggerInterface
  47. * compatible logger. See https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md
  48. * for the full interface specification.
  49. *
  50. * MonoLog is an example implementing this interface.
  51. */
  52. class Log implements ILogger, IDataLogger {
  53. /** @var IWriter */
  54. private $logger;
  55. /** @var SystemConfig */
  56. private $config;
  57. /** @var boolean|null cache the result of the log condition check for the request */
  58. private $logConditionSatisfied = null;
  59. /** @var Normalizer */
  60. private $normalizer;
  61. /** @var IRegistry */
  62. private $crashReporters;
  63. /**
  64. * @param IWriter $logger The logger that should be used
  65. * @param SystemConfig $config the system config object
  66. * @param Normalizer|null $normalizer
  67. * @param IRegistry|null $registry
  68. */
  69. public function __construct(IWriter $logger, SystemConfig $config = null, $normalizer = null, IRegistry $registry = null) {
  70. // FIXME: Add this for backwards compatibility, should be fixed at some point probably
  71. if ($config === null) {
  72. $config = \OC::$server->getSystemConfig();
  73. }
  74. $this->config = $config;
  75. $this->logger = $logger;
  76. if ($normalizer === null) {
  77. $this->normalizer = new Normalizer();
  78. } else {
  79. $this->normalizer = $normalizer;
  80. }
  81. $this->crashReporters = $registry;
  82. }
  83. /**
  84. * System is unusable.
  85. *
  86. * @param string $message
  87. * @param array $context
  88. * @return void
  89. */
  90. public function emergency(string $message, array $context = []) {
  91. $this->log(ILogger::FATAL, $message, $context);
  92. }
  93. /**
  94. * Action must be taken immediately.
  95. *
  96. * Example: Entire website down, database unavailable, etc. This should
  97. * trigger the SMS alerts and wake you up.
  98. *
  99. * @param string $message
  100. * @param array $context
  101. * @return void
  102. */
  103. public function alert(string $message, array $context = []) {
  104. $this->log(ILogger::ERROR, $message, $context);
  105. }
  106. /**
  107. * Critical conditions.
  108. *
  109. * Example: Application component unavailable, unexpected exception.
  110. *
  111. * @param string $message
  112. * @param array $context
  113. * @return void
  114. */
  115. public function critical(string $message, array $context = []) {
  116. $this->log(ILogger::ERROR, $message, $context);
  117. }
  118. /**
  119. * Runtime errors that do not require immediate action but should typically
  120. * be logged and monitored.
  121. *
  122. * @param string $message
  123. * @param array $context
  124. * @return void
  125. */
  126. public function error(string $message, array $context = []) {
  127. $this->log(ILogger::ERROR, $message, $context);
  128. }
  129. /**
  130. * Exceptional occurrences that are not errors.
  131. *
  132. * Example: Use of deprecated APIs, poor use of an API, undesirable things
  133. * that are not necessarily wrong.
  134. *
  135. * @param string $message
  136. * @param array $context
  137. * @return void
  138. */
  139. public function warning(string $message, array $context = []) {
  140. $this->log(ILogger::WARN, $message, $context);
  141. }
  142. /**
  143. * Normal but significant events.
  144. *
  145. * @param string $message
  146. * @param array $context
  147. * @return void
  148. */
  149. public function notice(string $message, array $context = []) {
  150. $this->log(ILogger::INFO, $message, $context);
  151. }
  152. /**
  153. * Interesting events.
  154. *
  155. * Example: User logs in, SQL logs.
  156. *
  157. * @param string $message
  158. * @param array $context
  159. * @return void
  160. */
  161. public function info(string $message, array $context = []) {
  162. $this->log(ILogger::INFO, $message, $context);
  163. }
  164. /**
  165. * Detailed debug information.
  166. *
  167. * @param string $message
  168. * @param array $context
  169. * @return void
  170. */
  171. public function debug(string $message, array $context = []) {
  172. $this->log(ILogger::DEBUG, $message, $context);
  173. }
  174. /**
  175. * Logs with an arbitrary level.
  176. *
  177. * @param int $level
  178. * @param string $message
  179. * @param array $context
  180. * @return void
  181. */
  182. public function log(int $level, string $message, array $context = []) {
  183. $minLevel = $this->getLogLevel($context);
  184. array_walk($context, [$this->normalizer, 'format']);
  185. $app = $context['app'] ?? 'no app in context';
  186. // interpolate $message as defined in PSR-3
  187. $replace = [];
  188. foreach ($context as $key => $val) {
  189. $replace['{' . $key . '}'] = $val;
  190. }
  191. $message = strtr($message, $replace);
  192. try {
  193. if ($level >= $minLevel) {
  194. $this->writeLog($app, $message, $level);
  195. if ($this->crashReporters !== null) {
  196. $messageContext = array_merge(
  197. $context,
  198. [
  199. 'level' => $level
  200. ]
  201. );
  202. $this->crashReporters->delegateMessage($message, $messageContext);
  203. }
  204. } else {
  205. if ($this->crashReporters !== null) {
  206. $this->crashReporters->delegateBreadcrumb($message, 'log', $context);
  207. }
  208. }
  209. } catch (\Throwable $e) {
  210. // make sure we dont hard crash if logging fails
  211. }
  212. }
  213. private function getLogLevel($context) {
  214. $logCondition = $this->config->getValue('log.condition', []);
  215. /**
  216. * check for a special log condition - this enables an increased log on
  217. * a per request/user base
  218. */
  219. if ($this->logConditionSatisfied === null) {
  220. // default to false to just process this once per request
  221. $this->logConditionSatisfied = false;
  222. if (!empty($logCondition)) {
  223. // check for secret token in the request
  224. if (isset($logCondition['shared_secret'])) {
  225. $request = \OC::$server->getRequest();
  226. if ($request->getMethod() === 'PUT' &&
  227. strpos($request->getHeader('Content-Type'), 'application/x-www-form-urlencoded') === false &&
  228. strpos($request->getHeader('Content-Type'), 'application/json') === false) {
  229. $logSecretRequest = '';
  230. } else {
  231. $logSecretRequest = $request->getParam('log_secret', '');
  232. }
  233. // if token is found in the request change set the log condition to satisfied
  234. if ($request && hash_equals($logCondition['shared_secret'], $logSecretRequest)) {
  235. $this->logConditionSatisfied = true;
  236. }
  237. }
  238. // check for user
  239. if (isset($logCondition['users'])) {
  240. $user = \OC::$server->getUserSession()->getUser();
  241. // if the user matches set the log condition to satisfied
  242. if ($user !== null && in_array($user->getUID(), $logCondition['users'], true)) {
  243. $this->logConditionSatisfied = true;
  244. }
  245. }
  246. }
  247. }
  248. // if log condition is satisfied change the required log level to DEBUG
  249. if ($this->logConditionSatisfied) {
  250. return ILogger::DEBUG;
  251. }
  252. if (isset($context['app'])) {
  253. $app = $context['app'];
  254. /**
  255. * check log condition based on the context of each log message
  256. * once this is met -> change the required log level to debug
  257. */
  258. if (!empty($logCondition)
  259. && isset($logCondition['apps'])
  260. && in_array($app, $logCondition['apps'], true)) {
  261. return ILogger::DEBUG;
  262. }
  263. }
  264. return min($this->config->getValue('loglevel', ILogger::WARN), ILogger::FATAL);
  265. }
  266. /**
  267. * Logs an exception very detailed
  268. *
  269. * @param \Exception|\Throwable $exception
  270. * @param array $context
  271. * @return void
  272. * @since 8.2.0
  273. */
  274. public function logException(\Throwable $exception, array $context = []) {
  275. $app = $context['app'] ?? 'no app in context';
  276. $level = $context['level'] ?? ILogger::ERROR;
  277. $serializer = new ExceptionSerializer();
  278. $data = $serializer->serializeException($exception);
  279. $data['CustomMessage'] = $context['message'] ?? '--';
  280. $minLevel = $this->getLogLevel($context);
  281. array_walk($context, [$this->normalizer, 'format']);
  282. try {
  283. if ($level >= $minLevel) {
  284. if (!$this->logger instanceof IFileBased) {
  285. $data = json_encode($data, JSON_PARTIAL_OUTPUT_ON_ERROR | JSON_UNESCAPED_SLASHES);
  286. }
  287. $this->writeLog($app, $data, $level);
  288. }
  289. $context['level'] = $level;
  290. if (!is_null($this->crashReporters)) {
  291. $this->crashReporters->delegateReport($exception, $context);
  292. }
  293. } catch (\Throwable $e) {
  294. // make sure we dont hard crash if logging fails
  295. }
  296. }
  297. public function logData(string $message, array $data, array $context = []): void {
  298. $app = $context['app'] ?? 'no app in context';
  299. $level = $context['level'] ?? ILogger::ERROR;
  300. $minLevel = $this->getLogLevel($context);
  301. array_walk($context, [$this->normalizer, 'format']);
  302. try {
  303. if ($level >= $minLevel) {
  304. $data['message'] = $message;
  305. if (!$this->logger instanceof IFileBased) {
  306. $data = json_encode($data, JSON_PARTIAL_OUTPUT_ON_ERROR | JSON_UNESCAPED_SLASHES);
  307. }
  308. $this->writeLog($app, $data, $level);
  309. }
  310. $context['level'] = $level;
  311. } catch (\Throwable $e) {
  312. // make sure we dont hard crash if logging fails
  313. }
  314. }
  315. /**
  316. * @param string $app
  317. * @param string|array $entry
  318. * @param int $level
  319. */
  320. protected function writeLog(string $app, $entry, int $level) {
  321. $this->logger->write($app, $entry, $level);
  322. }
  323. public function getLogPath():string {
  324. if ($this->logger instanceof IFileBased) {
  325. return $this->logger->getLogFilePath();
  326. }
  327. throw new \RuntimeException('Log implementation has no path');
  328. }
  329. }