springboot logging

逃离我推掉我的手 2022-09-11 07:25 78阅读 0赞

--------------------

## springboot logging ##

**官网：[Spring Boot Features（logging）][Spring Boot Features_logging]**

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**控制台日志彩色输出**

**控制台彩色输出需要终端支持ansi**

# application.yml
    spring.output.ansi.enabled
    
    
    *************
    spring-configuration-metadata.json（配置提示）
    
        {
          "name": "spring.output.ansi.enabled",
          "type": "org.springframework.boot.ansi.AnsiOutput$Enabled",
          "description": "Configures the ANSI output.",
          "defaultValue": "detect"    # 默认值为detect，终端支持则显示彩色
        },
    
    
    *************
    AnsiOutput
    
    public abstract class AnsiOutput {
    
        。。。
    
        public static enum Enabled {
            DETECT,
            ALWAYS,
            NEVER;
    
            private Enabled() {
            }
        }
    }

**示例**

%clr(%5p)               # 随后5格式用彩色输出
                            # %5p表示右对齐，不足5位左边用空格填充
                            # %-5p表示左对齐，不足5为右边用空格填充
    
    %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){yellow}
                            # 随后日期时间彩色输出，格式为：yyyy-MM-dd HH:mm:ss.SSS
                            # 颜色为黄色

**日志级别默认输出颜色**

FATAL  Red
    ERROR  Red
    
    WARN   Yellow
    
    INFO   Green
    DEBUG  Green
    TRACE  Green

**支持输出的日志颜色**

red、blue、green、yellow
    cyan、faint、magenta

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**日志输出到文件**

By default, Spring Boot logs only to the console and does not write log files. 
    # springboot日志默认值输出到控制台
    
    If you want to write log files in addition to the console output, 
    you need to set a logging.file.name or logging.file.path property 
    (for example, in your application.properties)
    # 使用logging.file.name、logging.file.path可将日志同时输出到文件
    
    Log files rotate when they reach 10 MB and, as with console output, 
    ERROR-level, WARN-level, and INFO-level messages are logged by default
    # 日志文件达到10M就会新建一个文件，
    # 和console输出一样，默认值输出info、warn、error级别的日志

**使用规则**

不使用logging.file.name、logging.file.path   ==> 只输出到控制台
    只使用logging.file.name=my.log ==> 在项目路径下输出my.log文件
    之所以logging.file.path=./     ==> 在项目路径下输出spring.log（默认文件名）文件
    同时使用logging.file.name、logging.file.path ==> 以logging.file.name为准

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**日志文件滚动**

If you are using the Logback, it’s possible to fine-tune log rotation settings 
    using your application.properties or application.yaml file. 
    logback日志文件可直接在配置文件中配置
    
    For all other logging system, you’ll need to configure rotation settings directly 
    yourself (for example, if you use Log4J2 then you could add a log4j.xml file)
    其他日志框架，需要自行配置（如log4j2，需要使用log4j.xml进行配置）

**logback配置参数**

logging.logback.rollingpolicy.file-name-pattern        # 日志文件命名规则，默认${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz
    logging.logback.rollingpolicy.clean-history-on-start   # 启动时是否删除历史日志文件，默认false
    logging.logback.rollingpolicy.max-file-size            # 单个日志文件大小，默认10M
    logging.logback.rollingpolicy.total-size-cap           # 日志文件最大的总大小，默认0B（不限制）
    logging.logback.rollingpolicy.max-history              # 日志文件最大保存天数，默认7天

**spring-configuration-metadata.json(配置提示)**

{
          "name": "logging.logback.rollingpolicy.clean-history-on-start",
          "type": "java.lang.Boolean",
          "description": "Whether to clean the archive log files on startup.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": false
        },
        {
          "name": "logging.logback.rollingpolicy.file-name-pattern",
          "type": "java.lang.String",
          "description": "Pattern for rolled-over log file names.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": "${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz"
        },
        {
          "name": "logging.logback.rollingpolicy.max-file-size",
          "type": "org.springframework.util.unit.DataSize",
          "description": "Maximum log file size.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": "10MB"
        },
        {
          "name": "logging.logback.rollingpolicy.max-history",
          "type": "java.lang.Integer",
          "description": "Maximum number of days archive log files are kept.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": 7
        },
        {
          "name": "logging.logback.rollingpolicy.total-size-cap",
          "type": "org.springframework.util.unit.DataSize",
          "description": "Total size of log backups to be kept.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": "0B"
        },

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**设置日志级别**

