肢解架构-日志管理

2021-03-17  本文已影响0人  Kindey_S

日志组件介绍

常用组件

  1. jul
  2. jcl
  3. log4j2
  4. log4j
  5. slf4j
  6. logback
  7. jboss-logging

发展历史

slf4j

官方网站

官网原理图 spring boot 利用slf4j兼容多种日志框架

Spring Boot默认集成日志框架logback

简介

Logger、appender及layout

Logger作为日志的记录器，把它关联到应用的对应的context上后，主要用于存放日志对象，也可以定义日志类型、级别。
Appender主要用于指定日志输出的目的地，目的地可以是控制台、文件、远程套接字服务器、 MySQL、 PostreSQL、 Oracle和其他数据库、 JMS和远程UNIX Syslog守护进程等。
Layout 负责把事件转换成字符串，格式化的日志信息的输出。

logger context

各个logger 都被关联到一个 LoggerContext，LoggerContext负责制造logger，也负责以树结构排列各 logger。其他所有logger也通过org.slf4j.LoggerFactory 类的静态方法getLogger取得。 getLogger方法以 logger 名称为参数。用同一名字调用LoggerFactory.getLogger 方法所得到的永远都是同一个logger对象的引用。

有效级别及级别的继承

Logger 可以被分配级别。级别包括：TRACE、DEBUG、INFO、WARN 和 ERROR，定义于 ch.qos.logback.classic.Level类。如果 logger没有被分配级别，那么它将从有被分配级别的最近的祖先那里继承级别。root logger 默认级别是 DEBUG。

打印方法与基本的选择规则

打印方法决定记录请求的级别。例如，如果 L 是一个 logger 实例，那么，语句 L.info("..")是一条级别为 INFO 的记录语句。记录请求的级别在高于或等于其 logger 的有效级别时被称为被启用，否则，称为被禁用。记录请求级别为 p，其logger的有效级别为 q，只有则当 p>=q时，该请求才会被执行。

该规则是 logback 的核心。级别排序为： TRACE < DEBUG < INFO < WARN < ERROR。

关于多环境

logging:
  config: classpath:conf/logback-dev.xml

<springProfile name="dev">
    <logger name="com.sdcm.pmp" level="debug"/>
</springProfile>

logback配置信息

configuration

名称 说明，
scan 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
scanPeriod 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。
debug 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。

contextName

每个logger都关联到logger上下文，默认上下文名称为“default”。但可以使用contextName设置成其他名字，用于区分不同应用程序的记录。一旦设置，不能修改。

<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <contextName>myAppName</contextName>
</configuration>

property

用来定义变量值的标签，property 有两个属性，name和value；其中name的值是变量的名称，value的值时变量定义的值。通过property定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。

<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <property name="APP_Name" value="myAppName" /> 
    <contextName>${APP_Name}</contextName>
</configuration>

timestamp

两个属性 key:标识此timestamp的名字；datePattern：设置将当前时间（解析配置文件的时间）转换为字符串的模式，遵循java.txt.SimpleDateFormat的格式。

<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <timestamp key="bySecond" datePattern="yyyyMMdd'T'HHmmss"/>
</configuration>

loger

用来设置某一个包或者具体的某一个类的日志打印级别、以及指定appender。loger仅有一个name属性，一个可选的level和一个可选的addtivity属性。

名称 说明，
name 用来指定受此loger约束的某一个包或者具体的某一个类。
level 用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，还有一个特殊值INHERITED或者同义词NULL，代表强制执行上级的级别。如果未设置此属性，那么当前loger将会继承上级的级别。
addtivity 是否向上级loger传递打印信息。默认是true。loger可以包含零个或多个appender-ref元素，标识这个appender将会添加到这个loger。当loger中包含appender-ref时，如果addtivity=true，则会将打印信息传递到root；如果addtivity=false，则只会在loger中appender-ref打印信息，不会向上传递。

root

也是loger元素，但是它是根loger。只有一个level属性，应为已经被命名为"root".

appender

appender是configuration的子节点，是负责写日志的组件。
appender有两个必要属性name和class。name指定appender名称，class指定appender的全限定名。

ConsoleAppender

