Ao desenvolver um aplicativo moderno, o registro deve estar no topo da lista de prioridades.

O registro fornece uma maneira de visualizar seu aplicativo tanto no desenvolvimento quanto na produção, permitindo transparência e visibilidade. Com o registro corretamente estruturado, aplicativos modernos podem se tornar mais fáceis de manter, pois podemos identificar proativamente pontos de falha e gargalos de desempenho em nosso aplicativo.

A Framework Laravel vem com um robusto sistema de registro que lida com todos os obstáculos envolvidos na configuração de um sistema de registro devidamente estruturado fora da caixa. Este novo sistema de exploração do registro introduzido no Laravel 6.5 é poderoso e nós o exploraremos neste artigo.

Este artigo irá explorar os fundamentos dos registros no Laravel e por que você deve usar o registro de Laravel em seu próximo projeto. Discutiremos em detalhes o registro estruturado e o registro centralizado. Além disso, aprenderemos como implementar o registro Laravel através da construção de um aplicativo Todo.

Você obterá mais deste artigo se você já tiver o seguinte sob seu cinto:

O que é registro Laravel?

O registro Laravel é tudo sobre como Laravel lida com o registro, ou relatório automático de problemas, usando um sistema de registro PHP viral chamado Monolog. Entretanto, devido à filosofia de Laravel de usar bibliotecas populares existentes para implementar diferentes características de framework, Laravel emprega Monolog para todas as suas necessidades de registro.

Monolog é uma biblioteca de registros PHP altamente flexível e popular que podemos configurar para enviar seus registros para arquivos, soquetes, bancos de dados e outros serviços web. Monolog fornece uma interface familiar para escrever registros de arquivos de texto padrão para serviços avançados de gerenciamento de registros de terceiros. Laravel tipicamente configura Monolog para usar um arquivo de configuração de registro padrão.

Para mais informações sobre Monolog e suas funcionalidades, confira a documentação oficial, pois isso está além do escopo deste artigo.

Antes de mergulharmos na configuração e implementação do registro Laravel usando Monolog, vamos explorar mais razões para usar o registro Laravel e os diferentes tipos.

Por que usar o registro Laravel?

Por que é necessário o registro de dados?

O Manifesto dos Aplicativos de 12 Fatores trata a exploração do registro como uma das preocupações críticas de um aplicativo moderno, já que a exploração do registro é a chave para o desempenho e monitoramento.

Os registros ajudam na compreensão detalhada dos erros que acontecem na produção e de onde eles se originaram. Além disso, com estruturas de registros adequadas, ele pode mostrar o usuário em particular, a ação que causou o erro e a solução possível para a correção e manutenção mais rápida do bug.

O registro estruturado é um salva-vidas em aplicativos de produção, ajudando a solucionar defeitos e resolver problemas na produção. Além disso, você pode monitorar e coletar todas as suas mensagens de registro em tempo real usando ferramentas especializadas de registro para análise e relatórios ao vivo.

Por estas razões, você precisa fazer do registro estruturado uma prioridade máxima em seu próximo projeto de aplicativo moderno.

Vamos dar uma olhada na visão geral dos diferentes estilos de extração disponíveis.

Noções básicas de registros no Laravel

Aprender o básico da exploração do registro o ajudará a entender como Laravel lida com a exploração do registro e como você pode melhorar suas práticas estruturadas de exploração do registro.

Vamos examinar dois conceitos essenciais na exploração do registro para entender melhor como implementar nossos procedimentos de exploração do registro.

Registro estruturado do Laravel

No desenvolvimento de software, o registro estruturado está implementando um formato de mensagem pré-determinado e consistente para os registros de aplicativo. Este formato permite que as mensagens sejam tratadas como dados que podem ser monitorados, manipulados e visualizados muito melhor do que o formato de texto regular.

Você deve implementar uma abordagem de registro estruturado no desenvolvimento do seu aplicativo moderno porque os arquivos de registro são os ativos essenciais para os desenvolvedores quando algo errado acontece com o seu aplicativo em produção.

Como Laravel usa o Monolog, os desenvolvedores podem rapidamente implementar registros estruturados configurando o logger para receber tipos específicos de informações, armazenando os arquivos de registro em diferentes formatos e enviando os registros para vários serviços de gerenciamento de registros de terceiros para visualização.

Registro centralizado no Laravel

