Trouvez-vous java.util.logging suffisant?

Selon le titre, trouvez-vous que l’infrastructure de journalisation Java par défaut est suffisante pour vos besoins?

Utilisez-vous d’autres services de journalisation tels que log4j ou autres? Si oui, pourquoi? J’aimerais entendre vos conseils concernant les exigences de journalisation dans différents types de projets, et lorsque l’intégration de frameworks est réellement nécessaire et / ou utile.

Enregistrement des dépendances avec des bibliothèques tierces

La journalisation Java JDK dans la plupart des cas ne suffit pas à elle seule. Toutefois, si vous avez un projet volumineux utilisant plusieurs bibliothèques tierces, vous découvrirez rapidement que plusieurs d’entre elles ont des dépendances de journalisation disparates.

C’est dans ces cas que le besoin d’abstraire votre API de journalisation de votre implémentation de journalisation devient important. Je recommande d’utiliser slf4j ou logback (utilise l’API slf4j) comme API et si vous voulez restr avec la journalisation Java JDK, vous le pouvez toujours! Slf4j peut sortir vers de nombreuses implémentations de logger sans aucun problème.

Un exemple concret de son utilité s’est produit lors d’un projet récent: nous devions utiliser des librairies tierces nécessitant log4j, mais nous ne voulions pas exécuter deux frameworks de journalisation côte à côte. Nous avons donc utilisé les librairies api slf4j log4j et le problème a été résolu.

En résumé, la journalisation Java JDK est correcte, mais une API standardisée utilisée dans mes bibliothèques tierces vous fera gagner du temps à long terme. Essayez simplement d’imaginer le remaniement de chaque déclaration de journalisation!

java.util.logging (jul) était inutile depuis le début. N’y faites pas attention.

jul a en lui-même les inconvénients suivants:

  • Au moment où jul a été introduit dans Java 1.4, il existait déjà une structure de journalisation bien établie: LOG4J
  • les niveaux de consignation prédéfinis sont les suivants: SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST. Je ne vous dirai pas ce que je pense personnellement de ces niveaux prédéfinis pour garder cette réponse à moitié objective.
  • Des niveaux supplémentaires peuvent être définis. jul supporte jusqu’à 4G différents niveaux de log, ce qui est légèrement excessif, à mon humble avis. Moins c’est parfois plus.
  • Le point le plus important: si vous osez définir votre propre niveau de journalisation, vous risquez de rencontrer un problème de fuite de mémoire!
    N’hésitez pas à lire à propos de cet effet ici:

    • Le chargeur de classe fuit: l’exception redoutée “java.lang.OutOfMemoryError: PermGen space”
    • Comment réparer l’exception redoutée “java.lang.OutOfMemoryError: PermGen space” (fuite de classloader)

    C’est une lecture très intéressante, même si vous ne prévoyez pas d’utiliser des niveaux personnalisés, du fait que le problème est très répandu et ne concerne pas que jul.

  • il réside dans l’espace de noms java. *, de sorte que l’implémentation ne peut pas être échangée à l’exécution. Cela empêche effectivement de le relier à SLF4J de la même manière que possible en cas de commons.logging et de LOG4J. La façon dont le pont est effectué pour jul a un impact sur la performance. Cela fait de jul le cadre de journalisation le plus rigide.
  • En introduisant jul, Sun l’a implicitement défini comme étant la “structure de journalisation Java standard”. Cela a conduit à une idée fausse commune selon laquelle un “bon citoyen Java” devrait utiliser jul dans ses bibliothèques ou applications.
    Le contraire est le cas.
    Si vous utilisez commons.logging ou LOG4j, vous pourrez échanger la structure de journalisation réellement utilisée, si vous en avez besoin, en passant par SLF4J. Cela signifie que les bibliothèques utilisant commons.logging, LOG4J ou SLF4J peuvent toutes se connecter à la même cible de journalisation, par exemple un fichier.

Personnellement, je suggère d’utiliser le combo SLF4J + Logback à toutes les fins de journalisation. Les deux projets sont coordonnés par Ceki Gülcü, le responsable de LOG4J.
SLF4J est un successeur digne (mais non officiel puisqu’il ne fait pas partie du même groupe) de commons.logging. C’est moins problématique que CL car il résout statiquement le backend de journalisation utilisé. De plus, il possède une API plus riche que CL.
Logback, en revanche, est le (un) successeur officiel de LOG4J. Il implémente nativement SLF4J, ce qui évite toute surcharge due à un wrapper.

