laravel 5.2 fichier journal personnalisé pour différentes tâches

Ici vous allez... j'ai passé beaucoup de temps à ajouter des fonctionnalités personnalisées à Monolog, qui mesure de le faire d'une manière appropriée. J'ai essayé tellement de nombreuses façons différentes, mais tout était très orthodoxe. J'ai enfin trouvé un bon moyen pour obtenir cette fonctionnalité de travail....

Que la demande est grande, j'avais besoin de séparer les fichiers journaux, et de maintenir l'existant Laravel du Journal de l'interface autant que possible. J'ai besoin de quelque chose comme:

Log::write('audit', 'User logged in to the app.');

Log::info('event', 'User sent out 2 emails.');

La Solution:

App\Providers\AppServiceProvider.php (ajouter à la fonction register)

//Facade to Object binding
$this->app->bind('chanellog', 'App\Helpers\ChannelWriter');

config\app.php (ajouter des alias)

//Custom Alias Class
'ChannelLog' => App\Contracts\Facades\ChannelLog::class,

App\Contracts\Facades\ChannelLog.php

<?php

namespace App\Contracts\Facades;

use Illuminate\Support\Facades\Facade;

/**
 * @see \Illuminate\Log\Writer
 */
class ChannelLog extends Facade
{
    /**
     * Get the registered name of the component.
     *
     * @return string
     */
    protected static function getFacadeAccessor()
    {
        return 'chanellog';
    }
}

App\Helpers\ChannelWriter.php

<?php
namespace App\Helpers;
use Monolog\Logger;
use App\Helpers\ChannelStreamHandler;
class ChannelWriter
{
/**
* The Log channels.
*
* @var array
*/
protected $channels = [
'event' => [ 
'path' => 'logs/audit.log', 
'level' => Logger::INFO 
],
'audit' => [ 
'path' => 'logs/audit.log', 
'level' => Logger::INFO 
]
];
/**
* The Log levels.
*
* @var array
*/
protected $levels = [
'debug'     => Logger::DEBUG,
'info'      => Logger::INFO,
'notice'    => Logger::NOTICE,
'warning'   => Logger::WARNING,
'error'     => Logger::ERROR,
'critical'  => Logger::CRITICAL,
'alert'     => Logger::ALERT,
'emergency' => Logger::EMERGENCY,
];
public function __construct() {}
/**
* Write to log based on the given channel and log level set
* 
* @param type $channel
* @param type $message
* @param array $context
* @throws InvalidArgumentException
*/
public function writeLog($channel, $level, $message, array $context = [])
{
//check channel exist
if( !in_array($channel, array_keys($this->channels)) ){
throw new InvalidArgumentException('Invalid channel used.');
}
//lazy load logger
if( !isset($this->channels[$channel]['_instance']) ){
//create instance
$this->channels[$channel]['_instance'] = new Logger($channel);
//add custom handler
$this->channels[$channel]['_instance']->pushHandler( 
new ChannelStreamHandler( 
$channel, 
storage_path() .'/'. $this->channels[$channel]['path'], 
$this->channels[$channel]['level']
)
);
}
//write out record
$this->channels[$channel]['_instance']->{$level}($message, $context);
}
public function write($channel, $message, array $context = []){
//get method name for the associated level
$level = array_flip( $this->levels )[$this->channels[$channel]['level']];
//write to log
$this->writeLog($channel, $level, $message, $context);
}
//alert('event','Message');
function __call($func, $params){
if(in_array($func, array_keys($this->levels))){
return $this->writeLog($params[0], $func, $params[1]);
}
}
}

App\Helpers\ChannelStreamHandler.php

<?php
namespace App\Helpers;
use Monolog\Handler\StreamHandler;
/**
* Use channels to log into separate files
*
* @author Peter Feher
*/
class ChannelStreamHandler extends StreamHandler
{
/**
* Channel name
* 
* @var String 
*/
protected $channel;
/**
* @param String $channel Channel name to write
* @see parent __construct for params
*/
public function __construct($channel, $stream, $level = Logger::DEBUG, $bubble = true, $filePermission = null, $useLocking = false)
{
$this->channel = $channel;
parent::__construct($stream, $level, $bubble);
}
/**
* When to handle the log record. 
* 
* @param array $record
* @return type
*/
public function isHandling(array $record)
{
//Handle if Level high enough to be handled (default mechanism) 
//AND CHANNELS MATCHING!
if( isset($record['channel']) ){
return ( 
$record['level'] >= $this->level && 
$record['channel'] == $this->channel 
);
} else {
return ( 
$record['level'] >= $this->level
);
}
}
}

Après cela, vous pouvez le faire dans n'importe quel fichier:

use ChannelLog as Log;
...
function myFunction(){
//Recommended (writes INFO to logs/event.log)
Log::write('event', 'User sent out 3 voucher.')
//Possible to use (writes ALERT to logs/audit.log)
Log::alert('audit', 'User modified xyz entry.')
//Or even: 
Log::write('audit', 'User modified xyz entry.', ['user'=>1])
}

C'est pris en charge dans un moyen beaucoup plus facile maintenant

