Flume 自定义拦截器 多行读取日志+截断

前言：

　　Flume百度定义如下：

Flume是Cloudera提供的一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的系统，Flume支持在日志系统中定制各类数据发送方，用于收集数据；同时，Flume提供对数据进行简单处理，并写到各种数据接受方（可定制）的能力。

搭建并使用flume不是特别难，而且网上也有技术文章分享，我不再赘述了。本文主要建立在已经搭建并使用flume的情况。

业务场景：

flume读取日志是按行读取，无法进行多行读取，当出现如下日志时将无法读到日志的正确时间与类型信息,所以我们需要有一种可以多行读取日志信息的办法,这里采用自定义拦截器的方法：

1 2019-08-02 14:34:13.153 [DEBUG][tomcatThreadPool-7][com.xxx.xxx.xxx.xxx.web.CommonHandlerExceptionResolver] (CommonHandlerExceptionResolver.java:134) \n Exception:------------------------------------------------------------------\ncom.xxx.xxx.xx.exceptions.XxxException: \n### Error querying database.  Cause: com.mysql.jdbc.PacketTooBigException: Packet for query is too large (5638500 > 4194304). You can change this value on the server by setting the max_allowed_packet' variable.\n### The error may exist in com/xxx/xxx/xxx/basic/mapper/custom/CsWmFrtRateExtMapper.xml\n### The error may involve defaultParameterMap\n### The error occurred while setting parameters\n### SQL: SELECT * FROM ((SELECT cwfr.CS_WM_FRT_RATE_ID AS CS_WM_FRT_RATE_ID, cwfr.ACTIVE_DATE_BEGIN AS ACTIVE_DATE_BEGIN, cwfr.FRT_ITEM_CODE AS FRT_ITEM_CODE, cwfr.FRT_ITEM_NAME AS FRT_ITEM_NAME, cwfr.RP_FLAG AS RP_FLAG, cwfr.FRT_MODE AS FRT_MODE, cwfr.CALCULATION_ITEM AS CALCULATION_ITEM, cwfr.CHARGE_UOM_CODE AS CHARGE_UOM_CODE, cwfr.CHARGE_UOM_NAME AS 

对于一些业务系统的日志可能会比较大，超1M，2M甚至更多，可以根据实际情况只截取前面一部分保留下来即可，为了让功能更具有灵活性，在实现上增加开关属性，默认打开着，不需要时设置关闭。

自定义拦截器实现的属性：过滤正则，截断标识(即开关)，总截取最大长度，单个截取最大长度，最后一个事件流。最后一个事件流的作用保留下来与下一批次一起，按正则匹配后才发送出去，因为flume是按批次读取的，默认是100行，而这个配置又与flume运行内存有关系。这个是属于参数调优的话题。

特别注意：代码打包后是需要放到flume安装目录下的lib下。放进去后需要重新才会生效。

