【玩转Kafka】海量日志收集实战之架构介绍与日志输出

最新推荐文章于 2024-04-20 22:54:18 发布
最新推荐文章于 2024-04-20 22:54:18 发布
阅读量2.2k 收藏 3
点赞数 2
分类专栏： kafka 文章标签： 实时大数据 kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45455361/article/details/121569100
版权

海量日志收集实战

话不多说，看架构图：
在这里插入图片描述
最左侧，是Beats，它主要是用于收集日志的，比如这个Filebeat它的底层是用erlang语言写的，性能非常好，其实我们的系统中打印出来的日志，都会用这个Filebeat给我们抓取出来。
在我们这个架构中，Filebeat的主要作用就是把我们的日志搜集出来并转储到Kafka。

然后看Kafka的右边，是Logstash，它主要是用日志做一个过滤，然后它会把你过滤后的数据发送到Elasticsearch里。

最后利用Kibana进行展示。

接下来，我们就来说一下我们要做的事情，先看下这张图：
在这里插入图片描述
我们这了采用的是Log4j2，为什么不采用SpringBoot默认集成的logback？
这是因为Log4j2性能会更好一些，因为它的底层是基于无锁并行框架Disruptor做的，关于Disruptor大家可以看看这篇文章《java高阶编程之无锁并行计算框架——Disruptor初识》，当然，它想要发挥出威力还是有一定前提的，就是要求你配置一定要高，因为Disruptor比较耗内存和CPU，所以你想要日志收集的更实时，那对应的你应用服务的性能和配置也要高一些，并且也要经过一些压测。

这里我们看一下图中两个粉色的app.log与error.log，这里我们把它分成两个对应的log日志文件，app.log在这里我们可以存储一个全量的log日志，也就是说无论我们的业务打什么样级别的日志，都会存储到app.log里。然后error.log，只要出现异常就会存储在error.log里。这样的的目的主要是用于我们后续做一些告警和分析，所以我们后续的一些告警会通过对这个error.log做一些手段，比如定时任务做定时抓取。

最后，我们把这些日志通过filebeat抓取出来，转储到Kafka中，然后Kafka收到消息后，他对应的消费者也就是Logstash，它得到消息后在发送给Elasticsearch。

以上就是这个架构的整体设计。

日志输出

我们直接开拔，打开Idea，每天coding十小时，健康工作一百年。

首先引入依赖：

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/>
    </parent>
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.4</version>
        </dependency>
    </dependencies>

工具类：
这是Dubbo底层用到的一个工具类，可以拿来直接使用。

public class NetUtil {

    public static String normalizeAddress(String address) {
        String[] blocks = address.split("[:]");
        if (blocks.length > 2) {
            throw new IllegalArgumentException(address + " is invalid");
        }
        String host = blocks[0];
        int port = 80;
        if (blocks.length > 1) {
            port = Integer.valueOf(blocks[1]);
        } else {
            address += ":" + port; //use default 80
        }
        String serverAddr = String.format("%s:%d", host, port);
        return serverAddr;
    }

    public static String getLocalAddress(String address) {
        String[] blocks = address.split("[:]");
        if (blocks.length != 2) {
            throw new IllegalArgumentException(address + " is invalid address");
        }
        String host = blocks[0];
        int port = Integer.valueOf(blocks[1]);

        if ("0.0.0.0".equals(host)) {
            return String.format("%s:%d", NetUtil.getLocalIp(), port);
        }
        return address;
    }

    private static int matchedIndex(String ip, String[] prefix) {
        for (int i = 0; i < prefix.length; i++) {
            String p = prefix[i];
            if ("*".equals(p)) { //*, assumed to be IP
                if (ip.startsWith("127.") ||
                        ip.startsWith("10.") ||
                        ip.startsWith("172.") ||
                        ip.startsWith("192.")) {
                    continue;
                }
                return i;
            } else {
                if (ip.startsWith(p)) {
                    return i;
                }
            }
        }

        return -1;
    }

    public static String getLocalIp(String ipPreference) {
        if (ipPreference == null) {
            ipPreference = "*>10>172>192>127";
        }
        String[] prefix = ipPreference.split("[> ]+");
        try {
            Pattern pattern = Pattern.compile("[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+");
            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
            String matchedIp = null;
            int matchedIdx = -1;
            while (interfaces.hasMoreElements()) {
                NetworkInterface ni = interfaces.nextElement();
                Enumeration<InetAddress> en = ni.getInetAddresses();
                while (en.hasMoreElements()) {
                    InetAddress addr = en.nextElement();
                    String ip = addr.getHostAddress();
                    Matcher matcher = pattern.matcher(ip);
                    if (matcher.matches()) {
                        int idx = matchedIndex(ip, prefix);
                        if (idx == -1) continue;
                        if (matchedIdx == -1) {
                            matchedIdx = idx;
                            matchedIp = ip;
                        } else {
                            if (matchedIdx > idx) {
                                matchedIdx = idx;
                                matchedIp = ip;
                            }
                        }
                    }
                }
            }
            if (matchedIp != null) return matchedIp;
            return "127.0.0.1";
        } catch (Exception e) {
            return "127.0.0.1";
        }
    }

    public static String getLocalIp() {
        return getLocalIp("*>10>172>192>127");
    }

    public static String remoteAddress(SocketChannel channel) {
        SocketAddress addr = channel.socket().getRemoteSocketAddress();
        String res = String.format("%s", addr);
        return res;
    }

    public static String localAddress(SocketChannel channel) {
        SocketAddress addr = channel.socket().getLocalSocketAddress();
        String res = String.format("%s", addr);
        return addr == null ? res : res.substring(1);
    }

    public static String getPid() {
        RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
        String name = runtime.getName();
        int index = name.indexOf("@");
        if (index != -1) {
            return name.substring(0, index);
        }
        return null;
    }

    public static String getLocalHostName() {
        try {
            return (InetAddress.getLocalHost()).getHostName();
        } catch (UnknownHostException uhe) {
            String host = uhe.getMessage();
            if (host != null) {
                int colon = host.indexOf(':');
                if (colon > 0) {
                    return host.substring(0, colon);
                }
            }
            return "UnknownHost";
        }
    }
}

这个是FastJson通用的工具类：

public class FastJsonConvertUtil {

    private static final SerializerFeature[] featuresWithNullValue = { SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullBooleanAsFalse,
            SerializerFeature.WriteNullListAsEmpty, SerializerFeature.WriteNullNumberAsZero, SerializerFeature.WriteNullStringAsEmpty };

    /**
     * <B>方法名称：</B>将JSON字符串转换为实体对象<BR>
     * <B>概要说明：</B>将JSON字符串转换为实体对象<BR>
     * @param data JSON字符串
     * @param clzss 转换对象
     * @return T
     */
    public static <T> T convertJSONToObject(String data, Class<T> clzss) {
        try {
            T t = JSON.parseObject(data, clzss);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * <B>方法名称：</B>将JSONObject对象转换为实体对象<BR>
     * <B>概要说明：</B>将JSONObject对象转换为实体对象<BR>
     * @param data JSONObject对象
     * @param clzss 转换对象
     * @return T
     */
    public static <T> T convertJSONToObject(JSONObject data, Class<T> clzss) {
        try {
            T t = JSONObject.toJavaObject(data, clzss);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * <B>方法名称：</B>将JSON字符串数组转为List集合对象<BR>
     * <B>概要说明：</B>将JSON字符串数组转为List集合对象<BR>
     * @param data JSON字符串数组
     * @param clzss 转换对象
     * @return List<T>集合对象
     */
    public static <T> List<T> convertJSONToArray(String data, Class<T> clzss) {
        try {
            List<T> t = JSON.parseArray(data, clzss);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * <B>方法名称：</B>将List<JSONObject>转为List集合对象<BR>
     * <B>概要说明：</B>将List<JSONObject>转为List集合对象<BR>
     * @param data List<JSONObject>
     * @param clzss 转换对象
     * @return List<T>集合对象
     */
    public static <T> List<T> convertJSONToArray(List<JSONObject> data, Class<T> clzss) {
        try {
            List<T> t = new ArrayList<T>();
            for (JSONObject jsonObject : data) {
                t.add(convertJSONToObject(jsonObject, clzss));
            }
            return t;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * <B>方法名称：</B>将对象转为JSON字符串<BR>
     * <B>概要说明：</B>将对象转为JSON字符串<BR>
     * @param obj 任意对象
     * @return JSON字符串
     */
    public static String convertObjectToJSON(Object obj) {
        try {
            String text = JSON.toJSONString(obj);
            return text;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * <B>方法名称：</B>将对象转为JSONObject对象<BR>
     * <B>概要说明：</B>将对象转为JSONObject对象<BR>
     * @param obj 任意对象
     * @return JSONObject对象
     */
    public static JSONObject convertObjectToJSONObject(Object obj){
        try {
            JSONObject jsonObject = (JSONObject) JSONObject.toJSON(obj);
            return jsonObject;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * <B>方法名称：</B><BR>
     * <B>概要说明：</B><BR>
     * @param obj
     * @return
     */
    public static String convertObjectToJSONWithNullValue(Object obj) {
        try {
            String text = JSON.toJSONString(obj, featuresWithNullValue);
            return text;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

然后，我们再写一个工具类：

@Componet
public class InputMDC implements EnvironmentAware {

    private static Environment environment;
    @Override
    public void setEnvironment(Environment environment) {
        InputMDC.environment = environment;
    }

    public static void putMDC() {
        MDC.put("hostName",NetUtil.getLocalHostName());
        MDC.put("ip",NetUtil.getLocalIp());
        MDC.put("applicationName",environment.getProperty("spring.application.name"));
    }
}

创建Controller:

@Slf4j
@RestController
public class IndexController {

    @RequestMapping(value = "/index")
    public String index(){
        InputMDC.putMDC();
        log.info("我是一个info级别日志");
        log.warn("我是一个warn级别日志");
        log.error("我是一个error级别日志");
        return "idx";
    }
}

创建application.yml：

server:
  servlet:
    context-path: /
  port: 8001

spring:
  application:
    name: log-collector
  http:
    encoding:
      charset: UTF-8
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
    default-property-inclusion: NON_NULL

创建log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="INFO" schema="Log4J-V2.0.xsd" monitorInterval="600" >
    <Properties>
        <Property name="LOG_HOME">logs</Property>
        <property name="FILE_NAME">collector</property>
        <property name="patternLayout">[%d{yyyy-MM-dd'T'HH:mm:ss.SSSZZ}] [%level{length=5}] [%thread-%tid] [%logger] [%X{hostName}] [%X{ip}] [%X{applicationName}] [%F,%L,%C,%M] [%m] ## '%ex'%n</property>
    </Properties>
    <Appenders>
        <Console name="CONSOLE" target="SYSTEM_OUT">
            <PatternLayout pattern="${patternLayout}"/>
        </Console>  
        <RollingRandomAccessFile name="appAppender" fileName="${LOG_HOME}/app-${FILE_NAME}.log" filePattern="${LOG_HOME}/app-${FILE_NAME}-%d{yyyy-MM-dd}-%i.log" >
          <PatternLayout pattern="${patternLayout}" />
          <Policies>
              <TimeBasedTriggeringPolicy interval="1"/>
              <SizeBasedTriggeringPolicy size="500MB"/>
          </Policies>
          <DefaultRolloverStrategy max="20"/>         
        </RollingRandomAccessFile>
        <RollingRandomAccessFile name="errorAppender" fileName="${LOG_HOME}/error-${FILE_NAME}.log" filePattern="${LOG_HOME}/error-${FILE_NAME}-%d{yyyy-MM-dd}-%i.log" >
          <PatternLayout pattern="${patternLayout}" />
          <Filters>
              <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
          </Filters>              
          <Policies>
              <TimeBasedTriggeringPolicy interval="1"/>
              <SizeBasedTriggeringPolicy size="500MB"/>
          </Policies>
          <DefaultRolloverStrategy max="20"/>         
        </RollingRandomAccessFile>            
    </Appenders>
    <Loggers>
        <!-- 业务相关 异步logger -->
        <AsyncLogger name="com.wcl.*" level="info" includeLocation="true">
          <AppenderRef ref="appAppender"/>
        </AsyncLogger>
        <AsyncLogger name="com.wcl.*" level="info" includeLocation="true">
          <AppenderRef ref="errorAppender"/>
        </AsyncLogger>       
        <Root level="info">
            <Appender-Ref ref="CONSOLE"/>
            <Appender-Ref ref="appAppender"/>
            <AppenderRef ref="errorAppender"/>
        </Root>         
    </Loggers>
</Configuration>

我们这里重点关注一下这个AsyncLogger，它这里就是底层使用了Disruptor，我们可以进到源码里看看：
在这里插入图片描述
点进去：
在这里插入图片描述
不难发现，它的log4j2的底层确实是采用了Disruptor，大家可以打个断点看看，这里就不详细探讨了。

项目结构：
在这里插入图片描述
我们启动一下项目，查看控制台：
在这里插入图片描述
可以看到，我们的控制台没有任何错误信息，说明已经正常启动起来了。

并且项目下多出来一个logs目录：
在这里插入图片描述

我们访问localhost:8001/index，在查看控制台

在这里插入图片描述
可以看到，我们想要的一些信息也通过InputMDC拿到了。

然后，我们人为制造一个异常：
在这里插入图片描述
访问后查看控制台：
在这里插入图片描述
并且我们也能在错误日志中看到这个错误信息：
在这里插入图片描述

怎能止步于此
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spark通过kafka-appender指定日志输出到kafka引发的死锁问题
10-15
主要介绍了spark通过kafka-appender指定日志输出到kafka引发的死锁，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
架构师入门笔记八 并发框架Disruptor场景应用
热门推荐
ITDragon博客
09-09 1万+
架构师入门笔记八 并发框架Disruptor场景应用 今天用一个停车场问题来加深对Disruptor的理解。一个有关汽车进入停车场的问题。当汽车进入停车场时，系统首先会记录汽车信息。同时也会发送消息到其他系统处理相关业务，最后发送短信通知车主收费开始。看了很多文章，里面的代码都是大同小异的，可能代码真的是很经典。以下代码也是来源网络，只是自己手动敲的，加了一些注释。 代码包含以下内容：
Disruptor和Kafka
weixin_43186756的博客
02-18 1187
disruptor和kafka区别 disruptor，内存队列，使用场景一般在系统内部，提高在高并发的情况下系统的性能，一般作用于线程间的消息传递 kafka，分布式消息队列，使用场景一般在系统和系统间的消息传递，吞吐量高，也适用于消息流数据处理的中间件 队列 队列有两种实现思路。一种是基于链表实现的链式队列，另一种是基于数组实现的顺序队列。不同的需求背景下，我们会选择不同的实现方式。 无界队列，指的是队列的大小事先不确定，这种情况下，我们适合选用链表来实现队列。因为链表支持快速地动态扩容。 有界队列，指
Disruptor：一个高性能内存缓冲队列
weixin_43996530的博客
09-06 291
Disruptor是由LMAX Exchange开发的开源库，旨在解决高性能、低延迟的并发编程需求。它基于环形缓冲区和无锁并发算法，通过最小化锁竞争和线程阻塞，实现高效的事件处理核心组件RingBuffer(环形缓冲区): 环形缓冲区是Disruptor的核心数据结构，用于存储事件。它采用固定大小的数组，每个元素存储一个事件对象。环形缓冲区支持并发读写，并且没有锁竞争。Sequence(序号): 序号表示每个消费者对事件的处理进度。
提升--20---Disruptor-----号称最快的消息队列
时光里的博客
10-03 1307
文章目录Disruptor Disruptor
Disruptor、Kafka、Netty整合之路
weixin_34301132的博客
09-23 998
2019独角兽企业重金招聘Python工程师标准>>> ...
基于kafka的日志收集
qq_52077701的博客
08-13 5146
关于收集前端nginx web静态页面的访问日志，通过filebeat统一存入kafka集群，借助淘宝对日志进行清晰，将json格式日志清洗转化为业务需要的信息（eg:ip省份、运营商、带宽、日志产生时间等）保存到数据库中，同时借助celery通过设置阈值对日志进行实时监控并报警.........
实战：kafka实现日志收集系统
chuanchengdabing的博客
11-17 4998
Kafka作业 使用Kafka做日志收集。 一、需要收集的信息： 1、用户ID（user_id） 2、时间（act_time） 3、操作（action，可以是：点击：click，收藏：job_collect，投简历：cv_send，上传简历：cv_upload） 4、对方企业编码（job_code） 二、工作流程： 1、HTML可以理解为拉勾的职位浏览页面 2、用户的操作会由Web服务器进行响应。 3、同时用户的操作也会使用ajax向Nginx发送请求，nginx用于收集用户的点击数据流。
kafka操作日志管理
花语无痕的博客
02-11 3786
一、操作日志 首先附上kafka 操作日志配置文件：log4j.properties 根据相应的需要设置日志。 #日志级别覆盖规则 优先级：ALL < DEBUG < INFO <WARN < ERROR < FATAL < OFF #1.子日志log4j.logger会覆盖主日志log4j.rootLogger，这里设置的是日志输出级别，Threshold设置appender的日志接收级别； #2.log4j.logger级别低于Threshold,appen
基于kafka，zookeeper实现的日志收集平台搭建
qq_57472200的博客
08-14 1710
l项目描述：分别使用3台Linux服务器来作为nginx集群搭建前端web服务，kafka集群和zookeeper集群,2台Linux机器做反向代理集群。
基于kafka的日志收集分析平台
qq_48391148的博客
07-26 2459
Windows10机器（测试用）、Linux（centos7）、Nginx（1.20.1）、Filebeat（7.17.5）、kafka（1.12）、zookeeper（3.6.3）、Pycharm2020.3、mysql（5.7.34）创建/tmp/zookeeper目录，在目录中添加myid文件，文件内容就是本机指定的zookeeperid内容。selinux是linux里面的一个安全子系统，里面有许多关于安全的规则，很麻烦，会影响项目运行。设置broker节点，这代表这台kafka机器。.......
图解 Kafka 之实战指南
03-29
图解 Kafka 之实战指南.pdf
java kafka架构与实战高级特性&源码分析
06-19
1、kafka架构与实战 2、kafkfa高级特性 3、kafka集群与运维 4、kafka源码剖析
Kafka基本架构介绍
01-27
消息系统负责将数据从一个应用程序传输到另一个应用程序，因此应用程序可以专注于数据，但不担心如何共享它。分布式消息传递基于可靠消息队列的概念。消息在客户端应用程序和消息传递系统之间异步排队。...
记一次kafkakerberos认证问题
weixin_51473488的博客
04-17 319
principal文件不带kafka，去掉我自己配置的kerberos.kafka.principal重试。但是查看kafka_client_jass.conf文件，发现。排查思路：检查kerberos配置文件。报错信息是没有找到borker的映射。检查本机确实发现连接的映射没有配置。更改后的kerberos配置文件。加上主机映射测试OK了。
kafka实验部署
sea_bunch的博客
04-18 589
在zookeeper后继续进行操作。
kafka---topic详解
qq_41768644的博客
04-17 1310
kafka topic详解 topic partition 架构详解 log 日志文件详解
面试题：Kafka中Controller的作用是什么？选举流程是怎样的？以及如何避免脑裂问题？
最新发布
qq_26432153的博客
04-20 673
面试题：Kafka中Controller的作用是什么？选举流程是怎样的？以及如何避免脑裂问题？
springboot项目整合kafka实现消息队列
qq_43634655的博客
04-20 484
springboot项目整合kafka
kafka如何收集日志
03-05
Kafka可以通过Producer将日志数据发送到Kafka集群中的Topic中，然后通过Consumer从Topic中消费数据进行处理和存储。Kafka的高吞吐量和可扩展性使其成为收集和处理大量日志数据的理想选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值