**命令格式：logging.level.<logger-name>=<level>**

**level 可选值：**trace、debug、info、warn、error、fatal、off

**配置文件设置日志级别**

logging:
      level:
        root: "warn"
        org.springframework.web: "debug"
        org.hibernate: "error"
        com.example.demo.controller.HelloController: debug

**环境变量设置日志级别：LOGGING\_LEVEL\_ORG\_SPRINGFRAMEWORK\_WEB=DEBUG**

It’s also possible to set logging levels using environment variables. 
    For example, LOGGING_LEVEL_ORG_SPRINGFRAMEWORK_WEB=DEBUG will set 
    org.springframework.web to DEBUG
    # 可使用环境变量设置日志级别，LOGGING_LEVEL_ORG_SPRINGFRAMEWORK_WEB=DEBUG，
    # 会将org.springframework.web包的日志级别设置为debug
    
    
    The above approach will only work for package level logging. 
    Since relaxed binding always converts environment variables to lowercase, 
    it’s not possible to configure logging for an individual class in this way. 
    # 上述方法只能设置包的日志级别，
    # 由于会将环境变量转换为小写，类的日志级别不能这么设置
    
    If you need to configure logging for a class, you can use the 
    SPRING_APPLICATION_JSON variable
    # 可以使用SPRING_APPLICATION_JSON设置日志级别
    
    
    SPRING_APPLICATION_JSON设置日志级别
    java -jar demo.jar --spring.application.json='{"logging":{"level":{"com.example.demo.controller.HelloController":"debug"}}}'
    java -jar demo.jar --spring.application.json='{"logging":{"level":{"com.example.demo.controller.HelloController":"debug"}}}'

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**日志组**

It’s often useful to be able to group related loggers together so that 
    they can all be configured at the same time. 
    # 将相关日志(logger)组合在一起，可以方便的对这些日志进行管理
    
    For example, you might commonly change the logging levels for all Tomcat 
    related loggers, but you can’t easily remember top level packages.
    # 例如，你可能经常改变tomcat日志，但是不能记住所有相关的包，
    # 此时，可将相关的包建立为一个tomcat组合

**示例**

logging:
      group:
        tomcat: "org.apache.catalina,org.apache.coyote,org.apache.tomcat"
    # 定义tomcat日志组合：org.apache.catalina, org.apache.coyote,org.apache.tomcat
    
    # 直接对日志组合设置日志级别
    logging:
      level:
        tomcat: "debug"

**预置的日志组合**

# web 日志组合
    org.springframework.core.codec, 
    org.springframework.http, 
    org.springframework.web, 
    org.springframework.boot.actuate.endpoint.web, org.springframework.boot.web.servlet.ServletContextInitializerBeans
    
    # sql 日志组合
    org.springframework.jdbc.core, 
    org.hibernate.SQL, 
    org.jooq.tools.LoggerListener

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**log shutdown hook**

In order to release logging resources when your application terminates, 
    a shutdown hook that will trigger log system cleanup when the JVM exits is provided. 
    # shutdown hook可在jvm关闭的时候释放日志资源
    
    This shutdown hook is registered automatically unless your application 
    is deployed as a war file.
    # 除非打包成war文件，shutdown hook会自动注册
    
    If your application has complex context hierarchies the shutdown hook 
    may not meet your needs. If it does not, disable the shutdown hook and 
    investigate the options provided directly by the underlying logging system
    # 在应用系统比较复杂的情况下，shutdown hook可能不符合需求，
    # 这时可关闭shutdown hook自动注册功能
    
    For example, Logback offers context selectors which allow each Logger 
    to be created in its own context
    # 例如，logback提供context selectors，这可以context创建logger，
    # 这时就可能不需要注册shutdown hook

**关闭自动注册shutdown hook**

logging:
      register-shutdown-hook: false

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**自定义日志配置**

