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

301

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.?

Zeodtr
la source
1
Pour mémoire, une autre option consiste à définir le niveau de journalisation comme variable d'environnement, par exemple via le tableau de bord heroku. In Settings-> Config Varsréglé logging.level.com.yourpackageau niveau souhaité (INFO, ERREUR, DEBUG).
LukeSolar

Réponses:

355

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"/>     
M. Deinum
la source
8
Normalement, tout ce que vous pouvez faire sur la ligne de commande fonctionne dans un fichier de configuration externe. Donc, debug = true le ferait, je pense. Ce drapeau est un peu spécial car la journalisation doit être initialisée très tôt, mais je pense que cela fonctionnerait.
Dave Syer
7
BTW le système de journalisation préféré est logback, et c'est ce que vous obtenez par défaut des poms de démarrage. Donc logback.xml est l'outil le plus courant pour configurer la journalisation de manière fine. L'indicateur --debug active simplement certains canaux de journalisation Spring sélectionnés.
Dave Syer
Autre astuce, la botte de printemps comprend un joli base.xml . Ce qui est un bon point de départ. (Voir ma réponse détaillée).
M. Deinum
@ M.Deinum Merci encore pour votre excellent conseil! Maintenant, je peux changer le niveau de journalisation de mon propre code.
2013
2
Il semble que nous pouvons, maintenant. En ce qui concerne Spring v4.1.3.RELEASE (avec Spring Boot v1.2.0.RELEASE), les paramètres de application.propertiesou application.ymls'appliquent, comme l'a répondu Richard (modulo le :ou =problème --- les deux points semblent fonctionner pour moi).
Eric Platon
108

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;)).

Richard
la source
1
Le signe «=» pour l'affectation n'a pas fonctionné. L'affectation a été effectuée avec un «:» comme séparateur. logging.level.:DEBUG
randominstanceOfLivingThing
2
Étrange, cette configuration fonctionne dans un exemple de projet. Les signes '' (espace), '=' et ':' sont traités également comme séparateurs, sauf dans les cas où des séparateurs sont utilisés dans les clés. Êtes-vous sûr que votre clé ne contient aucun espace blanc?
Richard
1
Peut confirmer que ":" fonctionne mais "=" est ignoré, Edit: Spoke à bientôt, il y avait un espace entre "=" et le niveau. tout fonctionne maintenant.
Mike R
1
Cela ne fonctionne pas dans mon test avec spring-boot 1.4.0: logging.level.=DEBUGle démarrage de l'application échouera et une erreur se produira:java.lang.ClassCircularityError: java/util/logging/LogRecord
Eric Wang
2
Il me semble que ce logging.level.n'est qu'un raccourci syntaxique pratique logging.level.root, qui pourrait être préféré (1) moins susceptible d'être confondu avec une faute de frappe, (2) potentiellement plus explicite et (3) de travailler avec le =signe d'affectation, ce qui offre une cohérence plus globale. dans le fichier de configuration.
Alain BECKER
66

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
Le poignard de Gilbert Arenas
la source
15

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

shaunthomas999
la source
14

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

Hardik Patel
la source
Je ne sais pas pourquoi mais logging.level.tech.hardik = trace cela ne fonctionne pas dans mon cas quand je mets logging.level.roo = trace ça fonctionne
Arvind Kumar
10

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.

oravecz
la source
8

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!

atripes
la source
Cette exclusion a fonctionné pour moi. Mon REST Api n'a pas été choisi ma dépendance log4j et log4j.properties.
ankitjaininfo
ils ont aussi maintenant spring-boot-starter-log4j2
Kalpesh Soni
4

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
Ahmed Salem
la source
3

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".

Eric Platon
la source
2

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>
Sheldon Papa
la source
2

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é.

Martin Choraine
la source
2

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.

fascynacja
la source
1
Cela s'installe au niveau de l'application. OP ne souhaite effectuer le suivi que pour les journaux d'hibernation pour lesquels vous auriez besoin d'un filtre de niveau de package dans les paramètres de journal
Sudip Bhandari
2

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"
}
siddartha kamble
la source
1

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.

Sabarish Kumaran.V
la source
1

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
Jakudaba
la source
pour la configuration des variables d'environnement, vous préférez utiliser LOGGING_LEVEL_ROOT=DEBUG
:, en