1. Créer un canal

   goto: root/config/logging.php, sous channels tableau ajouter votre canal personnalisé-je.e

   'paiements' => [ 
   'driver' => 'unique', 
   'path' => storage_path ("logs/paiements.le journal), 
   'niveau' => 'info', 
   ],

2. Dans votre parcours d'un contrôleur ou d'écrire dans ce journal

       Log::channel('payments')->info('A transaction has been made!');

3. Le paiement des journaux peut être trouvé à /storage/logs/payments.log

REMARQUE: extensible à améliorer d'autres personnes à vos exigences

Laravel version 5.6 Docs

Façon la plus rapide de journal de sortie pour différents fichiers

Log::useFiles('path/to/file.log');
Log::info('Info');

Basé sur la ShQ réponse plus courte et la plus simple logger assistant qui vous permet de vous connecter à un fichier personnalisé à la volée. Vous pouvez également ajouter votre gestionnaire personnalisé et de définir le chemin d'accès au fichier.

App\Helper

<?php
/**
* Logger helper to log into different files
*
* @package    App\Helpers
* @author     Romain Laneuville <[email protected]>
*/
namespace App\Helpers;
use Monolog\Logger;
use Monolog\Handler\HandlerInterface;
use Monolog\Handler\StreamHandler;
/**
* Class LogToChannels
*
* @package App\Helpers
*/
class LogToChannels
{
/**
* The LogToChannels channels.
*
* @var Logger[]
*/
protected $channels = [];
/**
* LogToChannels constructor.
*/
public function __construct()
{
}
/**
* @param string $channel The channel to log the record in
* @param int    $level   The error level
* @param string $message The error message
* @param array  $context Optional context arguments
*
* @return bool Whether the record has been processed
*/
public function log(string $channel, int $level, string $message, array $context = []): bool
{
//Add the logger if it doesn't exist
if (!isset($this->channels[$channel])) {
$handler = new StreamHandler(
storage_path() . DIRECTORY_SEPARATOR . 'logs' . DIRECTORY_SEPARATOR . $channel . '.log'
);
$this->addChannel($channel, $handler);
}
//LogToChannels the record
return $this->channels[$channel]->{Logger::getLevelName($level)}($message, $context);
}
/**
* Add a channel to log in
*
* @param string           $channelName The channel name
* @param HandlerInterface $handler     The channel handler
* @param string|null      $path        The path of the channel file, DEFAULT storage_path()/logs
*
* @throws \Exception When the channel already exists
*/
public function addChannel(string $channelName, HandlerInterface $handler, string $path = null)
{
if (isset($this->channels[$channelName])) {
throw new \Exception('This channel already exists');
}
$this->channels[$channelName] = new Logger($channelName);
$this->channels[$channelName]->pushHandler(
new $handler(
$path === null ?
storage_path() . DIRECTORY_SEPARATOR . 'logs' . DIRECTORY_SEPARATOR . $channelName . '.log' :
$path . DIRECTORY_SEPARATOR . $channelName . '.log'
)
);
}
/**
* Adds a log record at the DEBUG level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function debug(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::DEBUG, $message, $context);
}
/**
* Adds a log record at the INFO level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function info(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::INFO, $message, $context);
}
/**
* Adds a log record at the NOTICE level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function notice(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::NOTICE, $message, $context);
}
/**
* Adds a log record at the WARNING level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function warn(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::WARNING, $message, $context);
}
/**
* Adds a log record at the WARNING level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function warning(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::WARNING, $message, $context);
}
/**
* Adds a log record at the ERROR level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function err(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::ERROR, $message, $context);
}
/**
* Adds a log record at the ERROR level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function error(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::ERROR, $message, $context);
}
/**
* Adds a log record at the CRITICAL level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function crit(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::CRITICAL, $message, $context);
}
/**
* Adds a log record at the CRITICAL level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return Boolean Whether the record has been processed
*/
public function critical(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::CRITICAL, $message, $context);
}
/**
* Adds a log record at the ALERT level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function alert(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::ALERT, $message, $context);
}
/**
* Adds a log record at the EMERGENCY level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function emerg(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::EMERGENCY, $message, $context);
}
/**
* Adds a log record at the EMERGENCY level.
*
* @param  string $channel The channel name
* @param  string $message The log message
* @param  array  $context The log context
*
* @return bool Whether the record has been processed
*/
public function emergency(string $channel, string $message, array $context = []): bool
{
return $this->log($channel, Logger::EMERGENCY, $message, $context);
}
}

App\Providers\AppServiceProvider.php (ajouter à la fonction register)

//Facade to Object binding
$this->app->bind('LogToChannels', 'App\Helpers\LogToChannels');

config\app.php (ajouter des alias)

//Custom Alias Class
'Log' => App\Contracts\Facades\LogToChannels::class

Puis n'importe où dans votre application, vous pouvez appeler

Log::info('logger_name', 'Log message');
Log::error('other_logger_name', 'Log message', $someContext);

Vous pouvez même personnaliser votre enregistreur de sortie en appelant

Log::addChannel('channel_name', $customHandler);

Et il sera accessible lorsque vous appelez son nom n'importe où dans votre application.