The various logging systems can be activated by including the appropriate libraries 
    on the classpath and can be further customized by providing a suitable configuration 
    file in the root of the classpath or in a location specified by the following Spring 
    Environment property: logging.config
    # 日志系统激活方式：导入相应jar包、在classpath或者指定路径(logging.config)中提供配置文件
    
    You can force Spring Boot to use a particular logging system by using the
    org.springframework.boot.logging.LoggingSystem system property. The value should be the 
    fully qualified class name of a LoggingSystem implementation. 
    # 可以使用系统变量org.springframework.boot.logging.LoggingSystem强制使用某个日志系统
    # 这个值需要是LoggingSystem的实现类的全限定名
    
    You can also disable Spring Boot’s logging configuration entirely by using a value of none
    # 将org.springframework.boot.logging.LoggingSystem设置为none，
    # 可以禁用springboot日志配置
    
    Since logging is initialized before the ApplicationContext is created, it is not 
    possible to control logging from @PropertySources in Spring @Configuration files. 
    The only way to change the logging system or disable it entirely is via System properties
    # 日志在ApplicationContext创建之前初始化，不能通过@PropertySources加载日志配置
    # 唯一改变日志配置的方法就是使用系统变量

**日志系统默认加载的配置文件**

Logback ==> logback-spring.xml, logback-spring.groovy, 
                logback.xml, logback.groovy
    
    Log4j2  ==> log4j2-spring.xml, log4j2.xml
    JDK (Java Util Logging) ==> logging.properties

**配置文件使用注意**

When possible, we recommend that you use the -spring variants for your logging 
    configuration (for example, logback-spring.xml rather than logback.xml). If you use 
    standard configuration locations, Spring cannot completely control log initialization
    # 推荐使用 -spring后缀的配置文件（logback-spring.xml）
    # 如果使用logback.xml，spring就不能完全控制日志初始化
    
    There are known classloading issues with Java Util Logging that cause problems when 
    running from an 'executable jar'. We recommend that you avoid it when running from an 
    'executable jar' if at all possible
    # java util logging在使用时会有一些问题，尽量避免使用

**spring配置 ==> 对应的系统配置**

PID                               ==> PID(进程id)
    
    logging.file.name                 ==> LOG_FILE               #日志文件名称，默认为spring.log
    logging.file.path                 ==> LOG_PATH               #日志文件路径，同时设置以logging.file.name为准
    
    logging.charset.console           ==> CONSOLE_LOG_CHARSET    #控制台字符集
    logging.charset.file              ==> FILE_LOG_CHARSET       #日志文件字符集
    
    logging.pattern.console           ==> CONSOLE_LOG_PATTERN    #控制台日志输出样式
    logging.pattern.dateformat        ==> LOG_DATEFORMAT_PATTERN #日期输出样式
    logging.pattern.file              ==> FILE_LOG_PATTERN       #日志文件输出样式
    logging.pattern.level             ==> LOG_LEVEL_PATTERN      #日志级别（info、warn等）输出格式
                                                                 #默认%5p，右对齐，占5个占位符，不足左边补空格
    
    logging.exception-conversion-word ==> LOG_EXCEPTION_CONVERSION_WORD
                                                                 #日志输出发生异常时，使用的转换文字
    
    
    # spring-configuration-metadata.json
    
        {
          "name": "logging.pattern.console",
          "type": "java.lang.String",
          "description": "Appender pattern for output to the console. Supported only with the default Logback setup.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": "%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"
        },
        {
          "name": "logging.pattern.dateformat",
          "type": "java.lang.String",
          "description": "Appender pattern for log date format. Supported only with the default Logback setup.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": "yyyy-MM-dd HH:mm:ss.SSS"
        },
        {
          "name": "logging.pattern.file",
          "type": "java.lang.String",
          "description": "Appender pattern for output to a file. Supported only with the default Logback setup.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": "%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}} ${LOG_LEVEL_PATTERN:-%5p} ${PID:- } --- [%t] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"
        },
        {
          "name": "logging.pattern.level",
          "type": "java.lang.String",
          "description": "Appender pattern for log level. Supported only with the default Logback setup.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": "%5p"
        },
    
        {
          "name": "logging.exception-conversion-word",
          "type": "java.lang.String",
          "description": "Conversion word used when logging exceptions.",
          "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
          "defaultValue": "%wEx"
        },

