Spring Boot: Wie kann ich die Protokollierungsstufe mit application.properties festlegen?

Dies ist eine sehr einfache Frage, aber ich kann keine Informationen finden.
(Vielleicht fehlt mein Wissen über Java-Frameworks stark)

Wie kann ich die Protokollierungsstufe mit application.properties festlegen?
Und Speicherort der Protokolldatei usw.?

Update: Ab Spring Boot v1.2.0.RELEASE gelten die Einstellungen in application.propertiesoder application.ymlgelten. Weitere Informationen finden Sie im Abschnitt Protokollebenen des Referenzhandbuchs.

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

Für frühere Versionen von Spring Boot ist dies nicht möglich. Dazu müssen Sie lediglich die normale Konfiguration für Ihr Protokollierungsframework (log4j, logback) verwenden. Fügen Sie die entsprechende Konfigurationsdatei ( log4j.xmloder logback.xml) zum src/main/resourcesVerzeichnis hinzu und konfigurieren Sie sie nach Ihren Wünschen.

Sie können die Debug-Protokollierung aktivieren, indem Sie --debugbeim Starten der Anwendung über die Befehlszeile angeben.

Frühlings - Boot bietet auch einen schönen Ausgangspunkt für logback einige Standardeinstellungen zu konfigurieren, Färben usw. der base.xml - Datei , die Sie einfach in Ihre logback.xml Datei enthalten kann. (Dies wird auch aus der Standarddatei logback.xml in Spring Boot empfohlen .

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

Sie können dies mit Ihren application.properties tun.

logging.level.=ERROR-> Setzt die Root - Protokollebene auf Fehler
...
logging.level.=DEBUG-> Setzt die Root - Protokollebene auf DEBUG

logging.file=${java.io.tmpdir}/myapp.log-> Setzt der absolute Protokolldateipfad zu TMPDIR / myapp.log

Eines vernünftigen Standardsatz von application.properties über Logging - Profile wäre: 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=

Wenn Sie in Ihrer bevorzugten IDE entwickeln, fügen Sie -Dspring.profiles.active=devder Run / Debug-Konfiguration Ihrer App einfach ein Argument als VM hinzu.

Dadurch erhalten Sie nur Fehler beim Anmelden in der Produktion und beim Debuggen der Protokollierung während der Entwicklung, OHNE die Ausgabe in eine Protokolldatei zu schreiben. Dies verbessert die Leistung während der Entwicklung (und spart SSD-Laufwerke einige Betriebsstunden;)).

Die richtige Methode zum Festlegen der Root- Protokollierungsstufe ist die Verwendung der Eigenschaft logging.level.root. Siehe Dokumentation , die aktualisiert wurde, seit diese Frage ursprünglich gestellt wurde.

Beispiel:

logging.level.root=WARN

Angenommen, Ihre Anwendung hat den Paketnamen als com.company.myproject. Anschließend können Sie die Protokollierungsstufe für Klassen in Ihrem Projekt wie unten in den Dateien application.properties angegeben festlegen

logging.level.com.company.myproject = DEBUG

logging.level.org.springframework.web = DEBUGund logging.level.org.hibernate = DEBUGlegt die Protokollierungsstufe nur für Klassen von Spring Framework Web und Hibernate fest.

Verwenden Sie zum Festlegen des Speicherorts der Protokolldatei

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

Wenn Sie Spring Boot verwenden, können Sie die folgenden Eigenschaften direkt in die Datei application.properties einfügen, um die Protokollierungsstufe festzulegen, das Protokollierungsmuster anzupassen und Protokolle in der externen Datei zu speichern.

Dies sind verschiedene Protokollierungsstufen und deren Reihenfolge von 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"

Bitte gehen Sie über diesen Link, um Ihr Protokoll lebendiger anzupassen.

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

Stellen Sie sicher, dass der Tipp von Dave Syer etwas Liebe findet, da das Hinzufügen debug=truezu application.properties tatsächlich die Debug-Protokollierung ermöglicht.

Wenn Sie ein anderes Protokollierungsframework verwenden möchten, z. B. log4j, ist es für mich am einfachsten, die eigene Protokollierung von Spring Boots zu deaktivieren und Ihre eigene zu implementieren. Auf diese Weise kann ich jede Google-Ebene in einer Datei konfigurieren, nämlich log4j.xml (in meinem Fall).

