När man utvecklar en modern applikation bör loggning stå högst upp på prioriteringslistan.

Loggning ger ett sätt att visualisera din app i både utveckling och produktion, vilket möjliggör transparens och synlighet. Med en korrekt strukturerad loggning kan moderna applikationer bli lättare att underhålla eftersom vi proaktivt kan identifiera felpunkter och flaskhalsar i appens prestanda.

Laravel-ramverket levereras med ett robust loggningssystem som hanterar alla hinder som kan uppstå när man konfigurerar ett korrekt strukturerat loggningssystem direkt ur lådan. Det nya loggningssystemet som introducerades i Laravel 6.5 är kraftfullt och vi kommer att utforska detta i den här artikeln.

Den här artikeln kommer att utforska grunderna i Laravel-loggning och varför du bör använda Laravel-loggning i ditt nästa projekt. Vi kommer att diskutera strukturerad loggning och centraliserad loggning i detalj. Vi kommer dessutom att lära oss hur man implementerar Laravel-loggning genom att bygga en Todo-applikation.

Du kommer att få ut mer av den här artikeln om du redan har följande i bagaget:

Vad är Laravel-loggning?

Laravel logging handlar om hur Laravel hanterar loggning, eller automatisk problemrapportering, med hjälp av ett viralt PHP-loggningssystem som heter Monolog. På grund av Laravels filosofi att använda populära befintliga bibliotek för att implementera olika ramfunktioner använder Laravel dock Monolog för alla loggningsbehov.

Monolog är ett mycket flexibelt och populärt PHP-loggningsbibliotek som vi kan konfigurera för att skicka dina loggar till filer, sockets, databaser och andra webbtjänster. Monolog erbjuder ett välbekant gränssnitt för att skriva loggar från vanliga textfiler till avancerade logghanteringstjänster från tredje part. Laravel ställer vanligtvis in Monolog så att det nyttjas en standardkonfigurationsfil för loggning.

För mer information om Monolog och dess funktioner, kolla in den officiella dokumentationen, eftersom detta ligger utanför den här artikelns räckvidd.

Innan vi djupdyker i konfigurering och implementering av Laravel-loggning med Monolog, ska vi utforska fler anledningar till att använda Laravel-loggning och de olika typerna.

Varför ska man använda Laravel-loggning?

Varför är loggning nödvändig?

Manifestet Twelve-Factor App behandlar loggning som en av de kritiska frågorna för en modern applikation, eftersom loggning är en nyckel till prestanda och övervakning.

Loggningar hjälper till med en detaljerad förståelse av fel som inträffar i produktionen och var de har sitt ursprung. Med rätt loggstrukturer kan man dessutom visa vilken användare som det rör sig om, vilken åtgärd som orsakade felet och en möjlig lösning för snabbare fel-korrigering och underhåll.

Strukturerad loggning är en livräddare i produktionsapplikationer genom att den hjälper till att felsöka fel och lösa problem i produktionen. Du kan dessutom övervaka och samla in alla dina loggmeddelanden i realtid med hjälp av specialiserade loggningsverktyg för liveanalys och rapportering.

Av dessa skäl måste du göra strukturerad loggning till högsta prioritet i ditt nästa moderna applikationsprojekt.

Låt oss titta på en översikt av de olika loggningsstilarna som finns tillgängliga.

Grunderna för loggning i Laravel

Om du lär dig grunderna för loggning kommer du att förstå hur Laravel hanterar loggning och hur du kan förbättra dina metoder för strukturerad loggning.

Låt oss undersöka två viktiga begrepp inom loggning för att bättre förstå hur vi ska implementera våra loggningsprocedurer.

Strukturerad loggning i Laravel

Inom mjukvaruutveckling innebär strukturerad loggning att man implementerar ett förutbestämt och konsekvent meddelandeformat för applikationsloggar. Detta format gör att meddelandena kan behandlas som data som kan övervakas, manipuleras och visualiseras mycket bättre än i det vanliga textformatet.

Du måste implementera en strukturerad loggningsmetod i din moderna applikationsutveckling eftersom loggfiler är viktiga tillgångar för utvecklare när det uppstår något fel med din applikation i produktion.

Eftersom Laravel använder Monolog kan utvecklare snabbt implementera strukturerad loggning genom att konfigurera loggaren så att den tar emot specifika typer av information, lagrar loggfilerna i olika format och skickar loggarna till olika logghanteringstjänster från tredje part för visualisering.

