Spring Boot: Comment puis-je définir le niveau de journalisation avec application.properties?

C'est une question très simple, mais je ne trouve pas d'informations.
(Peut-être que mes connaissances sur les frameworks Java font gravement défaut)

Comment puis-je définir le niveau de journalisation avec application.properties?
Et l'emplacement du fichier journal, etc.?

Mise à jour: à partir de Spring Boot v1.2.0.RELEASE, les paramètres de application.propertiesou application.ymls'appliquent. Voir la section Niveaux de journalisation du guide de référence.

logging.level.org.springframework.web: DEBUG
logging.level.org.hibernate: ERROR

Pour les versions antérieures de Spring Boot, vous ne pouvez pas. Vous devez simplement utiliser la configuration normale de votre infrastructure de journalisation (log4j, logback) pour cela. Ajoutez le fichier de configuration approprié ( log4j.xmlou logback.xml) dans le src/main/resourcesrépertoire et configurez à votre guise.

Vous pouvez activer la journalisation du débogage en spécifiant --debuglors du démarrage de l'application à partir de la ligne de commande.

Spring Boot fournit également un bon point de départ pour la déconnexion afin de configurer certaines valeurs par défaut, la coloration, etc. du fichier base.xml que vous pouvez simplement inclure dans votre fichier logback.xml. (Ceci est également recommandé à partir du fichier logback.xml par défaut dans Spring Boot.

<include resource="org/springframework/boot/logging/logback/base.xml"/>     

Vous pouvez le faire en utilisant votre application.properties.

logging.level.=ERROR-> Définit le niveau de journalisation racine sur erreur
...
logging.level.=DEBUG-> Définit le niveau de journalisation racine sur DEBUG

logging.file=${java.io.tmpdir}/myapp.log-> Définit le chemin absolu du fichier journal sur TMPDIR / myapp.log

Un ensemble par défaut sain de application.properties concernant la journalisation à l'aide de profils serait: application.properties:

spring.application.name=<your app name here>
logging.level.=ERROR
logging.file=${java.io.tmpdir}/${spring.application.name}.log

application-dev.properties:

logging.level.=DEBUG
logging.file=

Lorsque vous développez à l'intérieur de votre IDE préféré, vous ajoutez simplement un -Dspring.profiles.active=devargument as VM à la configuration d'exécution / débogage de votre application.

Cela vous donnera uniquement une erreur de journalisation dans la production et une journalisation de débogage pendant le développement SANS écrire la sortie dans un fichier journal. Cela améliorera les performances pendant le développement (et permettra aux disques SSD d'économiser quelques heures de fonctionnement;)).

La bonne façon de définir le niveau de journalisation racine utilise la propriété logging.level.root. Voir la documentation qui a été mise à jour depuis que cette question a été posée à l'origine.

Exemple:

logging.level.root=WARN

Supposons que votre application porte le nom du package com.company.myproject. Ensuite, vous pouvez définir le niveau de journalisation pour les classes à l'intérieur de votre projet comme indiqué ci-dessous dans les fichiers application.properties

logging.level.com.company.myproject = DEBUG

logging.level.org.springframework.web = DEBUGet logging.level.org.hibernate = DEBUGdéfinira le niveau de journalisation pour les classes du framework Spring web et Hibernate uniquement.

Pour définir l'emplacement du fichier journal, utilisez

logging.file = /home/ubuntu/myproject.log

Si vous êtes sur Spring Boot, vous pouvez directement ajouter les propriétés suivantes dans application.properties fichier pour définir le niveau de journalisation, personnaliser le modèle de journalisation et stocker les journaux dans le fichier externe.

Ce sont différents niveaux de journalisation et son ordre du minimum << maximum.

OFF << FATAL << ERROR << WARN << INFO << DEBUG << TRACE << ALL

# To set logs level as per your need.
logging.level.org.springframework = debug
logging.level.tech.hardik = trace

# To store logs to external file
# Here use strictly forward "/" slash for both Windows, Linux or any other os, otherwise, its won't work.      
logging.file=D:/spring_app_log_file.log

# To customize logging pattern.
logging.pattern.file= "%d{yyyy-MM-dd HH:mm:ss} - %msg%n"

Veuillez passer par ce lien pour personnaliser plus précisément votre journal.

https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-logging.html

Faire en sorte que le conseil de Dave Syer reçoive de l'amour, car l'ajout debug=trueà application.properties permettra en effet la journalisation du débogage.

Dans le cas où vous souhaitez utiliser un cadre de journalisation différent, log4j par exemple, j'ai trouvé que l'approche la plus simple consiste à désactiver la journalisation de Spring Boots et à implémenter la vôtre. De cette façon, je peux configurer chaque niveau de journal dans un fichier, log4j.xml (dans mon cas).

Pour ce faire, il vous suffit d'ajouter ces lignes à votre pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j</artifactId>
</dependency>

Vous avez probablement déjà la première dépendance et n'avez besoin que des deux autres. Veuillez noter que cet exemple ne couvre que log4j.
C'est tout, maintenant vous êtes prêt à configurer la journalisation pour le démarrage dans votre fichier de configuration log4j!

Vous pouvez essayer de définir le niveau de journalisation sur DEBUG, il affichera tout lors du démarrage de l'application

logging.level.root=DEBUG

Pour les enregistrements: la documentation officielle , comme pour Spring Boot v1.2.0.RELEASE et Spring v4.1.3.RELEASE:

Si la seule modification que vous devez apporter à la journalisation est de définir les niveaux de divers enregistreurs, vous pouvez le faire dans application.properties en utilisant le préfixe "logging.level", par exemple

logging.level.org.springframework.web: DEBUG logging.level.org.hibernate: ERROR

Vous pouvez également définir l'emplacement d'un fichier auquel vous souhaitez vous connecter (en plus de la console) à l'aide de "logging.file".

Pour configurer les paramètres les plus fins d'un système de journalisation, vous devez utiliser le format de configuration natif pris en charge par le LoggingSystem en question. Par défaut, Spring Boot récupère la configuration native à partir de son emplacement par défaut pour le système (par exemple classpath: logback.xml pour Logback), mais vous pouvez définir l'emplacement du fichier de configuration à l'aide de la propriété "logging.config".

Si vous souhaitez définir plus de détails, veuillez ajouter un nom de fichier de configuration de journal "logback.xml" ou "logback-spring.xml".

dans votre fichier application.properties, saisissez comme ceci:

logging.config: classpath:logback-spring.xml

dans le loback-spring.xml, entrez comme ceci:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        <include resource="org/springframework/boot/logging/logback/base.xml"/>

        <appender name="ROOT_APPENDER" class="ch.qos.logback.core.rolling.RollingFileAppender">

            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>INFO</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>

            <file>sys.log</file>

            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">


                <fileNamePattern>${LOG_DIR}/${SYSTEM_NAME}/system.%d{yyyy-MM-dd}.%i.log</fileNamePattern>

                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>500MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
            </rollingPolicy>

            <encoder>
                <pattern>%-20(%d{yyy-MM-dd HH:mm:ss.SSS} [%X{requestId}]) %-5level - %logger{80} - %msg%n
                </pattern>
            </encoder>
        </appender>


        <appender name="BUSINESS_APPENDER" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>TRACE</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>

            <file>business.log</file>

            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

                <fileNamePattern>${LOG_DIR}/${SYSTEM_NAME}/business.%d{yyyy-MM-dd}.%i.log</fileNamePattern>

                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>500MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
            </rollingPolicy>

            <encoder>
                <pattern>%-20(%d{yyy-MM-dd HH:mm:ss.SSS} [%X{requestId}]) %-5level - %logger{80} - %msg%n
                </pattern>
            </encoder>
        </appender>


        <logger name="{project-package-name}" level="TRACE">
            <appender-ref ref="BUSINESS_APPENDER" />
        </logger>

        <root level="INFO">
            <appender-ref ref="ROOT_APPENDER" />
        </root>

    </configuration>

Les réponses existantes sont excellentes. Je veux juste partager avec vous une nouvelle fonctionnalité de démarrage de printemps permettant de regrouper les journaux et de définir le niveau de journalisation sur l'ensemble du groupe.

Exemple tiré de la documentation:

• Créer un groupe de journalisation

logging.group.tomcat=org.apache.catalina, org.apache.coyote, org.apache.tomcat

• Définir le niveau de journalisation pour le groupe

logging.level.tomcat=TRACE

C'est une fonctionnalité intéressante qui apporte plus de flexibilité.

Dans ma configuration actuelle, je l'ai défini dans application.yaml comme ça:

logging:
  level:
    ROOT: TRACE

J'utilise spring-boot: 2.2.0.RELEASE. Vous pouvez définir n'importe quel package qui devrait avoir le niveau TRACE comme ça.

dans le projet de démarrage de printemps, nous pouvons écrire logging.level.root = WARN, mais ici le problème est que nous devons redémarrer à nouveau même si nous avons ajouté la dépendance devtools, dans le fichier de propriétés si nous sommes modifiés, aucune valeur ne sera détectable automatiquement, pour cette limitation, j'ai appris la solution i, e, nous pouvons ajouter un actionneur dans pom.xml et passer le niveau de l'enregistreur comme indiqué ci-dessous dans le client postman dans la barre d'url http: // localhost: 8080 / loggers / ROOT ou http: // localhost: 8080 / loggers / com .mycompany et dans le corps, vous pouvez passer le format json comme ci-dessous

{
  "configuredLevel": "WARN"
}

En cas d'éclipse IDE et que votre projet est maven, n'oubliez pas de nettoyer et de construire le projet pour refléter les changements.

Avec Springboot 2, vous pouvez définir le niveau de journalisation racine avec une variable d'environnement comme celle-ci:

logging.level.root=DEBUG

Ou vous pouvez définir une journalisation spécifique pour des packages comme celui-ci:

logging.level.my.package.name=TRACE