Logback的目标是作为Log4j的继任者。Logback使用模块化的架构，主要分为三个部分：logback-core、logback-classic、logback-access。

模块logback-classic作为Log4j的继任者，它做了根本性的改进。该模块实现了SLF4J API，你可以方便的切换到其它日志框架。模块logback-access和Servlet容器集成，提供HTTP访问日志的功能。在logback-core的基础上，你可以方便的轻易的构建自己的模块。

Logback比起Log4j的优势包括：

1. 在某些关键的执行路径上，提供高于Log4j十倍的性能，同时具有比Log4j更低的内存占用
2. logback-classic直接实现了SLF4J API，而Log4J需要经过适配才能使用SLF4J
3. 支持XML和Groovy两种配置风格
4. 在配置文件修改后，实时的重新加载，不需要重启应用
5. 优雅的重IO错误中恢复：FileAppender及其子类（例如RollingFileAppender）能在文件服务器宕机恢复后，自动重连，不需要重启应用
6. 自动移除旧日志归档，你可以设置TimeBasedRollingPolicy、SizeAndTimeBasedFNATP的maxHistory属性，以控制日志文件的数量
7. 自动压缩日志归档文件，RollingFileAppender 能够在Rollover时自动、异步的压缩日志文件
8. Prudent Mode：支持多个JVM中运行的FileAppender安全的向同一个文件进行写入
9. 配置文件的条件式处理，你可以在配置文件中添加

   <if>

   等元素
10. 过滤器，Logback提供比Log4j更加强大的过滤器机制
11. SiftingAppender，可以基于任何运行时属性来分离日志。例如，根据用户会话来分割日志，每个会话产生一个日志文件
12. 异常栈增强 —— 支持软件包信息，例如

    struts-1.2.9.jar:1.2.9

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

你可以通过编程，或者指定配置文件，来配置Logback。默认配置行为如下：

1. 尝试寻找类路径下的 logback-test.xml
2. 如果找不到，尝试寻找logback.groovy
3. 如果找不到，尝试寻找logback.xml 
4. 尝试寻找类路径下META-INF/services/ch.qos.logback.classic.spi.Configurator指定的配置类，获得的全限定名称用于配置Logback
5. 如果以上步骤都失败，使用 BasicConfigurator，直接打印到控制台

注意，配置文件位置可以通过系统属性

-Dlogback.configurationFile=/path/to/config.xml

这是根配置元素：

<!--
    debug设置为true，打印Logback状态信息
    scan设置为true，自动扫描配置文件的修改，并重新载入
    scanPeriod 默认每分钟扫描一次，如果不指定单位，则单位ms
    packagingData="true" 在栈信息中附加包信息，1.1.4以后默认禁用
-->
<configuration debug="true" scan="true" scanPeriod="30 seconds" packagingData="true">
    <!-- 设置LoggerContext名称 -->
    <contextName>logbacktesst</contextName>

    <!-- 定义属性 -->
    <property name="USER_HOME" value="/home/alex"/>
    <!-- 从JNDI获取属性 -->
    <insertFromJNDI env-entry-name="java:comp/env/userhome" as="USER_HOME"/>
    <!-- 将当前时间定义为属性-->
    <timestamp key="bySecond" datePattern="yyyyMMdd'T'HHmmss"/>

    <!-- 下面的子元素单独阐述 -->
    <include />
    <if />
    <appender />
    <logger />
</configuration>

用于包含其它文件中的配置信息：

<include file="http://dev.gmem.cc/logback/basic.xml"/>

被包含的文件，格式必须如下：

<!-- 必须以include为根元素 -->
<included>
    <appender name="includedConsole" class="ch.qos.logback.core.ConsoleAppender" />
</included>

用于条件化配置：

<if condition='property("HOSTNAME").contains("zircon")'>
    <then>
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>%d %-5level %logger{35} - %msg %n</pattern>
            </encoder>
        </appender>
        <root>
            <appender-ref ref="STDOUT"/>
        </root>
    </then>
    <else>
    </else>
</if>

<!-- 根日志器 -->
<root level="debug"> <!-- 设置为OFF则关闭根日志器 -->
    <!-- 每个日志器都可以引用多个Appender -->
    <appender-ref ref="STDOUT"/>
    <appender-ref ref="FILE"/>
</root>
<!-- 自定义日志器，以及其最低级别-->
<logger name="cc.gmem" level="INFO"/>
<!-- 默认情况下，每个日志器会调用自己的Appender，也会使用所有祖先的Appender -->
<!-- 设置additivity为false，则不使用任何祖先Appender -->
<logger name="cc.gmem.study.logback.LogbackTest" level="DEBUG" additivity="false">
    <appender-ref ref="FILE"/>
</logger>

定义日志追加器，负责把LogEvent输出到目的地。

<!-- 输出到控制台的Appender -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
    <!-- 也可以输出到System.err -->
    <target>System.out</target>
    <!-- 设置为true则可以在Windows下支持彩色输出，需要依赖org.fusesource.jansi:jansi:1.9 -->
    <withJansi>false</withJansi>
</appender>

<!-- 输出到文件的Appender -->
<appender name="FILE" class="ch.qos.logback.core.FileAppender">
    <!-- 可以引用定义的属性，进行变量替换 -->
    <file>${USER_HOME}logbacktest.log</file>
    <!-- 唯一性文件名  -->
    <file>log-${bySecond}.txt</file>
    <encoder>
        <pattern>%date %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
    </encoder>
    <!-- 默认true，是否附加到文件的尾部，设置为false则文件的原有内容被清除 -->
    <append>true</append>
    <!-- 默认true，设置为false可以大大提升日志吞吐量，但是程序崩溃可能丢失日志 -->
    <immediateFlush>false</immediateFlush>
    <!-- 如果设置为true则日志被安全的写入文件，即使存在其它JVM的FileAppender在使用此文件 -->
    <prudent>false</prudent>
</appender>

<!-- 滚动文件Appender -->
<appender name="RFILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logFile.log</file>
    <!--
        滚动策略，基于时间滚动
    -->
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <!--
            文件名模式：
            %d{yyyy-MM-dd-HH, UTC}
            %d{yyyy-MM-dd}
        -->
        <!-- 每日滚动出一个文件-->
        <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>
        <!-- 最多保留的日志文件数量，老的日志自动移除 -->
        <!-- 保留30天的日志历史 -->
        <maxHistory>30</maxHistory>
        <!-- 日志占用空间限制，如果超过限制，从最老的文件开始删除，删除是异步的 -->
        <!-- 最多占用3GB -->
        <totalSizeCap>3GB</totalSizeCap>
        <!-- 如果设置为true，则在启动时移除归档日志 -->
        <cleanHistoryOnStart>false</cleanHistoryOnStart>
    </rollingPolicy>
    <!--
        滚动策略，基于时间 + 尺寸
    -->
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <!-- 每日滚定，%i为文件计数，初始值0 -->
        <fileNamePattern>mylog-%d{yyyy-MM-dd}.%i.txt</fileNamePattern>
        <!-- 单个文件最多100MB，保留60天历史，最大占用空间20GB -->
        <maxFileSize>100MB</maxFileSize>
        <maxHistory>60</maxHistory>
        <totalSizeCap>20GB</totalSizeCap>
    </rollingPolicy>
    <!-- 触发策略：负责确定何时执行rollover -->
    <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
        <!-- 如果当前文件超过5MB，则触发Appender进行是否需要rollover的判断 -->
        <maxFileSize>5MB</maxFileSize>
    </triggeringPolicy>
    <encoder>
        <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>
    </encoder>
</appender>