把日志添加到控制台，有以下子节点：

<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <!-- Console 输出设置 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} | %thread | %-5level | %logger{64}:%line | %msg%n</pattern>
            <charset>UTF8</charset>
        </encoder>
    </appender>
</configuration>

FileAppender

把日志添加到文件，有以下子节点：

<configuration>

    <appender name="FILE"  class="ch.qos.logback.core.rolling.FileAppender">
        <file>${logPath}/${appName}-${appModule}-${appVersion}-${appNode}.log</file>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} | %thread | %-5level | %logger{64}:%line | %msg%n</pattern>
        </encoder>
    </appender>

</configuration>

RollingFileAppender

滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。有以下子节点：

TimeBasedRollingPolicy

最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。有以下子节点：

FixedWindowRollingPolicy

根据固定窗口算法重命名文件的滚动策略。有以下子节点：

SizeBasedTriggeringPolicy

查看当前活动文件的大小，如果超过指定大小会告知RollingFileAppender 触发当前活动文件滚动。只有一个节点:

<configuration>

    <appender name="FILE"  class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${logPath}/${appName}-${appModule}-${appVersion}-${appNode}.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <FileNamePattern>${logPath}/${appName}-${appModule}-${appVersion}-${appNode}.%d{yyyy-MM-dd}.%i.log.gz</FileNamePattern>
            <!--日志文件保留天数-->
            <MaxHistory>180</MaxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${appName}-${appModule}-${appVersion}-${appNode} | %d{yyyy-MM-dd HH:mm:ss.SSS} | %thread | %-5level | %logger{64}:%line | %msg%n</pattern>
        </encoder>
        <!--日志文件最大的大小-->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>128MB</MaxFileSize>
        </triggeringPolicy>
    </appender>

</configuration

SocketAppender && SSLSocketAppender

SocketAppender就是被设计用来输出日志到远程实例中的。 SocketAppender输出日志采用明文方式， SSLSocketAppender则采用加密方式传输日志。

SMTPAppender

可以将logging event存放在一个或多个固定大小的缓冲区中，然后在用户指定的event到来之时，将适当的大小的logging event以邮件方式发送给运维人员 。

DBAppender

可以将日志事件插入到3张数据表中。它们分别是logging_event，logging_event_property，logging_event_exception。这三张数据表必须在DBAppender工作之前存在。它们的sql脚本可以在 logback-classic/src/main/java/ch/qos/logback/classic/db/script folder 这个目录下找到。这个脚本对大部分SQL数据库都是有效的，除了少部分，少数语法有差异需要调整。

SiftingAppender

提供过滤筛选日志的功能。你可以通过用户的sessions的数据来筛选日志，然后分发到不同日志文件。

自定义Appender

你可以很简单的创建自己的Appender，通过继承父类AppenderBase。AppenderBase已经实现了对filters，status以及一些其他被大多数appender共享的功能的支持。我们所要做的仅仅是实现append(Object evenObject)这个方法。

encoder && layout

区别

在0.9.19版本之前，都是使用layout来控制输出的格式。在0.9.19就变成了使用encoder来控制。
encoder：主要工作有两个：①将一个event事件转换成一组byte数组，②将转换后的字节数据输出到文件中。
layout：主要的功能就是：将一个event事件转化为一个String字符串。

格式控制

转换符 作用
c {length}、lo {length}、logger {length} 输出日志的logger名，可有一个整形参数，功能是缩短logger名，设置为0表示只输入logger最右边点符号之后的字符串。 Conversion specifier Logger name Result
C {length}、class {length} 输出执行记录请求的调用者的全限定名。参数与上面的一样。尽量避免使用，除非执行速度不造成任何问题。
contextName、cn 输出上下文名称。
d{pattern}、date{pattern} 输出日志的打印日志，模式语法与java.text.SimpleDateFormat 兼容。 Conversion Pattern Result
F、file 输出执行记录请求的java源文件名。尽量避免使用，除非执行速度不造成任何问题。
caller{depth}、caller{depth, evaluator-1, ... evaluator-n} 输出生成日志的调用者的位置信息，整数选项表示输出信息深度。
L、line 输出执行日志请求的行号。尽量避免使用，除非执行速度不造成任何问题。
m、msg、message 输出应用程序提供的信息。
M、method 输出执行日志请求的方法名。尽量避免使用，除非执行速度不造成任何问题。
n 输出平台先关的分行符“\n”或者“\r\n”。
p、le、level 输出日志级别。
r、relative 输出从程序启动到创建日志记录的时间，单位是毫秒。
t、thread 输出产生日志的线程名。
replace(p){r,t} p 为日志内容，r 是正则表达式，将p 中符合r 的内容替换为t。例如， "%replace(%msg){'\s', ''}"。

