web-dev-qa-db-fra.com

Définir le niveau de journalisation lors du démarrage printanier via une variable d'environnement

Devrait-il être possible de définir des niveaux de journalisation à l'aide de variables d'environnement uniquement dans une application Spring Boot?

Je ne veux pas utiliser application.properties alors que je travaille sur Cloud Foundry et que je souhaite prendre en compte les modifications sans déploiement (mais après le redémarrage de l'application ou sa restitution plus précise).

J'ai essayé de régler env vars comme LOGGING_LEVEL_ORG_SPRINGFRAMEWORK=TRACE mais cela n'a aucun effet. En mettant logging.level.org.springframework: TRACE dans application.properties fonctionne bien cependant.

javaspringspring-boot
45
EngineerBetter_DJ

Ceci est juste une idée, mais avez-vous essayé de définir

_Java_OPTIONS=-Dlogging.level.org.springframework=TRACE?

Théoriquement, de cette façon -Dlogging.level.org.springframework=TRACE sera passé en tant qu'argument JVM par défaut et devrait affecter toutes les instances JVM de votre environnement.

57
Timekiller

J'ai également essayé de définir le niveau de journalisation via une variable d'environnement, mais comme déjà mentionné, il n'est pas possible d'utiliser une variable d'environnement avec un nom en majuscule, par exemple. LOGGING_LEVEL_ORG_SPRINGFRAMEWORK=DEBUG. Je ne voulais pas non plus le faire via application.properties ou _Java_OPTIONS.

Après avoir creusé dans la classe org.springframework.boot.logging.LoggingApplicationListener J'ai vérifié que Spring Boot tente de définir le niveau de consignation DEBUG sur ORG_SPRINGFRAMEWORK package qui n'est pas un nom de package réel. La conclusion est donc que vous pouvez utiliser une variable d’environnement pour définir le niveau de journalisation, mais elle doit se présenter sous la forme: LOGGING_LEVEL_org.springframework=DEBUG ou logging.level.org.springframework=DEBUG

Testé sur la botte de printemps 1.5.3

16
pepuch

Oui, vous pouvez contrôler le niveau de journalisation à l'aide d'une variable d'environnement. Voici comment j'ai implémenté mon application Spring Boot, déployée sur la plateforme Cloud Foundry.

Dans votre fichier de configuration de journal, indiquez un espace réservé permettant au niveau de journalisation de lire la valeur de la variable d’environnement. La valeur par défaut est INFO.

    <logger name="com.mycompany.apps.cf" level="${APP_LOGGING_LEVEL:-INFO}">
      <appender-ref ref="CONSOLE"/>
    </logger>

Et puis, dans le fichier de déploiement de déploiement CF, fournissez une variable d’environnement.

 applications: 
 - nom: mon-app-nom 
 mémoire: 2048 
 env: 
 APP_LOGGING_LEVEL: DEBUG

J'espère que cela aidera.

6
Sparkle8

Également en utilisant Spring Boot (v1.2.3) dans Cloud Foundry, j'ai découvert qu'il était possible d'ajuster le niveau de journalisation racine à l'aide d'une variable d'environnement, comme suit:

$ cf set-env <app name> LOGGING_LEVEL_ROOT DEBUG

Malheureusement, il ne semble pas possible d'abaisser le niveau de journalisation de packages spécifiques (du moins avec la version de Java Buildpack et Spring Boot que j'utilise). Par exemple, en plus de ce qui précède ne réduit pas le niveau de log pour la structure Spring:

$ cf set-env <app name> LOGGING_LEVEL_ORG_SPRINGFRAMEWORK INFO

Si vous utilisez quelque chose comme Splunk pour rassembler vos journaux, vous pourrez peut-être filtrer le bruit, cependant.

Une autre alternative qui semble prometteuse pourrait être basée sur la personnalisation de l’option arguments du build pack (voir here ):

$ cf set-env <app name> '{arguments: "-logging.level.root=DEBUG -logging.level.org.springframework=INFO"}'

Malheureusement, je ne pouvais pas obtenir que cela fonctionne réellement. Je conviens certainement que pouvoir reconfigurer les niveaux de journalisation au niveau des packages sans modifier le code de l'application serait pratique.

2
Allan Lang

De toute façon, je vous suggérerais d’utiliser des profils Spring:

  1. Créez 2 fichiers de propriétés:

    application-local.properties et application-remote.properties

    (les noms de profil peuvent être évidemment différents)

  2. Définissez le niveau de consignation dans chaque fichier en conséquence (logging.level.org.springframework)

  3. Exécutez votre application avec -Dspring.profiles.active=local localement et -Dspring.profiles.active=remote pour les FC.

2
Michał Urbaniak

À partir de Spring Boot 2.0.x, cela fonctionne à nouveau. Testé avec Spring Boot v2.0.9.RELEASE. Par exemple. activer le journal de débogage du pool de connexions:

LOGGING_LEVEL_COM_ZAXXER=DEBUG Java -jar myApp.jar

ou journal de débogage de la structure Spring:

LOGGING_LEVEL_ORG_SPRINGFRAMEWORK=DEBUG Java -jar myApp.jar

ou les deux:

LOGGING_LEVEL_ORG_SPRINGFRAMEWORK=DEBUG LOGGING_LEVEL_COM_ZAXXER=DEBUG Java -jar myApp.jar

Voir Documentation Spring Boot "Annexe A. Propriétés communes des applications" pour plus de propriétés.

1
t0r0X

Dans spring-boot 2.0.0, ajouter --trace travaux. Par exemple Java -jar myapp.jar --debug ou Java -jar myapp.jar --trace

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

1
PetroCliff

Voici un exemple d'utilisation de Logback avec Janino pour inclure conditionnellement différentes configurations de journalisation via propriétés ou variables d'environnement ... La configuration de base, logback.xml, est utiliser des conditions pour la journalisation de la console de développement ou la journalisation des fichiers de production ... déposez simplement les fichiers suivants dans /resources/

logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true">
    <if condition='property("spring.profiles.active").contains("dev")'>
        <then>
            <include resource="org/springframework/boot/logging/logback/base.xml"/>
            <include resource="dev.xml" optional="true"/>
        </then>
    </if>
    <if condition='property("spring.profiles.active").contains("pro")'>
        <then>
            <include resource="org/springframework/boot/logging/logback/base.xml"/>
            <include resource="pro.xml" optional="true"/>
        </then>
    </if>
</configuration>

dev.xml

<included>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <charset>utf-8</charset>
            <Pattern>%-30([%p] [%c:%L]) » %m%n%rEx</Pattern>
        </encoder>
    </appender>

    <!-- CHATTY LOGGERS HERE.-->
    <logger name="org.springframework" level="DEBUG"/>

    <contextListener class="ch.qos.logback.classic.jul.LevelChangePropagator">
        <resetJUL>true</resetJUL>
    </contextListener>

    <root level="${logback.loglevel}">
        <appender-ref ref="CONSOLE"/>
    </root>

</included>

pro.xml

<included>
    <conversionRule conversionWord="wex"
                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <property name="FILE_LOG_PATTERN"
              value="%d{yyyy-MM-dd HH:mm:ss.SSS} %5p ${PID:- } --- [%t] %-40.40logger{39} : %m%n%wex"/>
    <property name="FILE_NAME_PATTERN" value="./logs/%d{yyyy-MM-dd}-exec.log"/>

    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>FILE_NAME_PATTERN</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${FILE_LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
        <queueSize>512</queueSize>
        <appender-ref ref="FILE"/>
    </appender>

    <!-- APP SPECIFIC LOGGERS HERE.-->
    <logger name="org.springframework.boot.SpringApplication" level="INFO"/>

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

</included>
0
Eddie B

Les gens peuvent-ils expliquer pourquoi cela ne fonctionne pas?

$ export LOGGING_LEVEL_COM_ACME = ERREUR

Pour toute autre configuration, l'utilisation de variables d'environnement en tant que substitution semble fonctionner sans problème, par exemple:

$ export EUREKA_CLIENT_ENABLED = false

Merci.

0
Damian O' Neill

La définition des niveaux de journal via des variables d'environnement ne peut être effectuée que pour les packages, mais pas pour les classes

J'ai eu le même problème que l'OP. Et je me demandais pourquoi certains des utilisateurs ici ont déclaré que les solutions proposées fonctionnaient bien, alors que d'autres ont répondu que non.
Je suis sur Spring Boot 2.1 et le problème a évidemment changé un peu au cours des dernières années, mais la situation actuelle est la suivante:

TL; DR

La définition du niveau de journalisation d'un package fonctionne :

LOGGING_LEVEL_COM_ACME_PACKAGE=DEBUG

Lors de la définition du niveau de journalisation pour une classe spécifique , aucun effet :

LOGGING_LEVEL_COM_ACME_PACKAGE_CLASS=DEBUG

Comment cela peut-il être?

Jetez un coup d'œil à Spring Boot's LoggingApplicationListener .
Si vous voulez le déboguer et définir un point d'arrêt dans le bloc de code en surbrillance, la définition du niveau de journalisation d'une classe com.acme.mypackage.MyClass devient com.acme.mypackage.myclass.
Ainsi une définition de niveau de journalisation pour une classe ressemble exactement à la définition de journal d'un package.

Ceci est lié à Spring Relaxed Binding , qui propose une notation en majuscule pour les variables d'environnement. Ainsi, la notation de casse-chameau typique d'une classe n'est pas disponible pour LoggingApplicationListener. D'autre part, je pense qu'on ne peut pas vérifier si le chemin pleinement qualifié donné correspond à une classe. Il faudrait générer toutes les notations de casse de chameau possibles pour le nom de la classe et interroger le chargeur de classe pour chacune d'elles. Ce n'est pas faisable. Ainsi, les définitions de journal dans les variables d'environnement ne fonctionnent pas pour les classes mais uniquement pour les packages.

0
Peter Wippermann