<!-- 连接到远程日志服务器，推送日志 -->
<!-- 通过套接字发送日志 -->
<appender name="SOCKET" class="ch.qos.logback.classic.net.SocketAppender">
    <remoteHost>${host}</remoteHost>
    <port>${port}</port>
    <reconnectionDelay>10000</reconnectionDelay>
    <includeCallerData>${includeCallerData}</includeCallerData>
</appender>
<!-- 通过SSL发送日志 -->
<appender name="SOCKETSSL" class="ch.qos.logback.classic.net.SSLSocketAppender">
    <remoteHost>${host}</remoteHost>
    <port>${port}</port>
    <reconnectionDelay>10000</reconnectionDelay>
    <ssl>
        <trustStore>
            <location>${truststore}</location>
            <password>${password}</password>
        </trustStore>
    </ssl>
</appender>

<!-- 创建一个日志服务器并监听，向所有连接到此服务器的客户端推送日志 -->
<!-- 在客户端连接之前产生的日志，简单的丢弃 -->
<appender name="SERVER" class="ch.qos.logback.classic.net.server.ServerSocketAppender">
    <port>${port}</port>
    <includeCallerData>${includeCallerData}</includeCallerData>
</appender>
<appender name="SERVERSSL" class="ch.qos.logback.classic.net.server.SSLServerSocketAppender">
    <port>${port}</port>
    <includeCallerData>${includeCallerData}</includeCallerData>
    <ssl>
        <keyStore>
            <location>${keystore}</location>
            <password>${password}</password>
        </keyStore>
    </ssl>
</appender>

<!-- 将日志记录到数据库 -->
<appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
    <connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">
        <driverClass>com.mysql.jdbc.Driver</driverClass>
        <url>jdbc:mysql://host_name:3306/datebase_name</url>
        <user>username</user>
        <password>password</password>
    </connectionSource>
</appender>

<!-- 写到Syslog中 -->
<appender name="SYSLOG" class="ch.qos.logback.classic.net.SyslogAppender">
    <syslogHost>remote_home</syslogHost>
    <facility>AUTH</facility>
    <suffixPattern>[%thread] %logger %msg</suffixPattern>
</appender>

<!-- 根据特定的运行时属性，对日志文件进行分割 -->
<appender name="SIFT" class="ch.qos.logback.classic.sift.SiftingAppender">
    <!-- 根据运行时属性userid进行分割 -->
    <discriminator class="ch.qos.logback.classic.sift.MDCBasedDiscriminator">
        <key>userid</key>
        <defaultValue>unknown</defaultValue>
    </discriminator>
    <sift>
        <appender name="FILE-${userid}" class="ch.qos.logback.core.FileAppender">
            <!-- 运行时属性可以随意引用 -->
            <file>${userid}.log</file>
            <append>false</append>
            <layout class="ch.qos.logback.classic.PatternLayout">
                <pattern>%d [%thread] %level %mdc %logger{35} - %msg%n</pattern>
            </layout>
        </appender>
    </sift>
</appender>

配合此Appender的Java代码：

logger.debug("Application started");
// 设置运行时属性
MDC.put("userid", "Alice");
logger.debug("Alice says hello");

此日志追加器能够异步的记录ILoggingEvent，它本身仅仅作为事件分发器，必须引用其它Appender负责实际的日志记录。

AsyncAppender在BlockingQueue中对日志进行缓冲，它会创建一个专门的工作线程，从队列的头部获取日志，并分发给单个子Appender。默认情况下，队列用量超过80%后，AsyncAppender会丢弃TRACE, DEBUG,INFO级别的日志信息。

队列的默认容量为256，如果队列满了，调用logger.***的应用程序线程会阻塞。

你必须在关闭JVM进程之前，明确的关闭AsyncAppender，以防止日志事件丢失（未来得及分发）。你可以显式调用：

LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
loggerContext.stop();

或者使用Java的ShutdownHook：

<configuration debug="true">
   <shutdownHook class="ch.qos.logback.core.hook.DelayingShutdownHook" />
</configuration>

AsyncAppender配置示例：

<appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
    <!-- 队列容量 -->
    <queueSize>256</queueSize>
    <!-- 仅剩多少容量时，开始丢弃不重要的日志，设置为0则不丢弃 -->
    <discardingThreshold>20</discardingThreshold>
    <!-- 当LoggerContext停止时，AsyncAppender.stop()等待多长时间，让日志被刷出到appender-ref -->
    <maxFlushTime>1000</maxFlushTime>
    <!-- 如果设置为true，队列满了会直接丢弃信息，而不是阻塞 -->
    <neverBlock>false</neverBlock>

    <!-- 实际负责日志记录的Appender -->
    <appender-ref ref="FILE" />
</appender>

此接口负责格式化日志事件：

public interface Layout<E> extends ContextAware, LifeCycle {
    String doLayout(E event);
    String getFileHeader();
    String getPresentationHeader();
    String getFileFooter();
    String getPresentationFooter();
    String getContentType();
}

你可以注册自己实现的Layout：

<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
        <layout class="cc.gmem.study.logback.JsonLayout" />
    </encoder>
</appender>

这是一个灵活的Layout，通过一个字符串指定输出格式。

%logger      mainPackage.sub.sample.Bar   mainPackage.sub.sample.Bar
%logger{0}   mainPackage.sub.sample.Bar   Bar
%logger{5}   mainPackage.sub.sample.Bar   m.s.s.Bar
%logger{10}  mainPackage.sub.sample.Bar   m.s.s.Bar
%logger{15}  mainPackage.sub.sample.Bar   m.s.sample.Bar
%logger{16}  mainPackage.sub.sample.Bar   m.sub.sample.Bar
%logger{26}  mainPackage.sub.sample.Bar   mainPackage.sub.sample.Bar

%d                                2006-10-20 14:06:49,812
%date                             2006-10-20 14:06:49,812
%date{ISO8601}                    2006-10-20 14:06:49,812
%date{HH:mm:ss.SSS}               14:06:49.812
%date{dd MMM yyyy;HH:mm:ss.SSS}   20 oct. 2006;14:06:49.812

 格式化修饰符，下面是一些修是%logger的例子：

修饰符	说明
%20logger	如果宽度不足20，左侧补空白
%-20logger	如果宽度不足20，右侧补空白
%.30logger	如果宽度超过30，从左侧截断
%.-30logger	如果宽度超过30，从右侧截断
%20.30logger	如果宽度不足20，左侧补空白；如果宽度超过30，从左侧截断

支持颜色代码：%black", "%red", "%green","%yellow","%blue", "%magenta","%cyan", "%white", "%gray", "%boldRed","%boldGreen", "%boldYellow", "%boldBlue", "%boldMagenta""%boldCyan", "%boldWhite" 和 "%highlight" 。

Pattern示例：

[%thread] %highlight(%-5level) %cyan(%logger{15}) - %msg %n
# 输出
[main] WARN  c.l.TrivialMain - a warning message 0
[main] DEBUG c.l.TrivialMain - hello world number1

ch.qos.logback.access.PatternLayout扩展了以下转换符：

编码器，负责将日志事件转换为字节数组，并写入到输出流。

JSON格式编码器，用于配合Logstash，示例：

<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
        <!-- 对输出的JSON进行格式化 -->
        <jsonGeneratorDecorator class="net.logstash.logback.decorate.PrettyPrintingJsonGeneratorDecorator"/>
        <!-- 时间输出为UNIX时间戳 -->
        <timestampPattern>[UNIX_TIMESTAMP_AS_NUMBER]</timestampPattern>
        <!-- 对字段进行重命名 -->
        <fieldNames>
            <timestamp>instant</timestamp>
            <logger>loggerName</logger>
            <thread>thread</thread>
            <stackTrace>thrown</stackTrace>
            <!-- 丢弃字段 -->
            <version>[ignore]</version>
            <levelValue>[ignore]</levelValue>
        </fieldNames>
    </encoder>
    <target>System.out</target>