filter

Logback的过滤器基于三值逻辑（ternary logic），允许把它们组装或成链，从而组成任意的复合过滤策略。过滤器很大程度上受到Linux的iptables启发。这里的所谓三值逻辑是说，过滤器的返回值只能是ACCEPT、DENY和NEUTRAL的其中一个。

过滤器被添加到Appender中，为Appender添加一个或多个过滤器后，可以用任意条件对日志进行过滤。Appender有多个过滤器时，按照配置顺序执行。

LevelFilter

级别过滤器，根据日志级别进行过滤。如果日志级别等于配置级别，过滤器会根据onMath 和 onMismatch接收或拒绝日志。有以下子节点：

<configuration> 
  <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"> 
    <filter class="ch.qos.logback.classic.filter.LevelFilter"> 
      <level>INFO</level> 
      <onMatch>ACCEPT</onMatch> 
      <onMismatch>DENY</onMismatch> 
    </filter> 
    <encoder> 
      <pattern> 
        %-4relative [%thread] %-5level %logger{30} - %msg%n 
      </pattern> 
    </encoder> 
  </appender> 
  <root level="DEBUG"> 
    <appender-ref ref="CONSOLE" /> 
  </root> 
</configuration>

ThresholdFilter

当日志级别等于或高于临界值时，过滤器返回NEUTRAL；当日志级别低于临界值时，日志会被拒绝。

<configuration> 
  <appender name="CONSOLE" 
    class="ch.qos.logback.core.ConsoleAppender"> 
    <!-- 过滤掉 TRACE 和 DEBUG 级别的日志--> 
    <filter class="ch.qos.logback.classic.filter.ThresholdFilter"> 
      <level>INFO</level> 
    </filter> 
    <encoder> 
      <pattern> 
        %-4relative [%thread] %-5level %logger{30} - %msg%n 
      </pattern> 
    </encoder> 
  </appender> 
  <root level="DEBUG"> 
    <appender-ref ref="CONSOLE" /> 
  </root> 
</configuration>

EvaluatorFilter

求值过滤器，评估、鉴别日志是否符合指定条件。需要额外的两个JAR包，commons-compiler.jar和janino.jar。

<configuration>
  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
      <evaluator> <!-- 默认为 ch.qos.logback.classic.boolex.JaninoEventEvaluator -->
        <expression>return message.contains("billing");</expression>
      </evaluator>
      <OnMatch>ACCEPT </OnMatch>
      <OnMismatch>DENY</OnMismatch>
    </filter>
    <encoder>
      <pattern>
        %-4relative [%thread] %-5level %logger - %msg%n
      </pattern>
    </encoder>
  </appender>

  <root level="INFO">
    <appender-ref ref="STDOUT" />
  </root>
</configuration>

Spring Boot下的日志归集

思路

  1. 需要有个日志的服务器，用于归集各个模块产生的日志信息
  2. 每个模块的日志除了输出到本地，还要同步输出到日志服务器
  3. 每个模块输出的日志格式应该是统一的
  4. 日志服务器至少要提供精确、准确的检索能力

最简方案：SocketAppender+ServerSocketReceiver

client端

