Magento 2. Monolog ou comment écrire des journaux

Table des matières

Monolog
Fonctionnalités de l'application dans Magento 2
Implémentation
Journalisation à l'aide de l'enregistreur standard
Journalisation à l'aide d'un enregistreur standard avec un canal personnalisé
Écriture dans un fichier personnalisé à l'aide de votre propre gestionnaire
Écriture dans un fichier personnalisé à l'aide de virtualType
Enregistrement rapide des données
Conclusion

Monolog

use Monolog\Logger; use Monolog\Handler\StreamHandler; use Monolog\Formatter\HtmlFormatter; //     "name" $log = new Logger('name'); //  ,      "path/to/your1.log"       "WARNING"   (notice, info  debug   ). $log->pushHandler(new StreamHandler('path/to/your1.log', Logger::WARNING)); //  ,      "path/to/your2.log"       "ALERT"   (..        alert  emergency).    ,    .         html   HtmlFormatter. $log->pushHandler(new StreamHandler('path/to/your2.log', Logger::ALERT,false) ->setFormatter(new HtmlFormatter)); //  ,       . $log->pushProcessor(function ($record) { $record['extra']['dummy'] = 'Hello world!'; return $record; }); //   $log->warning('Foo'); $log->error('Bar',['test']); $log->info('Test'); //   ,    1     INFO //your1.log // [2019-08-12 02:57:52] name.WARNING: Foo [] ['extra'=>['dummy'=>'Hello world!']] // [2019-08-12 02:57:53] name.ERROR: BAR ['test'] ['extra'=>['dummy'=>'Hello world!']] //your2.log // , .    ALERT  EMERGENCY 

• L'enregistreur est un objet que nous utilisons pour enregistrer des journaux. L'enregistreur lui-même n'enregistre pas, mais gère les gestionnaires. N'importe quel nombre peut être créé.
• Handler - un objet qui traite directement les données. Vous pouvez ajouter autant de gestionnaires à l'enregistreur que vous le souhaitez. Tous seront appelés tour à tour, que le gestionnaire donné ait pu traiter l'erreur ou non. La méthode isHandling détermine si ce gestionnaire sera capable de gérer l'erreur reçue.
  
  

   public function isHandling(array $record) { return $record['level'] >= $this->level; } 

  
  La ressemblance la plus proche avec le gestionnaire, à mon avis, est l'observateur d'événements.
  