</appender> 

当前版本可以和JDK7 + Tomcat 7.0.62配合使用：

1. 将logback-access.jar与logback-core.jar复制到$TOMCAT_HOME/lib/目录下 
2. 修改配置文件：
   

   <!-- 添加在Engine或Host元素内部 -->
   <!-- quiet进制打印默认的状态信息 -->
   <ValveclassName="ch.qos.logback.access.tomcat.LogbackValve" quiet="true" filename="logback-access.xml"/> 

3. logback默认会在$TOMCAT_HOME/conf下查找配置文件logback-access.xml，配置示例：

   <configuration>
     <statusListener class="ch.qos.logback.core.status.OnConsoleStatusListener" />  
     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
       <encoder>
         <pattern>%h %l %u %user %date "%r" %s %b</pattern>
       </encoder>
     </appender>
     <appender-ref ref="STDOUT" />
   </configuration>

重启Tomcat即可。

The post Logback学习笔记 appeared first on 绿色记忆.

参考：ElasticSearch学习笔记

Fluentd是一个C编写的开源的日志收集器，支持100+不同系统的日志收集处理。

定义Fluentd的输入，需要指定一个输入插件。例如：

<source>
  # 使用什么插件
  @type http
  # 你可以这样推送日志：http://localhost:8888/tag.name?json={...}
  port 8888
  bind 0.0.0.0
</source>

定义了一个HTTP输入。Fluentd会在8888端口上监听，等待外部传入事件。事件的例子：

curl -i -X POST -d 'json={"action":"login","user":2}' http://localhost:8888/test.cycle

source捕获到的Fluentd事件，交由Fluentd路由引擎处理。

多个filter可以构成事件处理流水线。使用filter你可以将不需要的事件过滤掉，不再继续下一步处理。例如：

<filter test.cycle>
  @type grep
  <exclude>
    key action
    pattern ^logout$
  </exclude>
</filter>

根据正则式匹配输入事件的action字段，如果匹配，路由给match处理，否则丢弃。

定义Fluentd的输出，并将匹配的事件传递给目标。例如：

<match test.cycle>
  @type stdout
</match>

会匹配具有Tag：test.cycle的输入事件，并传递给stdout这个输出插件。

用于定义一个可以被跳转到的路由片段，打破默认的从上到下的路由搜索顺序。该指令内部可以包含filter、match指令。示例：

<source>
  @type http
  bind 0.0.0.0
  port 8888
  # 指定路由标签
  @label @STAGING
</source>

<filter test.cycle>
</filter>

# http源直接跳转到这里，不使用上面的filter
<label @STAGING>
  <filter test.cycle>
    @type grep
    <exclude>
      key action
      pattern ^logout$
    </exclude>
  </filter>

  <match test.cycle>
    @type stdout
  </match>
</label>

可以位于source、match、filter指令的内部。对于那些支持的插件，用于解析原始数据。示例：

<source>
  @type tail
  # 输入插件的参数
  <parse>
    # 解析插件的类型
    @type apache2
    # 解析插件的参数
  </parse>
</source>

每个Parser都可以覆盖这些参数的值：

可以位于match指令的内部，指定如何对事件进行缓冲（避免对输出的目的地造成压力）。Fluentd内置了两种缓冲插件：memory、file。

使用buffer指令时，你也需要通过@type来指定插件类型。如果省略@type，则使用输出插件（match）指定的默认插件，或者使用memory。

你可以为buffer指定分块键：

# 为空，或者逗号分隔的字符串
<buffer ARGUMENT_CHUNK_KEYS>
</buffer>

分块键决定了事件被收集到哪个缓冲块：

1. 如果不指定分块键（并且输出插件也没有指定默认分块键），则输出插件将所有的事件都写到单个块中，直到此块充满
2. 如果分块键被设置为“tag”，则不同标签（Tag）的事件被收集到不同的缓冲块
3. 如果分块键被设置为“time”，且指定了timekey参数，则每个Time Key对应一个缓冲块：
   

   <buffer time>
     # 如果不指定单位，默认为秒
     timekey      1h # 每小时一个块
     timekey_wait 5m # 延迟5分钟刷出缓冲
   </buffer>

4. 如果分块键被设置为其它值，则认为是事件记录的字段名
5. 使用事件记录的嵌套字段也支持：

   <buffer $.nest.field> # 访问记录的nest.field字段

6. 联用多个分块键也支持：

   <buffer tag,time,$.nest.field>

某些输出插件，可以使用分块键作为变量：

<match log.*>
  @type file
  path  /data/${tag}/access.${key1}.${$.nest.field}.log # 输出文件名使用变量，不同块输出到不同文件
  <buffer tag,key1,$.nest.field>
  </buffer>
</match>

部分插件支持在内部包含format指令，用来指定如何对日志记录进行格式化。match、filter指令内部可以包含format指令：

<match tag.*>
  @type file
  <format>
    @type json
  </format>
</match>

内置的插件包括：out_file、json、ltsv、csv、msgpack、hash、single_value。下面的配置，将事件的log字段存储到文件：

<match **>
  @type file
  path  /var/log/kubernetes
  <format>
    @type single_value
    message_key log
  </format>
</match>

可以位于match、filter指令内部，向事件记录注入额外的字段。

可以位于source、match、filter指令内部，从事件记录中抽取值。

部分插件支持此指令，用于指定如何存储插件的内部状态。可以位于source、match、filter指令内部。

使用server插件助手的source、match、filter插件，支持在内部配置该指令。用于说明如何处理网络连接。

该指令用于包含其它配置文件

该指令用于进行系统级的配置，包括配置项：

每个Fluentd事件包含以下部分：

1. Tag：标签，用于说明事件的“来源”，用于事件路由。标签是点号（.）分隔的多个字符串
2. Time：事件发生的时间，必须是UNIX time格式
3. Record：实际的日志内容，JSON对象形式

标签（Tag）是日志事件的一种属性。filter、match指令可以指定一个匹配Pattern，来声明它负责处理哪些事件：

Fluentd根据配置文件中声明的顺序，自上而下的尝试匹配，一旦找到匹配日志事件的filter、match就不再继续。

如果通过td-agent包安装，则配置文件位置为/etc/td-agent/td-agent.conf。

如果通过Ruby Gem安装，则配置文件位置为/etc/fluent/fluent.conf。

要修改配置文件的位置，使用环境变量FLUENT_CONF，或者命令行选项 -c

任何一个Fluentd插件都暴露若干可配置参数。

["key1", "key2"]

key1,key2

{"key1":"value1", "key2":"value2"}

key1:value1,key2:value2

Fluentd定义了一系列以@开头的参数：

type, id 和 log_level是对应上面几个参数，向后兼容用。

你可以在字符串中包含

#{}

host_param "#{Socket.gethostname}"
env_param "foo-#{ENV["FOO_BAR"]}"

这是一个内置插件，不需要额外的安装步骤。该插件从目标配置文件的尾部开始读取新产生的日志。