Um sistema de registro centralizado é onde os registros são enviados para soluções de Gerenciamento Centralizado de registro (CLM) a partir de múltiplas fontes para fácil consolidação e visualização. Entretanto, o CLM é uma solução de logger especializada que coleta mensagens de registro de diferentes fontes e consolida os dados para facilitar o processamento e a visualização.

Além da coleta de dados, espera-se que o CLM também suporte a análise dos dados de registro e a apresentação clara dos dados após a análise.

Registros estruturados vs Registros básicos

Vamos examinar a diferença entre o registro estruturado e o registro básico (não estruturado) e porque você deve usar o registro estruturado em seu projeto Laravel.

Registro básico

No registro básico, os arquivos de registro são armazenados em um formato bruto com dados limitados para consulta e identificação de registros individuais.

Ao usar o registro básico, os desenvolvedores não serão capazes de usar ferramentas analíticas de terceiros para ler, visualizar e analisar os registros, a menos que eles desenvolvam uma ferramenta customizada ou que se fixem com uma ferramenta limitada que suporte seu formato de registros.

Há três grandes razões para evitar o uso do corte básico:

  1. Sistemas centralizados de gerenciamento de registros não podem funcionar com os dados sem suporte adicional.
  2. Uma solução personalizada é necessária para ler e analisar os dados de uma solução básica de registro.
  3. Pode ser um desafio para os administradores ler os dados básicos de registro, uma vez que eles são brutos e não estruturados.

Registro estruturado

O registro estruturado economiza tempo dos desenvolvedores ao usar ferramentas analíticas de registro de terceiros de código aberto que suportam a estrutura padrão de registro para ler, visualizar e analisar os registros.

Os registros são úteis se eles contiverem os dados corretos listados abaixo, que é o que o registro estruturado visa alcançar. Nós podemos usar os dados incluídos no registro estruturado para criar painéis, gráficos, gráficos e qualquer outra visualização útil para determinar a saúde do aplicativo.

Estes são exemplos básicos das informações que podemos incluir em mensagens de registro estruturadas. Além disso, você pode personalizar completamente os dados para atender às suas necessidades.

Aqui estão alguns exemplos dos dados que você pode coletar com o registro estruturado:

  1. A porta usada para executar a função
  2. A data e a hora em que o evento aconteceu
  3. O nome de usuário ou ID do cliente
  4. Uma descrição do evento (mensagem de registro)
  5. O protocolo usado para executar a função
  6. A localização do evento acionado (indicar API ou aplicativo em execução)
  7. O ID único do evento
  8. O tipo de ação acionada (nível de log)

Os registros devem conter dados suficientes para visualizar facilmente a solução ou a razão do evento de log. Observe também que você não deve armazenar todos os tipos de informações, tais como senhas ou dados sensíveis nos registros.

Agora que vislumbramos o que é a exploração do registro Laravel, vamos passar à implementação da exploração do registro Laravel, construindo um aplicativo com exploração do registro como um cidadão de primeira classe.

Como implementar o registro Laravel com o aplicativo Todo

Agora nós vamos aplicar o que aprendemos até agora, criando um novo projeto Laravel e implementando o registro Laravel.

Se você nunca usou Laravel antes, você pode ler o que Laravel é ou espreitar nossa lista de excelentes tutoriais de Laravel para começar.

Configurando o Laravel

Primeiro, vamos criar uma nova instância de Laravel usando o comando abaixo. Você pode consultar a documentação oficial para mais informações.

Abra seu console e navegue até onde você armazena seus projetos PHP antes de executar os comandos abaixo. Certifique-se de ter o Composer instalado e configurado corretamente.

composer create-project laravel/laravel laravel-logging-app
cd laravel-logging-app // Change directory to current Laravel installation
php artisan serve // Start Laravel development server

Configurando e alimentando o banco de dados

Em seguida, vamos montar nosso banco de dados, criar um novo modelo Todo, e alimentar 200 dados falsos para testes.

Abra seu cliente de banco de dados e crie um novo banco de dados. Faremos o mesmo com o nome laravel_logging_app_db e então preencheremos nosso arquivo .env com as credenciais do banco de dados:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel_logging_app_db
DB_USERNAME=//DB USERNAME HERE
DB_PASSWORD=//DB PASSWORD HERE

Em seguida, executaremos o seguinte comando para criar a migração e o modelo Todo simultaneamente:

php artisan make:model Todo -mc

Abra o database/migrations/xxx-create-todos-xxx.php e cole nos seguintes códigos:

<?php
use IlluminateSupportFacadesSchema;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateDatabaseMigrationsMigration;
class CreateTodosTable extends Migration
{
  /**
  * Run the migrations.
  *
  * @return void
  */
  public function up()
  {
    Schema::create('todos', function (Blueprint $table) {
      $table->id();
      $table->string('title');
      $table->text('description')->nullable();
      $table->boolean('is_completed')->default(false);
      $table->timestamps();
    });
  }
  /**
  * Reverse the migrations.
  *
  * @return void
  */
  public function down()
  {
    Schema::dropIfExists('todos');
  }
}

Você pode alimentar seus todos com dados falsos aprendendo a alimentar seus bancos de dados em Laravel usando o Faker.

Visão geral do Monolog

Com Laravel Monolog, você pode transmitir e enviar registros estruturados para diferentes canais, como e-mails, Slack, arquivos, soquetes, caixas de entrada, bancos de dados e vários serviços web. No Laravel, você pode configurar o registro a partir de um único arquivo de configuração localizado em config/logging.php.

O arquivo de configuração vem com drivers de registro pré-definidos para escolher, e o driver padrão é um stack que usa o canal single para logar em um arquivo laravel.log encontrado na pasta storage/logs. Nós demonstraremos o registro estruturado usando um par de drivers de registro Laravel.

Laravel fornece um punhado de métodos para interagir com os registros, como demonstrado em geral no arquivo do controlador TodosController.php em breve.

Escrevendo mensagens de registro no controlador

Abra o arquivo recém-criado TodosController.php controller encontrado na pasta app/Http/Controllers e cole nos seguintes códigos:


<?php
namespace AppHttpControllers;
use AppModelsTodo;
use IlluminateHttpRequest;
use AppHttpControllersController;
use IlluminateSupportFacadesAuth;
use IlluminateSupportFacadesLog;
class TodosController extends Controller
{
  public function index(Request $request)
  {
    $todos = Todo::all();
    Log::warning('User is accessing all the Todos', ['user' => Auth::user()->id]);
    return view('dashboard')->with(['todos' => $todos]);
  }
  public function byUserId(Request $request)
  {
    $todos = Todo::where('user_id', Auth::user()->id)->get();
    Log::info('User is accessing all his todos', ['user' => Auth::user()->id]);
    return view('dashboard')->with(['todos' => $todos]);
  }
  public function show(Request $request, $id)
  {
    $todo = Todo::find($id);
    Log::info('User is accessing a single todo', ['user' => Auth::user()->id, 'todo' => $todo->id]);
    return view('show')->with(['todo' => $todo]);
  }
  public function update(Request $request, $id)
  {
    # Validations before updating
    $todo = Todo::where('user_id', Auth::user()->id)->where('id', $id)->first();
    Log::warning('Todo found for updating by user', ['user' => Auth::user()->id, 'todo' => $todo]);
    if ($todo) {
      $todo->title = $request->title;
      $todo->desc = $request->desc;
      $todo->status = $request->status == 'on' ? 1 : 0;
      if ($todo->save()) {
        Log::info('Todo updated by user successfully', ['user' => Auth::user()->id, 'todo' => $todo->id]);
        return view('show', ['todo' => $todo]);
      }
      Log::warning('Todo could not be updated caused by invalid todo data', ['user' => Auth::user()->id, 'todo' => $todo->id, 'data' => $request->except('password')]);
      return; // 422
    }
    Log::error('Todo not found by user', ['user' => Auth::user()->id, 'todo' => $id]);
    return; // 401
  }
  public function store(Request $request)
  {
    Log::warning('User is trying to create a single todo', ['user' => Auth::user()->id, 'data' => $request->except('password')]);
    # Validations before updating
    $todo = new Todo;
    $todo->title = $request->title;
    $todo->desc = $request->desc;
    $todo->user_id = Auth::user()->id;
    if ($todo->save()) {
      Log::info('User create a single todo successfully', ['user' => Auth::user()->id, 'todo' => $todo->id]);
      return view('show', ['todo' => $todo]);
    }
    Log::warning('Todo could not be created caused by invalid todo data', ['user' => Auth::user()->id, 'data' => $request->except('password')]);
    return; // 422
  }
  public function delete(Request $request, $id)
  {
    Log::warning('User is trying to delete a single todo', ['user' => Auth::user()->id, 'todo' => $id]);
    $todo = Todo::where('user_id', Auth::user()->id)->where('id', $id)->first();
    if ($todo) {
      Log::info('User deleted a single todo successfully', ['user' => Auth::user()->id, 'todo' => $id]);
      $todo->delete();
      return view('index');
    }
    Log::error('Todo not found by user for deleting', ['user' => Auth::user()->id, 'todo' => $id]);
    return; // 404
  }
}