• Processeur - toute entité appelée (appelable). Peut-être quelques-uns. Ils peuvent être attribués globalement et installés pour le gestionnaire. Premièrement, des processeurs mondiaux sont lancés. La tâche principale du processeur consiste à ajouter des données supplémentaires au journal (par exemple, l'adresse IP à partir de laquelle la connexion était, la valeur des variables globales, les informations sur la branche git sur laquelle se trouve le code, etc.).
• Formateur - Convertit la sortie du message avant l'écriture. Il ne peut y en avoir qu'un par gestionnaire. Il est nécessaire de modifier la mise en forme du corps du message, par exemple, pour convertir du texte en html ou json.
• Canal - le nom de l'enregistreur. Il sera écrit lors de l'enregistrement du journal. Comme 1 gestionnaire peut être utilisé dans 2 enregistreurs différents (il écrira les journaux dans 1 même fichier), cela déterminera d'où vient l'erreur.
• Niveau - niveau d'erreur. Ce paramètre pour le gestionnaire signifie le niveau d'erreur minimum qu'il gérera.
• Bulle - popup de message. Une fois que le gestionnaire a traité le message, l'enregistreur transmet le message au gestionnaire suivant. Ce processus peut être arrêté à l'aide de la propriété bubble. Si le gestionnaire a la valeur de cette propriété false (la valeur par défaut est toujours vraie), après que ce gestionnaire a fait son travail (a pu traiter cette erreur), les autres gestionnaires ne démarrent pas.
• Ordre de tri - ordre d'exécution. Le dernier gestionnaire ajouté est toujours lancé le tout premier. C'est cette fonctionnalité qui vous permet de mettre en œuvre un mécanisme pour désactiver complètement l'enregistreur (via bullage faux). Les gestionnaires ajoutés via le constructeur vont dans l'ordre spécifié dans le constructeur.

Étant donné que PSR-3 n'oblige pas les développeurs à implémenter des valeurs de correction automatique dans le texte, Monolog ne le fait pas par défaut. Si vous écrivez -> Emerg ('test 1111 {placeholder}', ['placeholder' => 'foo']), vous obtiendrez ce qui suit
[2019-08-12 02:57:52] main.EMERGENCY: test 1111 {placeholder} {"placeholder": "foo"} []

Pour que le remplacement fonctionne, vous devez connecter un processeur supplémentaire - \ Monolog \ Processor \ PsrLogMessageProcessor.

Fonctionnalités de l'application dans Magento 2

 2019-08-12T01:00:27+00:00 DEBUG (7): ALARM! 

 [2019-08-12 02:56:43] main.INFO: ALARM! [] [] 

Si l'objet n'a pas une telle propriété (_logger ou logger), alors nous devons d'abord ajouter la dépendance \ Psr \ Log \ LoggerInterface à votre classe et écrire l'objet résultant dans la propriété $ logger (selon la clause 4.2 du PSR-2 et l' exemple présenté sur le site Web de Magento ) .

 $this->_logger->{level}($message, $context = []); //$this->_logger->log('{level}', $message, $context = []); 

 public function commit() { $this->getConnection()->commit(); if ($this->getConnection()->getTransactionLevel() === 0) { $callbacks = CallbackPool::get(spl_object_hash($this->getConnection())); try { foreach ($callbacks as $callback) { call_user_func($callback); } } catch (\Exception $e) { $this->getLogger()->critical($e); } } return $this; } … private function getLogger() { if (null === $this->_logger) { $this->_logger = ObjectManager::getInstance()->get(\Psr\Log\LoggerInterface::class); } return $this->_logger; } 

 … <preference for="Psr\Log\LoggerInterface" type="Magento\Framework\Logger\Monolog" /> ... <type name="Magento\Framework\Logger\Monolog"> <arguments> <argument name="name" xsi:type="string">main</argument> <argument name="handlers" xsi:type="array"> <item name="system" xsi:type="object">Magento\Framework\Logger\Handler\System</item> <item name="debug" xsi:type="object">Magento\Framework\Logger\Handler\Debug</item> <item name="syslog" xsi:type="object">Magento\Framework\Logger\Handler\Syslog</item> </argument> </arguments> </type> ... 

 ... public function write(array $record) { if (isset($record['context']['exception'])) { $this->exceptionHandler->handle($record); return; } $record['formatted'] = $this->getFormatter()->format($record); parent::write($record); } ... 

Magento 2 à 2.2 a eu un problème avec l'enregistreur incapable de passer à un autre gestionnaire après le premier trouvé. Ce problème était dû au fait que Monolog s'attendait à ce que tous les gestionnaires y arrivent dans un tableau avec des clés numériques et avec des clés alphabétiques (['system' =>, 'debug' =>, ...]). Les développeurs de Magento ont ensuite corrigé la situation - ils convertissent le hachage en un tableau régulier avec des clés numériques avant de le transmettre à Monolog. Monolog a désormais également modifié l'algorithme d'énumération du gestionnaire et utilise la méthode next ().

Implémentation

1. Journalisation à l'aide de l'enregistreur standard

 class RandomClass { private $logger; public function __construct(\Psr\Log\LoggerInterface $logger) { $this->logger = $logger; } public function foo() { $this->logger->info('Something went wrong'); //[...some date...] main.INFO: Something went wrong [] [] } } 

 … $this->_logger->info('Something went wrong'); //    ->debug,   ,      debug.log ... 

2. Journalisation à l'aide d'un enregistreur standard avec un canal personnalisé

 class RandomClass { private $logger; public function __construct(\Psr\Log\LoggerInterface $logger) { $this->logger = $logger->withName('api'); //    } public function foo() { $this->logger->info('Something went wrong'); //[...some date...] api.INFO: Something went wrong [] [] } } 

 grep -rn 'api' var/log/system.log 

3. Écrire dans un fichier personnalisé à l'aide de votre propre gestionnaire

 <?php namespace Oxis\Log\Logger\Handler; use Magento\Framework\Filesystem\DriverInterface; use Magento\Framework\Logger\Handler\Base; use Monolog\Logger; class Test extends Base { protected $fileName = 'var/log/critical.log'; protected $loggerType = Logger::CRITICAL; public function __construct(DriverInterface $filesystem) { parent::__construct($filesystem,null,null); $this->bubble = false; //      setBubble() } } 

Dans Magento 2 2.2+ dans le constructeur \ Magento \ Framework \ Logger \ Handler \ Base, la façon de traiter le chemin d'accès au fichier journal a changé

 // BP . $this->fileName // BP. DIRECTORY_SEPARATOR . $this->fileName 

Par conséquent, dans les anciens gestionnaires, vous pouvez toujours trouver / au début de $ fileName.

 use Oxis\Log\Logger\Handler\Test; use Psr\Log\LoggerInterface; class RandomClass { private $logger; public function __construct( LoggerInterface $logger, Test $handler ) { $logger->pushHandler($handler); //  setHandlers([$handler]),        . $this->logger = $logger; } public function foo() { $this->logger->critical('Something went wrong'); //      critical.log //[...some date...] main.CRITICAL: Something went wrong [] [] } } 

4. Écriture dans un fichier personnalisé à l'aide de virtualType

Dans Magento 2 2.2+, un nouveau paramètre a été ajouté au constructeur \ Magento \ Framework \ Logger \ Handler \ Base, qui vous permet de créer un gestionnaire virtuel et de spécifier via di.xml le chemin relatif vers le fichier pour écrire le journal. Auparavant, il était nécessaire de spécifier le chemin d'accès complet via $ filePath, ou de créer un nouveau gestionnaire et d'écrire le chemin d'accès relatif à la propriété du fichier protégé $ fileName.

  <!--      ,     --> <virtualType name="ApiHandler" type="Magento\Framework\Logger\Handler\Base"> <arguments> <argument name="fileName" xsi:type="string">var/log/api.log</argument> </arguments> </virtualType> <!--  ,     --> <virtualType name="ApiLogger" type="Magento\Framework\Logger\Monolog"> <arguments> <argument name="name" xsi:type="string">api</argument> <argument name="handlers" xsi:type="array"> <item name="default" xsi:type="object">ApiHandler</item> </argument> </arguments> </virtualType> <!--       --> <type name="Oxis\Log\Model\A"> <arguments> <argument name="logger" xsi:type="object">ApiLogger</argument> </arguments> </type> 

 namespace Oxis\Log\Model; class A { private $logger; public function __construct(\Psr\Log\LoggerInterface $logger) { $this->logger = $logger; } public function foo() { $this->logger->info('Something went wrong'); } } 

 <virtualType name="ApiHandler" type="Magento\Framework\Logger\Handler\Base"> <arguments> <argument name="fileName" xsi:type="string">var/log/api.log</argument> </arguments> </virtualType> <virtualType name="ApiLogger" type="Magento\Framework\Logger\Monolog"> <arguments> <argument name="name" xsi:type="string">api</argument> <argument name="handlers" xsi:type="array"> <item name="default" xsi:type="object">ApiHandler</item> </argument> </arguments> </virtualType> <!--       logger--> <virtualType name="ApiLogContainingContext" type="Magento\Framework\Model\Context"> <arguments> <argument name="logger" xsi:type="object">ApiLogger</argument> </arguments> </virtualType> <!--    --> <type name="Oxis\Log\Model\A"> <arguments> <argument name="context" xsi:type="object">ApiLogContainingContext</argument> </arguments> </type> 

5. Enregistrement rapide des données

 ... $log = new \Monolog\Logger('custom', [new \Monolog\Handler\StreamHandler(BP.'/var/log/custom.log')]); $log->error('test'); ... 

 ... file_put_contents(BP.'/var/log/custom.log', 'test',FILE_APPEND); ... 

Conclusion