Maîtriser le logging Java : fondamentaux et bonnes pratiques

Fondamentaux du logging Java

Dans ce tutoriel, nous apprendrons le logging Java et ses divers composants avec l'aide d'exemples.

Java nous permet de créer et capturer des messages et fichiers de log à travers le processus de logging.

En Java, le logging nécessite des frameworks et APIs. Java a un framework de logging intégré dans le package java.util.logging.

Nous pouvons aussi utiliser des frameworks tiers comme Log4j, Logback, et bien d'autres pour le logging.

---

Composants du logging Java

La figure ci-dessous représente les composants principaux et le flux de contrôle de l'API Java Logging (java.util.logging).

1. Logger

La classe Logger fournit des méthodes pour le logging. Nous pouvons instancier des objets depuis la classe Logger et appeler ses méthodes pour le logging.

Prenons un exemple.

Logger logger = Logger.getLogger("newLoggerName"); 

La méthode getLogger() de la classe Logger est utilisée pour trouver ou créer un nouveau Logger. L'argument string définit le nom du logger.

Ici, cela crée un nouvel objet Logger ou retourne un Logger existant avec le même nom.

C'est une convention de définir un Logger après la classe courante en utilisant class.getName().

Logger logger = Logger.getLogger(MyClass.class.getName()); 

Note : Cette méthode lancera NullPointerException si le nom passé est null.

Chaque Logger a un niveau qui détermine l'importance du message de log. Il y a 7 niveaux de log de base :

Niveau de log (ordre décroissant)	Usage
SEVERE	échec grave
WARNING	message d'avertissement, problème potentiel
INFO	information générale d'exécution
CONFIG	information de configuration
FINE	information développeur générale (messages de traçage)
FINER	information développeur détaillée (messages de traçage)
FINEST	information développeur très détaillée (messages de traçage)
OFF	désactiver le logging pour tous les niveaux (ne rien capturer)
ALL	activer le logging pour tous les niveaux (tout capturer)

Chaque niveau de log a une valeur entière qui détermine leur sévérité sauf pour deux niveaux spéciaux OFF et ALL.

---

Journalisation du message

Par défaut, les trois premiers niveaux de log sont toujours journalisés. Pour définir un niveau différent, nous pouvons utiliser le code suivant :

logger.setLevel(Level.LogLevel); // exemple logger.setLevel(Level.FINE); 

Dans cet exemple, seul le niveau FINE et les niveaux au-dessus sont définis pour être journalisés. Tous les autres messages de log sont ignorés.

Maintenant, pour journaliser un message, nous utilisons la méthode log().

logger.log(Level.LogLevel, "log message"); // exemple logger.log(Level.INFO, "This is INFO log level message"); 

Il y a des méthodes raccourcies pour journaliser aux niveaux désirés.

logger.info("This is INFO log level message"); logger.warning("This is WARNING log level message"); 

Toutes les requêtes de log qui ont passé le niveau de log défini sont alors transmises au LogRecord.

Note : Si le niveau d'un logger est défini à null, son niveau est hérité de son parent et ainsi de suite dans l'arbre.

---

2. Filtres

Un filtre (s'il est présent) détermine si le LogRecord doit être transmis ou non. Comme son nom l'indique, il filtre les messages de log selon des critères spécifiques.

Un LogRecord n'est passé du logger au gestionnaire de log et du gestionnaire de log aux systèmes externes que s'il passe les critères spécifiés.

// définir un filtre logger.setFilter(filter); // obtenir un filtre Filter filter = logger.getFilter(); 

---

3. Gestionnaires (Appenders)

Le gestionnaire de log ou les appenders reçoivent le LogRecord et l'exportent vers diverses cibles.

Java SE fournit 5 gestionnaires intégrés :

Gestionnaires	Usage
StreamHandler	écrit vers un OutputStream
ConsoleHandler	écrit vers la console
FileHandler	écrit vers un fichier
SocketHandler	écrit vers des ports TCP distants
MemoryHandler	écrit en mémoire

Un gestionnaire peut passer le LogRecord à un filtre pour déterminer à nouveau s'il peut être transmis aux systèmes externes ou non.

Pour ajouter un nouveau gestionnaire, nous utilisons le code suivant :

logger.addHandler(handler); // exemple Handler handler = new ConsoleHandler(); logger.addHandler(handler); 

Pour supprimer un gestionnaire, nous utilisons le code suivant :

logger.removeHandler(handler); // exemple Handler handler = new ConsoleHandler(); logger.addHandler(handler); logger.removeHandler(handler); 

Un logger peut avoir plusieurs gestionnaires. Pour obtenir tous les gestionnaires, nous utilisons le code suivant :

Handler[] handlers = logger.getHandlers(); 

---

4. Formateurs

Un gestionnaire peut aussi utiliser un Formateur pour formater l'objet LogRecord en chaîne avant de l'exporter vers des systèmes externes.

Java SE a deux Formateurs intégrés :

Formateurs	Usage
SimpleFormatter	formate LogRecord en chaîne
XMLFormatter	formate LogRecord en forme XML

Nous pouvons utiliser le code suivant pour formater un gestionnaire :

// formate en forme chaîne handler.setFormatter(new SimpleFormatter()); // formate en forme XML handler.setFormatter(new XMLFormatter()); 

---

LogManager

L'objet LogManager garde trace de l'information de logging globale. Il lit et maintient la configuration de logging et les instances de logger.

Le log manager est un singleton, ce qui signifie qu'une seule instance en est instanciée.

Pour obtenir l'instance du log manager, nous utilisons le code suivant :

LogManager manager = LogManager.getLogManager(); 

---

Avantages du logging

Voici quelques avantages du logging en Java.

• aide à surveiller le flux du programme
• aide à capturer toute erreur qui peut survenir
• fournit un support pour le diagnostic de problèmes et le débogage