Guide de journalisation Java : les bases

Arfan Sharif - 13 février 2023

La journalisation vous aide à comprendre comment une application fonctionne ou ce qui s'est mal passé en cas d'échec. Ces informations peuvent être essentielles à des fins de débogage et d'audit. Les journaux conservent une trace de chaque événement pendant l'exécution d'un programme, rendant ces enregistrements disponibles pour une analyse ultérieure.

Cependant, une journalisation efficace ne se produit pas automatiquement. Les développeurs d'applications doivent s'assurer qu'une application enregistre systématiquement les détails importants dans un format facile à traiter.

L'approche la plus rudimentaire de la journalisation consiste à utiliser simplement des instructions d'impression pour afficher les détails de l'application souhaitée. Bien sûr, ce n'est pas une approche idéale pour les raisons suivantes :

Pour toutes ces raisons, de nombreux langages de programmation, comme Java, incluent des API et des frameworks de journalisation dédiés. Dans cette vue d'ensemble, la première partie de la série, nous présenterons les concepts de journalisation de base pour les applications Java. Nous examinerons les options de journalisation, puis examinerons plusieurs frameworks de journalisation disponibles et leurs configurations prises en charge.

Explorez la série complète de guides de journalisation Java :

Comme tout le reste de son architecture, Java adopte une approche extensible et personnalisable de la journalisation. Le framework java.util.logging est l'option par défaut pour toutes les fonctions liées à la journalisation. Ce framework fournit toutes les fonctionnalités de base nécessaires à la journalisation tout en permettant aux frameworks tiers d'étendre ces fonctionnalités.

Ce framework de journalisation comprend trois modules principaux :

Un autre concept à noter ici est le filtre. Les filtres permettent au développeur d'intercepter un LogRecord et de décider quel gestionnaire doit être utilisé. Bien qu'ils ne soient pas nécessaires pour la journalisation de base, les filtres peuvent aider à répondre aux exigences de journalisation complexes.

Pour la structure de journalisation de Java, l'emplacement de sortie par défaut est le répertoire personnel de l'utilisateur.

Alors que le framework de journalisation de Java fournit toutes les fonctionnalités de base, les frameworks tiers peuvent faire beaucoup en combinant des enregistreurs, des gestionnaires et des formateurs. Log4j 2 et Logback sont deux frameworks de journalisation populaires, chacun avec ses propres forces.

Étant donné que plusieurs frameworks sont disponibles pour Java et que leurs ensembles de fonctionnalités évoluent constamment, les développeurs souhaitent souvent essayer quelque chose de différent. C'est là que les abstracteurs de journalisation entrent en jeu. Les abstracteurs permettent aux développeurs de basculer rapidement entre les frameworks de journalisation en utilisant une spécification de fonction standard. Simple Logging Facade for Java (SLF4J) est un abstracteur de journalisation populaire qui prend en charge le framework par défaut, Log4j 2, et Logback. Apache commons-logging est un autre abstracteur de ce type.

Il est important de noter, cependant, que les versions non corrigées de Log4j 2 présentent un risque de sécurité critique (CVE-2021-44228). Bien que moins graves, des risques de sécurité considérables existent également pour Log4j 1.x (CVE-2021-4104) et Logback (CVE-2021-42550). Étant donné que l'utilisation des abstracteurs dépend toujours de ces frameworks sous-jacents, il est impératif que ces bibliothèques vulnérables soient correctement mises à jour et corrigées pour une utilisation sécurisée.

Le framework par défaut utilise un fichier de configuration pour définir les détails des appenders, des loggers et des mises en page. Par défaut, ce fichier est présent dans le dossier lib du répertoire d'installation de Java, mais il s'agit d'un fichier de configuration global.

Il est recommandé de définir un fichier de configuration spécifique à l'application. Vous pouvez le faire en spécifiant le nom du fichier de propriétés lors du démarrage de l'application, comme indiqué ci-dessous :

Un fichier de configuration simple ressemblera à ceci :

Ici, la configuration enregistrera les événements de l'application dans un fichier qu'elle créera dans le répertoire personnel de l'utilisateur. La valeur %h indique le répertoire personnel et %u indique un nombre unique arbitraire que java définira pour distinguer les fichiers journaux.

Maintenant, pour créer un nouveau fichier journal à partir d'une nouvelle classe, vous pouvez utiliser l'extrait de code ci-dessous :

Quand et quoi enregistrer dépend entièrement du développeur de l'application, et cela dépend de la stratégie de journalisation adoptée par l'équipe d'application. Une fois que le développeur a décidé des événements à consigner, la journalisation nécessite simplement une seule ligne de code. Voici un exemple:

Ici, l'extrait utilise la méthode logger.log pour conserver un événement de journal. La méthode prend deux entrées : la configuration au niveau de l'enregistreur et le texte à enregistrer.

Vous pouvez utiliser deux autres méthodes pour conserver les événements du journal. La méthode logp enregistre le nom de la classe et des fonctions avec le texte. La méthode logrb vous permet de spécifier le groupe de ressources pour la localisation. Ceci est important pour les applications multilingues. Les deux méthodes peuvent être utilisées à la place de la méthode log.