Dentro de cada um dos métodos no TodoController, nós adicionamos a fachada Log com um nível de registro específico para definir o tipo de erro que queremos enviar. Abaixo está um exemplo de como usar o

Fachada de log no método store.

public function store(Request $request)
{
  Log::warning('User is trying to create a single todo', ['user' => Auth::user()->id, 'data' => $request->except('password')]);
  # Validations before updating
  $todo = new Todo;
  $todo->title = $request->title;
  $todo->desc = $request->desc;
  $todo->user_id = Auth::user()->id;
  if ($todo->save()) {
    Log::info('User create a single todo successfully', ['user' => Auth::user()->id, 'todo' => $todo->id]);
    return view('show', ['todo' => $todo]);
  }
  Log::warning('Todo could not be created caused by invalid todo data', ['user' => Auth::user()->id, 'data' => $request->except('password')]);
  return; // 422
}

Formatação de mensagens de registro

Suponha que você não esteja confortável com o padrão LineFormatter usado por Laravel, que faz um ótimo trabalho de fornecer mensagens legíveis e úteis.

Nesse caso, você pode facilmente girar um objeto formatador personalizado para se ajustar ao seu caso de uso e usá-lo durante toda a aplicação.

A documentação oficial do Monolog dá uma lista completa de formatadores disponíveis e pode facilmente criar um formatador personalizado.

Em Laravel, você pode facilmente configurar qualquer um dos drivers para usar seu formatador personalizado adicionando-o à lista como abaixo dentro do arquivo de configuração localizado em config/logging.php:

'daily' => [
  'driver' => 'daily',
  'path' => storage_path('logs/laravel.log'),
  'level' => env('LOG_LEVEL', 'debug'),
  'days' => 14,
  'formatter' => MonologFormatterHtmlFormatter::class,
  'formatter_with' => [
    'dateFormat' => 'Y-m-d',
  ]
],

O exemplo acima adiciona um MonologFormatterHtmlFormatter personalizado ao driver daily usando a tecla formatter e formatter_with na configuração do canal daily para alterar o formato das datas.

Envio de registros para diferentes canais

Com a ajuda do Monolog, Laravel pode enviar registros para diferentes canais e múltiplos canais simultaneamente.

Vamos demonstrar como enviar registros para o nosso canal Slack seguindo estes simples passos. Mude o canal de registro padrão para Slack e adicione a URL Slack Webhook em seu arquivo .env.

LOG_CHANNEL=slack
LOG_SLACK_WEBBHOOK_URL= Slack_webhook_url_here

Em seguida, teste sua configuração registrando uma mensagem em seu aplicativo usando a fachada Log como a mostrada abaixo:

Log::debug("The API instance is on fire caused by:", ['user' => 1])

Você pode abrir seu canal Slack para verificar o erro impresso no canal desejado que você especificou ao gerar a URL do Webhook.

Resumo

O Registro é tão importante quanto qualquer outro fator do seu aplicativo, se não for mais. É por isso que é sugerido pelo Manifesto dos 12 Fatores como uma das preocupações mais críticas de qualquer aplicativo moderno.

Com o registro efetivo, você pode facilmente ler, visualizar erros e defeitos que acontecem em seu aplicativo pronto para produção. Para este fim, é importante que você implemente um registro estruturado em seu aplicativo desde o início do projeto.

Neste artigo, exploramos o registro Laravel e porque você deve usá-lo em seu próximo projeto. Nós discutimos em detalhes tanto o registro estruturado quanto o registro centralizado. Além disso, aprendemos como implementar o registro Laravel através da construção de um aplicativo Todo.

Como você planeja implementar o login em seu próximo aplicativo? Informe-nos na seção de comentários.

Solomon Eseme

Sou um Engenheiro de Software e Criador de Conteúdo voltado para a construção de produtos de alta performance e inovadores, seguindo as melhores práticas e padrões da indústria. Também adoro escrever sobre isso no Masteringbackend.com. Siga-me no X, LinkedIn e About Me.