**logback spring配置 ==> 对应的系统配置**

logging.logback.rollingpolicy.file-name-pattern
    ==> LOGBACK_ROLLINGPOLICY_FILE_NAME_PATTERN
    # 默认为：${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz).
    
    logging.logback.rollingpolicy.clean-history-on-start
    ==> LOGBACK_ROLLINGPOLICY_CLEAN_HISTORY_ON_START
    # 是否在启动时清理历史日志文件，默认为false
    
    logging.logback.rollingpolicy.max-file-size
    ==> LOGBACK_ROLLINGPOLICY_MAX_FILE_SIZE
    # 单个文件最大大小
    
    logging.logback.rollingpolicy.total-size-cap
    ==> LOGBACK_ROLLINGPOLICY_TOTAL_SIZE_CAP
    # 日志文件总大小，默认不设限
    
    logging.logback.rollingpolicy.max-history
    ==> LOGBACK_ROLLINGPOLICY_MAX_HISTORY
    # 日志文件保存的最长时间，默认为7天

**logback 配置使用示例**

Notably, if you use Logback, you should use : as the delimiter 
    between a property name and its default value and not use :-
    # 属性名和默认值之间使用 “:”分隔，不要用“:-”
    
    logging.pattern.level=user:%X{user:-gtlx} %5p  # user和%X{user}用 “:”间隔
                                             # %X{user:-gtlx}，user如果没有，默认为gtlx
    
    输出示例
    2021-09-15 12:15:31.635 user:gtlx  INFO 936 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
    2021-09-15 12:15:31.657 user:gtlx  INFO 936 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 2.253 seconds (JVM running for 3.234)

**\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**相关类与接口**

**LogbackLoggingSystem**

public class LogbackLoggingSystem extends Slf4JLoggingSystem {
                                //Slf4JLoggingSystem是AbstractLoggingSystem的子类
    
        。。。
    
        protected String[] getStandardConfigLocations() {
            return new String[]{"logback-test.groovy", "logback-test.xml", "logback.groovy", "logback.xml"};
        }

**AbstractLoggingSystem**

public abstract class AbstractLoggingSystem extends LoggingSystem {
        protected static final Comparator<LoggerConfiguration> CONFIGURATION_COMPARATOR = new LoggerConfigurationComparator("ROOT");
        private final ClassLoader classLoader;
    
        public AbstractLoggingSystem(ClassLoader classLoader) {
            this.classLoader = classLoader;
        }
    
        public void beforeInitialize() {
        }
    
        public void initialize(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile) {
            if (StringUtils.hasLength(configLocation)) {
                this.initializeWithSpecificConfig(initializationContext, configLocation, logFile);
            } else {
                this.initializeWithConventions(initializationContext, logFile);
            }
        }
    
        private void initializeWithSpecificConfig(LoggingInitializationContext initializationContext, String configLocation, LogFile logFile) {
            configLocation = SystemPropertyUtils.resolvePlaceholders(configLocation);
            this.loadConfiguration(initializationContext, configLocation, logFile);
        }
    
        private void initializeWithConventions(LoggingInitializationContext initializationContext, LogFile logFile) {
            String config = this.getSelfInitializationConfig();
                            //先加载SelfInitializationConfig
            if (config != null && logFile == null) {
                this.reinitialize(initializationContext);
            } else {
                if (config == null) {
                    config = this.getSpringInitializationConfig();
                }           //如果没有，则加载SpringInitializationConfig
    
                if (config != null) {
                    this.loadConfiguration(initializationContext, config, logFile);
                } else {
                    this.loadDefaults(initializationContext, logFile);
                }           //如果没有，则加载默认配置
            }
        }
    
        protected String getSelfInitializationConfig() {
            return this.findConfig(this.getStandardConfigLocations());
        }                   //"logback-test.groovy", "logback-test.xml", 
                            // "logback.groovy", "logback.xml"
    
        protected String getSpringInitializationConfig() {
            return this.findConfig(this.getSpringConfigLocations());
        }                   //"logback-test-spring.groovy", "logback-test-spring.xml", 
                            // "logback-spring.groovy", "logback-spring.xml"
    