# 仅仅读取default命名空间的日志
path /var/log/containers/*_default_*.log
# 日期
path /path/to/%Y/%m/%d/*

exclude_path ["/path/to/*.gz", "/path/to/*.zip"]

读取并解析Systemd日志。示例：

<source>
  @type systemd
  @id in_systemd_kubelet
  # 读取Kubelet.service的0-5级别的日志
  matches [{ "_SYSTEMD_UNIT": "kubelet.service", "PRIORITY": [0,1,2,3,4,5] }]
  <storage>
    @type local
    persistent true
    path /var/log/fluentd-journald-kubelet-cursor.json
  </storage>
  <entry>
    fields_strip_underscores true
  </entry>
  read_from_head false
  tag kubelet
</source>

支持以多种方式来修改事件。

<filter kubernetes.**>
  @type record_transformer
  enable_ruby
  <record>
    # 添加主机名
    hostname "#{Socket.gethostname}"
    # 将事件的标签存储为记录字段
    tag ${tag}
    # 读取事件标签的第2部分
    service_name ${tag_parts[1]}
    # 读取记录的字段并进行运算
    avg ${record["total"] / record["count"]}
    # 一个名为message的字段，使用$进行字符串插值
    message yay, ${record["message"]}
  </record>
</filter>

<filter kubernetes.**>
  @type record_transformer
  enable_ruby
  remove_keys [ "log" ]
  <record>
    # 从%-5p %d{yyyy-MM-dd HH:mm:ss.SSS} ::: [%15.15t] %-48.48c{36} ::: %m%n%ex
    # 形式的Logback Pattern中抽取字段
    level ${record["log"][0,5].strip}
    timestamp ${record["log"][6,23]}
    thread ${record["log"][35,15].strip}
    class  ${record["log"][52,49].strip}
    message ${record["log"][105..-1].strip}
  </record>
</filter>

# 将记录转换为JSON
${record.to_json}
# 格式化时间
${time.strftime('%Y-%m-%dT%H:%M:%S%z')}
# 取标签的最后一段
${tag_parts.last}
# 访问嵌套字段
${record["payload"]["key"]}

根据事件的字段进行过滤，不匹配的记录被丢弃。

参数	类型	说明
<and>	directive	内部指定几个其它指令，进行与操作： <and> <exclude> </exclude> <exclude> </exclude> </and>
<or>	directive	内部指定几个其它指令，进行或操作
<regexp>	directive	指定基于正则式的匹配规则，不匹配的事件会被排除： <regexp> # 检查的字段 key price # 匹配的正则式 pattern /[1-9]\d*/ </regexp>
<exclude>	directive	类似上面，但是匹配的事件会被排除

示例：

# 针对所有以calico-node开头的日志
<filter kubernetes.var.log.containers.calico-node-*.log>
  @type grep
  @id filter_grep_container_calico_node
  <regexp>
    # 针对日志记录的log字段
    key log
    # 仅仅保留警告、错误日志
    pattern ^.{25}(W|E)
  </regexp>
</filter>

# 仅仅保留具有标签tier=application的Pod产生的日志
<filter kubernetes.**>
  @type grep
  @id filter_grep_kubernetes
  <regexp>
    key $.kubernetes.labels.tier
    pattern ^application$
  </regexp>
</filter>

解析日志的字符串字段，并把事件记录替换为解析结果：

示例，解析ElasticSearch的JSON格式的日志，并把Wrapping Docker日志替换掉：

<filter kubernetes.var.log.containers.es-master-*.log>
  @type parser
  @id filter_parser_containers_es_master
  key_name log
  reserve_time true
  reserve_data true
  remove_key_name_field true
  <parse>
    @type json
    time_format %Y-%m-%dT%H:%M:%S.%NZ
  </parse>
</filter>

该插件非内置，执行

gem install fluent-plugin-concat

用于将多个日志事件合并为一个。具有工作三种模式：

1. n_lines 将连续的N个事件合并为一个
2. multiline_start_regexp ... 根据正则式匹配来确定该事件是否作为合并后的第一个、中间事件、最后一个
3. partial_key 取源事件中的某个字段，如果该字段的值为partial_value指定的值，则认为它应该合并到前面的事件

注意： 如果超时后仍然没有接收到被合并序例的的最后一个事件，则整个序列会被丢弃。

下面的示例用于处理被Docker的日志驱动按行收集的Java Logback日志信息，它会将日志中的异常栈合并到一起，然后与它们之前的（紧靠着的）那个事件合并：

<filter kubernetes.**>
  @type concat
  @log_level trace
  key log
  multiline_start_regexp /^(TRACE|DEBUG|INFO|WARN|ERROR|FATAL)/
  timeout_label @ES
</filter>

<match kubernetes.**>
  @type relabel
  @label @ES
</match>

<label @ES>
...
</label>

根据正则式来解析日志。指定的正则式至少需要指定一个命名捕获，命名捕获会作为记录的字段，名字为time的命名捕获，会作为事件的发生时间。

expression /^(?<time>.{30}) (?<stream>\w+) . (?<log>.*)$/ 

types <field_name_1>:<type_name_1>,<field_name_2>:<type_name_2>
# 示例
types user_id:integer,paid:bool,paid_usd_amount:float

regexp的多行版本，支持将多行日志合并为一个事件，特别适用于解析异常栈。

Java异常日志的例子：

<parse>
  @type multiline
  # 识别新记录的正则式
  format_firstline /\d{4}-\d{1,2}-\d{1,2}/
  # 解析完整记录的正则式
  format1 /^(?<time>\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}) \[(?<thread>.*)\] (?<level>[^\s]+)(?<message>.*)/
</parse>

# 第一个记录
2013-3-03 14:27:33 [main] INFO  Main - Start
# 第二个记录
2013-3-03 14:27:33 [main] ERROR Main - Exception
javax.management.RuntimeErrorException: null
    at Main.main(Main.java:16) ~[bin/:na]
# 第三个记录
2013-3-03 14:27:33 [main] INFO  Main - End

Rails日志的例子：

<parse>
  @type multiline
  # 识别新记录的正则式
  format_firstline /^Started/
  # 分为多个参数，每个参数对应一行日志信息
  format1 /Started (<method>[^ ]+) "(<path>[^"]+)" for (<host>[^ ]+) at (<time>[^ ]+ [^ ]+ [^ ]+)\n/
  format2 /Processing by (<controller>[^\u0023]+)\u0023(<controller_method>[^ ]+) as (<format>[^ ]+)\n/
  format3 /(  Parameters: (<parameters>[^ ]+)\n)/
  format4 /  Rendered (<template>[^ ]+) within (<layout>.+) \([\d\.]+ms\)\n/
  format5 /Completed (<code>[^ ]+) [^ ]+ in (<runtime>[\d\.]+)ms \(Views: (<view_runtime>[\d\.]+)ms \| ActiveRecord: (<ar_runtime>[\d\.]+)ms\)/
</parse>

# 第一个记录
Started GET "/users/123/" for 127.0.0.1 at 2013-06-14 12:00:11 +0900
Processing by UsersController#show as HTML
  Parameters: {"user_id"=>"123"}
  Rendered users/show.html.erb within layouts/application (0.3ms)
Completed 200 OK in 4ms (Views: 3.2ms | ActiveRecord: 0.0ms)

在Fluentd 1.0，允许三种输出插件的缓冲/刷出模式：

1. 无缓冲模式，直接写出到外部系统
2. 同步缓冲模式，使用缓冲块（事件集），缓冲块排队等候刷出。行为由buffer段控制
3. 异步缓冲模式，类似2，但是输出插件在后台异步的提交请求给外部系统

每个插件可以支持全部3种模式，也可以仅仅支持一种模式。如果对不支持缓冲的插件配置buffer段，fluentd会出错并终止。

该插件非内置，执行

gem install fluent-plugin-route

fluent-plugin-route支持修改标签，支持定义多个路由规则。可以实现事件复制分发：

<match worker.**>
  @type route
  # 修改标签前缀
  remove_tag_prefix worker
  add_tag_prefix metrics.event

  # 复制事件，走路由规则一
  <route **>
    copy # 不使用COPY会导致路由在此结束
  </route>
  # 复制事件，走路由规则二
  <route **>
    copy
    @label @BACKUP
  </route>
</match>

# 路由规则一
<match metrics.event.**>
  @type stdout
</match>

