php - plantillas - mail::send laravel example

Laravel: Cómo registrar INFO en un archivo separado

Question

¿Cómo especificar un archivo separado para logging INFO en Laravel 5.1 ?

Cualquier ayuda inmediata será altamente apreciable. Gracias

Answer 1

¿Desea registrar específicamente la info en un archivo de registro y otro tipo de registro en otra ubicación? Mi solución podría no ser útil en ese caso, pero podría ser útil.

Para escribir un archivo de registro en otra ubicación, use el método useDailyFiles o useFiles , y luego información para iniciar sesión en el archivo de registro en la ruta que acaba de especificar. Al igual que:

    Log::useDailyFiles(storage_path().''/logs/name-of-log.log'');
    Log::info([info to log]);

El primer parámetro para ambos métodos es la ruta del archivo de registro (que se crea si aún no existe) y para useDailyFiles el segundo argumento es el número de días que Laravel registrará antes de borrar los registros anteriores. El valor predeterminado es ilimitado, por lo que en mi ejemplo no he ingresado un valor.

Answer 2

En Laravel 5.6 puede crear su propio canal en config/logging.php . Si ha actualizado desde una versión anterior de Laravel, necesita crear este archivo ( https://laravel.com/docs/5.6/upgrade ).

Agregue esto a su matriz de canales en config/logging.php

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

A continuación, puede llamar a cualquiera de los 8 niveles de registro de esa manera:

lluminate/Support/Facades/Log::channel(''your_channel_name'')->info(''your_message'');

Los registros se almacenarán en logs/your_file_name.log

Answer 3

Laravel usa el monólogo para el registro, pero usa una versión anterior que no admite múltiples canales en un único nivel de registro.

Aquí hay una sugerencia que puede ayudar: laravel 5.2 archivo de registro personalizado para diferentes tareas

Answer 4

Si desea agregar otro manejador monólogo, puede usar el método configureMonologUsing de la aplicación.

Realice una llamada a este método en el archivo bootstrap / app.php justo antes de que se devuelva la variable $ app:

$app->configureMonologUsing(function($monolog) {
    $monolog->pushHandler(new StreamHandler(''path/to/info.log'', Logger::INFO, false)); // false value as third argument to disable bubbling up the stack
});

return $app;

Answer 5

Un asistente de registro simple que le permite iniciar sesión en múltiples archivos personalizados sobre la marcha. También puede agregar su controlador personalizado y establecer la ruta del archivo.

App / Helper / LogToChannels.php

<?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;
use Monolog/Formatter/LineFormatter;

/**
 * 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''
            );

            $handler->setFormatter(new LineFormatter(null, null, true, true));

            $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);
    }
}

Aplicación / Proveedores / LogToChannelsServiceProvider.php

<?php
/**
 * Logger service provider to be abled to log in different files
 *
 * @package    App/Providers
 * @author     Romain Laneuville <[email protected]>
 */

namespace App/Providers;

use Illuminate/Support/ServiceProvider;
use App/Helpers/LogToChannels;

/**
 * Class LogToChannelsServiceProvider
 *
 * @package App/Providers
 */
class LogToChannelsServiceProvider extends ServiceProvider
{
    /**
     * Initialize the logger
     *
     * @return void
     */
    public function register()
    {
        $this->app->singleton(''App/Helpers/LogToChannels'', function () {
            return new LogToChannels();
        });
    }
}

config / app.php (agregue el proveedor del servicio)

// Register Service Providers
$app->register(App/Providers/LogToChannelsServiceProvider::class);

Luego, en cualquier lugar de su aplicación, puede llamar usando la inyección de dependencia (agregue la clase en su constructor y vincúlela a un atributo de clase de log )

$this->log->info(''logger_name'', ''Log message'');
$this->log->error(''other_logger_name'', ''Log message'', $someContext);

Incluso puede personalizar su salida de registrador llamando

$this->log->addChannel(''channel_name'', $customHandler);

Y estará accesible cuando llame su nombre en cualquier lugar de su aplicación.