Coding technique - Global log switch

Development process , Business log is very important and necessary , It can often help us troubleshoot problems , Such as abnormal reasons 、 In and out 、 Whether there is dirty data 、 What step has been taken ; But the more logs, the better , For large flow interfaces , You need to be careful when logging , A large number of logs will lead to frequent IO、 Affect machine load ;

" Based on experience ,4 nucleus 8G Machine ,1 Hours Log volume Not more than 20W "

—— Experienced soaring logs, resulting in machine load reaching 80 A module of SE Experience given

Besides , When the middleware is abnormal , Such as ZK Can't connect 、MQ When link exceptions occur , Rebooting the machine will also produce a crazy amount of logs , It may cause the service to still fail to restart successfully ; Now , If there is a global log switch , Can mask some specified Class Printed logs , You can temporarily solve the problem of soaring logs ;

Here are respectively Log4j and Logback Tool class implementation under the logging framework , The principle is to get the specified class Logger object , Set its log level to shielding , This attribute is judged in real time when printing logs , Therefore, there is no need to restart the machine to take effect ; Triggers are configuration center change time messages , It can be ZK、Apollo etc. ;

1. Log4J Log switch

package com.AA.service.helper.logger;

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Maps;
import com.AA.client.ConfigManager;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author AA
 * @description  Global log switching tool 
 * @date 2022/3/25
 */
@Slf4j
@Component
public class LoggerSwitchHelper implements InitializingBean {

    /**
     *  Mask logs only for specified classes 
     */
    private static final String LOGGER_BLACKLIST = "logger.switch.blacklist";

    /**
     *  Temporarily save the last closed log object switch , It is used to restore the logs under the original class after modifying the configuration 
     */
    private static Map<String, Level> LAST_LOGGER_BLACKLIST_MAP = new ConcurrentHashMap<>();

    @Override
    public void afterPropertiesSet() throws Exception {
        String conf = ConfigManager.getString(LOGGER_BLACKLIST, "");
        refreshLoggerSwitch(conf);

        ConfigManager.addListener((item, type) -> {
            if (StringUtils.equalsIgnoreCase(item.getName(), LOGGER_BLACKLIST)) {
                refreshLoggerSwitch(item.getValue());
            }
        });
    }

    /**
     *  Refresh configuration 
     */
    private synchronized void refreshLoggerSwitch(String conf) {
        try {
            log.info("refreshLoggerSwitch. [conf={}]", conf);
            //  Temporarily record the current blacklist 
            Map<String, Level> current_logger_blacklist = Maps.newConcurrentMap();
            if (StringUtils.isNotEmpty(conf)) {
                List<String> loggerBlackList = Arrays.asList(StringUtils.split(conf, ","));
                if (CollectionUtils.isNotEmpty(loggerBlackList)) {
                    for (String loggerName : loggerBlackList) {
                        org.apache.log4j.Logger logger = LogManager.getLogger(loggerName);
                        if (null != logger) {
                            if (null != logger.getLevel()) {
                                current_logger_blacklist.put(loggerName, logger.getLevel());
                            }
                            //  The level of the current log object is empty   And there is a parent log   Then initialize its current level to the level of the parent log object 
                            else if (logger.getAdditivity()) {
                                current_logger_blacklist.put(loggerName, logger.getParent().getLevel());
                            }
                            logger.setLevel(Level.OFF);
                            log.info("logger_turn_off. [loggerName={}]", loggerName);
                        } else {
                            log.info("logger_not_found. [loggerName={}]", loggerName);
                        }
                    }
                }
            }

            //  For the last closed class , The log opened this time needs to be restored 
            if (MapUtils.isNotEmpty(LAST_LOGGER_BLACKLIST_MAP)) {
                for (Map.Entry<String, Level> entry : LAST_LOGGER_BLACKLIST_MAP.entrySet()) {
                    String loggerName = entry.getKey();
                    if (!current_logger_blacklist.containsKey(loggerName)) {
                        //  Remove from snapshot 
                        LAST_LOGGER_BLACKLIST_MAP.remove(entry.getKey());
                        org.apache.log4j.Logger logger = LogManager.getLogger(loggerName);
                        if (null != logger) {
                            //  According to the snapshot   Set to the log level before closing 
                            logger.setLevel(entry.getValue());
                            log.info("logger_remove_fr_blackList_reopen. [loggerName={} level={}]", loggerName, entry.getValue());
                        }
                    }
                }
            }

            //  Save snapshots 
            current_logger_blacklist.forEach((loggerName, level) -> {
                LAST_LOGGER_BLACKLIST_MAP.putIfAbsent(loggerName, level);
            });
            log.info("save_last_loggerCfg. [last_loggerCfg={}]", JSON.toJSONString(LAST_LOGGER_BLACKLIST_MAP));

            log.info("refreshLoggerSwitch_suc.");
        } catch (Exception e) {
            log.error("refreshLoggerSwitch_error. [conf={}]", conf);
        }
    }

}