# 路由规则二
<label @BACKUP>
  <match metrics.event.**>
    @type file
    path /var/log/fluent/bakcup
  </match>
</label>

fluent-plugin-rewrite-tag-filter支持根据日志事件的内容来修改标签。示例：

<match app.**>
  @type rewrite_tag_filter
  # 根据内容的message字段，对齐进行正则式匹配，获取日志级别，捕获为$1，作为Tag的前缀
  rewriterule1 message ^\[(\w+)\] $1.${tag}
</match>

# 错误消息路由到这里
<match error.app.**>
  @type mail
</match>
# 其它消息路由到这里
<match *.app.**>
  @type file
</match>

将日志记录输出到ES中。插件参数：

#{logstash_prefix}-#{formated_date}

示例：

<match *.**>
  @type elasticsearch
  host 10.0.10.2
  port 9200
  user logstash_system
  password logstash_system
  logstash_format true
  logstash_prefix openstack
  enable_ilm true
  index_date_pattern "now/m{yyyy.mm}"
  flush_interval 10s
</match>

简单的丢弃事件，示例：

<match fluent.**>
    @type null
</match>

将日志写入到Kafka主题中。

执行下面的命令安装此插件：

fluent-gem install fluent-plugin-kafka

配置示例：

<match pattern>
  @type kafka_buffered

  # 种子代理列表
  brokers <broker1_host>:<broker1_port>,<broker2_host>:<broker2_port>

  # 缓冲设置
  buffer_type file
  buffer_path /var/log/td-agent/buffer/td
  flush_interval 3s

  # Kafka主题
  default_topic messages

  # 数据类型设置
  output_data_type json
  compression_codec gzip

  # 生产者配置
  max_send_retries 1
  required_acks -1

</match>

此插件用于给事件重新打标签，例如：

<match pattern>
  @type relabel
  @label @foo
</match>

<label @foo>
  <match pattern>
    ...
  </match>
</label>

会给Tag匹配pattern的事件全部打上@foo标签，这些事件会全部交由名为@foo的label区段处理。

将事件写入到文件。不是记录写入后立即就生成文件，只有time_slice_format条件满足时文件才生成，默认情况下该插件每天生成一个文件。

插件参数：

# append false
log.20140608_0.log
log.20140608_1.log
log.20140609_0.log
log.20140609_1.log

# append true
log.20140608.log
log.20140609.log 

一个实例：

<label @K8S_OUT_FILE>
  <match **>
    @type file
    # 目录 %Y-%m-%d.%H.${$.kubernetes.labels.application} 中会存放缓冲文件，每小时（3600）刷出
    # 文件名称示意 2018-11-14.17.account.log.gz，  log.gz自动添加，不需要在path中声明
    path  /var/log/kubernetes/%Y-%m-%d.%H.${$.kubernetes.labels.application}
    append true
    # 压缩文件可以这样浏览：gzip -dc 2018-11-14.17.account.log.gz  | grep ERROR
    compress gzip
    <buffer time,$.kubernetes.labels.application>
      timekey 3600
      timekey_wait 10
      timekey_zone +0800
    </buffer>
    <format>
      @type single_value
      message_key log
    </format>
  </match>
</label> 

为了保证节点的时间戳精确，你需要安装NTP守护程序，例如chrony、ntpd。

文件描述符数量：

root soft nofile 65536
root hard nofile 65536
* soft nofile 65536
* hard nofile 65536

对于高负载、多个Fluentd的环境，需要修改网络参数：

net.core.somaxconn = 1024
net.core.netdev_max_backlog = 5000
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216relabel
net.ipv4.tcp_wmem = 4096 12582912 16777216
net.ipv4.tcp_rmem = 4096 12582912 16777216
net.ipv4.tcp_max_syn_backlog = 8096
net.ipv4.tcp_slow_start_after_idle = 0
net.ipv4.tcp_tw_reuse = 1

重启或者

sysctl -p

如果日志的目的地是远程设备、存储，可以使用该选项来并行化输出（默认1）。使用多线程可以缓和网络延迟的影响。

所有输出插件支持该参数。

Ruby提供了若干GC参数，你可以通过环境变量来设置它们。

要减少内存占用，可以设置RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR为较小的值，此参数默认值2.0。资源受限环境下可以设置为1.2-

处理10亿级别的日志输入时，CPU会出现瓶颈，这时考虑增加工作进程数量：

<system>
  workers 8
</system>

Kibana是一个开源的分析和可视化平台，必须配合ES一起使用。可以使用Kibana来检索、分析ES索引中的数据，日志分析是最常用的应用场景。

用于交互式的日志查询，使用Lucene查询语法：

Visualize用于设计一个小器件，例如饼图、曲线图。Dashboard则可以将小器件组合为仪表盘。

这里以曲线图为例，点击曲线图的图标，首先要选择数据源，也就是索引。点选fluentd-*索引，看到如下界面：

点击顶部的Add a filter，可以添加过滤条件。

Metrics区域用于定义统计指标（度量），支持多个度量。

Buckets区域用于指定如何分组展示，示例：

可以选取在“可视化“中定义的小器件，并拖拽以布局，效果示例：

首页是总体状态信息，包括ES、Kibana的健康状态，已用/可用的各类硬件资源信息：

如果Elasticsearch的健康状态为red，则说明集群存在问题。截图中的情况是主分片尚未分配到节点导致。

点击上图Elasticsearch区域的Overview连接，可以看到ES集群更多的信息：

本页面显示ES的读（检索）、写（索引）性能指标，包括QPS和延迟。

Shard Activity通常是空的，上图中的情况是正在应用事务日志到ES数据节点。Translog是一种写前日志，记录所有针对ES的写操作。

此页面显示索引的列表，如果有红色说明索引存在问题。下图中第一个索引有一个分片不正常。

每个索引包含的文档数量、占用的磁盘空间、读写速率也显示在页面上。

该页面显示单个索引文档数量、占用的磁盘空间、读写速率随时间的变化曲线，以及索引各分片的状态。

上图中，es-data-0分配了序号为4的分片，并且此分片正在初始化。其它分配均正常。

捆绑了X-pack的ElasticSearch镜像：https://git.gmem.cc/alex/docker-elasticsearch

ElasticSearch+Kibana的Helm Chart：https://git.gmem.cc/alex/oss-charts/src/branch/master/elasticsearch

Fluentd的Helm Chart：https://git.gmem.cc/alex/oss-charts/src/branch/master/fluentd

iotop看到fluentd进程有高达200M/s的读操作，但是定位不到针对的是什么文件

使用csysdig跟踪进程系统调用，发现大量内存映射操作，针对/var/log/journal/4f2be1039e944e028f2e86e02fe410e1目录，删除目录后问题消失。

设置Kibana的环境变量XPACK_MONITORING_UI_CONTAINER_ELASTICSEARCH_ENABLED为false 

The post 基于EFK构建日志分析系统 appeared first on 绿色记忆.

Apache Log4j 2是Log4j的重大升级， 引入了Logback包含的大量改进，并修复了Logback架构中某些内在的问题。Log4j2的特性包括：

1. API和实现分离：接口更加稳定
2. 性能提升：使用基于LMAX Disruptor库的异步日志机制。在多线程应用中，异步日志比Log4j、Logback有更低数量级的延迟时间，以及18倍的吞吐量
3. 支持多种API：包括Log4j、SLF4J、Commons Logging 、java.util.logging
4. 方便切换到其它日志实现：由于log4j-to-slf4j的存在，你可以随时切换使用别的日志库
5. 配置自动重新载入：类似于Logback，当配置文件修改后，Log4j2能够自动重新载入。比Logback更好的时，不会因此丢失日志
6. 高级过滤：类似于Logback，Log4j2支持基于上下文数据、Marker、正则式、或者其它日志事件中的组件进行过滤。过滤可以在日志事件传递给Logger之前、传递给Appender之前生效。Loggers可以和过滤器关联
7. 支持Property：你可以在配置文件中使用属性，进行动态解析
8. Lambda支持：Log4j2支持Java8的Lambda，并且在日志级别不匹配的情况下不会主动解析Lambda，因而能提升性能
9. 不产生内存垃圾：可以减轻JVM垃圾回收器的压力

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

