src/Core/Logger.php

   1 <?php
   2 /**
   3  * @file src/Core/Logger.php
   4  */
   5 namespace Friendica\Core;
   6
   7 use Friendica\BaseObject;
   8 use Friendica\Network\HTTPException\InternalServerErrorException;
   9 use Friendica\Util\LoggerFactory;
  10 use Psr\Log\LoggerInterface;
  11 use Psr\Log\LogLevel;
  12
  13 /**
  14  * @brief Logger functions
  15  */
  16 class Logger extends BaseObject
  17 {
  18         /**
  19          * @see Logger::error()
  20          */
  21         const WARNING = LogLevel::ERROR;
  22         /**
  23          * @see Logger::warning()
  24          */
  25         const INFO = LogLevel::WARNING;
  26         /**
  27          * @see Logger::notice()
  28          */
  29         const TRACE = LogLevel::NOTICE;
  30         /**
  31          * @see Logger::info()
  32          */
  33         const DEBUG = LogLevel::INFO;
  34         /**
  35          * @see Logger::debug()
  36          */
  37         const DATA = LogLevel::DEBUG;
  38         /**
  39          * @see Logger::debug()
  40          */
  41         const ALL = LogLevel::DEBUG;
  42
  43         /**
  44          * @var array the legacy loglevels
  45          * @deprecated 2019.03 use PSR-3 loglevels
  46          * @see https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md#5-psrlogloglevel
  47          *
  48          */
  49         public static $levels = [
  50                 self::WARNING => 'Warning',
  51                 self::INFO => 'Info',
  52                 self::TRACE => 'Trace',
  53                 self::DEBUG => 'Debug',
  54                 self::DATA => 'Data',
  55                 self::ALL => 'All',
  56         ];
  57
  58         /**
  59          * @var LoggerInterface A PSR-3 compliant logger instance
  60          */
  61         private static $logger;
  62
  63         /**
  64          * @var LoggerInterface A PSR-3 compliant logger instance for developing only
  65          */
  66         private static $devLogger;
  67
  68         /**
  69          * Sets the default logging handler for Friendica.
  70          * @todo Can be combined with other handlers too if necessary, could be configurable.
  71          *
  72          * @param LoggerInterface $logger The Logger instance of this Application
  73          *
  74          * @throws InternalServerErrorException if the logger factory is incompatible to this logger
  75          */
  76         public static function setLogger($logger)
  77         {
  78                 $debugging = Config::get('system', 'debugging');
  79                 $logfile = Config::get('system', 'logfile');
  80                 $loglevel = Config::get('system', 'loglevel');
  81
  82                 if (!$debugging || !$logfile) {
  83                         return;
  84                 }
  85
  86                 $loglevel = self::mapLegacyConfigDebugLevel((string)$loglevel);
  87
  88                 LoggerFactory::addStreamHandler($logger, $logfile, $loglevel);
  89
  90                 self::$logger = $logger;
  91
  92                 $logfile = Config::get('system', 'dlogfile');
  93
  94                 if (!$logfile) {
  95                         return;
  96                 }
  97
  98                 $developIp = Config::get('system', 'dlogip');
  99
 100                 self::$devLogger = LoggerFactory::createDev('develop', $developIp);
 101                 LoggerFactory::addStreamHandler(self::$devLogger, $logfile, LogLevel::DEBUG);
 102         }
 103
 104         /**
 105          * Mapping a legacy level to the PSR-3 compliant levels
 106          * @see https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md#5-psrlogloglevel
 107          *
 108          * @param string $level the level to be mapped
 109          *
 110          * @return string the PSR-3 compliant level
 111          */
 112         private static function mapLegacyConfigDebugLevel($level)
 113         {
 114                 switch ($level) {
 115                         // legacy WARNING
 116                         case "0":
 117                                 return LogLevel::ERROR;
 118                         // legacy INFO
 119                         case "1":
 120                                 return LogLevel::WARNING;
 121                         // legacy TRACE
 122                         case "2":
 123                                 return LogLevel::NOTICE;
 124                         // legacy DEBUG
 125                         case "3":
 126                                 return LogLevel::INFO;
 127                         // legacy DATA
 128                         case "4":
 129                                 return LogLevel::DEBUG;
 130                         // legacy ALL
 131                         case "5":
 132                                 return LogLevel::DEBUG;
 133                         // default if nothing set
 134                         default:
 135                                 return $level;
 136                 }
 137         }
 138
 139         /**
 140          * System is unusable.
 141          *
 142          * @see LoggerInterface::emergency()
 143          *
 144          * @param string $message
 145          * @param array  $context
 146          *
 147          * @return void
 148          * @throws \Exception
 149          */
 150         public static function emergency($message, $context = [])
 151         {
 152                 if (!isset(self::$logger)) {
 153                         return;
 154                 }
 155
 156                 $stamp1 = microtime(true);
 157                 self::$logger->emergency($message, $context);
 158                 self::getApp()->saveTimestamp($stamp1, 'file');
 159         }
 160
 161         /**
 162          * Action must be taken immediately.
 163          * @see LoggerInterface::alert()
 164          *
 165          * Example: Entire website down, database unavailable, etc. This should
 166          * trigger the SMS alerts and wake you up.
 167          *
 168          * @param string $message
 169          * @param array  $context
 170          *
 171          * @return void
 172          * @throws \Exception
 173          */
 174         public static function alert($message, $context = [])
 175         {
 176                 if (!isset(self::$logger)) {
 177                         return;
 178                 }
 179
 180                 $stamp1 = microtime(true);
 181                 self::$logger->alert($message, $context);
 182                 self::getApp()->saveTimestamp($stamp1, 'file');
 183         }
 184
 185         /**
 186          * Critical conditions.
 187          * @see LoggerInterface::critical()
 188          *
 189          * Example: Application component unavailable, unexpected exception.
 190          *
 191          * @param string $message
 192          * @param array  $context
 193          *
 194          * @return void
 195          * @throws \Exception
 196          */
 197         public static function critical($message, $context = [])
 198         {
 199                 if (!isset(self::$logger)) {
 200                         return;
 201                 }
 202
 203                 $stamp1 = microtime(true);
 204                 self::$logger->critical($message, $context);
 205                 self::getApp()->saveTimestamp($stamp1, 'file');
 206         }
 207
 208         /**
 209          * Runtime errors that do not require immediate action but should typically
 210          * be logged and monitored.
 211          * @see LoggerInterface::error()
 212          *
 213          * @param string $message
 214          * @param array  $context
 215          *
 216          * @return void
 217          * @throws \Exception
 218          */
 219         public static function error($message, $context = [])
 220         {
 221                 if (!isset(self::$logger)) {
 222                         echo "not set!?\n";
 223                         return;
 224                 }
 225
 226                 $stamp1 = microtime(true);
 227                 self::$logger->error($message, $context);
 228                 self::getApp()->saveTimestamp($stamp1, 'file');
 229         }
 230
 231         /**
 232          * Exceptional occurrences that are not errors.
 233          * @see LoggerInterface::warning()
 234          *
 235          * Example: Use of deprecated APIs, poor use of an API, undesirable things
 236          * that are not necessarily wrong.
 237          *
 238          * @param string $message
 239          * @param array  $context
 240          *
 241          * @return void
 242          * @throws \Exception
 243          */
 244         public static function warning($message, $context = [])
 245         {
 246                 if (!isset(self::$logger)) {
 247                         return;
 248                 }
 249
 250                 $stamp1 = microtime(true);
 251                 self::$logger->warning($message, $context);
 252                 self::getApp()->saveTimestamp($stamp1, 'file');
 253         }
 254
 255         /**
 256          * Normal but significant events.
 257          * @see LoggerInterface::notice()
 258          *
 259          * @param string $message
 260          * @param array  $context
 261          *
 262          * @return void
 263          * @throws \Exception
 264          */
 265         public static function notice($message, $context = [])
 266         {
 267                 if (!isset(self::$logger)) {
 268                         return;
 269                 }
 270
 271                 $stamp1 = microtime(true);
 272                 self::$logger->notice($message, $context);
 273                 self::getApp()->saveTimestamp($stamp1, 'file');
 274         }
 275
 276         /**
 277          * Interesting events.
 278          * @see LoggerInterface::info()
 279          *
 280          * Example: User logs in, SQL logs.
 281          *
 282          * @param string $message
 283          * @param array  $context
 284          *
 285          * @return void
 286          * @throws \Exception
 287          */
 288         public static function info($message, $context = [])
 289         {
 290                 if (!isset(self::$logger)) {
 291                         return;
 292                 }
 293
 294                 $stamp1 = microtime(true);
 295                 self::$logger->info($message, $context);
 296                 self::getApp()->saveTimestamp($stamp1, 'file');
 297         }
 298
 299         /**
 300          * Detailed debug information.
 301          * @see LoggerInterface::debug()
 302          *
 303          * @param string $message
 304          * @param array  $context
 305          *
 306          * @return void
 307          * @throws \Exception
 308          */
 309         public static function debug($message, $context = [])
 310         {
 311                 if (!isset(self::$logger)) {
 312                         return;
 313                 }
 314
 315                 $stamp1 = microtime(true);
 316                 self::$logger->debug($message, $context);
 317                 self::getApp()->saveTimestamp($stamp1, 'file');
 318         }
 319
 320     /**
 321      * @brief Logs the given message at the given log level
 322      *
 323      * @param string $msg
 324      * @param string $level
 325          *
 326          * @throws \Exception
 327          * @deprecated since 2019.03 Use Logger::debug() Logger::info() , ... instead
 328      */
 329     public static function log($msg, $level = LogLevel::INFO)
 330     {
 331                 if (!isset(self::$logger)) {
 332                         return;
 333                 }
 334
 335         $stamp1 = microtime(true);
 336                 self::$logger->log($level, $msg);
 337         self::getApp()->saveTimestamp($stamp1, "file");
 338     }
 339
 340         /**
 341          * @brief An alternative logger for development.
 342          * Works largely as log() but allows developers
 343          * to isolate particular elements they are targetting
 344          * personally without background noise
 345          *
 346          * @param string $msg
 347          * @param string $level
 348          * @throws \Exception
 349          */
 350     public static function devLog($msg, $level = LogLevel::DEBUG)
 351     {
 352                 if (!isset(self::$logger)) {
 353                         return;
 354                 }
 355
 356         $stamp1 = microtime(true);
 357         self::$devLogger->log($level, $msg);
 358         self::getApp()->saveTimestamp($stamp1, "file");
 359     }
 360 }