一种通过nacos动态配置实现多租户的log4j2日志物理隔离的设计

1、背景

1.1、背景

旧服务改造为多租户服务后，log4j日志打印在一起不能区分是哪个租户的，日志太多，太杂，不好定位排除问题，排查问题较难。

1.2、前提

不改动以前的日志代码（工作量太大）

1.3、打印日志示例

package com.cherf.sauth.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.cherf.common.ResultVo;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author cherf
 * @description: test
 * @date 2023/03/01 17:33
 **/
@RestController
@RequestMapping("/v1")
public class TestController {

	private static Logger log = LoggerFactory.getLogger(TestController.class); 
	   
    @PostMapping("/test")
    @ApiOperation(value = "test", notes = "test")
    public ResultVo<?> authorization() {
        log.trace("test：{}", "trace");
        log.debug("test：{}", "debug");
        log.info("test：{}", "info");
        log.warn("test：{}", "warn");
        log.error("test：{}", "error");
        return ResultVo.ok();
    }

}

2、实现

2.1、版本依赖

nacos： 2.1.0

slf4j-api： 1.7.36

slf4j-log4j12： 1.7.36

spring-boot：2.6.14

spring-cloud：2021.0.1

spring-cloud-alibaba：2021.0.1.0

（注： log4j-api和 logback-core用的是 spring-boot-starter-test 2.6.14中的版本分别是 2.17.2 1.2.11）

2.2、实现思路

2.2.1、日志分租户打印

logback通过加载ogback.xml 配置，通过 Appender 接口来实现打印，原理请看：logback

通过跟踪源码，可以找到AppenderAttachableImpl 这个类，其中通过Appender.doAppend 方法实现根据logabck配置中的类（默认是：RollingFileAppender）来打印日志，我们需要自定义重写doAppend方法来实现

2.2.2、logback配置动态生效

通过JoranConfiguration来实现 。Joran 是 logback 使用的一个配置加载库，动态生效 logback 的配置可以通过joranConfigurator.doConfigure方法实现，（实现代码在下面）；

2.2.3、新增租户时新增logback配置

主要思路是通过nacos来动态修改和发布配置从而实现logback.xml动态修改；XML格式比较烦，如果配置较多可以使用DOM4J来实现修改XML；（我们的较为简单，所以只是通过字符串替换来实现~）

2.3、实现

2.3.1、日志分离打印

2.3.1.1 重写doAppend方法

日志分离打印主要的实现就是重写doAppend方法,示例如下：
其中TenantContextHolder是用来存放租户id本地变量，实现可参考：多租户改造（字段隔离和表隔离混合模式）（也可使用自己的方法）

package com.cherf.common.logback;

import ch.qos.logback.core.rolling.RollingFileAppender;
import com.cherf.common.context.TenantContextHolder;
import com.cherf.common.util.StringUtil;


/**
 * @author cherf
 * @description:logback复写
 * @date 2023/02/24 11:49
 **/
public class TenantRollingFileAppender<E> extends RollingFileAppender<E> {

    /**
     * 日志打印会调用此方法，进行复写，判断租户，根据租户打印到不同日志文件
     *
     * @param eventObject
     */
    public void doAppend(E eventObject) {
        String tenantId = TenantContextHolder.getTenantId();
        if (StringUtil.isBlank(tenantId)) {
            //没有租户id的日志，打印到public下面
            tenantId = "public";
        }
        //  this.getName() 是在logback.xml中配置的<appender name="appenderName" class="com.cherf.common.logback.TenantRollingFileAppender">
        // 只打印当前租户的Append，RollingFileAppender追加器以租户类型标识开头的执行追加
        if (this.getName().startsWith(tenantId)) {
            super.doAppend(eventObject);
        }
    }
}

2.3.1.2 logback配置示例