// 获取日志记录器对象
Logger logger = LogManager.getLogger("HelloWorld");

// 参数替换
logger.debug("Logging in user {} with birthday {}", user.getName(), user.getBirthday());
// 参数数量没有限制
logger.debug( "Batch {} item {} : {}", batchId, i + 1, names );

// 参数格式化，语法类似于Java的Formatter
Logger logger = LogManager.getFormatterLogger("HelloWorld");
logger.debug("Logging in user %s with birthday %s", user.getName(), user.getBirthday());
// 混合使用日志记录器、格式化日志记录器：
Logger logger = LogManager.getLogger("HelloWorld");
logger.printf(Level.INFO, "Logging in user %1$s with birthday %2$tm", user.getName(), user.getBirthday());

// 使用Lambda实现延迟日志
// 立即执行expensiveOperation
if (logger.isTraceEnabled()) {
    logger.trace("Some long-running operation returned {}", expensiveOperation());
}
// 仅仅在必要时才执行expensiveOperation
logger.trace("Some long-running operation returned {}", () -> expensiveOperation());

日志框架的一个主要目的是，仅仅在需要的时候生成调试和诊断信息。并允许对信息进行过滤，避免加重系统负担或者难以阅读。Log4j2使用标记（Markers）实现满足这种需求：

Logger logger = LogManager.getLogger(HelloWorld.class.getName());
// 定义一个Marker
Marker SQL_MARKER = MarkerManager.getMarker("SQL");
// Marker可以形成树状层次
Marker UPDATE_MARKER = MarkerManager.getMarker("SQL_UPDATE").setParents(SQL_MARKER);
Marker QUERY_MARKER = MarkerManager.getMarker("SQL_QUERY").setParents(SQL_MARKER);

// 使用Marker
logger.debug(QUERY_MARKER, "SELECT * FROM {}", table);
logger.debug(UPDATE_MARKER, "UPDATE {} SET {}", table, formatCols());

上面的代码配合MarkerFilters即可实现仅仅对SQL更新操作记录日志，或者记录所有SQL操作日志，或者记录全部应用日志。

使用Marker时，要注意以下规则：

1. Marker必须是独特唯一的，起名字时要注意，名字是不是已经被依赖项使用了。当然，你特地要使用同样名字也是可以的
2. 父Marker可以被动态的添加、移除。但是这种操作比较昂贵
3. 具有多级祖先的Marker解析起来比较消耗资源 

Logger类提供了一些方法，方便你跟踪应用程序的执行路径。这些方法会产生从其它调试日志中单独过滤掉的日志事件。你可以使用这些方法来：

1. 在开发阶段辅助问题诊断，而不需要单步调试
2. 在运维阶段辅助问题诊断，如果单步调试不可用
3.  帮助新用户理解应用程序的行为

流程跟踪的主要方法是

entry()

traceEntry()

exit()

traceExit()

此外，

throwing()

catching()

示例代码：

logger.traceEntry(new JsonMessage(messages));
logger.traceExit();
try {...} catch (Exception ex) {
    logger.catching(ex);
} 

对Log4j2的配置可以通过四种方式之一完成：

1. 配置文件，支持的格式包括XML、JSON、YAML、Properties
2. 编程式配置，创建ConfigurationFactory和Configuration实现类
3. 编程式配置，调用Configuration接口暴露的API，对默认实现添加组件
4. 编程式配置，调用Logger暴露的接口

Log4j2能够在初始化时进行自动配置，它会定位到所有ConfigurationFactory并根据权重值对它们排序。开箱即用的ConfigurationFactory实现有4种，分别处理XML、JSON、YAML、Properties格式的配置文件。具体配置步骤如下：

1. 检查系统属性log4j.configurationFile，如果该属性存在，会尝试利用ConfigurationFactory加载匹配扩展名的文件
2. 如果没有上述属性，尝试加载类路径下的log4j2-test.propertie
3. 如果没有上述文件，尝试加载类路径下的log4j2-test.yaml或者log4j2-test.yml
4. 如果没有上述文件，尝试加载类路径下的log4j2-test.json或者log4j2-test.jsn
5. 如果没有上述文件，尝试加载类路径下的log4j2-test.xml
6. 如果没有上述文件，一次尝试加载log4j2.*版本（没有-test后缀）的配置文件
7. 如果找不到任何配置文件，使用DefaultConfiguration。此配置直接打印日志到stdout

此配置行为如下：

1. 根日志级别为ERROR
2. 将ConsoleAppender附加到根日志记录器
3. 将PatternLayout：

   %d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n

   附加到ConsoleAppender

以XML形式表示默认配置：

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
  <Appenders>
    <Console name="Console" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    </Console>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="Console"/>
    </Root>
  </Loggers>
</Configuration>

<?xml version="1.0" encoding="UTF-8"?>;
<Configuration>
  <Properties>
    <Property name="name1">value</property>
    <Property name="name2" value="value2"/>
  </Properties>
  <Filter type="type" ... />
  <Appenders>
    <Appender type="type" name="name">
      <Filter type="type" ... />
    </Appender>
    ...
  </Appenders>
  <Loggers>
    <Logger name="name1">
      <Filter type="type" ... />
    </Logger>
    ...
    <Root level="level">
      <AppenderRef ref="name"/>
    </Root>
  </Loggers>
</Configuration>

<?xml version="1.0" encoding="UTF-8"?>
<!--
    status Log4j2内部事件的日志级别
    strict 是否使用严格XML格式
    name 配置的名称
    packages 此哪些包中加载插件，逗号分隔多个包
    monitorInterval  检查配置文件变更的间隔，单位秒，如果发现变更则重新加载配置