<configuration scan="true" scanPeriod="60 seconds" debug="false">

    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
    <conversionRule conversionWord="wex"
                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <conversionRule conversionWord="wEx"
                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>

    <!-- 系统名称 通过启动参数 -Dapp.api.name="***" 指定 -->
    <property scope="context" name="appName" value="${app.api.name:-appName}"/>
    <!-- 模块名称 通过启动参数 -Dapp.api.module="***" 指定 -->
    <property scope="context" name="appModule" value="${app.api.module:-moduleName}"/>
    <!-- 版本 通过启动参数 -Dapp.api.version="***" 指定 -->
    <property scope="context" name="appVersion" value="${app.api.version:-v1}"/>
    <!-- 节点名称 通过启动参数 -Dapp.api.node="***" 指定 -->
    <property scope="context" name="appNode" value="${app.api.node:-node1}"/>
    <!-- 日志文件路径 通过启动参数 -Dapp.log.path="***" 指定 -->
    <property scope="context" name="logPath" value="${app.log.path:-/joinway}"/>
    <!-- 日志文件备份路径 通过启动参数 -Dapp.log.path="***" 指定 -->
    <property scope="context" name="backPath" value="${logPath}/backFiles"/>

    <property name="appName" value="${appName}-${appModule}-${appVersion}-${appNode}" />
    <contextName>${appName}</contextName>

    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN"
              value="%clr(%cn){blue} | %clr(%date{yyyy-MM-dd HH:mm:ss.SSS}){yellow} | %clr(%-5level){highlight} | %clr(%thread){faint} | %clr(%logger{64}:%line){magenta} | %clr(%msg%n){cyan}${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"/>

    <!-- Console 输出设置 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <charset>UTF8</charset>
        </encoder>
    </appender>

    <appender name="SOCKET" class="ch.qos.logback.classic.net.SocketAppender">
        <remoteHost>192.168.3.166</remoteHost>
        <port>9898</port>
        <reconnectionDelay>10000</reconnectionDelay>
        <includeCallerData>true</includeCallerData>
    </appender>

    <logger name="org.springframework" level="INFO"/>

    <logger name="DemoContorller2" level="TRACE" addtivity="false">
        <appender-ref ref="SOCKET"/>
    </logger>

    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>

server端

<configuration scan="true" scanPeriod="60 seconds" debug="false">

    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
    <conversionRule conversionWord="wex"
                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <conversionRule conversionWord="wEx"
                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>

    <!-- 系统名称 通过启动参数 -Dapp.api.name="***" 指定 -->
    <property scope="context" name="appName" value="${app.api.name:-appName}"/>
    <!-- 模块名称 通过启动参数 -Dapp.api.module="***" 指定 -->
    <property scope="context" name="appModule" value="${app.api.module:-moduleName}"/>
    <!-- 版本 通过启动参数 -Dapp.api.version="***" 指定 -->
    <property scope="context" name="appVersion" value="${app.api.version:-v1}"/>
    <!-- 节点名称 通过启动参数 -Dapp.api.node="***" 指定 -->
    <property scope="context" name="appNode" value="${app.api.node:-node1}"/>
    <!-- 日志文件路径 通过启动参数 -Dapp.log.path="***" 指定 -->
    <property scope="context" name="logPath" value="${app.log.path:-/joinway}"/>
    <!-- 日志文件备份路径 通过启动参数 -Dapp.log.path="***" 指定 -->
    <property scope="context" name="backPath" value="${logPath}/backFiles"/>

    <property name="appName" value="${appName}-${appModule}-${appVersion}-${appNode}" />
    <contextName>${appName}</contextName>

    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN"
              value="%clr(%cn){blue} | %clr(%date{yyyy-MM-dd HH:mm:ss.SSS}){yellow} | %clr(%-5level){highlight} | %clr(%thread){faint} | %clr(%logger{64}:%line){magenta} | %clr(%msg%n){cyan}${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"/>

    <!-- Console 输出设置 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <charset>UTF8</charset>
        </encoder>
    </appender>

    <logger name="org.springframework" level="INFO"/>
    <logger name="DemoContorller2" level="TRACE"/>

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

    <receiver class="ch.qos.logback.classic.net.server.ServerSocketReceiver">
        <port>9898</port>
    </receiver>
</configuration>

后续方案实现过程相对复杂，就不在这里详述，另外再找时间分享给大家

主流方案ETL：Elasticsearch+Logstash+Kibana

进阶方案：

自定义Appender+kafka+hadoop

其他。。。。。。

上一篇 下一篇

猜你喜欢

热点阅读