Spring Boot: Jak ustawić poziom rejestrowania za pomocą application.properties?

To bardzo proste pytanie, ale nie mogę znaleźć informacji.
(Być może brakuje mi mojej wiedzy na temat środowisk Java)

Jak ustawić poziom rejestrowania za pomocą application.properties?
Lokalizacja logowania pliku itp.?

Aktualizacja: Począwszy od wersji Spring Boot 1.2.0. ZWOLNIJ, ustawienia w application.propertieslub application.ymlobowiązują. Zobacz sekcję Poziomy dziennika w podręczniku.

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

W przypadku wcześniejszych wersji Spring Boot nie możesz. W tym celu wystarczy użyć normalnej konfiguracji środowiska rejestrowania (log4j, logback). Dodaj odpowiedni plik konfiguracyjny ( log4j.xmllub logback.xml) do src/main/resourceskatalogu i skonfiguruj według własnych upodobań.

Można włączyć rejestrowanie debugowania, określając --debugpodczas uruchamiania aplikacji z wiersza polecenia.

Spring Boot stanowi również dobry punkt wyjścia dla logback do skonfigurowania niektórych ustawień domyślnych, kolorowania itp. Pliku base.xml , który można po prostu dołączyć do pliku logback.xml. (Jest to również zalecane z domyślnego pliku logback.xml w Spring Boot.

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

Możesz to zrobić za pomocą pliku application.properties.

logging.level.=ERROR-> Ustawia poziom rejestrowania root na błąd
...
logging.level.=DEBUG-> Ustawia poziom rejestrowania root na DEBUG

logging.file=${java.io.tmpdir}/myapp.log-> Ustawia bezwzględną ścieżkę pliku dziennika na TMPDIR / myapp.log

Domyślny rozsądny zestaw application.properties dotyczący rejestrowania przy użyciu profili to: 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=

Kiedy tworzysz w swoim ulubionym IDE, po prostu dodajesz -Dspring.profiles.active=devargument jako VM do konfiguracji uruchamiania / debugowania twojej aplikacji.

To da ci tylko błąd przy logowaniu produkcyjnym i debugowaniu podczas programowania BEZ zapisywania danych wyjściowych do pliku dziennika. Poprawi to wydajność podczas programowania (i zaoszczędzi dyski SSD kilka godzin pracy;)).

Właściwym sposobem ustawienia głównego poziomu rejestrowania jest użycie właściwości logging.level.root. Zobacz dokumentację , która została zaktualizowana od momentu pierwotnego pytania.

Przykład:

logging.level.root=WARN

Załóżmy, że aplikacja ma nazwę pakietu jako com.company.myproject. Następnie możesz ustawić poziom rejestrowania klas w projekcie, jak podano poniżej w plikach application.properties

logowanie.level.com.company.myproject = DEBUG

logging.level.org.springframework.web = DEBUGi logging.level.org.hibernate = DEBUGustawi poziom rejestrowania tylko dla klas Spring Framework Web i Hibernacji.

Aby ustawić lokalizację pliku dziennika, użyj

logowanie.plik = /home/ubuntu/myproject.log

Jeśli korzystasz z Spring Boot, możesz bezpośrednio dodać następujące właściwości do pliku application.properties , aby ustawić poziom rejestrowania, dostosować wzorzec rejestrowania i przechowywać dzienniki w pliku zewnętrznym.

Są to różne poziomy rejestrowania i ich kolejność od minimum << maksimum.

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"

Przekaż ten link, aby bardziej dynamicznie dostosować swój dziennik.

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

Upewnienie się, że wskazówka Dave Syer zyska trochę miłości, ponieważ dodanie debug=truedo application.properties rzeczywiście umożliwi rejestrowanie debugowania.

Na przykład, jeśli chcesz użyć innej struktury rejestrowania, na przykład log4j, najłatwiejszym sposobem jest wyłączenie rejestrowania własnego rozruchu i wdrożenie własnego. W ten sposób mogę skonfigurować każdy loglevel w jednym pliku, to znaczy log4j.xml (w moim przypadku).