logback.xml需要将配置中的appender标签的class属性修改为刚刚重写的方法全限定类名：com.cherf.common.logback.TenantRollingFileAppender

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
	<property name="log.path" value="../../logs/system" />
	<property name="log.pattern" value="%date [%level] [%thread] %logger{80} [%file : %line] %msg%n" />
	<appender class="ch.qos.logback.core.ConsoleAppender" name="STDOUT">
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
	</appender>
	<!--    public 公共-->
	<appender class="com.cherf.common.logback.TenantRollingFileAppender" name="public">
		<file>${log.path}/public/sys-api.log</file>
		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<fileNamePattern>${log.path}/public/sys-api.%d{yyyy-MM-dd}.log</fileNamePattern>
			<!-- 日志最大的历史 60天 -->
			<maxHistory>60</maxHistory>
		</rollingPolicy>
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
		<!-- 保留INFO级别及以上的日志 -->
		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
			<level>INFO</level>
		</filter>
	</appender>
	<!--    默认租户 -->
	<appender class="com.cherf.common.logback.TenantRollingFileAppender" name="tid20220831114008942">
		<file>${log.path}/tid20220831114008942/sys-api.log</file>
		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<fileNamePattern>${log.path}/tid20220831114008942/sys-api.%d{yyyy-MM-dd}.log</fileNamePattern>
			<!-- 日志最大的历史 60天 -->
			<maxHistory>60</maxHistory>
		</rollingPolicy>
		<encoder>
			<pattern>${log.pattern}</pattern>
		</encoder>
		<!-- 保留INFO级别及以上的日志 -->
		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
			<level>INFO</level>
		</filter>
	</appender>
	<logger additivity="false" name="com.cherf.system">
		<appender-ref ref="public" />
		<appender-ref ref="STDOUT" />
		<appender-ref ref="tid20220831114008942" />
	</logger>
	<root level="INFO">
		<appender-ref ref="public" />
		<appender-ref ref="STDOUT" />
		<appender-ref ref="tid20220831114008942" />
	</root>
</configuration>

2.3.2、配置动态生效

2.3.2.1、项目启动读取nacos配置

服务启动时logback默认加载 classpath:logback.xml 配置，需要在yml中指定logback配置 (logging.config后配置)
配置如下：

spring:
  cloud:
    nacos:
      discovery:
        # 不使用nacos的配置
        # enabled: false
        server-addr: 127.0.0.1:8848
 
#日志打印
logging:
  config: http://${spring.cloud.nacos.discovery.server-addr}/nacos/v1/cs/configs?group=${logback.group}&tenant=public&dataId=${logback.systemDataId}
  level:
    com.cherf: info
    com.cherf.mapper: info
    org.springframework: info
    org.spring.springboot.dao: info

logback:
  group: logback
  systemDataId: system-logback.xml

2.3.2.2、nacos配置监听+logback动态加载配置

主要采用nacos ConfigService的addListener方法来监听；
注意:网上很多直接通过 NacosFactory.createConfigService()来创建ConfigService的方法可能会重复创建实例，导致CPU上升，详情可参考：记一次CPU占用持续上升问题排查（Nacos动态路由引起）

1、nacos动态配置监听器

package com.cherf.common.nacos;

import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.joran.JoranConfigurator;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.ConfigType;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import com.cherf.common.nacos.NacosConfigService;
import com.cherf.common.util.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.concurrent.Executor;

/**
 * @author cherf
 * @description: nacos监听器，修改logback.xml后动态生效
 * @date 2023/03/04 16:35
 **/
@Component
public class NacosDynamicLogbackService {

    private static final Logger log = LoggerFactory.getLogger(NacosDynamicLogbackService.class);

    /**
     * 配置 ID
     */
    @Value("${logback.systemDataId}")
    private String dataId;

    /**
     * 配置 分组
     */
    @Value("${logback.group}")
    private String group;
    @Resource
    private NacosConfigService nacosConfigService;


    @PostConstruct
    public void dynamicLogbackByNacosListener() {
        try {
            ConfigService configService = nacosConfigService.getInstance();
            if (configService != null) {
                configService.getConfig(dataId, group, 5000);
                configService.addListener(dataId, group, new Listener() {
                    @Override
                    public void receiveConfigInfo(String configInfo) {
                        if (StringUtil.isNotBlank(configInfo)) {
                            System.out.println("configInfo=============================>" + configInfo);
                            try {
                                LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
                                JoranConfigurator configurator = new JoranConfigurator();
                                configurator.setContext(context);
                                context.reset();
                                //获取nacos配置，生成inputStream
                                InputStream inputStreamRoute = new ByteArrayInputStream(new String(configInfo).getBytes());
                                //configurator.doConfigure("/logback.xml");
                                configurator.doConfigure(inputStreamRoute);

                                context.start();
                            } catch (Exception e) {
                                log.error("加载logback.xml配置发生错误", e);
                            }
                        }
                    }

                    @Override
                    public Executor getExecutor() {
                        return null;
                    }
                });
            }
        } catch (NacosException e) {
            log.error("获取logback.xml配置发生错误", e);
        }
    }

    /**
     * 获取配置文件内容
     *
     * @return
     */
    public String getLogBackConfig(String dataId, String group) {
        try {
            ConfigService configService = nacosConfigService.getInstance();
            // 根据dataId、group定位到具体配置文件，获取其内容. 方法中的三个参数分别是: dataId, group, 超时时间
            String content = configService.getConfig(dataId, group, 5000L);
            return content;
        } catch (NacosException e) {
            log.error(e.getErrMsg());
        }
        return null;
    }

