Lors du développement d’une application moderne, la journalisation doit figurer en tête de liste des priorités.

La journalisation fournit un moyen de visualiser votre application tant en développement qu’en production, ce qui permet la transparence et la visibilité. Avec une journalisation correctement structurée, les applications modernes peuvent devenir plus faciles à maintenir, car nous pouvons identifier de manière proactive les points de défaillance et les goulots d’étranglement dans notre application.

Le framework Laravel est livré avec un système de journalisation robuste qui prend en charge tous les problèmes liés à la configuration d’un système de journalisation correctement structuré. Ce nouveau système de journalisation introduit dans Laravel 6.5 est puissant, et nous allons l’explorer dans cet article.

Cet article explorera les bases de la journalisation Laravel et les raisons pour lesquelles vous devriez utiliser la journalisation Laravel dans votre prochain projet. Nous aborderons en détail la journalisation structurée et la journalisation centralisée. En outre, nous apprendrons comment mettre en œuvre la journalisation Laravel en construisant une application Todo.

Vous tirerez davantage profit de cet article si vous avez déjà acquis les connaissances suivantes :

Qu’est-ce que la journalisation Laravel ?

La journalisation Laravel concerne la façon dont Laravel gère la journalisation, ou le signalement automatique des problèmes, en utilisant un système de journalisation PHP viral appelé Monolog. Cependant, en raison de la philosophie de Laravel qui consiste à utiliser des bibliothèques existantes populaires pour implémenter différentes fonctionnalités du framework, Laravel utilise Monolog pour tous ses besoins de journalisation.

Monolog est une bibliothèque de journalisation PHP très flexible et populaire que nous pouvons configurer pour envoyer vos journaux vers des fichiers, des sockets, des bases de données et d’autres services w eb. Monolog fournit une interface familière pour l’écriture de journaux à partir de fichiers texte standard jusqu’à des services tiers avancés de gestion de journaux. Laravel configure généralement Monolog pour utiliser un fichier de configuration de journalisation standard.

Pour plus d’informations sur Monolog et ses fonctionnalités, consultez la documentation officielle, car cela dépasse le cadre de cet article.

Avant de nous plonger dans la configuration et la mise en œuvre de la journalisation Laravel à l’aide de Monolog, explorons d’autres raisons d’utiliser la journalisation Laravel et les différents types.

Pourquoi utiliser la journalisation Laravel ?

Pourquoi la journalisation est-elle nécessaire ?

Le manifeste Twelve-Factor App traite la journalisation comme l’une des préoccupations essentielles d’une application moderne, car la journalisation est une clé de la performance et de la surveillance.

Les journaux aident à comprendre en détail les erreurs qui se produisent en production et leur origine. De plus, avec des structures de journal appropriées, ils peuvent montrer l’utilisateur particulier, l’action qui a causé l’erreur, et la solution possible pour une correction et une maintenance plus rapides.

La journalisation structurée est une bouée de sauvetage dans les applications de production en aidant à dépister les défauts et à résoudre les problèmes en production. En outre, vous pouvez surveiller et collecter tous vos messages de journalisation en temps réel à l’aide d’outils de journalisation spécialisés pour une analyse et des rapports en direct.

Pour ces raisons, vous devez faire de la journalisation structurée une priorité absolue dans votre prochain projet d’application moderne.

Voyons ensemble les différents styles de journalisation disponibles.

Les bases de la journalisation Laravel

Apprendre les bases de la journalisation vous aidera à comprendre comment Laravel gère la journalisation et comment vous pouvez améliorer vos pratiques de journalisation structurée.

Examinons deux concepts essentiels de la journalisation pour mieux comprendre comment mettre en œuvre nos procédures de journalisation.

Journalisation structurée de Laravel

Dans le développement de logiciels, la journalisation structurée consiste à mettre en œuvre un format de message prédéterminé et cohérent pour les journaux d’application. Ce format permet de traiter les messages comme des données qui peuvent être surveillées, manipulées et visualisées bien mieux que le format texte ordinaire.

Vous devez mettre en œuvre une approche de journalisation structurée dans le développement de vos applications modernes car les fichiers journaux sont les atouts essentiels des développeurs lorsque quelque chose d’anormal arrive à votre application en production.

Comme Laravel utilise Monolog, les développeurs peuvent rapidement mettre en œuvre une journalisation structurée en configurant l’outil de journalisation pour qu’il reçoive des types d’informations spécifiques, en stockant les fichiers journaux dans différents formats et en envoyant les journaux à divers services tiers de gestion des journaux pour les visualiser.

Journalisation centralisée de Laravel