Aby to osiągnąć, wystarczy dodać te linie do pliku 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>

Prawdopodobnie masz już pierwszą zależność i potrzebujesz tylko dwóch pozostałych. Pamiętaj, że ten przykład dotyczy tylko log4j.
To wszystko, teraz możesz już skonfigurować rejestrowanie rozruchu w pliku konfiguracyjnym log4j!

Możesz spróbować ustawić poziom dziennika na DEBUG, że pokaże wszystko podczas uruchamiania aplikacji

logging.level.root=DEBUG

Do dokumentacji: oficjalna dokumentacja , jak w przypadku Spring Boot v1.2.0.RELEASE i Spring v4.1.3.RELEASE:

Jeśli jedyną zmianą, którą musisz wprowadzić w logowaniu, jest ustawienie poziomów różnych programów rejestrujących, możesz to zrobić w application.properties, używając prefiksu „logowanie.poziom”, np.

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

Możesz także ustawić lokalizację pliku, w którym chcesz się zalogować (oprócz konsoli) za pomocą „logowania.plik”.

Aby skonfigurować bardziej szczegółowe ustawienia systemu rejestrowania, należy użyć rodzimego formatu konfiguracji obsługiwanego przez dany system rejestrowania. Domyślnie Spring Boot pobiera konfigurację natywną z domyślnej lokalizacji systemu (np. Ścieżka klasy: logback.xml dla Logback), ale można ustawić lokalizację pliku konfiguracyjnego za pomocą właściwości „logging.config”.

Jeśli chcesz ustawić więcej szczegółów, dodaj nazwę pliku konfiguracji dziennika „logback.xml” lub „logback-spring.xml”.

w pliku application.properties wprowadź następujące dane:

logging.config: classpath:logback-spring.xml

w pliku loback-spring.xml wprowadź następujące dane:

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

Istniejące odpowiedzi są świetne. Chcę tylko udostępnić Ci nową funkcję wiosennego rozruchu, która pozwala grupować dzienniki i ustawiać poziom rejestrowania dla całej grupy.

Przykład z dokumentów:

• Utwórz grupę rejestrowania

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

• Ustaw poziom rejestrowania dla grupy

logging.level.tomcat=TRACE

To miła funkcja, która zapewnia większą elastyczność.

W mojej obecnej konfiguracji mam to zdefiniowane w application.yaml w następujący sposób :

logging:
  level:
    ROOT: TRACE

Używam Spring-boot: 2.2.0. RELEASE. Możesz zdefiniować dowolny pakiet, który powinien mieć taki poziom TRACE.

w projekcie rozruchu wiosennego możemy napisać logowanie.level.root = OSTRZEŻENIE, ale tutaj jest problem, musimy ponownie uruchomić ponownie, nawet dodaliśmy zależność devtools, w pliku właściwości, jeśli zostanie zmodyfikowana, żadna wartość nie będzie automatycznie wykrywalna, dla tego ograniczenia poznałem rozwiązanie tj. możemy dodać siłownik w pom.xml i przekazać poziom rejestratora, jak pokazano poniżej w kliencie listonosza w pasku adresu URL http: // localhost: 8080 / loggers / ROOT lub http: // localhost: 8080 / loggers / com .mojafirma iw ciele możesz przekazać format json jak poniżej

{
  "configuredLevel": "WARN"
}

W przypadku zaćmienia IDE, a Twój projekt jest cudowny, pamiętaj o wyczyszczeniu i zbudowaniu projektu, aby odzwierciedlić zmiany.

Za pomocą Springboot 2 możesz ustawić Poziom rejestrowania katalogu głównego za pomocą Zmiennej Środowiska w następujący sposób:

logging.level.root=DEBUG

Lub możesz ustawić określone rejestrowanie dla pakietów takich jak ten:

logging.level.my.package.name=TRACE