    /**
     * 发布配置
     *
     * @param logbackXml
     * @return
     */
    public boolean publishLogBackConfig(String dataId, String group,String logbackXml) {
        try {
            ConfigService configService = nacosConfigService.getInstance();
            boolean isPublishOk = configService.publishConfig(dataId, group, logbackXml, ConfigType.XML.getType());
            return isPublishOk;
        } catch (Exception e) {
            log.error(e.getMessage());
        }
        return false;
    }

}

2、 ConfigService单例

package com.cherf.common.nacos;

import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.PropertyKeyConst;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.util.Properties;

/**
 * @author cherf
 * @description: NacosConfigservice单例
 * @date 2023/03/4 16:35
 **/
@Component
public class NacosConfigService {
    private static final Log log = LogFactory.get(NacosConfigService.class);
    /**
     * nacos地址
     */
    @Value("${spring.cloud.nacos.discovery.server-addr}")
    private  String ipAddress;

    //声明变量, 使用volatile关键字确保绝对线程安全
    private volatile  ConfigService configService = null;

    @Bean
    public  ConfigService getInstance() throws NacosException {
        if (configService == null) {
            //对单例类进行加锁
            synchronized (NacosConfigService.class) {
                if (configService == null) {
                    Properties properties = new Properties();
                    // nacos服务器地址，127.0.0.1:8848
                    properties.put(PropertyKeyConst.SERVER_ADDR, ipAddress);
                    //创建实例
                    configService = NacosFactory.createConfigService(properties);
                    log.info("==========创建configService实例===============");
                }
            }
        }
        return configService;
    }
}

2.3.3、logback配置动态修改

新增租户后，需要在logback.xml里添加新增租户的配置信息，以我们的为例是在其中添加如下三段配置

中间较大的这一段可以写在Resource目录下,然后读出来替换{tenantId}即可使用，配置如下

    <!-- {tenantId} 租户日志 -->
    <!--system日志-->
    <appender class="com.cherf.common.logback.TenantRollingFileAppender" name="{tenantId}">
        <file>${log.path}/{tenantId}/sys-api.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/{tenantId}/sys-api.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!-- 日志最大的历史 60天 -->
            <maxHistory>60</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
        </encoder>
        <!-- 保留INFO级别及以上的日志 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
    </appender>

研究了半天DOM4J用法，感觉很麻烦，为了省事就直接使用字符串替换来完成了；先压缩读到的XML配置，然后替换需要新增或删除的配置信息，再格式化XML，最后再去发布
可以参考下面代码，包括了读取ini配置，XML压缩，XML格式化，从nacos获取配置到发布配置到nacos都有示例；（使用了最笨的方法来实现，有好的思路大家可以发出来探讨探讨）。

package com.cherf.common.logback;

import cn.hutool.core.io.IoUtil;
import cn.hutool.core.io.resource.ClassPathResource;
import cn.hutool.core.io.resource.Resource;
import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;
import com.cherf.common.constant.StringPool;
import com.cherf.common.context.TenantContextHolder;
import com.cherf.common.nacos.NacosDynamicLogbackService;
import com.cherf.common.util.StringUtil;
import com.isearch.common.logback.LogbackXmlContent;
import com.sun.org.apache.xml.internal.serialize.OutputFormat;
import com.sun.org.apache.xml.internal.serialize.XMLSerializer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;


import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.*;

/**
 * @author cherf
 * @description:
 * @date 2023/03/04 11:29
 **/
@Component
public class DynamicModifyLogback {
    private static final Log log = LogFactory.get(DynamicModifyLogback.class);
    //group
    @Value("${logback.group}")
    private String group;
    //dataId
    @Value("${logback.systemDataId}")
    private String systemDataId;

    @Autowired
    private NacosDynamicLogbackService nacosDynamicLogbackService;

    /**
     * 新增配置
     */
    public void addLogbackXml() {
        String logBackConfig = this.getLogBackConfig(systemDataId);
        String addSystemXml = addSystemXml(logBackConfig);
        //发布配置
        publishLogBackConfig(systemDataId, addSystemXml);
    }

    /**
     * 删除配置
     */
    public void removeLogbackXml() {
        String logBackConfig = this.getLogBackConfig(systemDataId);
        String removeSystemXml = removeSystemXml(logBackConfig);
        //发布配置
        publishLogBackConfig(systemDataId, removeSystemXml);
    }


    public static String addSystemXml(String logBackXml) {
        String systemAppender = getIniResourec("logback/system-logback.ini").replace("{tenantId}", TenantContextHolder.getTenantId());
        log.info("appender:", systemAppender);
        String systemRef = "<appender-ref ref=\"tid20220831114008942\"/>".replace("tid20220831114008942", TenantContextHolder.getTenantId());
        log.info("ref", systemRef);
        return replaceLogBack(logBackXml, systemAppender);
    }