        private String findConfig(String[] locations) {
            String[] var2 = locations;
            int var3 = locations.length;
    
            for(int var4 = 0; var4 < var3; ++var4) {
                String location = var2[var4];
                ClassPathResource resource = new ClassPathResource(location, this.classLoader);
                if (resource.exists()) {
                    return "classpath:" + location;
                }            //在classpath路径下查找对应配置
            }
    
            return null;
        }
    
        protected abstract String[] getStandardConfigLocations();
    
        protected String[] getSpringConfigLocations() {
            String[] locations = this.getStandardConfigLocations();
    
            for(int i = 0; i < locations.length; ++i) {
                String extension = StringUtils.getFilenameExtension(locations[i]);
                locations[i] = locations[i].substring(0, locations[i].length() - extension.length() - 1) + "-spring." + extension;
            }
    
            return locations;
        }
    
        。。。

**LoggingSystem**

public abstract class LoggingSystem {
        public static final String SYSTEM_PROPERTY = LoggingSystem.class.getName();
        public static final String NONE = "none";
        public static final String ROOT_LOGGER_NAME = "ROOT";
        private static final LoggingSystemFactory SYSTEM_FACTORY = LoggingSystemFactory.fromSpringFactories();
    
        public LoggingSystem() {
        }

## \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ##

**logback 拓展**

Spring Boot includes a number of extensions to Logback that can help with advanced 
    configuration. You can use these extensions in your logback-spring.xml configuration file
    # springboot针对logback提供了一些拓展配置，可以在logback-spring.xml配置文件中进行设置
    
    Because the standard logback.xml configuration file is loaded too early, you cannot use 
    extensions in it. You need to either use logback-spring.xml or define a logging.config property
    # 由于logback.xml加载的很早，因此不能使用拓展配置
    # 可以在logback-spring.xml配置，或者使用logging.config指定自定义的配置文件

**profile 配置**

The <springProfile> tag lets you optionally include or exclude sections of configuration 
    based on the active Spring profiles. Profile sections are supported anywhere within the 
    <configuration> element. Use the name attribute to specify which profile accepts the 
    configuration. 
    # springProfile可让配置在特定的环境下激活
    # springProfile可在<configuration>内的任意地方使用
    
    The <springProfile> tag can contain a profile name (for example staging) or a profile 
    expression. A profile expression allows for more complicated profile logic to be expressed, 
    for example production & (eu-central | eu-west)
    # springProfile可包含profile、profile表达式
    
    
    *************
    示例
    
    <springProfile name="staging">
        
    </springProfile>
    
    <springProfile name="dev | staging">
        
    </springProfile>
    
    <springProfile name="production & (eu-central | eu-west)">
        
    </springProfile>
    
    <springProfile name="!production">
        
    </springProfile>

**springPropety 使用环境变量**

The <springProperty> tag lets you expose properties from the Spring Environment for 
    use within Logback. Doing so can be useful if you want to access values from your 
    application.properties file in your Logback configuration. 
    # springProperty可以实现在logback配置中使用application.properties中的属性
    
    The tag works in a similar way to Logback’s standard <property> tag. However, rather than 
    specifying a direct value, you specify the source of the property (from the Environment). 
    # 这和property标签作用相似，但是property标签只能直接设值，springProperty可读取环境变量中的值
    
    If you need to store the property somewhere other than in local scope, you can use the scope attribute. If you need a fallback value (in case the property is not set in the Environment), you can use the defaultValue attribute
    # springProperty可设置属性的存储范围（scope设置，可选值local、context等）
    # default可设置属性的默认值
    
    
    ***************
    示例
    
    <springProperty scope="context" name="fluentHost" source="myapp.fluentd.host"
            defaultValue="localhost"/>
    # logback 属性值名称为fluent，作用范围是整个上下文
    # myapp.fluentd.host读取属性文件中的值，默认值：localhost
    
    <appender name="FLUENT" class="ch.qos.logback.more.appenders.DataFluentAppender">
        <remoteHost>${fluentHost}</remoteHost>   # 引用属性值
        ...
    </appender>

[Spring Boot Features_logging]: https://docs.spring.io/spring-boot/docs/current/reference/html/features.html#features.logging