代码实现如下：

 package org.apache.flume.custom;

 import com.google.common.collect.Lists;
 import org.apache.commons.codec.Charsets;
 import org.apache.flume.Context;
 import org.apache.flume.Event;
 import org.apache.flume.interceptor.Interceptor;

 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 /**
  * 自定义拦截器 参考 Author: xiufen.huang Create Data: 2019/8/12 15:46
  */
 public class MultInterceptor implements Interceptor {

     // 过滤正则
     private static Pattern regex = null;
     // 截取标志
     private static Boolean cutFlag = true;
     // 总截取最大长度
     private static Integer cutMax = null;
     // 单个截取最大长度
     private static Integer singleCut = null;
     // 最后一个事件流
     private static List<Event> lastList = Lists.newArrayList();

     @Override
     public void initialize() {

     }

     @Override
     public Event intercept(Event event) {
 //        System.out.println("----------intercept(Event event)方法执行，处理单个event");
         return event;
     }

     @Override
     public List<Event> intercept(List<Event> list) {
 //        System.out.println("进来方法了吗？");

         // 处理结果 event list
         List<Event> intercepted = null;

         int addnum = 0;// 记录上一个正确匹配的event在队列中的位置,以便下一event有和它连接的需要

         if (lastList != null && lastList.size() >0){
             // 初始化
             int initCapacity = list.size() + lastList.size();
             intercepted = Lists.newArrayListWithCapacity(initCapacity);
             // 添加
             intercepted.addAll(lastList);

             // 清空
             lastList = Lists.newArrayList();
         }else {
             intercepted = Lists.newArrayListWithCapacity(list.size());
         }

         // 有正则的情况
         for (int i = 0; i < list.size(); i++) {
             Event interceptedEvent  = null;
             Matcher matcher = regex.matcher(new String(list.get(i).getBody(), Charsets.UTF_8));
             if (matcher.find()) {
                 interceptedEvent = intercept((Event)list.get(i));
                 // 单个的body
                 String singleBody = new String(interceptedEvent.getBody(), Charsets.UTF_8);
                 int singleBodyLen = singleBody.length();
                 System.out.println("正则匹配-原始body---------:" + singleBody);
                 if (cutFlag) {
                     // 处理最大截取数边界条件--一定要重新一个变量接收
                     int lsSingleCut = singleCut > singleBodyLen ? singleBodyLen : singleCut;
                     // 截取字符串--新变量
                     String singleCutBody = new String(singleBody.substring(0, lsSingleCut));

                     System.out.println("单个截取-截取后body=============:" + singleCutBody);
                     // 重新赋值body
                     interceptedEvent.setBody(singleCutBody.getBytes());
                 }

                 intercepted.add(interceptedEvent);
                 addnum = addnum +1;
 //                System.out.println("matcher.find() 下的：addnum：" + addnum);
             } else {
                 if (intercepted.size() == 0) {
                     // 表示本次没有匹配上
                     continue;
                 }

                  addnum = addnum >= intercepted.size() ? intercepted.size() - 1 : addnum;

                 String body = new String(intercepted.get(addnum).getBody(), Charsets.UTF_8) + "\n"
                         + new String(list.get(i).getBody(), Charsets.UTF_8);

                 System.out.println("总截取-原始body---------:" + body);
                 int bodyLen = body.length();
                 // 截取body-新变量
                 String cutBody = body;
                 if (cutFlag) {

                     // 处理最大截取数边界条件--新变量
                     int lsCutMax = cutMax > bodyLen ? bodyLen : cutMax;
                     // 截取字符串
                     cutBody = new String(body.substring(0, lsCutMax));
                     System.out.println("-处理截取-截取后body=============: " + body);
                 }

                 intercepted.get(addnum).setBody(cutBody.getBytes());
             }
         }

         // 最后一个保存在静态变量，等待下一批次
         if (intercepted != null && intercepted.size() > 0){
             int lastIndex = intercepted.size() -1;
             lastList.add(intercepted.get(lastIndex));
             // 移除最后一个索引
             intercepted.remove(lastIndex);
         }

         return intercepted;
     }

     @Override
     public void close() {
         System.out.println("----------自定义拦截器close方法执行");
     }

     public static class Builder implements Interceptor.Builder {
         @Override
         public Interceptor build() {
             System.out.println("----------build方法执行");
             return new MultInterceptor();
         }

         @Override
         public void configure(Context context) {
             String regexStr = context.getString("regex", null);
             cutFlag = context.getBoolean("cutFlag", true);
             cutMax = context.getInteger("cutMax", 0);
             singleCut = context.getInteger("singleCut", 0);
             System.out.println("参数regexStr：" + regexStr + ",参数cutMax： " + cutMax + ",cutFlag: " + cutFlag
                     + " ,singleCut: " + singleCut);

             // 由于外面传过来的单位是kb，所以这边需要乘以1024
             cutMax = cutMax * 1024;
             System.out.println("总截取最大值：" + cutMax);
             singleCut = singleCut * 1024;
             System.out.println("单个截取最大值：" + singleCut);

             if (null != regexStr) {
                 // 转换正则
                 regex = Pattern.compile(regexStr);
             }

         }
     }
 }

使用说明：

在flume启动配置文件增加以下内容：

#匹配时间并转换为时间戳到header中
a1.sources.tail.interceptors.i2.type=org.apache.flume.custom.MultInterceptor$Builder
#正则表达式，按需求定
a1.sources.tail.interceptors.i2.regex=(((?!0000)[0-9]{4}-((0[1-9]|1[0-2])-(0[1-9]|1[0-9]|2[0-8])|(0[13-9]|1[0-2])-(29|30)|(0[13578]|1[02])-31)|([0-9]{2}(0[48]|[2468][048]|[13579][26])|(0[48]|[2468][048]|[13579][26])00)-02-29))
#开启日志长度截取标志，默认true，开启
a1.sources.tail.interceptors.i2.cutFlag = true
#最大截取字符串长度,整数,尽量控制在2M以内，单位：kb，1M=1024
a1.sources.tail.interceptors.i2.cutMax = 2048
#单个截取字符串长度，整数，尽量控制在1.5M以内，单位：kb,1M=1024
a1.sources.tail.interceptors.i2.singleCut=1024
a1.sources.tail.interceptors.i2.serializers=se1
a1.sources.tail.interceptors.i2.serializers.se1.type=org.apache.flume.interceptor.RegexExtractorInterceptorMillisSerializer
a1.sources.tail.interceptors.i2.serializers.se1.name=timestamp
a1.sources.tail.interceptors.i2.serializers.se1.pattern=yyyy-MM-dd

参考实现：

flume 自定义拦截器实现多行读取日志 https://blog.csdn.net/nougats/article/details/71188920