开发一个二方包，优雅地为系统接入ELK（elasticsearch+logstash+kibana） ...

小秦哥  金牌会员 | 2023-4-4 14:33:57 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 648|帖子 648|积分 1944

去年公司由于不断发展，内部自研系统越来越多，所以后来搭建了一个日志收集平台，并将日志收集功能以二方包形式引入各个自研系统，避免每个自研系统都要建立一套自己的日志模块，节约了开发时间，管理起来也更加容易。
这篇文章主要介绍如何编写二方包，并整合到各个系统中。
先介绍整个ELK日志平台的架构。其中xiaobawang-log就是今天的主角。

xiaobawang-log主要收集三种日志类型：


  • 系统级别日志： 收集系统运行时产生的各个级别的日志（ERROR、INFO、WARN、DEBUG和TRACER），其中ERROR级别日志是我们最关心的。
  • 用户请求日志： 主要用于controller层的请求，捕获用户请求信息和响应信息、以及来源ip等，便于分析用户行为。
  • 自定义操作日志： 顾名思义，就是收集手动打的日志。比如定时器执行开始，都会习惯性写一个log.info("定时器执行开始！")的描述，这种就是属于自定义操作日志的类型。
二方包开发

先看目录结构

废话不多说，上代码。
1、首先创建一个springboot项目，引入如下包：
  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>net.logstash.logback</groupId>
  7.     <artifactId>logstash-logback-encoder</artifactId>
  8.     <version>7.0.1</version>
  9. </dependency>
  10. <dependency>
  11.     <groupId>ch.qos.logback</groupId>
  12.     <artifactId>logback-core</artifactId>
  13.     <version>1.2.10</version>
  14. </dependency>
  15. <dependency>
  16.     <groupId>ch.qos.logback</groupId>
  17.     <artifactId>logback-classic</artifactId>
  18.     <version>1.2.10</version>
  19. </dependency>
  20. <dependency>
  21.     <groupId>ch.qos.logback</groupId>
  22.     <artifactId>logback-access</artifactId>
  23.     <version>1.2.10</version>
  24. </dependency>
  25. <dependency>
  26.     <groupId>cn.hutool</groupId>
  27.     <artifactId>hutool-all</artifactId>
  28.     <version>5.7.18</version>
  29. </dependency>
  30. <dependency>
  31.     <groupId>org.projectlombok</groupId>
  32.     <artifactId>lombok</artifactId>
  33.     <optional>true</optional>
  34.     <version>1.18.26</version>
  35. </dependency>
  36. <dependency>
  37.     <groupId>org.springframework.boot</groupId>
  38.     <artifactId>spring-boot-starter-aop</artifactId>
  39. </dependency>
复制代码
SysLog实体类
  1. public class SysLog {
  3.     /**
  4.      * 日志名称
  5.      */
  6.     private String logName;
  8.     /**
  9.      * ip地址
  10.      */
  11.     private String ip;
  13.     /**
  14.      * 请求参数
  15.      */
  16.     private String requestParams;
  18.     /**
  19.      * 请求地址
  20.      */
  21.     private String requestUrl;
  23.     /**
  24.      * 用户ua信息
  25.      */
  26.     private String userAgent;
  28.     /**
  29.      * 请求时间
  30.      */
  31.     private Long useTime;
  33.     /**
  34.      * 请求时间
  35.      */
  36.     private String exceptionInfo;
  38.     /**
  39.      * 响应信息
  40.      */
  41.     private String responseInfo;
  43.     /**
  44.      * 用户名称
  45.      */
  46.     private String username;
  48.     /**
  49.      * 请求方式
  50.      */
  51.     private String requestMethod;
  53. }
复制代码
LogAction

创建一个枚举类，包含三种日志类型。
  1. public enum LogAction {
  3.     USER_ACTION("用户日志", "user-action"),
  4.     SYS_ACTION("系统日志", "sys-action"),
  5.     CUSTON_ACTION("其他日志", "custom-action");
  7.     private final String action;
  9.     private final String actionName;
  11.     LogAction(String action,String actionName) {
  12.         this.action = action;
  13.         this.actionName = actionName;
  14.     }
  16.     public String getAction() {
  17.         return action;
  18.     }
  20.     public String getActionName() {
  21.         return actionName;
  22.     }
  24. }
复制代码
配置logstash

更改logstash配置文件，将index名称更改为log-%{[appname]}-%{+YYYY.MM.dd}-%{[action]}，其中appname为系统名称，action为日志类型。
整个es索引名称是以“系统名称+日期+日志类型”的形式。比如“mySystem-2023.03.05-system-action”表示这个索引，是由mySystem在2023年3月5日产生的系统级别的日志。
  1. # 输入端
  2. input {
  3.   stdin { }
  4.   #为logstash增加tcp输入口，后面springboot接入会用到
  5.   tcp {
  6.       mode => "server"
  7.       host => "0.0.0.0"
  8.       port => 5043
  9.       codec => json_lines
  10.   }
  11. }
  13. #输出端
  14. output {
  15.   stdout {
  16.     codec => rubydebug
  17.   }
  18.   elasticsearch {
  19.     hosts => ["http://你的虚拟机ip地址:9200"]
  20.     # 输出至elasticsearch中的自定义index名称
  21.     index => "log-%{[appname]}-%{+YYYY.MM.dd}-%{[action]}"
  22.   }
  23.   stdout { codec => rubydebug }
  24. }
复制代码
AppenderBuilder

使用编程式配置logback，AppenderBuilder用于创建appender。

  • 这里会创建两种appender。consoleAppender负责将日志打印到控制台，这对开发来说是十分有用的。而LogstashTcpSocketAppender则负责将日志保存到ELK中。
  • setCustomFields中的参数，对应上面logstash配置文件的参数[appname]和[action]。
  1. @Component
  2. public class AppenderBuilder {
  4.     public static final String SOCKET_ADDRESS = "你的虚拟机ip地址";
  6.     public static final Integer PORT = 5043;//logstash tcp输入端口
  8.     /**
  9.      * logstash通信Appender
  10.      * @param name
  11.      * @param action
  12.      * @param level
  13.      * @return
  14.      */
  15.     public LogstashTcpSocketAppender logAppenderBuild(String name, String action, Level level) {
  16.         LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
  17.         LogstashTcpSocketAppender appender = new LogstashTcpSocketAppender();
  18.         appender.setContext(context);
  19.         //设置logstash通信地址
  20.         InetSocketAddress inetSocketAddress = new InetSocketAddress(SOCKET_ADDRESS, PORT);
  21.         appender.addDestinations(inetSocketAddress);
  22.         LogstashEncoder logstashEncoder = new LogstashEncoder();
  23.         //对应前面logstash配置文件里的参数
  24.         logstashEncoder.setCustomFields("{"appname":"" + name + "","action":"" + action + ""}");
  25.         appender.setEncoder(logstashEncoder);
  27.         //这里设置级别过滤器
  28.         LevelFilter levelFilter = new LevelFilter();
  29.         levelFilter.setLevel(level);
  30.         levelFilter.setOnMatch(ACCEPT);
  31.         levelFilter.setOnMismatch(DENY);
  32.         levelFilter.start();
  33.         appender.addFilter(levelFilter);
  34.         appender.start();
  36.         return appender;
  37.     }
  38.    
  39.    
  40.     /**
  41.      * 控制打印Appender
  42.      * @return
  43.      */
  44.     public ConsoleAppender consoleAppenderBuild() {
  45.         ConsoleAppender consoleAppender = new ConsoleAppender();
  46.         LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
  47.         PatternLayoutEncoder encoder = new PatternLayoutEncoder();
  48.         encoder.setContext(context);
  49.         //设置格式
  50.         encoder.setPattern("%red(%d{yyyy-MM-dd HH:mm:ss}) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger) - %cyan(%msg%n)");
  51.         encoder.start();
  52.         consoleAppender.setEncoder(encoder);
  53.         consoleAppender.start();
  54.         return consoleAppender;
  56.     }
复制代码
LoggerBuilder

LoggerBuilder主要用于创建logger类。创建步骤如下：

  • 获取logger上下文。
  • 从上下文获取logger对象。创建过的logger会保存在LOGCONTAINER中，保证下次获取logger不会重复创建。这里使用ConcurrentHashMap防止出现并发问题。
  • 创建appender，并将appender加入logger对象中。
  1. @Component
  2. public class LoggerBuilder {
  3.     @Autowired
  4.     AppenderBuilder appenderBuilder;
  6.     @Value("${spring.application.name:unknow-system}")
  7.     private String appName;
  9.     private static final Map<String, Logger> LOGCONTAINER = new ConcurrentHashMap<>();
  11.     public Logger getLogger(LogAction logAction) {
  12.         Logger logger = LOGCONTAINER.get(logAction.getActionName() + "-" + appName);
  13.         if (logger != null) {
  14.             return logger;
  15.         }
  16.         logger = build(logAction);
  17.         LOGCONTAINER.put(logAction.getActionName() + "-" + appName, logger);
  19.         return logger;
  20.     }
  22.     public Logger getLogger() {
  23.         return getLogger(LogAction.CUSTON_ACTION);
  24.     }
  26.     private Logger build(LogAction logAction) {
  27.         //创建日志appender
  28.         List<LogstashTcpSocketAppender> list = createAppender(appName, logAction.getActionName());
  29.         LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
  30.         Logger logger = context.getLogger(logAction.getActionName() + "-" + appName);
  31.         logger.setAdditive(false);
  32.         //打印控制台appender
  33.         ConsoleAppender consoleAppender = appenderBuilder.consoleAppenderBuild();
  34.         logger.addAppender(consoleAppender);
  35.         list.forEach(appender -> {
  36.             logger.addAppender(appender);
  37.         });
  38.         return logger;
  39.     }
  41.     /**
  42.      * LoggerContext上下文中的日志对象加入appender
  43.      */
  44.     public void addContextAppender() {
  45.         //创建四种类型日志
  46.         String action = LogAction.SYS_ACTION.getActionName();
  47.         List<LogstashTcpSocketAppender> list = createAppender(appName, action);
  48.         LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
  49.         //打印控制台
  50.         ConsoleAppender consoleAppender = appenderBuilder.consoleAppenderBuild();
  51.         context.getLoggerList().forEach(logger -> {
  52.             logger.setAdditive(false);
  53.             logger.addAppender(consoleAppender);
  54.             list.forEach(appender -> {
  55.                 logger.addAppender(appender);
  56.             });
  57.         });
  58.     }
  60.     /**
  61.      * 创建连接elk的appender，每一种级别日志创建一个appender
  62.      *
  63.      * @param name
  64.      * @param action
  65.      * @return
  66.      */
  67.     public List<LogstashTcpSocketAppender> createAppender(String name, String action) {
  68.         List<LogstashTcpSocketAppender> list = new ArrayList<>();
  69.         LogstashTcpSocketAppender errorAppender = appenderBuilder.logAppenderBuild(name, action, Level.ERROR);
  70.         LogstashTcpSocketAppender infoAppender = appenderBuilder.logAppenderBuild(name, action, Level.INFO);
  71.         LogstashTcpSocketAppender warnAppender = appenderBuilder.logAppenderBuild(name, action, Level.WARN);
  72.         LogstashTcpSocketAppender debugAppender = appenderBuilder.logAppenderBuild(name, action, Level.DEBUG);
  73.         LogstashTcpSocketAppender traceAppender = appenderBuilder.logAppenderBuild(name, action, Level.TRACE);
  74.         list.add(errorAppender);
  75.         list.add(infoAppender);
  76.         list.add(warnAppender);
  77.         list.add(debugAppender);
  78.         list.add(traceAppender);
  79.         return list;
  80.     }
  81. }
复制代码
LogAspect

使用spring aop，实现拦截用户请求，记录用户日志。比如ip、请求参数、请求用户等信息，需要配合下面的XiaoBaWangLog注解使用。
这里拦截上面所说的第二种日志类型。
  1. @Aspect
  2. @Component
  3. public class LogAspect {
  5.     @Autowired
  6.     LoggerBuilder loggerBuilder;
  8.     private ThreadLocal<Long> startTime = new ThreadLocal<>();
  10.     private SysLog sysLog;
  12.     @Pointcut("@annotation(com.xiaobawang.common.log.annotation.XiaoBaWangLog)")
  13.     public void pointcut() {
  14.     }
  16.     /**
  17.      * 前置方法执行
  18.      *
  19.      * @param joinPoint
  20.      */
  21.     @Before("pointcut()")
  22.     public void before(JoinPoint joinPoint) {
  23.         startTime.set(System.currentTimeMillis());
  24.         //获取请求的request
  25.         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
  26.         HttpServletRequest request = attributes.getRequest();
  27.         String clientIP = ServletUtil.getClientIP(request, null);
  28.         if ("0.0.0.0".equals(clientIP) || "0:0:0:0:0:0:0:1".equals(clientIP) || "localhost".equals(clientIP) || "127.0.0.1".equals(clientIP)) {
  29.             clientIP = "127.0.0.1";
  30.         }
  31.         sysLog = new SysLog();
  32.         sysLog.setIp(clientIP);
  33.         String requestParams = JSONUtil.toJsonStr(getRequestParams(request));
  34.         sysLog.setRequestParams(requestParams.length() > 5000 ? ("请求参数过长，参数长度为：" + requestParams.length()) : requestParams);
  35.         MethodSignature ms = (MethodSignature) joinPoint.getSignature();
  36.         Method method = ms.getMethod();
  37.         String logName = method.getAnnotation(XiaoBaWangLog.class).value();
  38.         sysLog.setLogName(logName);
  39.         sysLog.setUserAgent(request.getHeader("User-Agent"));
  40.         String fullUrl = request.getRequestURL().toString();
  41.         if (request.getQueryString() != null && !"".equals(request.getQueryString())) {
  42.             fullUrl = request.getRequestURL().toString() + "?" + request.getQueryString();
  43.         }
  44.         sysLog.setRequestUrl(fullUrl);
  45.         sysLog.setRequestMethod(request.getMethod());
  46.         //tkSysLog.setUsername(JwtUtils.getUsername());
  47.     }
  49.     /**
  50.      * 方法返回后执行
  51.      *
  52.      * @param ret
  53.      */
  54.     @AfterReturning(returning = "ret", pointcut = "pointcut()")
  55.     public void after(Object ret) {
  56.         Logger logger = loggerBuilder.getLogger(LogAction.USER_ACTION);
  57.         String retJsonStr = JSONUtil.toJsonStr(ret);
  58.         if (retJsonStr != null) {
  59.             sysLog.setResponseInfo(retJsonStr.length() > 5000 ? ("响应参数过长，参数长度为：" + retJsonStr.length()) : retJsonStr);
  60.         }
  61.         sysLog.setUseTime(System.currentTimeMillis() - startTime.get());
  62.         logger.info(JSONUtil.toJsonStr(sysLog));
  63.     }
  65.     /**
  66.      * 环绕通知,收集方法执行期间的错误信息
  67.      *
  68.      * @param proceedingJoinPoint
  69.      * @return
  70.      * @throws Throwable
  71.      */
  72.     @Around("pointcut()")
  73.     public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  75.         try {
  76.             Object obj = proceedingJoinPoint.proceed();
  77.             return obj;
  78.         } catch (Exception e) {
  79.             e.printStackTrace();
  80.             sysLog.setExceptionInfo(e.getMessage());
  81.             Logger logger = loggerBuilder.getLogger(LogAction.USER_ACTION);
  82.             logger.error(JSONUtil.toJsonStr(sysLog));
  83.             throw e;
  84.         }
  85.     }
  87.     /**
  88.      * 获取请求的参数
  89.      *
  90.      * @param request
  91.      * @return
  92.      */
  93.     private Map getRequestParams(HttpServletRequest request) {
  94.         Map map = new HashMap();
  95.         Enumeration paramNames = request.getParameterNames();
  96.         while (paramNames.hasMoreElements()) {
  97.             String paramName = (String) paramNames.nextElement();
  98.             String[] paramValues = request.getParameterValues(paramName);
  99.             if (paramValues.length == 1) {
  100.                 String paramValue = paramValues[0];
  101.                 if (paramValue.length() != 0) {
  102.                     map.put(paramName, paramValue);
  103.                 }
  104.             }
  105.         }
  106.         return map;
  107.     }
  110. }
复制代码
XiaoBaWangLog

LoggerLoad主要是实现用户级别日志的收集功能。
这里定义了一个注解，在controller方法上加上@XiaoBaWangLog("操作内容"),即可拦截并生成请求日志。
  1. @Target({ElementType.TYPE, ElementType.METHOD})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Component
  5. public @interface XiaoBaWangLog {
  7.     String value() default "";
  9. }
复制代码
LoggerLoad

LoggerLoad主要是实现系统级别日志的收集功能。
继承ApplicationRunner，可以在springboot执行后，自动创建系统级别日志logger对象。
  1. @Component
  2. @Order(value = 1)
  3. @Slf4j
  4. public class LoggerLoad implements ApplicationRunner {
  5.     @Autowired
  6.     LoggerBuilder loggerBuilder;
  8.     @Override
  9.     public void run(ApplicationArguments args) throws Exception {
  10.         loggerBuilder.addContextAppender();
  11.         log.info("加载日志模块成功");
  12.     }
  13. }
复制代码
LogConfig

LogConfig主要实现自定义级别日志的收集功能。
生成一个logger对象交给spring容器管理。后面直接从容器取就可以了。
  1. @Configuration
  2. public class LogConfig {
  4.     @Autowired
  5.     LoggerBuilder loggerBuilder;
  7.     @Bean
  8.     public Logger loggerBean(){
  9.         return loggerBuilder.getLogger();
  10.     }
  11. }
复制代码
代码到现在已经全部完成，怎么将上述的所有Bean加入到spring呢？这个时候就需要用到spring.factories了。
spring.factories

在EnableAutoConfiguration中加入类的全路径名,在项目启动的时候，SpringFactoriesLoader会初始化spring.factories，包括pom中引入的jar包中的配置类。
注意，spring.factories在2.7开始已经不推荐使用，3.X版本的springBoot是不支持使用的。
  1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  2.   com.xiaobawang.common.log.config.AppenderBuilder,\
  3.   com.xiaobawang.common.log.config.LoggerBuilder,\
  4.   com.xiaobawang.common.log.load.LoggerLoad,\
  5.   com.xiaobawang.common.log.aspect.LogAspect,\
  6.   com.xiaobawang.common.log.config.LogConfig
复制代码
测试

先将xiaobawang进行打包
新建一个springboot项目，引入打包好的xiaobawang-log.

运行springboot，出现“加载日志模块成功”表示日志模块启动成功。
接着新建一个controller请求

访问请求后，可以看到了三种不同类型的索引了

结束

还有很多需要优化的地方，比如ELK设置用户名密码登录等，对ELK比较了解的童鞋可以自己尝试优化！
如果这篇文章对你有帮助，记得一键三连~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

小秦哥

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表