Maintenant, vous pouvez me retirer si vous pensez toujours que je le mérite. 😉

Nous utilisons java.util.logging partout. Aussi pour les grands projets. Il y a quelques petites choses à modifier (par exemple, le formatage par défaut), mais ce n’est pas le cas. Je trouve que le nombre de frameworks de journalisation en Java et les fonctionnalités qu’ils ont implémentées ont été plutôt gênants et quelque peu gênants pour la communauté Java. Le niveau de débat sur la journalisation est un signe certain que quelque chose a vraiment mal tourné.

Ce que JUL vous donne est une API simple mais suffisante et un endroit unique pour configurer la sortie de journal que vous voulez voir (logging.properties ou JMX …). Et c’est toujours là et stable.

Tout le code qui veut se connecter doit respecter les conventions standard (le niveau par défaut est INFO) et ne pas en faire plus, mais utiliser des enregistreurs avec un nom significatif (par exemple, nom du package ou de la classe) et cela vous conviendra.

A moins qu’il y ait une raison impérieuse d’utiliser quelque chose en dehors du JDK, je préfère utiliser ce qui est fourni par Sun.

De nombreux projets utilisant la journalisation Log4J l’utilisaient avant que l’API de journalisation “standard” n’existe.

Les installations de journalisation de JDK ont toujours fait ce dont elles avaient besoin – jamais eu de problème avec elle.

Pour moi, les outils de journalisation tiers ne sont ni nécessaires ni souhaitables.

Je n’ai pas pu déterminer comment contrôler le niveau de journalisation des classes individuelles dans le framework java.util.logging, ce qui est possible dans log4j. Si j’ai du mal à diagnostiquer un bogue ou s’il existe une classe à fort trafic qui enregistre les informations importantes, je peux modifier le niveau d’une seule classe pour pouvoir me connecter et laisser le rest de mes classes relativement silencieux.

NB: Il se peut que je ne comprenne pas comment faire ou java.util.logging aurait pu changer depuis que j’ai essayé.

java.util.logging est sympa mais n’a pas de configuration qui est récupérée par défaut dans le classpath. C’est plutôt un problème pour nous car nous avons de nombreux déploiements qui ne partagent pas les configurations de journalisation et il est plutôt compliqué de le faire en juillet.

Log4j n’est actuellement pas développé beaucoup, donc s’il y a un besoin de développement sur la partie backend, le logback est actuellement l’option la plus dynamic à mon avis.

(avertissement: impliqué dans un développement obscur de slf4j et de logback mais qui est dû et ne provoque pas les instructions que je fais ci-dessus :))

Je pensais utiliser log4j – comme mentionné par @ ScArcher2, simplement parce que tout le monde le fait. Mais après avoir traité les deux options, j’ai découvert que java.util.logging était suffisamment suffisant pour répondre à la plupart de mes besoins – et je parle d’un système énorme avec de nombreux composants de propagation fonctionnant ensemble.

Donc, à mon avis, il n’y a pas besoin d’utiliser des services alternatifs. Java.util.logging est suffisamment puissant pour la plupart des cas.

Nous utilisons log4j avec la journalisation des commons . Je pense que nous les utilisons simplement parce que tout le monde le fait. Cela et nous utilisions log4j avant la journalisation supscope par jdk.

Edit: Le juste parce que tout le monde le fait était une blague, mais probablement pourquoi j’ai commencé avec log4j et commons logging.

Voici quelques raisons d’utiliser la journalisation des commons.

Il est assez facile d’écrire une classe jul LogManager qui reportera toute la journalisation à une implémentation sur mesure qui utilise Log4J. Cela signifie que vous pouvez utiliser log4j mais que les bibliothèques qui se connectent à jul peuvent être contrôlées comme si elles avaient utilisé Log4J.

Ayant utilisé les deux (et les commons-logging), je dois dire que ce qui me gêne vraiment, vraiment , c’est ceci:

 log4j.error("An Exception", e); jul.severe("An Exception", e); // GRRR! no such method jul.log(Level.SEVERE, "An Exception", e); //Must use this method 

Pourquoi ont-ils fait ce choix de conception? Pourquoi? L’autre chose est qu’il n’y a pas de PatternFormatter qui est livré avec jul – vous devez lancer votre propre.

Cela dit, je me trompe en utilisant dorénavant jul car cela réduit les dépendances externes et n’est pas plus compliqué à utiliser.