Laravel centraliserad loggning

Ett centraliserat loggningssystem är ett system där loggar skickas till lösningar för centraliserad logghantering (CLM) från flera källor för enkel konsolidering och visualisering. CLM är dock en specialiserad loggningslösning som samlar in loggmeddelanden från olika källor och konsoliderar data för enkel bearbetning och visualisering.

Förutom datainsamling förväntas CLM även stödja analysen av loggdata och ge en tydlig presentation av data efter analysen.

Strukturerad loggning kontra grundläggande loggning

Låt oss undersöka skillnaden mellan strukturerad loggning och grundläggande (ostrukturerad) loggning och anledningen till att du bör använda strukturerad loggning i ditt Laravel-projekt.

Grundläggande loggning

Vid grundläggande loggning lagras loggfilerna i ett rått format med begränsade data för att söka och identifiera enskilda loggar.

När Grundläggande loggning används kommer utvecklare inte att kunna använda tredjepartsanalysverktyg för att läsa, visa och analysera loggar om de inte utvecklar ett anpassat verktyg eller håller sig till ett begränsat verktyg som stöder deras loggformat.

Det finns tre viktiga anledningar till att undvika att använda grundläggande loggning:

  1. Centraliserade logghanteringssystem kan inte arbeta med data utan ytterligare stöd.
  2. Det krävs en anpassad lösning för att läsa och analysera data från en grundläggande loggningslösning.
  3. Det kan vara en utmaning för administratörer att läsa grundläggande loggningsdata eftersom de är råa och ostrukturerade.

Strukturerad loggning

Med strukturerad loggning sparar utvecklare tid genom att använda logganalysverktyg från tredje part med öppen källkod som stöder standardloggstruktur för att läsa, visa och analysera loggar.

Loggar är användbara om de innehåller de korrekta data som anges nedan, vilket är vad strukturerad loggning syftar till att uppnå. Vi kan använda de data som ingår i strukturerad loggning för att skapa instrumentpaneler, grafer, diagram och andra användbara visualiseringar för att fastställa applikationens hälsa.

Detta är grundläggande exempel på information som vi kan inkludera i strukturerade loggmeddelanden. Du kan dessutom helt och hållet anpassa uppgifterna till dina behov.

Här är några exempel på data som du kan samla in med strukturerad loggning:

  1. Den port som används för att utföra funktionen
  2. Datum och tid då händelsen inträffade
  3. Kundens användarnamn eller ID
  4. En beskrivning av händelsen (loggmeddelande)
  5. Det protokoll som användes för att utföra funktionen
  6. Platsen för den utlösta händelsen (ange API eller app som körs)
  7. Unikt ID för händelsen
  8. Typ av utlöst åtgärd (loggnivå)

Loggar bör innehålla tillräckligt med data för att enkelt visualisera lösningen eller orsaken till logghändelsen. Observera även att du inte bör lagra alla typer av information, t.ex. lösenord eller känsliga uppgifter i loggar.

Nu när vi har fått en glimt av vad Laravel-loggning handlar om, låt oss gå vidare till att implementera Laravel-loggning genom att bygga en applikation med en förstklassig loggning.

Hur man implementerar Laravel-loggning med Todo App

Nu ska vi tillämpa det som vi har lärt oss hittills genom att skapa ett nytt Laravel-projekt och implementera Laravel-loggning.

Om du inte har använt Laravel tidigare kan du läsa igenom vad Laravel är eller kika på vår lista över utmärkta Laravel-tutorials för att komma igång.

Konfigurera Laravel

Vi ska först skapa en ny Laravel-instans med hjälp av kommandot nedan. Du kan titta på den officiella dokumentationen för mer information.

Öppna din konsol och navigera till den plats där du lagrar dina PHP-projekt innan du kör kommandona nedan. Se till att Composer är installerad och konfigurerad på rätt sätt.

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

Konfigurering och utsättning av databasen

Därefter ska vi konfigurera vår databas, skapa en ny Todo -modell och sålla 200 falska data för testning.

Öppna din databasklient och skapa en ny databas. Vi gör samma sak med namnet laravel_logging_app_db och fyller sedan vår .env-fil med databasens autentiseringsuppgifter:

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

Därefter kör vi följande kommando för att skapa migreringen och Todo -modellen samtidigt:

php artisan make:model Todo -mc

Öppna den nyligen skapade migreringen som finns i database/migrations/xxx-create-todos-xxx.php och klistra in följande koder:

<?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');
  }
}

Du kan skapa dina todos med Faker-data genom att lära dig att skapa dina databaser i Laravel med hjälp av Faker.

Översikt över Monolog

Med Laravel Monolog kan du strömma och skicka strukturerade loggar till olika kanaler som e-post, Slack, filer, sockets, inboxar, databaser och olika webbtjänster. I Laravel kan du konfigurera loggning från en enda konfigurationsfil som finns i config/logging.php.

Konfigurationsfilen innehåller fördefinierade loggdrivrutiner att välja mellan, och standarddrivrutinen är en stack som använder kanalen single för att logga till en laravel.log-fil som finns i mappen storage/logs. Vi kommer att demonstrera strukturerad loggning genom att använda ett par av Laravel’s loggdrivrutiner.

Laravel tillhandahåller en handfull metoder för att interagera med loggar, vilket inom kort demonstreras generellt i kontrollantfilen TodosController.php.

Skriva loggmeddelanden i styrenheten

Öppna den nyligen skapade kontrollantfilen TodosController.php som finns i mappen app/Http/Controllers och klistra in följande koder:


<?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
  }
}

I varje metod i TodoController lägger vi till Log -fasaden med en specifik loggnivå för att definiera vilken typ av fel som vi vill skicka. Nedan följer ett exempel på hur man använder

Log-fasaden i metoden 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
}

Formatering av loggmeddelanden

Anta att du inte är bekväm med standardinställningen LineFormatter som används av Laravel, som gör ett bra jobb med att ge läsbara och användbara meddelanden.

I det fallet kan du enkelt skapa ett anpassat formateringsobjekt som passar ditt användningsområde och använda det i hela programmet.

I den officiella Monolog-dokumentationen finns en fullständig lista över tillgängliga formaterare och du kan enkelt skapa en anpassad formaterare.

I Laravel kan du enkelt ställa in någon av drivrutinerna för att använda din anpassade formaterare genom att lägga till den i listan som nedan i konfigurationsfilen som finns på 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',
  ]
],

Exemplet ovan lägger till en anpassad MonologFormatterHtmlFormatter till drivrutinen daily och använder nycklarna formatter och formatter_with i kanalkonfigurationen daily för att ändra datumformatet.

Skicka loggar till olika kanaler

Med hjälp av Monolog kan Laravel skicka loggar till olika kanaler och flera kanaler samtidigt.

Låt oss demonstrera hur vi skickar loggar till vår Slack-kanal genom att följa dessa enkla steg. Ändra standardloggkanalen till Slack och lägg till Slack Webhook-webbadressen i din .env-fil.

LOG_CHANNEL=slack
LOG_SLACK_WEBBHOOK_URL= Slack_webhook_url_here

Testa sedan konfigurationen genom att logga ett meddelande i din applikation med hjälp av Log -fasaden, som den som visas nedan:

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

Du kan öppna din Slack-kanal för att kontrollera om felet skrivs ut i den önskade kanalen som du angav när du genererade Webhook-webbadressen.

Sammanfattning

Loggning är lika viktigt som alla andra faktorer i din applikation, om inte viktigare. Det är därför som detta nämns som en av de mest kritiska frågorna för alla moderna applikationer i manifestet Twelve-Factor App.

Med effektiv loggning kan du enkelt läsa, visa och visualisera fel och defekter som inträffar i din produktionsklara applikation. Det är därför viktigt att du implementerar strukturerad loggning i din applikation redan från början av projektet.

I den här artikeln har vi utforskat Laravel-loggning och anledningen till att du bör använda detta i ditt nästa projekt. Vi diskuterade både strukturerad loggning och centraliserad loggning i detalj. Dessutom lärde vi oss hur man implementerar Laravel-loggning genom att bygga en Todo-applikation.

Hur planerar du att implementera loggning i din nästa app? Låt oss veta i kommentarsfältet.

Solomon Eseme

Jag är en mjukvaruingenjör och innehållsskapare. Min inriktning är att bygga högpresterande och innovativa produkter enligt bästa praxis och branschstandarder. Jag älskar även att skriva om detta på Masteringbackend.com. Följ mig på X, LinkedIn och About Me