L'infrastructure de journalisation prend en charge cinq types de gestionnaires (et, par conséquent, cinq types de destinations). Ceux-ci peuvent être facilement configurés dans le fichier de propriétés ou le code. Explorons ces cinq gestionnaires et voyons comment ils sont censés être utilisés.

Gestionnaire de console : Comme son nom l'indique, cela affichera les événements du journal sur la console. Il n'y a pas de mécanisme pour conserver la sortie ici. Toutes les entrées du journal seront perdues une fois la console terminée. Vous pouvez spécifier le gestionnaire dans le fichier de propriétés :

FileHandler : ce gestionnaire écrit des journaux dans un fichier. Ce gestionnaire vous permet de faire pivoter les fichiers journaux lorsqu'ils atteignent une taille spécifique. L'extrait ci-dessous montre comment définir ce gestionnaire, ainsi que ses paramètres spécifiques dans le fichier de propriétés :

Le paramètre limit définit la taille maximale du fichier journal en octets, après quoi un nouveau fichier journal sera créé. Le paramètre append stipule si l'ajout doit être autorisé si le nom de fichier existe. Le paramètre pattern définit le nom du fichier journal.

SocketHandler : ce gestionnaire écrit des journaux sur un socket HTTP. Cela peut être utile lorsque vous devez stocker les journaux dans une autre instance ou un autre service que celui qui est déjà en cours d'exécution. Le format par défaut utilisé ici est XMLFormatter.

StreamHandler : ce gestionnaire écrit la sortie dans un OutputStream qui peut ensuite être utilisé pour écrire dans n'importe quelle destination. Ce gestionnaire est une classe de base servant de base au cas où un gestionnaire personnalisé basé sur une destination différente doit être défini. Le définir est aussi simple que de définir le gestionnaire dans le fichier de propriétés.

MemoryHandler : ce gestionnaire écrit toutes les entrées de journal dans un tampon circulaire en mémoire. Il écrit dans la mémoire tampon si un enregistrement entrant a un niveau supérieur à celui prédéfini ou s'il répond à des conditions spécifiques. Ces conditions peuvent être personnalisées en implémentant une classe qui remplace la fonction log. La nouvelle fonction peut analyser tous les enregistrements et décider quand écrire. Ce gestionnaire est souvent utilisé car, en termes de performances, la mise en mémoire tampon est bon marché tandis que le formatage est coûteux. En utilisant ce gestionnaire, les coûts de formatage sont différés jusqu'à ce que l'écriture soit nécessaire.

Les gestionnaires sont un domaine où les frameworks de journalisation tiers font mieux que l'API de journalisation par défaut. Par exemple, Log4j 2 fournit de nombreux gestionnaires couramment utilisés dans une configuration d'entreprise. Par exemple, le SysLogAppender écrit des entrées dans le journal du système d'exploitation (tel que syslog) ou un serveur d'agrégation de journaux.

Les niveaux de journalisation aident les développeurs à classer les journaux en fonction de leur importance. Ceci est très utile lors de la migration de code via différents environnements, tels que le développement, la mise en scène ou la production. Dans l'environnement de développement, les développeurs peuvent souhaiter obtenir toutes les informations possibles pour le débogage ou les tests. Une fois le code déployé en production, l'équipe d'exploitation peut souhaiter être avertie uniquement des événements de journal SEVERE. L'infrastructure de journalisation Java prend en charge sept niveaux de journalisation. Généralement, les applications utilisent les suivantes par ordre croissant de gravité :

La définition d'un niveau de journalisation lorsque la classe Logger est initialisée aide les développeurs à filtrer tous les journaux en dessous de ce niveau. Par exemple, lorsque le niveau de journalisation est défini sur INFO, seuls les événements marqués comme INFO, WARNING ou SEVERE seront générés. Vous pouvez définir le niveau de journalisation avec une simple commande :

La fonction de journal permet de définir le niveau des entrées de journal persistantes.

Dans cette première partie de notre aperçu, nous avons couvert les bases du framework de journalisation par défaut de Java. Alors que le framework fournit toutes les fonctionnalités de base nécessaires à la journalisation au niveau de l'application, les fonctionnalités avancées nécessitent que les développeurs écrivent des gestionnaires personnalisés. Les infrastructures de journalisation tierces telles que Log4j 2 ou Logback étendent l'ensemble des fonctionnalités et suppriment la nécessité pour un développeur de faire un développement personnalisé.

Dans la deuxième partie de cette série, nous découvrirons les concepts avancés de la journalisation Java, notamment la gestion des exceptions, les formateurs et l'agrégation de journaux.

Arfan Sharif est responsable du marketing produit pour le portefeuille d'observabilité chez CrowdStrike. Il a plus de 15 ans d'expérience dans la conduite de solutions de gestion des journaux, d'ITOps, d'observabilité, de sécurité et d'expérience client pour des entreprises telles que Splunk, Genesys et Quest Software. Arfan est diplômé en informatique de l'Université Bucks and Chilterns et a une carrière couvrant le marketing produit et l'ingénierie des ventes.