web-dev-qa-db-fra.com

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

Pouvons-nous créer un fichier journal personnalisé à différentes fins dans laravel 5.2 comme pour les entrées de journal liées à la commande qui devraient figurer dans order.log et pour les commandes liées au paiement, l'entrée doit être enregistrée

Je veux trouver le meilleur moyen possible de Laravel.

Actuellement, nous pouvons uniquement modifier la fréquence du fichier journal (quotidienne, unique) ou modifier le nom du fichier journal autre que celui par défaut i.e laravel.log

phplogginglaravel-5
26
Gaurav Bakshi

Il y a un moyen simple:

use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$log = ['orderId' => 10,
        'description' => 'Some description'];

$orderLog = new Logger(order);
$orderLog->pushHandler(new StreamHandler(storage_path('logs/order.log')), Logger::INFO);
$orderLog->info('OrderLog', $log);

Sortie dans logs/order.log:

[2017-04-30 00:00:00] order.INFO: OrderLog {"orderId":10, "description":"Some description"} []
34
massreuy

Vous pouvez essayer de réaffecter les fonctions de journal pour écrire différents types de journaux dans différents fichiers. Cela peut être fait en modifiant le fichier bootstrap/app.php:

$app->configureMonologUsing(function($monolog) {
    $bubble = false;
    $infoStreamHandler = new Monolog\Handler\StreamHandler( storage_path("/logs/orders.log"), Monolog\Logger::INFO, $bubble);
    $monolog->pushHandler($infoStreamHandler);

    $warningStreamHandler = new Monolog\Handler\StreamHandler( storage_path("/logs/logins.log"), Monolog\Logger::WARNING, $bubble);
    $monolog->pushHandler($warningStreamHandler);
});

Ensuite dans votre code, vous pouvez faire:

Log::info('Order was created', ['ORDER-123']);

Log::warning('User login', ['USER-1']);

Vous pouvez utiliser cette méthode pour éditer toutes les fonctions de journal disponibles:

  • DÉBOGUER
  • INFO
  • REMARQUER
  • ATTENTION
  • ERREUR
  • CRITIQUE
  • ALERTE
  • URGENCE
11
Niraj Shah

Pour développer la réponse de ShQ:

Un problème que j'ai remarqué est que le journal sera ajouté avec [] [], qui sont les valeurs de tableau vides pour $context et $extra dans LineFormatter.format();. 

c'est-à-dire vendor/monolog/monolog/src/Monolog/Formatter/LineFormatter.php

Il existe deux manières de contourner ce problème: fournir un format n'incluant ni extra ni contexte dans le constructeur de LineFormatter, ou fournir le 4ème argument $ignoreEmptyContextAndExtra = true.

Tous les fichiers dans la réponse de ShQ restent les mêmes mais ChannelStreamHandler doit changer.

ChannelStreamHandler: 

<?php

namespace App\Helpers;

use Monolog\Formatter\LineFormatter;
use Monolog\Handler\StreamHandler;
use Monolog\Logger;

/**
 * Use channels to log into separate files
 *
 */
class ChannelStreamHandler extends StreamHandler
{
    /**
     * Channel name
     *
     * @var String
     */
    protected $channel;

    /**
     * @param String $channel Channel name to write
     * @param bool|int $stream
     * @param bool|int $level
     * @param bool $bubble
     * @param null $filePermission
     * @param bool $useLocking
     * @see parent __construct for params
     */
    public function __construct(
        $channel,
        $stream,
        $level = Logger::DEBUG,
        $bubble = true,
        $filePermission = null,
        $useLocking = false
    ) {
        $this->channel = $channel;

        $formatter = new LineFormatter(null, null, false, true);
        $this->setFormatter($formatter);

        parent::__construct($stream, $level, $bubble);
    }

    /**
     * When to handle the log record.
     *
     * @param array $record
     * @return bool
     */
    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);
        }
    }

}

Le changement important est de fournir le 4ème paramètre de true, qui est $ignoreEmptyContextAndExtra. Ce paramètre dit à LineFormatter d'ignorer l'un des tableaux context of extra s'il est vide:

$formatter = new LineFormatter(null, null, false, true);
$this->setFormatter($formatter);