-->
<Configuration status="debug" strict="true" name="XMLConfigTest" monitorInterval="10" packages="org.apache.logging.log4j.test">
    <!-- 定义属性，属性可以在后续使用${} 引用 -->
    <!--
        Log4j2支持很多预定义的上下文属性对象。可以通过 ${prefix:name} 语法引用
        bundle：资源束对象，用法示例 ${bundle:BundleName:BundleKey}
        ctx：线程上下文映射（Thread Context Map，MDC）
        date：当前时间或者日期
        env：系统环境变量
        jndi：JNDI上下文
        jvmrunargs：JVM参数
        sys：系统属性
    -->
    <Properties>
        <Property name="filename">target/test.log</Property>
    </Properties>
    <!--
        过滤器可以出现在四种地方：
        1、全局级别，可以在日志事件传递给日志记录器（LoggerConfig）之前接受/拒绝它
        2、logger元素内部，针对单个日志记录器
        3、appender元素内部，针对单个Appender
        4、AppenderRef元素内部，针对日志记录器+Appender的组合
    -->
    <!-- 全局过滤器 -->
    <Filter type="ThresholdFilter" level="trace"/>

    <!-- Appender负责向外输出日志内容 -->
    <Appenders>
        <!-- 基于控制台输出 -->
        <Appender type="Console" name="STDOUT">
            <!-- 日志输出格式 -->
            <Layout type="PatternLayout" pattern="%m MDC%X%n"/>
            <!-- 针对Appender的过滤器 -->
            <Filters>
                <!-- 如果日志事件使用标记FLOW，则拒绝输出日志 -->
                <Filter type="MarkerFilter" marker="FLOW" onMatch="DENY" onMismatch="NEUTRAL"/>
                <Filter type="MarkerFilter" marker="EXCEPTION" onMatch="DENY" onMismatch="ACCEPT"/>
            </Filters>
        </Appender>
        <Appender type="Console" name="FLOW">
            <!--
                日志格式（布局），支持的布局：
                CSV布局，包括子类CsvParameterLayout、CsvLogEventLayout
                GELF布局，将JSON压缩为GZIP/ZLIB格式
                HTML布局，生成HTML页面
                JSON布局，生成一系列JSON字符串
                Pattern布局，自定义格式对LogEvent进行格式化
                RFC5424布局
                Syslog布局，格式化为BSD Syslog记录
                XML布局
                YAML布局
            -->
            <Layout type="PatternLayout" pattern="%C{1}.%M %m %ex%n"/>
            <Filters>
                <Filter type="MarkerFilter" marker="FLOW" onMatch="ACCEPT" onMismatch="NEUTRAL"/>
                <Filter type="MarkerFilter" marker="EXCEPTION" onMatch="ACCEPT" onMismatch="DENY"/>
            </Filters>
        </Appender>
        <!-- 基于文件输出 -->
        <Appender type="File" name="File" fileName="${filename}">
            <Layout type="PatternLayout">
                <Pattern>%d %p %C{1.} [%t] %m%n</Pattern>
            </Layout>
        </Appender>
    </Appenders>
    <!-- 日志记录器 -->
    <Loggers>
        <!--
            level 此日志记录器最低输出级别，大小写不敏感
                  支持TRACE, DEBUG, INFO, WARN, ERROR, ALL, OFF。默认ERROR
            additivity：false表示日志事件被此记录器处理过后，不会传递给父记录器再次处理
        -->
        <Logger name="org.apache.logging.log4j.test1" level="debug" additivity="false">
            <!-- 针对日志记录器的过滤器 -->
            <Filter type="ThreadContextMapFilter">
                <KeyValuePair key="test" value="123"/>
            </Filter>
            <!-- 日志记录器关联哪个Appender -->
            <AppenderRef ref="STDOUT"/>
        </Logger>

        <Logger name="org.apache.logging.log4j.test2" level="debug" additivity="false">
            <AppenderRef ref="File"/>
        </Logger>
        <!-- 根记录器，每个配置都必须有一个根记录器 -->
        <Root level="trace">
            <AppenderRef ref="STDOUT"/>
        </Root>
    </Loggers>

</Configuration>

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-yaml</artifactId>
    <version>2.5.0</version>
</dependency> 

和XML配置的结构大体对应：

Configuration:
  status: warn
  name: YAMLConfigTest
  properties:
    property:
      name: filename
      value: target/test-yaml.log
  thresholdFilter:
    level: debug
  appenders:
    Console:
      name: STDOUT
      PatternLayout:
        Pattern: "%m%n"
    File:
      name: File
      fileName: ${filename}
      PatternLayout:
        Pattern: "%d %p %C{1.} [%t] %m%n"
      Filters:
        ThresholdFilter:
          level: error
 
  Loggers:
    logger:
      -
        name: org.apache.logging.log4j.test1
        level: debug
        additivity: false
        ThreadContextMapFilter:
          KeyValuePair:
            key: test
            value: 123
        AppenderRef:
          ref: STDOUT
      -
        name: org.apache.logging.log4j.test2
        level: debug
        additivity: false
        AppenderRef:
          ref: File
    Root:
      level: error
      AppenderRef:
        ref: STDOUT 

下面的配置参考Spring Boot的输出格式：

Configuration:
  name: development
  monitorInterval: 5
  thresholdFilter:
    level: trace
  appenders:
    Console:
      name: stdout
      PatternLayout:
        # %d{yyyy-MM-dd HH:mm:ss.SSS} %highlight{%-5p} %style{%t}{Magenta} %style{%c{1.}.%M}{Cyan}(%F:%L)%n%m%n
        Pattern: "%d{yyyy-MM-dd HH:mm:ss.SSS} %highlight{%5p} ${hostName} --- [%15.15t] %-40.40c{1.} : %m%n%ex"
  Loggers:
    logger:
      -
        name: cc.gmem.study.log4j2
        level: debug
        additivity: false
        AppenderRef:
          ref: stdout
    Root:
      level: error
      AppenderRef:
        ref: stdout

这是最常用的Layout，本节详细讨论它。

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.5.0</version>
</dependency> 

配置示例（请使用最新版本的Log4j2）：

status = error

appender.console.type = Console
appender.console.name = console
appender.console.layout.type = JsonLayout
appender.console.layout.charset = UTF-8
appender.console.layout.compact=false
appender.console.layout.eventEol=true
appender.console.layout.locationInfo=false
appender.console.layout.stacktraceAsString=true

rootLogger.level = info
rootLogger.appenderRef.console.ref = console 

可以使用KeyValuePair指定额外的输出字段：

<JsonLayout>
  <!-- 常量值-->
  <KeyValuePair key="additionalField1" value="constant value"/>
  <!-- 访问上下文变量 -->
  <KeyValuePair key="additionalField2" value="$${ctx:key}"/>
  <!-- 输出当前时间 -->
  <KeyValuePair key="timestamp" value="$${date:yyyy-MM-dd'T'HH:mm:ss.SSSZ}" />
</JsonLayout>

在启用安全管理器的情况下，你需要进行如下授权：

grant {
  permission java.lang.RuntimePermission "accessDeclaredMembers";
  permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
};

Maven依赖配置如下：

<!-- 使用Log4J2-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.8.2</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.8.2</version>
</dependency>
<!-- 让commons logging使用Log4j2 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-jcl</artifactId>
    <version>2.8.2</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.21</version>
</dependency>
<!-- 让Slf4j使用Log4j2 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.8.2</version>
</dependency> 

The post Log4J2学习笔记 appeared first on 绿色记忆.

spdlog是基于C++ 11的日志组件，它非常轻量，使用时你仅仅需要引入头文件就可以了。

名字空间

spdlog::

void spdlog::set_pattern(const std::string&);
void spdlog::set_formatter(formatter_ptr);
void spdlog::set_error_handler(log_err_handler);

日志器对象的大部分方法也是线程安全的，除了：

void spdlog::logger::set_pattern(const std::string&);
void spdlog::logger::set_formatter(formatter_ptr);
void spdlog::set_error_handler(log_err_handler);

所有以_mt结尾的SINK都是线程安全的，以_st结尾的则不是。 

#include "spdlog/spdlog.h"
#include <iostream>

// 多线程的基于控制台（stdout）的日志记录器，支持高亮。类似的stdout_color_st是单线程版本
auto console = spdlog::stdout_color_mt( "console" );
// 基于文件的简单日志
auto logger = spdlog::basic_logger_mt("basic_logger", "logs/basic.txt");
// 基于滚动文件的日志，每个文件5MB，三个文件
auto logger = spdlog::rotating_logger_mt("file_logger", "myfilename", 1024 * 1024 * 5, 3);

// 定制输出格式
spdlog::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");

// 多个日志器共享SINK
auto daily_sink = std::make_shared<spdlog::sinks::daily_file_sink_mt>("logfile", 23, 59);
// 下面几个同步日志器共享的输出到目标文件
auto net_logger = std::make_shared<spdlog::logger>("net", daily_sink);
auto hw_logger = std::make_shared<spdlog::logger>("hw", daily_sink);
auto db_logger = std::make_shared<spdlog::logger>("db", daily_sink); 