Um dies zu erreichen, müssen Sie einfach diese Zeilen zu Ihrer pom.xml hinzufügen:

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

Sie haben wahrscheinlich bereits die erste Abhängigkeit und benötigen nur die beiden anderen. Bitte beachten Sie, dass dieses Beispiel nur log4j abdeckt.
Das ist alles, jetzt können Sie die Protokollierung für den Start in Ihrer log4j-Konfigurationsdatei konfigurieren!

Sie können versuchen, die Protokollstufe auf DEBUG zu setzen. Beim Starten der Anwendung wird alles angezeigt

logging.level.root=DEBUG

Für die Aufzeichnungen: die offizielle Dokumentation , wie für Spring Boot v1.2.0.RELEASE und Spring v4.1.3.RELEASE:

Wenn die einzige Änderung, die Sie an der Protokollierung vornehmen müssen, darin besteht, die Ebenen verschiedener Protokollierer festzulegen, können Sie dies in application.properties mit dem Präfix "logging.level" tun, z

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

Sie können auch den Speicherort einer Datei festlegen, bei der Sie sich (zusätzlich zur Konsole) anmelden möchten, indem Sie "logging.file" verwenden.

Um die detaillierteren Einstellungen eines Protokollierungssystems zu konfigurieren, müssen Sie das native Konfigurationsformat verwenden, das vom betreffenden Protokollierungssystem unterstützt wird. Standardmäßig übernimmt Spring Boot die native Konfiguration von ihrem Standardspeicherort für das System (z. B. Klassenpfad: logback.xml für Logback). Sie können den Speicherort der Konfigurationsdatei jedoch mithilfe der Eigenschaft "logging.config" festlegen.

Wenn Sie weitere Details festlegen möchten, fügen Sie bitte einen Protokollkonfigurationsdateinamen "logback.xml" oder "logback-spring.xml" hinzu.

Geben Sie in Ihrer Datei application.properties Folgendes ein:

logging.config: classpath:logback-spring.xml

Geben Sie in der Datei loback-spring.xml Folgendes ein:

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

Bestehende Antworten sind großartig. Ich möchte Ihnen nur eine neue Spring-Boot-Funktion vorstellen, mit der Sie Protokolle gruppieren und die Protokollierungsstufe für die gesamte Gruppe festlegen können.

Beispiel aus den Dokumenten:

• Erstellen Sie eine Protokollierungsgruppe

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

• Legen Sie die Protokollierungsstufe für die Gruppe fest

logging.level.tomcat=TRACE

Es ist eine nette Funktion, die mehr Flexibilität bringt.

In meiner aktuellen Konfiguration habe ich es in application.yaml so definiert :

logging:
  level:
    ROOT: TRACE

Ich benutze Spring-Boot: 2.2.0.RELEASE. Sie können jedes Paket definieren, das die TRACE-Ebene so haben soll.

Im Spring Boot-Projekt können wir logging.level.root = WARN schreiben, aber hier ist das Problem, wir müssen neu starten, auch wenn wir die devtools-Abhängigkeit hinzugefügt haben. In der Eigenschaftendatei, wenn wir geändert werden, wird kein Wert automatisch erkannt, für diese Einschränkung habe ich erfahren Als Lösung können wir den Aktor in pom.xml hinzufügen und die Logger-Ebene wie unten im Postman-Client in der URL-Leiste http: // localhost: 8080 / loggers / ROOT oder http: // localhost: 8080 / loggers / com gezeigt übergeben .mycompany und im Körper können Sie das json-Format wie unten übergeben

{
  "configuredLevel": "WARN"
}

Denken Sie im Falle einer Eclipse-IDE und Ihres Projekts daran, das Projekt zu bereinigen und zu erstellen, um die Änderungen widerzuspiegeln.

Mit Springboot 2 können Sie die Root-Protokollierungsstufe mit einer Umgebungsvariablen wie der folgenden festlegen:

logging.level.root=DEBUG

Oder Sie können eine bestimmte Protokollierung für Pakete wie folgt festlegen:

logging.level.my.package.name=TRACE