    public static String removeSystemXml(String logBackXml) {
        String systemAppender = getIniResourec("logback/system-logback.ini").replace("{tenantId}", TenantContextHolder.getTenantId());
        log.info("appender:", systemAppender);
        //logBackXml = format(logBackXml);
        //压缩xml
        return packXml(logBackXml, systemAppender);
    }


    private static String replaceLogBack(String logBackXml, String appender) {
        String appenderRep = LogbackXmlContent.appenderRep;
        logBackXml = StringUtil.replaceLast(logBackXml, appenderRep, LogbackXmlContent.NULL + appenderRep + appender);
        logBackXml = logBackXml.replace("<appender-ref ref=\"tid20220831114008942\"/>", "<appender-ref ref=\"tid20220831114008942\"/>" + StringPool.NEWLINE + "<appender-ref ref=\"tid20220831114008942\"/>".replace("tid20220831114008942", TenantContextHolder.getTenantId()));
        logBackXml = format(logBackXml);
        log.info(logBackXml);
        return logBackXml;
    }

    private static String packXml(String logBackXml, String appender) {
        logBackXml = convertFromXml(logBackXml).replace(StringPool.ELEVE_SPACE, StringPool.EMPTY).replace(StringPool.NEWLINE, StringPool.EMPTY).trim();
        appender = convertFromXml(appender).trim();
        String systemRef = "<appender-ref ref=\"tid20220831114008942\"/>".replace("tid20220831114008942", TenantContextHolder.getTenantId());
        log.info("ref", systemRef);
        logBackXml = StringUtil.replaceLast(logBackXml, appender, StringPool.EMPTY);
        logBackXml = logBackXml.replace(systemRef, StringPool.EMPTY);
        logBackXml = format(logBackXml);
        log.info(logBackXml);
        return logBackXml;
    }


    /**
     * 获取配置
     */
    public String getLogBackConfig(String dataId) {
        return nacosDynamicLogbackService.getLogBackConfig(dataId, group);
    }

    /**
     * 发布
     */
    public Boolean publishLogBackConfig(String dataId, String logbackXml) {
        return nacosDynamicLogbackService.publishLogBackConfig(dataId, group, logbackXml);
    }

    /**
     * 格式化xml
     *
     * @param unformattedXml
     * @return
     */
    public static String format(String unformattedXml) {
        try {
            final Document document = parseXmlFile(unformattedXml);
            OutputFormat format = new OutputFormat(document);
            format.setLineWidth(256);
            format.setIndenting(true);
            format.setIndent(2);
            Writer out = new StringWriter();
            XMLSerializer serializer = new XMLSerializer(out, format);
            serializer.serialize(document);
            return out.toString();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static Document parseXmlFile(String in) {
        try {
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            DocumentBuilder db = dbf.newDocumentBuilder();
            InputSource is = new InputSource(new StringReader(in));
            return db.parse(is);
        } catch (ParserConfigurationException e) {
            throw new RuntimeException(e);
        } catch (SAXException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取配置
     *
     * @param fileName
     * @return
     */
    private static String getIniResourec(String fileName) {
        String xml = StringPool.EMPTY;
        Resource resource = new ClassPathResource(fileName);
        InputStream is = resource.getStream();
        xml = IoUtil.readUtf8(is);
        return xml;
    }

    /**
     * 压缩xml
     *
     * @param str
     * @return
     */
    public static String convertFromXml(String str) {
        boolean flag = true;
        boolean quotesFlag = true;
        StringBuffer ans = new StringBuffer();
        String tmp = "";
        for (int i = 0; i < str.length(); i++) {
            if ('"' == str.charAt(i)) {
                ans.append(str.charAt(i));
                quotesFlag = !quotesFlag;
            } else if ('<' == str.charAt(i)) {
                tmp = tmp.trim();
                ans.append(tmp);
                flag = true;
                ans.append(str.charAt(i));
            } else if ('>' == str.charAt(i)) {
                if (quotesFlag) {
                    flag = false;
                    ans.append(str.charAt(i));
                    tmp = "";
                } else {
                    ans.append("&gt;");
                }
            } else if (flag) {
                ans.append(str.charAt(i));
            } else {
                tmp += str.charAt(i);
            }
        }
        return ans.toString();
    }
}

3、总结

前面都还可以，只是由于时间关系，XML修改的方法确实有点挫，后期有时间再研究着改吧！

其中TenantContextHolder实现可以参考另一篇文章多租户改造（字段隔离和表隔离混合模式）

日志分离打印部分参考大佬实现：springboot logback多租户根据请求打印日志到不同文件