# File core/lib/Thelia/Log/Tlog.php | thelia

      1: <?php
      2: /*************************************************************************************/
      3: /*                                                                                   */
      4: /*      Thelia                                                                       */
      5: /*                                                                                   */
      6: /*      Copyright (c) OpenStudio                                                     */
      7: /*  email : info@thelia.net                                                      */
      8: /*      web : http://www.thelia.net                                                  */
      9: /*                                                                                   */
     10: /*      This program is free software; you can redistribute it and/or modify         */
     11: /*      it under the terms of the GNU General Public License as published by         */
     12: /*      the Free Software Foundation; either version 3 of the License                */
     13: /*                                                                                   */
     14: /*      This program is distributed in the hope that it will be useful,              */
     15: /*      but WITHOUT ANY WARRANTY; without even the implied warranty of               */
     16: /*      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
     17: /*      GNU General Public License for more details.                                 */
     18: /*                                                                                   */
     19: /*      You should have received a copy of the GNU General Public License            */
     20: /*      along with this program. If not, see <http://www.gnu.org/licenses/>.     */
     21: /*                                                                                   */
     22: /*************************************************************************************/
     23: namespace Thelia\Log;
     24:
     25: use Thelia\Model\ConfigQuery;
     26: use Psr\Log\LoggerInterface;
     27:
     28: /**
     29:  *
     30:  * Thelia Logger
     31:  *
     32:  * Allow to define different level and output.
     33:  *
     34:  * @author Franck Allimant <franck@cqfdev.fr>
     35:  * @author Manuel Raynaud <mraynaud@openstudio.fr>
     36:  */
     37: class Tlog Implements LoggerInterface
     38: {
     39:     // Nom des variables de configuration
     40:     const VAR_LEVEL         = "tlog_level";
     41:     const VAR_DESTINATIONS  = "tlog_destinations";
     42:     const VAR_PREFIXE       = "tlog_prefix";
     43:     const VAR_FILES         = "tlog_files";
     44:     const VAR_IP                = "tlog_ip";
     45:     const VAR_SHOW_REDIRECT     = "tlog_show_redirect";
     46:
     47:     // all level of trace
     48:     const DEBUG                 = 100;
     49:     const INFO                  = 200;
     50:     const NOTICE                = 300;
     51:     const WARNING               = 400;
     52:     const ERROR                 = 500;
     53:     const CRITICAL              = 600;
     54:     const ALERT                 = 700;
     55:     const EMERGENCY             = 800;
     56:     const MUET                  = PHP_INT_MAX;
     57:
     58:     protected $levels = array(
     59:         100 => "DEBUG",
     60:         200 => "INFO",
     61:         300 => "NOTICE",
     62:         400 => "WARNING",
     63:         500 => "ERROR",
     64:         600 => "CRITICAL",
     65:         700 => "ALERT",
     66:         800 => "EMERGENCY"
     67:     );
     68:
     69:     // default values
     70:     const DEFAULT_LEVEL         = self::DEBUG;
     71:     const DEFAUT_DESTINATIONS   = "Thelia\Log\Destination\TlogDestinationFile";
     72:     const DEFAUT_PREFIXE    = "#NUM: #NIVEAU [#FICHIER:#FONCTION()] {#LIGNE} #DATE #HEURE: ";
     73:     const DEFAUT_FILES      = "*";
     74:     const DEFAUT_IP         = "";
     75:     const DEFAUT_SHOW_REDIRECT  = 0;
     76:
     77:     /**
     78:      *
     79:      * @var \Thelia\Log\Tlog
     80:      */
     81:     private static $instance = false;
     82:
     83:     /**
     84:      *
     85:      * @var array containing class of destination handler
     86:      */
     87:     protected $destinations = array();
     88:
     89:     protected $mode_back_office = false;
     90:     protected $level = self::MUET;
     91:     protected $prefixe = "";
     92:     protected $files = array();
     93:     protected $all_files = false;
     94:     protected $show_redirect = false;
     95:
     96:     private $linecount = 0;
     97:
     98:     protected static $done = false;
     99:
    100:     // directories where are the Destinations Files
    101:     public $dir_destinations = array();
    102:
    103:     /**
    104:      *
    105:      */
    106:     private function __construct(){}
    107:
    108:     /**
    109:      *
    110:      * @return \Thelia\Log\Tlog
    111:      */
    112:     public static function getInstance() {
    113:         if (self::$instance == false) {
    114:             self::$instance = new Tlog();
    115:
    116:             // On doit placer les initialisations à ce level pour pouvoir
    117:             // utiliser la classe Tlog dans les classes de base (Cnx, BaseObj, etc.)
    118:             // Les placer dans le constructeur provoquerait une boucle
    119:             self::$instance->init();
    120:         }
    121:
    122:         return self::$instance;
    123:     }
    124:
    125:     /**
    126:      * initialize default configuration
    127:      */
    128:     protected function init()
    129:     {
    130:
    131:         $this->setLevel(ConfigQuery::read(self::VAR_LEVEL, self::DEFAULT_LEVEL));
    132:
    133:         $this->dir_destinations = array(
    134:                 __DIR__.'/Destination'
    135:                 //, __DIR__.'/../client/tlog/destinations'
    136:         );
    137:
    138:         $this->setPrefix(ConfigQuery::read(self::VAR_PREFIXE, self::DEFAUT_PREFIXE));
    139:         $this->setFiles(ConfigQuery::read(self::VAR_FILES, self::DEFAUT_FILES));
    140:         $this->setIp(ConfigQuery::read(self::VAR_IP, self::DEFAUT_IP));
    141:         $this->setDestinations(ConfigQuery::read(self::VAR_DESTINATIONS, self::DEFAUT_DESTINATIONS));
    142:         $this->setShowRedirect(ConfigQuery::read(self::VAR_SHOW_REDIRECT, self::DEFAUT_SHOW_REDIRECT));
    143:
    144:         // Au cas ou il y aurait un exit() quelque part dans le code.
    145:         register_shutdown_function(array($this, 'writeOnExit'));
    146:     }
    147:
    148:     // Configuration
    149:     // -------------
    150:
    151:     /**
    152:      *
    153:      * @param string $destinations
    154:      */
    155:     public function setDestinations($destinations)
    156:     {
    157:         if (! empty($destinations)) {
    158:
    159:             $this->destinations = array();
    160:
    161:             $classes_destinations = explode(';', $destinations);
    162:             $this->loadDestinations($this->destinations, $classes_destinations);
    163:         }
    164:     }
    165:
    166:     /**
    167:      *
    168:      * change the debug level. Use Tlog constant : \Thelia\Log\Tlog::DEBUG set level to Debug
    169:      *
    170:      * @param int $level
    171:      */
    172:     public function setLevel($level)
    173:     {
    174:             $this->level = $level;
    175:     }
    176:
    177:     public function setPrefix($prefixe)
    178:     {
    179:             $this->prefixe = $prefixe;
    180:     }
    181:
    182:     public function setFiles($files)
    183:     {
    184:             $this->files = explode(";", $files);
    185:
    186:             $this->all_files = in_array('*', $this->files);
    187:     }
    188:
    189:     public function setIp($ips)
    190:     {
    191:             // isset($_SERVER['REMOTE_ADDR']) if we are in cli mode
    192:             if (! empty($ips) && isset($_SERVER['REMOTE_ADDR']) && ! in_array($_SERVER['REMOTE_ADDR'], explode(";", $ips))) $this->level = self::MUET;
    193:     }
    194:
    195:     public function setShowRedirect($bool)
    196:     {
    197:             $this->show_redirect = $bool;
    198:     }
    199:
    200:     // Configuration d'une destination
    201:     public function setConfig($destination, $param, $valeur)
    202:     {
    203:             if (isset($this->destinations[$destination])) {
    204:                     $this->destinations[$destination]->setConfig($param, $valeur);
    205:             }
    206:     }
    207:
    208:     // Configuration d'une destination
    209:     public function getConfig($destination, $param)
    210:     {
    211:             if (isset($this->destinations[$destination])) {
    212:                     return $this->destinations[$destination]->getConfig($param);
    213:             }
    214:
    215:             return false;
    216:     }
    217:
    218:     // Methodes d'accès aux traces
    219:     // ---------------------------
    220:
    221:     /**
    222:      * Detailed debug information.
    223:      *
    224:      * @param string $message
    225:      * @param array $context
    226:      * @return null
    227:      */
    228:     public function debug($message, array $context = array())
    229:     {
    230:         $this->log(self::DEBUG, $message, $context);
    231:     }
    232:
    233:     /**
    234:      *
    235:      * Alias of debug method. With this method you can put all parameter you want
    236:      *
    237:      * ex : Tlog::getInstance()->addDebug($arg1, $arg2, $arg3);
    238:      *
    239:      */
    240:     public function addDebug()
    241:     {
    242:         $args = func_get_args();
    243:
    244:         foreach ($args as $arg) {
    245:             $this->log(self::DEBUG, $arg);
    246:         }
    247:     }
    248:
    249:     /**
    250:      * Interesting events.
    251:      *
    252:      * Example: User logs in, SQL logs.
    253:      *
    254:      * @param string $message
    255:      * @param array $context
    256:      * @return null
    257:      */
    258:     public function info($message, array $context = array())
    259:     {
    260:         $this->log(self::INFO, $message, $context);
    261:     }
    262:
    263:     /**
    264:      *
    265:      * Alias of info method. With this method you can put all parameter you want
    266:      *
    267:      * ex : Tlog::getInstance()->addInfo($arg1, $arg2, $arg3);
    268:      *
    269:      */
    270:     public function addInfo()
    271:     {
    272:         $args = func_get_args();
    273:
    274:         foreach ($args as $arg) {
    275:             $this->log(self::INFO, $arg);
    276:         }
    277:     }
    278:
    279:     /**
    280:      * Normal but significant events.
    281:      *
    282:      * @param string $message
    283:      * @param array $context
    284:      * @return null
    285:      */
    286:     public function notice($message, array $context = array())
    287:     {
    288:         $this->log(self::NOTICE, $message, $context);
    289:     }
    290:
    291:     /**
    292:      *
    293:      * Alias of notice method. With this method you can put all parameter you want
    294:      *
    295:      * ex : Tlog::getInstance()->addNotice($arg1, $arg2, $arg3);
    296:      *
    297:      */
    298:     public function addNotice()
    299:     {
    300:         $args = func_get_args();
    301:
    302:         foreach ($args as $arg) {
    303:             $this->log(self::NOTICE, $arg);
    304:         }
    305:     }
    306:
    307:     /**
    308:      * Exceptional occurrences that are not errors.
    309:      *
    310:      * Example: Use of deprecated APIs, poor use of an API, undesirable things
    311:      * that are not necessarily wrong.
    312:      *
    313:      * @param string $message
    314:      * @param array $context
    315:      * @return null
    316:      */
    317:     public function warning($message, array $context = array())
    318:     {
    319:         $this->log(self::WARNING, $message, $context);
    320:     }
    321:
    322:     /**
    323:      *
    324:      * Alias of warning method. With this method you can put all parameter you want
    325:      *
    326:      * ex : Tlog::getInstance()->addWarning($arg1, $arg2, $arg3);
    327:      *
    328:      */
    329:     public function addWarning()
    330:     {
    331:         $args = func_get_args();
    332:
    333:         foreach ($args as $arg) {
    334:             $this->log(self::WARNING, $arg);
    335:         }
    336:     }
    337:
    338:     /**
    339:      * Runtime errors that do not require immediate action but should typically
    340:      * be logged and monitored.
    341:      *
    342:      * @param string $message
    343:      * @param array $context
    344:      * @return null
    345:      */
    346:     public function error($message, array $context = array())
    347:     {
    348:         $this->log(self::ERROR, $message, $context);
    349:     }
    350:
    351:     /**
    352:      *
    353:      * Alias of error method. With this method you can put all parameter you want
    354:      *
    355:      * ex : Tlog::getInstance()->addError($arg1, $arg2, $arg3);
    356:      *
    357:      */
    358:     public function addError()
    359:     {
    360:         $args = func_get_args();
    361:
    362:         foreach ($args as $arg) {
    363:             $this->log(self::ERROR, $arg);
    364:         }
    365:     }
    366:
    367:     /**
    368:      *
    369:      * @see error()
    370:      */
    371:     public function err($message, array $context = array())
    372:     {
    373:         $this->error($message, $context);
    374:     }
    375:
    376:     /**
    377:      * Critical conditions.
    378:      *
    379:      * Example: Application component unavailable, unexpected exception.
    380:      *
    381:      * @param string $message
    382:      * @param array $context
    383:      * @return null
    384:      */
    385:     public function critical($message, array $context = array())
    386:     {
    387:         $this->log(self::CRITICAL, $message, $context);
    388:     }
    389:
    390:     /**
    391:      *
    392:      * Alias of critical method. With this method you can put all parameter you want
    393:      *
    394:      * ex : Tlog::getInstance()->addCritical($arg1, $arg2, $arg3);
    395:      *
    396:      */
    397:     public function addCritical()
    398:     {
    399:         $args = func_get_args();
    400:
    401:         foreach ($args as $arg) {
    402:             $this->log(self::CRITICAL, $arg);
    403:         }
    404:     }
    405:
    406:     /**
    407:      *
    408:      * @see critical()
    409:      */
    410:     public function crit($message, array $context = array())
    411:     {
    412:         $this->critical($message, $context);
    413:     }
    414:
    415:     /**
    416:      * Action must be taken immediately.
    417:      *
    418:      * Example: Entire website down, database unavailable, etc. This should
    419:      * trigger the SMS alerts and wake you up.
    420:      *
    421:      * @param string $message
    422:      * @param array $context
    423:      * @return null
    424:      */
    425:     public function alert($message, array $context = array())
    426:     {
    427:         $this->log(self::ALERT, $message, $context);
    428:     }
    429:
    430:     /**
    431:      *
    432:      * Alias of alert method. With this method you can put all parameter you want
    433:      *
    434:      * ex : Tlog::getInstance()->addAlert($arg1, $arg2, $arg3);
    435:      *
    436:      */
    437:     public function addAlert()
    438:     {
    439:         $args = func_get_args();
    440:
    441:         foreach ($args as $arg) {
    442:             $this->log(self::ALERT, $arg);
    443:         }
    444:     }
    445:
    446:     /**
    447:      * System is unusable.
    448:      *
    449:      * @param string $message
    450:      * @param array $context
    451:      * @return null
    452:      */
    453:     public function emergency($message, array $context = array())
    454:     {
    455:         $this->log(self::EMERGENCY, $message, $context);
    456:     }
    457:
    458:     /**
    459:      *
    460:      * Alias of emergency method. With this method you can put all parameter you want
    461:      *
    462:      * ex : Tlog::getInstance()->addEmergency($arg1, $arg2, $arg3);
    463:      *
    464:      */
    465:     public function addEmergency()
    466:     {
    467:         $args = func_get_args();
    468:
    469:         foreach ($args as $arg) {
    470:             $this->log(self::EMERGENCY, $arg);
    471:         }
    472:     }
    473:
    474:     /**
    475:      * Logs with an arbitrary level.
    476:      *
    477:      * @param mixed $level
    478:      * @param string $message
    479:      * @param array $context
    480:      * @return null
    481:      */
    482:     public function log($level, $message, array $context = array()) {
    483:         if($this->level > $level || array_key_exists($level, $this->levels) === false)
    484:             return;
    485:
    486:         $this->out($this->levels[$level], $message, $context);
    487:     }
    488:
    489:
    490:
    491:     // Mode back office
    492:     public static function SetBackOfficeMode($booleen)
    493:     {
    494:             foreach (Tlog::getInstance()->destinations as $dest) {
    495:                     $dest->SetBackOfficeMode($booleen);
    496:             }
    497:     }
    498:
    499:     /**
    500:      *
    501:      * final end method. Write log for each destination handler
    502:      *
    503:      * @param string $res
    504:      * @return void
    505:      */
    506:     public function write(&$res)
    507:     {
    508:             self::$done = true;
    509:
    510:             // Muet ? On ne fait rien
    511:             if ($this->level == self::MUET) return;
    512:
    513:             foreach ($this->destinations as $dest) {
    514:                     $dest->write($res);
    515:             }
    516:     }
    517:
    518:     /**
    519:      * @see write()
    520:      */
    521:     public function writeOnExit()
    522:     {
    523:         // Si les infos de debug n'ont pas été ecrites, le faire maintenant
    524:         if (self::$done === false) {
    525:
    526:                 $res = "";
    527:
    528:                 $this->write($res);
    529:
    530:                 echo $res;
    531:         }
    532:     }
    533:
    534:     public function showRedirect($url)
    535:     {
    536:         if ($this->level != self::MUET && $this->show_redirect) {
    537:                 echo "
    538: <html>
    539: <head><title>Redirection...</title></head>
    540: <body>
    541: <a href=\"$url\">Redirection vers $url</a>
    542: </body>
    543: </html>
    544:         ";
    545:
    546:                 return true;
    547:         } else {
    548:                 return false;
    549:         }
    550:     }
    551:
    552:     /**
    553:      *
    554:      * check if level is activated and control if current file is activated
    555:      *
    556:      * @param int $level
    557:      * @return boolean
    558:      */
    559:     public function isActivated($level)
    560:     {
    561:         if ($this->level <= $level) {
    562:
    563:             $origin = $this->findOrigin();
    564:
    565:             $file = basename($origin['file']);
    566:
    567:             if ($this->isActivedFile($file)) {
    568:                     return true;
    569:             }
    570:         }
    571:
    572:         return false;
    573:     }
    574:
    575:     /**
    576:      *
    577:      * check if $file is in authorized files
    578:      *
    579:      * @param string $file
    580:      * @return boolean
    581:      */
    582:     public function isActivedFile($file)
    583:     {
    584:         return ($this->all_files || in_array($file, $this->files)) && ! in_array("!$file", $this->files);
    585:     }
    586:
    587:     /* -- Methodes privees ---------------------------------------- */
    588:
    589:
    590:     private function findOrigin()
    591:     {
    592:         $origine = array();
    593:
    594:         if (function_exists('debug_backtrace')) {
    595:
    596:             $trace = debug_backtrace();
    597:             $prevHop = null;
    598:             // make a downsearch to identify the caller
    599:             $hop = array_pop($trace);
    600:
    601:             while ($hop !== null) {
    602:                 if (isset($hop['class'])) {
    603:                     // we are sometimes in functions = no class available: avoid php warning here
    604:                     $className = $hop['class'];
    605:
    606:                     if (! empty($className) and ($className == ltrim(__CLASS__,'\\') or strtolower(get_parent_class($className)) == ltrim(__CLASS__,'\\'))) {
    607:                             $origine['line'] = $hop['line'];
    608:                             $origine['file'] = $hop['file'];
    609:                             break;
    610:                     }
    611:                 }
    612:                 $prevHop = $hop;
    613:                 $hop = array_pop($trace);
    614:             }
    615:
    616:             $origine['class'] = isset($prevHop['class']) ? $prevHop['class'] : 'main';
    617:
    618:             if(isset($prevHop['function']) and
    619:                 $prevHop['function'] !== 'include' and
    620:                 $prevHop['function'] !== 'include_once' and
    621:                 $prevHop['function'] !== 'require' and
    622:                 $prevHop['function'] !== 'require_once') {
    623:
    624:                 $origine['function'] = $prevHop['function'];
    625:             } else {
    626:                 $origine['function'] = 'main';
    627:             }
    628:         }
    629:
    630:         return $origine;
    631:     }
    632:
    633:     protected function interpolate($message, array $context = array())
    634:     {
    635:         // build a replacement array with braces around the context keys
    636:         $replace = array();
    637:         foreach ($context as $key => $val) {
    638:             $replace['{' . $key . '}'] = $val;
    639:         }
    640:
    641:         // interpolate replacement values into the message and return
    642:         return strtr($message, $replace);
    643:     }
    644:
    645:     private function out($level, $message, array $context = array())
    646:     {
    647:         $text = '';
    648:
    649:         /*if (is_array($message)) {
    650:             foreach ($message as $arg) {
    651:                 $text .= is_scalar($arg) ? $arg : print_r($arg, true);
    652:             }
    653:         } else */ if (is_scalar($message) === false) {
    654:             $text = print_r($message, true);
    655:         } else {
    656:             $text = $message;
    657:         }
    658:
    659:         $text = $this->interpolate($text, $context);
    660:
    661:         $origine = $this->findOrigin();
    662:
    663:         $file = basename($origine['file']);
    664:
    665:         if ($this->isActivedFile($file)) {
    666:
    667:             $function = $origine['function'];
    668:             $line = $origine['line'];
    669:
    670:             $prefixe = str_replace(
    671:                 array("#NUM", "#NIVEAU", "#FICHIER", "#FONCTION", "#LIGNE", "#DATE", "#HEURE"),
    672:                 array(1+$this->linecount, $level, $file, $function, $line, date("Y-m-d"), date("G:i:s")),
    673:                 $this->prefixe
    674:             );
    675:
    676:             $trace = $prefixe . $text;
    677:
    678:             foreach ($this->destinations as $dest) {
    679:                 $dest->add($trace);
    680:             }
    681:
    682:             $this->linecount++;
    683:         }
    684:     }
    685:
    686:     /**
    687:      *
    688:      * @param type  $destinations
    689:      * @param array $actives      array containing classes instanceof AbstractTlogDestination
    690:      */
    691:     protected function loadDestinations(&$destinations, array $actives = NULL)
    692:     {
    693:         foreach ($actives as $active) {
    694:             if (class_exists($active)) {
    695:                 $class = new $active();
    696:
    697:                 if (!$class instanceof AbstractTlogDestination) {
    698:                     throw new \UnexpectedValueException($active." must extends Thelia\Tlog\AbstractTlogDestination");
    699:                 }
    700:
    701:                 $destinations[$active] = $class;
    702:             }
    703:         }
    704:     }
    705: }
    706: