MDC、ttl及EFK安装与详细使用

最新推荐文章于 2024-06-12 09:59:04 发布

Digimon-Y

最新推荐文章于 2024-06-12 09:59:04 发布

阅读量1k

点赞数 42

本文链接：https://blog.csdn.net/y666__/article/details/138129200

版权

MDC 同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

TTL

1 篇文章 0 订阅

订阅专栏

EFK

1 篇文章 0 订阅

订阅专栏

本文介绍了MDC（MappedDiagnosticContext）在多线程日志记录中的作用，如何在SpringBoot应用中配置TraceId，以及如何通过TransmittableThreadLocal实现在子线程间的数据传递。同时讨论了Elasticsearch和Filebeat的日志集成及其配置。

摘要由CSDN通过智能技术生成

MDC

1.简介

MDC 介绍 MDC（Mapped Diagnostic Context，映射调试上下文）是 log4j 和 logback 提供的一种方便在多线程条件下记录日志的功能。MDC 可以看成是一个与当前线程绑定的Map，可以往其中添加键值对。MDC 中包含的内容可以被同一线程中执行的代码所访问。当前线程的子线程会继承其父线程中的 MDC 的内容。当需要记录日志时，只需要从 MDC 中获取所需的信息即可。MDC 的内容则由程序在适当的时候保存进去。对于一个 Web 应用来说，通常是在请求被处理的最开始保存这些数据。
简而言之，MDC就是日志框架提供的一个InheritableThreadLocal，项目代码中可以将键值对放入其中，然后使用指定方式取出打印即可

原理：当请求来时生成一个traceId放在InheritableThreadLocal里，然后打印时去取就行了。但在不改动原有输出语句的前提下自然需要日志框架的支持了。

2.使用

在这里插入图片描述

2.1 配置TraceId 过滤器

@Order(1)

@WebFilter(urlPatterns = "/*",filterName = "traceIdFilter")
public class TraceIdFilter implements Filter {

    public final static String MDC_TRACE_ID = "traceId";

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String traceId = httpRequest.getHeader(MDC_TRACE_ID);
        if (StringUtils.isBlank(traceId)) {
            traceId = IdUtil.fastSimpleUUID();;
        }
        MDC.put(MDC_TRACE_ID, traceId);

        chain.doFilter(request, response);
    }
}

2.2 启动类开启

@SpringBootApplication

@ServletComponentScan
public class OpenApp {
    public static void main(String[] args) {
        SpringApplication.run(OpenApp.class, args);
    }

}

2.3 配置文件配置日志输出格式

# Spring Boot 日志配置
logging:
  # 控制台日志输出格式
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} %clr(%-5level) %clr([%X{traceId}]) %clr(${PID:-}) --- %clr(%logger{50}) - %m%n"

# 注释说明：
# %d{yyyy-MM-dd HH:mm:ss.SSS}: 时间戳，格式为年-月-日 时:分:秒:毫秒
# %-5level: 日志级别，左对齐且至少占用5个字符宽度
# %clr(...): 使用颜色编码（如果支持）
# [%X{traceId}]: Mapped Diagnostic Context中的traceId，用于记录跟踪请求的唯一标识
# ${PID:-}: 当前进程ID，如果没有则显示空字符串
# ---: 分隔符
# %logger{50}: 日志器名称，最多显示50个字符
# %m: 日志消息内容
# %n: 换行符

结果显示
在这里插入图片描述
那如果我们new一个子线程结果会怎样呢？？

TransmittableThreadLocal实现链路追踪

1、引入依赖

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>transmittable-thread-local</artifactId>
            <version>2.11.5</version>
            <scope>compile</scope>
        </dependency>

2、重写{LogbackMDCAdapter}类

注意：要在org.slf4j包下写才可以。
在这里插入图片描述

package org.slf4j;
 
import ch.qos.logback.classic.util.LogbackMDCAdapter;
import org.slf4j.spi.MDCAdapter;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
/**
 * 描述：
 * 重写{@link LogbackMDCAdapter}类，搭配TransmittableThreadLocal实现父子线程之间的数据传递
 * 内容直接从{@link LogbackMDCAdapter}类中copy。把copyOnThreadLocal实例化对象更改为TransmittableThreadLocal即可
 */
public class TtlMDCAdapter implements MDCAdapter {
    final ThreadLocal<Map<String, String>> copyOnThreadLocal = new InheritableThreadLocal();
    private static final int WRITE_OPERATION = 1;
    private static final int MAP_COPY_OPERATION = 2;
    final ThreadLocal<Integer> lastOperation = new ThreadLocal();
    private static TtlMDCAdapter mtcMDCAdapter;
    static {
        mtcMDCAdapter = new TtlMDCAdapter();
        MDC.mdcAdapter = mtcMDCAdapter;
    }
 
    public TtlMDCAdapter() {
    }
    public static MDCAdapter getInstance() {
        return mtcMDCAdapter;
    }
 
    private Integer getAndSetLastOperation(int op) {
        Integer lastOp = (Integer)this.lastOperation.get();
        this.lastOperation.set(op);
        return lastOp;
    }
 
    private boolean wasLastOpReadOrNull(Integer lastOp) {
        return lastOp == null || lastOp == MAP_COPY_OPERATION;
    }
 
    private Map<String, String> duplicateAndInsertNewMap(Map<String, String> oldMap) {
        Map<String, String> newMap = Collections.synchronizedMap(new HashMap());
        if (oldMap != null) {
            synchronized(oldMap) {
                newMap.putAll(oldMap);
            }
        }
 
        this.copyOnThreadLocal.set(newMap);
        return newMap;
    }
 
    public void put(String key, String val) throws IllegalArgumentException {
        if (key == null) {
            throw new IllegalArgumentException("key cannot be null");
        } else {
            Map<String, String> oldMap = (Map)this.copyOnThreadLocal.get();
            Integer lastOp = this.getAndSetLastOperation(WRITE_OPERATION);
            if (!this.wasLastOpReadOrNull(lastOp) && oldMap != null) {
                oldMap.put(key, val);
            } else {
                Map<String, String> newMap = this.duplicateAndInsertNewMap(oldMap);
                newMap.put(key, val);
            }
 
        }
    }
 
    public void remove(String key) {
        if (key != null) {
            Map<String, String> oldMap = (Map)this.copyOnThreadLocal.get();
            if (oldMap != null) {
                Integer lastOp = this.getAndSetLastOperation(WRITE_OPERATION);
                if (this.wasLastOpReadOrNull(lastOp)) {
                    Map<String, String> newMap = this.duplicateAndInsertNewMap(oldMap);
                    newMap.remove(key);
                } else {
                    oldMap.remove(key);
                }
 
            }
        }
    }
 
    public void clear() {
        this.lastOperation.set(WRITE_OPERATION);
        this.copyOnThreadLocal.remove();
    }
 
    public String get(String key) {
        Map<String, String> map = (Map)this.copyOnThreadLocal.get();
        return map != null && key != null ? (String)map.get(key) : null;
    }
 
    public Map<String, String> getPropertyMap() {
        this.lastOperation.set(MAP_COPY_OPERATION);
        return (Map)this.copyOnThreadLocal.get();
    }
 
    public Set<String> getKeys() {
        Map<String, String> map = this.getPropertyMap();
        return map != null ? map.keySet() : null;
    }
 
    public Map<String, String> getCopyOfContextMap() {
        Map<String, String> hashMap = copyOnThreadLocal.get();
        return hashMap == null ? null : new HashMap(hashMap);
    }
 
    public void setContextMap(Map<String, String> contextMap) {
        this.lastOperation.set(WRITE_OPERATION);
        Map<String, String> newMap = Collections.synchronizedMap(new HashMap());
        newMap.putAll(contextMap);
        this.copyOnThreadLocal.set(newMap);
    }
}

3、更改spring.factories

在resource/META-INF/spring.factories中进行配置。

org.springframework.context.ApplicationContextInitializer=\
com.jarvan.demo.config.TtlMDCAdapterInitializer

4、TtlMDCAdapterInitializer类如下

package com.by.config;
 
import org.slf4j.TtlMDCAdapter;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
 
public class TtlMDCAdapterInitializer implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
        TtlMDCAdapter.getInstance();
    }
}

查看结果
在这里插入图片描述

EFK安装与使用

1.docker-compose.yml

version: '3'
services:

  kibana:
    image: kibana:7.14.0
    ports:
      - "5601:5601"

    environment:
      - ELASTICSEARCH_HOSTS=http://192.168.11.81:9200
      - I18N_LOCALE="zh-CN"

  filebeat:
    image: elastic/filebeat:7.14.0
    volumes:
      - ./filebeat.yml:/usr/share/filebeat/filebeat.yml
      - /opt/efk/logs:/usr/share/filebeat/logs

    command: ["-e"]

2.filebeat.yml

filebeat.inputs:
- type: log
  paths:
    - /usr/share/filebeat/logs/*.log

output.elasticsearch:
  hosts: ["192.168.11.81:9200"]

3. 在docker中运行以下命令

docker-compose up -d

4.日志配置

 #日志配置
# Console Appender 日志格式
logging.pattern.console=${spring.application.name} %d{yyyy-MM-dd HH:mm:ss.SSS} %clr(%-5level) %clr([%X{traceId}]) %clr([%X{memberId}]) %clr(${PID:-}) --- %clr(%logger{50}) - %m%n

# File Appender
logging.file.name=/opt/efk/logs/${spring.application.name}.log
logging.pattern.file=${spring.application.name} %d{yyyy-MM-dd HH:mm:ss.SSS} %clr(%-5level) %clr([%X{traceId}]) %clr([%X{memberId}]) %clr(${PID:-}) --- %clr(%logger{50}) - %m%n
logging.file.max-size = 100MB
logging.file.max-history = 3

logging.level.root=error
logging.level.com.beiyou=debug

然后打jar包并复制到docker
在这里插入图片描述

最后运行jar包可在Elastic中查看

Digimon-Y

关注

42
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
MDC、ttl及EFK安装与详细使用

MDC 介绍 MDC（Mapped Diagnostic Context，映射调试上下文）是 log4j 和 logback 提供的一种方便在多线程条件下记录日志的功能。MDC 可以看成是一个与当前线程绑定的Map，可以往其中添加键值对。MDC 中包含的内容可以被同一线程中执行的代码所访问。当前线程的子线程会继承其父线程中的 MDC 的内容。当需要记录日志时，只需要从 MDC 中获取所需的信息即可。MDC 的内容则由程序在适当的时候保存进去。
复制链接

扫一扫

专栏目录