2. Logback Log switch

Add based on logback The implementation of the ;

package com.AA.service.config;

import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.LoggerContext;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Maps;
import com.AA.ConfigManager;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author AA
 * @description logback Log switch tool 
 * @date 2022/1/19
 */
@Slf4j
@Component
public class LoggerSwitchHelper implements InitializingBean {

    /**
     *  Mask logs only for specified classes 
     */
    private static final String LOGGER_BLACKLIST = "logger.switch.blacklist";

    /**
     *  Temporarily save the last closed log object switch , It is used to restore the logs under the original class after modifying the configuration 
     */
    private static Map<String, Level> LAST_LOGGER_BLACKLIST_MAP = new ConcurrentHashMap<>();

    @Override
    public void afterPropertiesSet() throws Exception {
        String conf = ConfigManager.getString(LOGGER_BLACKLIST, "");
        refreshLoggerSwitch(conf);

        ConfigManager.addListener((item, type) -> {
            if (StringUtils.equalsIgnoreCase(item.getName(), LOGGER_BLACKLIST)) {
                refreshLoggerSwitch(item.getValue());
            }
        });
    }

    /**
     *  Refresh configuration 
     */
    private synchronized void refreshLoggerSwitch(String conf) {
        try {
            log.info("refreshLoggerSwitch. [conf={}]", conf);
            //  Temporarily record the current blacklist 
            Map<String, ch.qos.logback.classic.Level> current_logger_blacklist = Maps.newConcurrentMap();
            //  Log configuration context 
            LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
            if (StringUtils.isNotEmpty(conf)) {
                List<String> loggerBlackList = Arrays.asList(StringUtils.split(conf, ","));
                if (CollectionUtils.isNotEmpty(loggerBlackList)) {

                    for (String loggerName : loggerBlackList) {
                        ch.qos.logback.classic.Logger logger = lc.getLogger(loggerName);
                        if (null != logger) {
                            if (null != logger.getLevel()) {
                                current_logger_blacklist.put(loggerName, logger.getLevel());
                            }
                            //  If the level is empty, take the parent level   Take when abnormal INFO Grade 
                            else if (logger.isAdditive()) {
                                try {
                                    Field field = logger.getClass().getDeclaredField("parent");
                                    field.setAccessible(true);
                                    final Logger parentLogger = (Logger) field.get(logger);
                                    current_logger_blacklist.put(loggerName, parentLogger.getLevel());
                                } catch (Exception e) {
                                    current_logger_blacklist.put(loggerName, ch.qos.logback.classic.Level.INFO);
                                }
                            }
                            logger.setLevel(Level.OFF);
                            log.info("logger_turn_off. [loggerName={}]", loggerName);
                        } else {
                            log.info("logger_not_found. [loggerName={}]", loggerName);
                        }
                    }
                }
            }

            //  For the last closed class , The log opened this time needs to be restored 
            if (MapUtils.isNotEmpty(LAST_LOGGER_BLACKLIST_MAP)) {
                for (Map.Entry<String, ch.qos.logback.classic.Level> entry : LAST_LOGGER_BLACKLIST_MAP.entrySet()) {
                    String loggerName = entry.getKey();
                    if (!current_logger_blacklist.containsKey(loggerName)) {
                        //  Remove from snapshot 
                        LAST_LOGGER_BLACKLIST_MAP.remove(entry.getKey());
                        ch.qos.logback.classic.Logger logger = lc.getLogger(loggerName);
                        if (null != logger) {
                            //  According to the snapshot   Set to the log level before closing 
                            logger.setLevel(entry.getValue());
                            log.info("logger_remove_fr_blackList_reopen. [loggerName={} level={}]", loggerName, entry.getValue());
                        }
                    }
                }
            }

            //  Save snapshots 
            current_logger_blacklist.forEach((loggerName, level) -> {
                LAST_LOGGER_BLACKLIST_MAP.putIfAbsent(loggerName, level);
            });
            log.info("save_last_loggerCfg. [last_loggerCfg={}]", JSON.toJSONString(LAST_LOGGER_BLACKLIST_MAP));

            log.info("refreshLoggerSwitch_suc.");
        } catch (Exception e) {
            log.error("refreshLoggerSwitch_error. [conf={}]", conf);
        }
    }

}

Mainly different from Logger Object acquisition ; You can also use the policy mode to be compatible with both logging frameworks ;