Dans les projets sur lesquels je travaille, nous avons tendance à utiliser la journalisation commune de Jakarta. Ce n’est pas un système de journalisation lui-même, mais il peut envelopper certains des enregistreurs les plus courants – log4j, java.util.logging ou autres.

Avec cela, il est relativement facile de basculer la journalisation en fonction de l’environnement sur lequel l’application est déployée (un développeur peut vouloir utiliser simplelog ou java.util.logging sur sa machine en raison de la facilité de maintenance, alors que sur un système SIT, log4j avec une configuration commune pour toutes les applications peut être déployé, etc.)

Tout dépend vraiment de vos exigences de journalisation. Les développeurs d’applications n’utilisent pas uniquement l’API, et franchement, c’est le moindre des problèmes, car la plupart des API de journalisation sont faciles à adapter, quel que soit votre choix.

L’important est le type de configuration de journalisation dont vous avez besoin pour les opérations et ils doivent vous dire ce dont ils ont besoin.

  1. Cela peut être aussi simple que des fichiers texte qui retournent.
  2. Cela peut être plus compliqué, comme de se connecter à un JMS ou à une firebase database.
  3. Il peut nécessiter des journaux séparés pour les performances, l’audit, etc.
  4. Il peut être nécessaire d’envoyer des détails par courrier électronique lorsqu’un événement de journal se produit.

Log4J dans leur package varia a eu un support pour ceux-ci et plus et testé avec leurs API. Maintenant, avec java.util.logging, vous devriez pouvoir les télécharger, mais ils ne sont pas aussi connus que Log4J et peuvent être plus difficiles à trouver.

Une autre chose à considérer est l’API du fournisseur que vous utilisez. La plupart des fournisseurs imposent une API de journalisation pour vous. Le spring en est un qui nécessite une consignation des données.

En tant que développeur, j’essaierais d’utiliser java.util.logging si je le pouvais pour mes propres besoins, mais dans des scénarios réels, vous devez ébranler ce dont ils ont besoin dans les opérations et laisser cela conduire votre choix car ce sont eux qui ont utiliser ces journaux lorsque l’application est activée. Ce n’est ni l’architecte de l’application, ni les développeurs qui doivent faire ce choix, même s’ils doivent faire des suggestions.

Une chose que personne n’a mentionnée dans ce sujet – java.util.logging ne supporte pas le syslog hors de la boîte. C’est un casse-tête pour moi (et cela m’a causé un peu de consternation de devoir réorganiser les trucs de java.util.logging à la place de quelque chose avec un peu plus de jus).

Voici ce que j’ai rencontré aujourd’hui:

Un des problèmes que j’ai avec TOUS les frameworks de journalisation est que, à moins que tout le monde ne passe son temps à maîsortingser exactement comment le configurer et le contrôler, vous ne savez jamais si une instruction de débogage donnée sera imprimée ou non.

Vous pouvez avoir un niveau (debug) désactivé, ou vous pouvez avoir un package désactivé.

J’ai perdu trop de temps en supposant qu’une instruction de débogage s’imprimerait et que ce ne serait pas le cas. Maintenant, je me fie principalement à System.out.println () et je passe juste à travers et je les supprime ou les convertis une fois le débogage terminé.

Je sais que cela ne répond pas à votre question – je dis simplement que vous voudrez peut-être examiner combien de justification vous avez avant d’append de la complexité.

La journalisation n’est pas si compliquée et se justifie certainement sur la plupart des grands projets.

Personnellement, j’utilise Simple Logger , mais au travail, j’utilise notre wrapper d’entreprise pour l’enregistreur JDK. J’utilise Simple Logger en raison de la facilité de configuration et de la prise en charge de la journalisation de 7 niveaux entre Fatal et Ludicrous.

Si vous avez besoin de vous connecter à votre application, vous avez probablement fait quelque chose de vraiment faux. Je dirais que signaler le problème occasionnel est correct, mais avoir des instructions debug, info etc dans beaucoup de classes avec de la logique est tout à fait faux. Toute application volumineuse comportant des instructions de journalisation dans la plupart de ses classes remplies de logique va se traduire par une surcharge d’informations, même si l’on ne prend que les bons enregistreurs. La plupart du temps, les informations seront incomplètes, bruyantes ou les informations dont vous avez besoin manquent.

Je dis essentiellement que vous ne devez écrire que des instructions de débogage pour informer l’utilisateur des réactions du programme à des facteurs externes

  • problème de formatage dans un fichier de configuration basé sur du texte.
  • Problèmes d’ouverture ou de localisation d’un fichier requirejs.