// 一个日志器使用多个SINK
std::vector<spdlog::sink_ptr> sinks;
sinks.push_back( std::make_shared<spdlog::sinks::stdout_sink_st>());
sinks.push_back( std::make_shared<spdlog::sinks::daily_file_sink_st>( "logfile", 23, 59 ));
auto combined_logger = std::make_shared<spdlog::logger>( "name", begin( sinks ), end( sinks ));
spdlog::register_logger( combined_logger );

// 异步
// 每个日志器分配8192长度的队列，队列长度必须2的幂
spdlog::set_async_mode(8192); 
// 程序退出前清理
spdlog::drop_all();

// 注册日志器
spdlog::register_logger(net_logger);
// 注册后，其它代码可以根据名称获得日志器
auto logger = spdlog::get(net_logger);

// 记录日志
// 设置最低级别
console->set_level(spdlog::level::debug);
console->debug("Hello World") ;
// 使用占位符
console->info("Hello {}" ,"World"); 
// 带格式化的占位符：d整数，x十六进制，o八进制，b二进制                
console->warn("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42);
// 带格式化的占位符：f浮点数
console->info("Support for floats {:03.2f}", 1.23456);
// 左对齐，保证30字符宽度
console->error("{:<30}", "left aligned");
// 指定占位符位置序号
console->info("Positional args are {1} {0}..", "too", "supported");

// 记录自定义类型，需要重载<<操作符
#include <spdlog/fmt/ostr.h> 
class Duck{}
std::ostream& operator<<(std::ostream& os, const Duck& duck){ 
    return os << duck.getName(); 
}
Duck duck;
console->info("custom class with operator<<: {}..", duck);

spdlog默认的输出格式为：

[2014-31-10 23:46:59.678] [info] [my_loggername] Some message

要定制输出格式，可以调用：

spdlog::set_pattern(pattern_string);
// 示例
spdlog::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");

或者实现自己的格式化器：

spdlog::set_formatter(std::make_shared<my_custom_formatter>());

输出格式的Pattern中可以有若干

%

The post C++日志组件spdlog appeared first on 绿色记忆.

在进行数据库开发时，我们经常需要监测SQL语句的执行情况，一般的手工编码记录、Hibernate日志记录，有如下的缺点：

1. 人工记录太麻烦，需要写很多日志记录语句
2. 无法获取PreparedStatement的传入参数，只能显示为"?"

log4jdbc这个小组件，恰恰解决了这些问题，其官网地址为：log4jdbc网站
该组件具有针对jdbc3、jdbc4的不同版本，如果你使用JDK1.4、1.5，可以使用log4jdbc3，使用JDK1.6以上，可以使用log4jdbc4。同时，log4jdbc需要日志记录框架的支持，建议使用SLF4J和Log4j的组合。

#标准的JDBC URL
mysql://192.168.0.201:3306/gmem
#使用log4jdbc时的URL
jdbc:log4jdbc:mysql://192.168.0.201:3306/gmem

#标准的JDBC驱动类名
com.mysql.jdbc.Driver
#使用log4jdbc时的驱动类名
net.sf.log4jdbc.DriverSpy

#下面的配置仅仅记录ERROR级别的日志，开发时可以适当改为DEBUG
#只记录执行的SQL语句，PreparedStatement的输入参数自动替换“?”
log4j.logger.jdbc.sqlonly=ERROR
#记录执行的SQL语句，并统计其消耗时间
log4j.logger.jdbc.sqltiming=ERROR
#记录所有JDBC的调用（针对ResultSet的除外）
log4j.logger.jdbc.audit=ERROR
#记录针对ResultSet的所用JDBC调用
log4j.logger.jdbc.resultset=ERROR
#记录数据库连接的打开和关闭，可以用于监控连接泄漏
log4j.logger.jdbc.connection=ERROR

我针对1.2版本（1.2-ext-3），进行了一些简单的扩展，其特性如下：

1. 支持基于Hibernate或者sqlinform的SQL语句格式化，增强可读性
2. 支持stacktracefilterincludes、stacktracefilterexcludes等log4jdbc.properties配置项，以便从调用栈里包含、清除包含某些字符的行，防止各种字节码框架生成的类干扰调试

log4jdbc.dump.sql.select=true
log4jdbc.dump.sql.insert=true
log4jdbc.dump.sql.update=true
log4jdbc.dump.sql.delete=true
log4jdbc.dump.sql.create=true

#是否格式化SQL语句
log4jdbc.dump.formatsql=true
#是否显示完整的调用堆栈
log4jdbc.dump.fulldebugstacktrace=true
#仅包含commons或者demo的调用栈的行，才会被记录
log4jdbc.dump.stacktracefilterincludes=commons,demo
#包含$、_的调用栈的行，一定被排除，即使符合stacktracefilterincludes
log4jdbc.dump.stacktracefilterexcludes=$,_

<dependency>
    <groupId>com.sqlinform</groupId>
    <artifactId>sqlinform</artifactId>
    <version>0.0.1</version>
    <optional>true</optional>
</dependency>

The post 使用log4jdbc记录SQL语句的执行情况 appeared first on 绿色记忆.

#include <log4cplus/logger.h>
#include <log4cplus/configurator.h>
#include <log4cplus/helpers/loglog.h>

using namespace std;
using namespace log4cplus;

const char* LOG4CPLUS_CONFIG_FILE = "log4cplus.properties";
try
{
    log4cplus::PropertyConfigurator::doConfigure( LOG4CPLUS_CONFIG_FILE );
}
catch ( std::runtime_error& e )
{
    std::cout << "Failed to initialize log4cplus with config file: " << LOG4CPLUS_CONFIG_FILE << " due to: " << e.what() << endl;
}

Logger logger = Logger::getRoot();
LOG4CPLUS_DEBUG(logger, "Hello " << "World");

log4cplus.rootLogger=DEBUG, Console, File
log4cplus.logger.AmqCppClient=DEBUG


log4cplus.appender.Console=log4cplus::ConsoleAppender
log4cplus.appender.Console.layout=log4cplus::PatternLayout
log4cplus.appender.Console.layout.ConversionPattern=[%-5p] [%t] %d (%F:%L) %n%m%n

log4cplus.appender.File=log4cplus::RollingFileAppender
log4cplus.appender.File.File=F:/Temp/amq-cpp-client.log
log4cplus.appender.File.MaxFileSize=5MB
log4cplus.appender.File.MaxBackupIndex=5
log4cplus.appender.Console.layout=log4cplus::PatternLayout
log4cplus.appender.Console.layout.ConversionPattern=[%-5p] [%t] %d (%F:%L) %n%m%n

The post 日志组件Log4cplus的使用 appeared first on 绿色记忆.

log4j.rootLogger=INFO, Console,File
log4j.logger.cc.gmem.demo=INFO

log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%-5p] [%t] %d{yyyy-MM-dd HH:mm:ss} %l%n%m%n

log4j.appender.File=org.apache.log4j.RollingFileAppender
log4j.appender.File.File=c:/logs/demo.log
log4j.appender.File.Append=true
log4j.appender.File.Threshold=ERROR
log4j.appender.File.MaxFileSize=256MB
log4j.appender.File.MaxBackupIndex=100
log4j.appender.File.layout=org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern=[%-5p] [%t] %d{yyyy-MM-dd HH:mm:ss} %l%n%m%n

依赖于该项目：https://git.gmem.cc/alex/log4j-json-layout

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

    <appender name="console" class="org.apache.log4j.ConsoleAppender">
        <param name="Target" value="System.out"/>
        <layout class="org.jetbrains.appenders.JsonLayout">
            <param name="excludedFields" value="host,@version" />
        </layout>
    </appender>

    <category name="cc.gmem">
        <priority value="debug"/>
    </category>
    <root>
        <priority value="info"/>
        <appender-ref ref="console"/>
    </root>

</log4j:configuration>

The post log4j配置文件样本 appeared first on 绿色记忆.