Configuration du logging via `application.properties`/`yml`

Introduction à la configuration simplifiée du logging

Le logging est un aspect crucial de toute application pour le débogage, la surveillance et l'audit. Spring Boot simplifie grandement sa configuration en offrant une abstraction par-dessus les frameworks de logging Java courants (Logback, Log4j2, Java Util Logging - JUL). Par défaut, Spring Boot utilise Logback, mais il peut s'adapter si d'autres sont présents et configurés.

Une des grandes forces de Spring Boot est de permettre la configuration des aspects les plus courants du logging directement via ses fichiers de propriétés standard : application.properties ou application.yml. Cela évite, dans de nombreux cas, d'avoir à créer des fichiers de configuration XML complexes spécifiques au framework de logging (comme logback.xml).

Grâce à un ensemble de propriétés préfixées par logging, vous pouvez contrôler les niveaux de log, la destination des logs (console, fichier), le format des messages, et même regrouper des loggers pour une gestion simplifiée.

Définir les niveaux de log

Le contrôle du niveau de verbosité des logs est essentiel. Spring Boot vous permet de définir le niveau de log globalement ou pour des packages/classes spécifiques. Les niveaux standards supportés sont (du plus verbeux au moins verbeux) : TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF.

Niveau racine (root logger) : Définit le niveau par défaut pour toute l'application.

# application.properties
logging.level.root=WARN

# application.yml
logging:
  level:
    root: WARN

Niveau spécifique : Définit le niveau pour un package ou une classe particulière. C'est très utile pour augmenter la verbosité de certaines parties de votre code pendant le débogage, sans inonder les logs avec les messages des autres composants.

# application.properties
# Niveau DEBUG pour tout le package 'com.example.service'
logging.level.com.example.service=DEBUG
# Niveau TRACE pour la classe 'com.example.web.MonController'
logging.level.com.example.web.MonController=TRACE
# Niveau WARN pour les logs de Spring Framework en général
logging.level.org.springframework=WARN
# Niveau INFO pour Hibernate (souvent verbeux en DEBUG)
logging.level.org.hibernate=INFO

# application.yml
logging:
  level:
    root: INFO # Exemple: racine à INFO
    com.example.service: DEBUG
    com.example.web.MonController: TRACE
    org.springframework: WARN
    org.hibernate: INFO

Les loggers spécifiques ont priorité sur les loggers plus généraux (com.example.service prime sur com.example, qui prime sur com, qui prime sur root).

Configurer la sortie des logs (console et fichier)

Par défaut, Spring Boot configure le logging pour écrire sur la console avec le niveau INFO. Vous pouvez facilement rediriger les logs vers un fichier.

Logging vers un fichier : Vous pouvez spécifier un nom de fichier ou un chemin.

# application.properties
# Option 1: Spécifier un nom de fichier (sera créé dans le répertoire courant)
# logging.file.name=mon-app.log

# Option 2: Spécifier un chemin (le fichier sera créé dans ce répertoire)
logging.file.path=/var/log/mon-app
# Si path est spécifié, un fichier 'spring.log' sera créé dedans.
# logging.file.name et logging.file.path sont mutuellement exclusifs.

# application.yml
logging:
  file:
    # name: mon-app.log
    path: /var/log/mon-app

Lorsque le logging fichier est activé, Spring Boot configure par défaut une rotation : les fichiers sont archivés lorsqu'ils atteignent 10 Mo, et seuls les logs de la console au niveau ERROR, WARN, et INFO sont écrits dans le fichier (par défaut).

Personnaliser le format (pattern) : Vous pouvez contrôler le format des messages de log pour la console et/ou le fichier.

# application.properties
# Pattern pour la console
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n

# Pattern pour le fichier (peut être différent)
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

# Personnaliser le format de date utilisé dans les patterns (%d)
logging.pattern.dateformat=yyyy-MM-dd HH:mm:ss.SSS

# application.yml
logging:
  pattern:
    console: "'%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n'"
    file: "'%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n'"
    dateformat: yyyy-MM-dd HH:mm:ss.SSS

Les éléments courants du pattern incluent : %d (date/heure), %thread (nom du thread), %level (niveau de log), %logger (nom du logger), %msg ou %message (le message de log), %n (nouvelle ligne).

Utiliser les groupes de loggers

Il est parfois utile de modifier le niveau de log pour plusieurs packages liés en une seule fois (par exemple, tous les composants liés à la couche web ou à la persistance). Spring Boot permet de définir des "groupes de loggers".

Définir un groupe : Associez un nom de groupe à une liste de packages/classes.

# application.properties
logging.group.web=com.example.web, org.springframework.web
logging.group.sql=org.hibernate, com.zaxxer.hikari

# application.yml
logging:
  group:
    web: com.example.web, org.springframework.web
    sql: org.hibernate, com.zaxxer.hikari

Appliquer un niveau au groupe : Utilisez le nom du groupe comme s'il s'agissait d'un logger normal.

# application.properties
# Met tous les loggers du groupe 'web' au niveau DEBUG
logging.level.web=DEBUG
# Met tous les loggers du groupe 'sql' au niveau TRACE (attention, très verbeux !)
logging.level.sql=TRACE

# application.yml
logging:
  level:
    # ... autres niveaux ...
    web: DEBUG
    sql: TRACE

C'est un moyen pratique de gérer la verbosité de sections entières de l'application ou de frameworks spécifiques sans avoir à lister chaque package individuellement dans la section logging.level.

Limitations et configuration avancée

La configuration via application.properties/yml couvre les cas d'utilisation les plus fréquents : définition des niveaux, configuration de la sortie fichier de base et personnalisation du format. C'est idéal pour démarrer rapidement et pour la plupart des besoins courants.

Cependant, pour des scénarios de logging plus avancés, vous devrez probablement recourir aux fichiers de configuration natifs du framework de logging sous-jacent (par exemple, logback-spring.xml ou log4j2-spring.xml). Ces fichiers permettent une configuration beaucoup plus fine :

• Définir plusieurs appenders (par exemple, logger dans un fichier ET envoyer vers un système de logging centralisé comme ELK ou Splunk).
• Configurer des stratégies de rotation de fichiers plus complexes (basées sur la date, la taille combinée, la compression des archives).
• Appliquer des filtres pour inclure/exclure des messages basés sur leur contenu, des marqueurs, etc.
• Configurer des appenders asynchrones pour améliorer les performances.
• Modifier la configuration du logging à chaud sans redémarrer l'application (via JMX ou l'endpoint Actuator /loggers).

Spring Boot détectera automatiquement la présence d'un fichier comme logback-spring.xml dans le classpath et l'utilisera à la place de la configuration de base via les propriétés logging.* (bien que certaines propriétés puissent encore influencer la configuration, comme la définition des profils Spring).

En résumé, commencez par la configuration simple et efficace via application.properties/yml. Si vos besoins dépassent ses capacités, passez alors à un fichier de configuration dédié au framework de logging.