Vous devez également vous assurer d’exécuter monolog 1.22 car il contient une correction de bogue concernant ignoreEmptyContextAndExtra.

J'ai également ajouté un remplacement pour info () à la classe ChannelWritter:

public function info($channel, $message, array $context = [])
{
    $level = array_flip($this->levels)[$this->channels[$channel]['level']];
    $this->writeLog($channel, $level, $message, $context);
}

De plus, je n'étais pas satisfait du "consignateur de charge paresseux" de la solution de ShQ, qui a été modifié pour utiliser le fournisseur de services/IoC.

Remplacez ChannelWriter.writeLog():

public function writeLog(string $channel, string $level, string $message, array $context = [])
{
    if (!in_array($channel, array_keys($this->channels))) {
        throw new InvalidArgumentException('Invalid channel used.');
    }

    $logger = \App::make("{$channel}log");
    $channelHandler = new ChannelStreamHandler(
        $channel,
        storage_path() . '/' . $this->channels[$channel]['path'],
        $this->channels[$channel]['level']
    );
    $logger->pushHandler($channelHandler);
    $logger->{$level}($message);
}

et dans votre AppServiceProvider:

    $this->app->bind('eventlog', function () {
        return new Logger('event');
    });

    $this->app->bind('auditlog', function () {
        return new Logger('audit');
    });

Je vais essayer de regrouper cela dans un paquet.

6
wired00

Ceci est pris en charge d'une manière beaucoup plus facile maintenant

  1. Créer un canal

    goto: app/config/logging.php, sous le tableau channels, ajoutez votre canal personnalisé i.e

    'paiements' => [
 'driver' => 'single', 
 'path' => storage_path ('logs/payments.log'), 
 'niveau' => 'info', 
],

  2. Dans votre route ou votre contrôleur, écrivez dans ce journal

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

  3. Les journaux de paiement peuvent être trouvés à /storage/logs/payments.log

NOTE: extensible pour améliorer vos besoins

Laravel version 5.6 Docs

4
Faiz Khan

Le moyen le plus rapide de générer le journal dans différents fichiers

Log::useFiles('path/to/file.log');
Log::info('Info');
0
Deepak Pandey
Solution:

step1: create a channel inside config/logging.php file

example :

'channels' => [
    'single' => [
    'driver' => 'single', 
    'path' => storage_path('logs/laravel.log'),
    'level' => 'debug',
],

'web' => [
      'driver' => 'single',
      'path' => storage_path('logs/web/web.log'),
   ],

]

Step2: Now set dynamic path from the controller  like this

config(['logging.channels.web.path' => storage_path('logs/web/'.time().'.log')]);

Step3 : now generate your log

  Log::channel('web')->info("your message goes here");

Enjoy :)
0
Kundan roy

Basé sur la réponse ShQ, un assistant enregistreur plus court et plus simple vous permettant de vous connecter à un fichier personnalisé à la volée. Vous pouvez également ajouter votre gestionnaire personnalisé et définir le chemin du 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 pour enregistrer la fonction) 

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

config\app.php (ajouter aux alias) 

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

Ensuite, 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 la sortie de votre enregistreur en appelant

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

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

0
Romain Laneuville

Pour moi dans Laravel 5.3, je ne sais pas si c’était mon installation auparavant mais j’ai trouvé que le fichier bootstrap/app.php ne fonctionnait pas pour moi.

Je devais mettre cela dans app/Providers/AppServiceProvider.php.

nb C’est là que j’avais auparavant défini le niveau de journalisation de la configuration, de sorte que je me retrouve avec 3 gestionnaires de journaux.

public function register()
{
   $monolog = Log::getMonolog();
   foreach ($monolog->getHandlers() as $handler) {
      $handler->setLevel(Config::get('app.log_level'));
   }

   $bubble = false;
   $infoStreamHandler = new \Monolog\Handler\StreamHandler( storage_path("logs/info.log"), \Monolog\Logger::INFO, $bubble);
   $monolog->pushHandler($infoStreamHandler);

   $warningStreamHandler = new \Monolog\Handler\StreamHandler( storage_path("logs/warning.log"), \Monolog\Logger::WARNING, $bubble);
   $monolog->pushHandler($warningStreamHandler);

}
0
tristanbailey