Dans un système de journalisation centralisée, les journaux sont envoyés à des solutions de gestion centralisée des journaux (Centralized Log Management ou CLM) à partir de plusieurs sources pour être facilement consolidés et visualisés. Cependant, la CLM est une solution de journalisation spécialisée qui collecte les messages de journalisation de différentes sources et consolide les données pour un traitement et une visualisation faciles.

Outre la collecte de données, la CLM est également censée prendre en charge l’analyse des données de journalisation et la présentation claire des données après analyse.

Journalisation structurée vs journalisation de base

Examinons la différence entre la journalisation structurée et la journalisation de base (non structurée) et pourquoi vous devriez utiliser la journalisation structurée dans votre projet Laravel.

Journalisation de base

Dans la journalisation de base, les fichiers journaux sont stockés dans un format brut avec des données limitées pour interroger et identifier les journaux individuels.

Lorsqu’ils utilisent la journalisation de base, les développeurs ne pourront pas utiliser d’outils d’analyse tiers pour lire, visualiser et analyser les journaux, à moins qu’ils ne développent un outil personnalisé ou qu’ils s’en tiennent à un outil limité qui prend en charge leur format de journal.

Il y a trois grandes raisons d’éviter d’utiliser la journalisation de base :

  1. Les systèmes centralisés de gestion des journaux ne peuvent pas travailler avec les données sans support supplémentaire.
  2. Une solution personnalisée est nécessaire pour lire et analyser les données d’une solution de journalisation de base.
  3. Il peut être difficile pour les administrateurs de lire les données de journalisation de base car elles sont brutes et non structurées.

La journalisation structurée

La journalisation structurée permet aux développeurs de gagner du temps en utilisant des outils d’analyse de journaux tiers à code open source qui prennent en charge la structure standard des journaux pour lire, visualiser et analyser les journaux.

Les journaux sont utiles s’ils contiennent les données correctes énumérées ci-dessous, ce qui est l’objectif de la journalisation structurée. Nous pouvons utiliser les données incluses dans la journalisation structurée pour créer des tableaux de bord, des graphiques, des diagrammes et toute autre visualisation utile pour déterminer la santé de l’application.

Ce sont des exemples de base des informations que nous pouvons inclure dans les messages de journalisation structurée. En outre, vous pouvez entièrement personnaliser les données en fonction de vos besoins.

Voici quelques exemples de données que vous pouvez collecter avec la journalisation structurée :

  1. Le port utilisé pour exécuter la fonction
  2. La date et l’heure auxquelles l’événement s’est produit
  3. Le nom d’utilisateur ou l’ID du client
  4. Une description de l’événement (message du journal)
  5. Le protocole utilisé pour exécuter la fonction
  6. L’emplacement de l’événement déclenché (indiquer l’API ou l’application en cours d’exécution)
  7. L’ID unique de l’événement
  8. Le type d’action déclenchée (niveau du journal)

Les journaux doivent contenir suffisamment de données pour permettre de visualiser facilement la solution ou la raison de l’événement de journal. Notez également que vous ne devez pas stocker tous les types d’informations, comme les mots de passe ou les données sensibles dans les journaux.

Maintenant que nous avons eu un aperçu de ce qu’est la journalisation Laravel, passons à la mise en œuvre de la journalisation Laravel en construisant une application avec la journalisation comme citoyen de première classe.

Comment mettre en œuvre la journalisation Laravel avec Todo App

Nous allons maintenant appliquer ce que nous avons appris jusqu’à présent en créant un nouveau projet Laravel et en implémentant la journalisation Laravel.

Si vous n’avez jamais utilisé Laravel auparavant, vous pouvez lire ce qu’est Laravel ou jeter un coup d’œil à notre liste d’excellents tutoriels Laravel pour commencer.

Configuration de Laravel

Tout d’abord, nous allons créer une nouvelle instance de Laravel à l’aide de la commande ci-dessous. Vous pouvez consulter la documentation officielle pour en savoir plus.

Ouvrez votre console et allez jusqu’à l’endroit où vous stockez vos projets PHP avant d’exécuter les commandes ci-dessous. Assurez-vous que Composer est installé et configuré correctement.

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

Configuration et ensemencement de la base de données

Ensuite, nous allons configurer notre base de données, créer un nouveau modèle Todo, et ensemencer 200 données factices pour les tests.

Ouvrez votre client de base de données et créez une nouvelle base de données. Nous ferons de même avec le nom laravel_logging_app_db, puis nous remplirons notre fichier .env avec les informations d’identification de la base de données :

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

Ensuite, nous allons exécuter la commande suivante pour créer simultanément la migration et le modèle Todo:

php artisan make:model Todo -mc

Ouvrez la migration nouvellement créée trouvée database/migrations/xxx-create-todos-xxx.php et collez les codes suivants :

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

Vous pouvez ensemencer vos todos avec des données Faker en apprenant à ensemencer vos bases de données dans Laravel à l’aide de Faker.

Aperçu de Monolog

Avec Laravel Monolog, vous pouvez diffuser et envoyer des journaux structurés vers différents canaux tels que des e-mails, Slack, des fichiers, des sockets, des boîtes de réception, des bases de données et divers services web. Dans Laravel, vous pouvez configurer la journalisation à partir d’un seul fichier de configuration situé dans config/logging.php.

Le fichier de configuration contient des pilotes de journalisation prédéfinis parmi lesquels vous pouvez choisir, et le pilote par défaut est un stack qui utilise le canal single pour journaliser vers un fichier laravel.log situé dans le dossier storage/logs. Nous allons faire la démonstration de la journalisation structurée en utilisant quelques-uns des pilotes de journalisation de Laravel.

Laravel fournit quelques méthodes pour interagir avec les journaux, comme nous allons le démontrer de manière générale dans le fichier contrôleur TodosController.php sous peu.

Écriture de messages de journal dans le contrôleur

Ouvrez le fichier contrôleur TodosController.php nouvellement créé qui se trouve dans le dossier app/Http/Controllers et collez les codes suivants :


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

Dans chacune des méthodes du site TodoController, nous avons ajouté la façade Log avec un niveau de journal spécifique pour définir le type d’erreur que nous voulons envoyer. Vous trouverez ci-dessous un exemple d’utilisation de la

facade Log dans la méthode 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
}

Formatage des messages du journal

Supposons que vous ne soyez pas à l’aise avec le site LineFormatter utilisé par défaut par Laravel, qui fait un excellent travail en fournissant des messages lisibles et utiles.

Dans ce cas, vous pouvez facilement créer un objet formateur personnalisé pour répondre à votre cas d’utilisation et l’utiliser dans toute l’application.

La documentation officielle de Monolog donne une liste complète des formateurs disponibles et permet de créer facilement un formateur personnalisé.

Dans Laravel, vous pouvez facilement configurer n’importe quel pilote pour utiliser votre formateur personnalisé en l’ajoutant à la liste comme ci-dessous dans le fichier de configuration situé à 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',
  ]
],

L’exemple ci-dessus ajoute un MonologFormatterHtmlFormatter personnalisé au pilote daily en utilisant les clés formatter et formatter_with dans la configuration du canal daily pour changer le format des dates.

Envoi de journaux à différents canaux

Avec l’aide de Monolog, Laravel peut envoyer des journaux à différents canaux et à plusieurs canaux simultanément.

Montrons comment envoyer des journaux à notre canal Slack en suivant ces étapes simples. Changez le canal de log par défaut en Slack et ajoutez l’URL du Webhook Slack dans votre fichier .env.

LOG_CHANNEL=slack
LOG_SLACK_WEBBHOOK_URL= Slack_webhook_url_here

Ensuite, testez votre configuration en enregistrant un message dans votre application à l’aide de la façade Log comme celle présentée ci-dessous :

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

Vous pouvez ouvrir votre canal Slack pour vérifier l’erreur imprimée dans le canal souhaité que vous avez spécifié lors de la génération de l’URL du Webhook.

Résumé

La journalisation est aussi importante que tout autre facteur de votre application, si ce n’est plus. C’est pourquoi elle est suggérée par le manifeste Twelve-Factor App comme l’une des préoccupations les plus critiques de toute application moderne.

Avec une journalisation efficace, vous pouvez facilement lire, voir et visualiser les erreurs et les défauts qui se produisent dans votre application prête pour la production. À cette fin, il est important que vous implémentiez une journalisation structurée dans votre application dès le début du projet.

Dans cet article, nous avons exploré la journalisation de Laravel et pourquoi vous devriez l’utiliser dans votre prochain projet. Nous avons abordé en détail la journalisation structurée et la journalisation centralisée. En outre, nous avons appris à mettre en œuvre la journalisation Laravel en construisant une application Todo.

Comment comptez-vous mettre en œuvre la journalisation dans votre prochaine application ? Faites-le nous savoir dans la section des commentaires.

Solomon Eseme

Je suis un ingénieur logiciel et un créateur de contenu orienté vers la construction de produits performants et innovants en suivant les meilleures pratiques et les normes de l'industrie. J'aime aussi écrire à ce sujet sur Masteringbackend.com. Suivez-moi sur X, LinkedIn et About Me.