Background

Everything has a cause and effect, and everything is event-driven. The log level switching of this solution comes from this background:

• There are hundreds and nearly a thousand microservices in a single production environment

• Log level switching does not require restarting the service, requiring immediate effects

• It is up to business developers to modify the code or add related dependency configurations, etc., which involves a wide range of issues and slows progress

• Later dynamic real-time filtering of junk logs to reduce IO and disk space costs

logback introduction

Before launching a war with the enemy, only the first Only by understanding the enemy's situation can we achieve victory in every battle. If you want to dynamically switch the log level of logback, you must first have at least a preliminary understanding of logback and see if it provides a ready-made implementation solution. Below is a brief introduction to logback related to this requirement.

Logback is an open source component for java logs. It was written by the founder of log4j. It is currently divided into 3 modules

• logback-core: core code module

• logback-classic: An improved version of log4j, which also implements the interface of slf4j

• logback-access: access module and Servlet container integration provides the function of accessing logs through Http

• ContextInitializer class is the logical implementation of the logback automatic configuration process

• The log level is maintained by Logger and use. Its member variable Level is maintained by Logger

• Logger has three filter log output methods with different parameters: filterAndLog_0_Or3Plus, filterAndLog_1, filterAndLog_2

• setLevel in Logger is to maintain the log level

Solution

Before working hard, first understand the market plan. This is the way designers and even product bosses seek optimal solutions.

Option 1: Automatically scan and update logback

This solution is a ready-made implementation of logback. As long as the configuration is turned on, the so-called dynamic switching of log levels can be achieved. Configuration method: In the logback configuration file, just add a scheduled scanner, such as:

<configuration scan="true" scanPeriod="30 seconds" debug="false">

This solution does not require R&D costs, and the operation and maintenance personnel can configure and use it themselves.

The disadvantage is:

• Every time the scan interval is adjusted, the service must be restarted

• More than 90% of scans It's all in vain, because the log level in production cannot be frequently switched, and it is not allowed to do so.

• The effect is not real-time. If you set it to scan every minute or every few minutes, Then making the log level adjustment take effect will not take effect immediately, but this can be ignored

• This solution cannot meet our junk log discarding needs, such as discarding logs based on certain keywords output. For this historical reason, a lot of junk logs are printed. Considering the time cost, it is impossible for business research and development to optimize it.

Option 2: ASM dynamically modifies the bytecode

Of course, there are other solutions, such as defining the interface API yourself. To directly call the setLevel method in Logger to adjust the level; springboot integration.

None of these plans can avoid the involvement of business development roles.

Through asm dynamic modification instructions, this solution can not only adjust the log level to take effect immediately. It can also meet the needs of filtering logs

The specific implementation is as follows. I will not introduce asm here. Students who don’t know it need to familiarize themselves with the instructions of asm, java agent and jvm first:

1. Idea creates a maven project

## 2. Maven introduces dependencies

<dependencies>
        <dependency>
            <groupId>org.ow2.asm</groupId>
            <artifactId>asm</artifactId>
            <version>7.1</version>
        </dependency>
        <dependency>
            <artifactId>asm-commons</artifactId>
            <groupId>org.ow2.asm</groupId>
            <version>7.1</version>
        </dependency>
        <dependency>
            <groupId>com.sun</groupId>
            <artifactId>tools</artifactId>
            <version>1.8</version>
            <scope>system</scope>
            <systemPath>/Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/lib/tools.jar</systemPath>
        </dependency>
    </dependencies>

<build>
  <plugins>
      <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.2.0</version>
          <configuration>
              <archive>
                  <manifestEntries>
                      <!-- 主程序啟動類 -->
                      <Agent-Class>
                          agent.LogbackAgentMain
                      </Agent-Class>
                      <!-- 允許重新定義類 -->
                      <Can-Redefine-Classes>true</Can-Redefine-Classes>
                      <!-- 允許轉換并重新加載類 -->
                      <Can-Retransform-Classes>true</Can-Retransform-Classes>
                  </manifestEntries>
              </archive>
          </configuration>
      </plugin>
      <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <configuration>
              <source>1.8</source>
              <target>1.8</target>
              <encoding>UTF-8</encoding>
              <compilerArguments>
                  <verbose />
                  <!-- 將jdk的依賴jar打入項目中-->
                  <bootclasspath>${java.home}/lib/rt.jar</bootclasspath>
              </compilerArguments>
          </configuration>
      </plugin>
  </plugins>
</build>

3. Writes the attrach startup class

package agent;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
/**
 * @author dengbp
 * @ClassName LogbackAgentMain
 * @Description attach 啟動器
 * @date 3/25/22 6:27 PM
 */
public class LogbackAgentMain {
    private static String FILTER_CLASS = "ch.qos.logback.classic.Logger";
    public static void agentmain(String agentArgs, Instrumentation inst) throws UnmodifiableClassException {
        System.out.println("agentArgs:" + agentArgs);
        inst.addTransformer(new LogBackFileTransformer(agentArgs), true);
        Class[] classes = inst.getAllLoadedClasses();
        for (int i = 0; i < classes.length; i++) {
            if (FILTER_CLASS.equals(classes[i].getName())) {
                System.out.println("----重新加載Logger開始----");
                inst.retransformClasses(classes[i]);
                System.out.println("----重新加載Logger完畢----");
                break;
            }
        }
    }
}

4. Implements words Section code conversion processor

package agent;
import jdk.internal.org.objectweb.asm.ClassReader;
import jdk.internal.org.objectweb.asm.ClassVisitor;
import jdk.internal.org.objectweb.asm.ClassWriter;
import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;
/**
 * @author dengbp
 * @ClassName LogBackFileTransformer
 * @Description 字節(jié)碼文件轉換器
 * @date 3/25/22 6:25 PM
 */
public class LogBackFileTransformer implements ClassFileTransformer {

    private final String level;
    private static String CLASS_NAME = "ch/qos/logback/classic/Logger";
    public LogBackFileTransformer(String level) {
        this.level = level;
    }
    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
        if (!CLASS_NAME.equals(className)) {
            return classfileBuffer;
        }
        ClassReader cr = new ClassReader(classfileBuffer);
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
        ClassVisitor cv1 = new LogBackClassVisitor(cw, level);
        /*ClassVisitor cv2 = new LogBackClassVisitor(cv1);*/
        // asm框架使用到訪問模式和責任鏈模式
        // ClassReader 只需要 accept 責任鏈中的頭節(jié)點處的 ClassVisitor即可
        cr.accept(cv1, ClassReader.SKIP_FRAMES | ClassReader.SKIP_DEBUG);
        System.out.println("end...");
        return cw.toByteArray();
    }
}

5. The visitor who implements the Logger element

package agent;
import jdk.internal.org.objectweb.asm.ClassVisitor;
import jdk.internal.org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
/**
 * @author dengbp
 * @ClassName LogBackClassVisitor
 * @Description Logger類元素訪問者
 * @date 3/25/22 5:01 PM
 */
public class LogBackClassVisitor extends ClassVisitor {
    private final String level;
    /**
     * asm版本
     */
    private static final int ASM_VERSION = Opcodes.ASM4;

    public LogBackClassVisitor(ClassVisitor classVisitor, String level) {
        super(ASM_VERSION, classVisitor);
        this.level = level;
    }
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature,
                                     String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
        return new LogFilterMethodVisitor(api, mv, access, name, descriptor, level);
    }
}

6. The visitor who finally implements the key method of Logger

This visitor (class), To switch log levels, you need to modify the instructions for Logger's three log filtering methods. The principle is to overwrite the value of the log level parameter entered in the command line with the value of its member variable effectiveLevelInt. Due to the large length, only the core part of the code is posted. Please see below:

package agent;
import jdk.internal.org.objectweb.asm.Label;
import jdk.internal.org.objectweb.asm.MethodVisitor;
import jdk.internal.org.objectweb.asm.commons.AdviceAdapter;
import org.objectweb.asm.Opcodes;
/**
 * @author dengbp
 * @ClassName LogFilterMethodVisitor
 * @Description Logger類日志過濾方法元素訪問者
 * @date 3/25/22 5:01 PM
 */
public class LogFilterMethodVisitor extends AdviceAdapter {
    private String methodName;
    private final String level;
    private static final String filterAndLog_1 = "filterAndLog_1";
    private static final String filterAndLog_2 = "filterAndLog_2";
    private static final String filterAndLog_0_Or3Plus = "filterAndLog_0_Or3Plus";
    protected LogFilterMethodVisitor(int api, MethodVisitor methodVisitor, int access, String name, String descriptor, String level) {
        super(api, methodVisitor, access, name, descriptor);
        this.methodName = name;
        this.level = level;
    }
    /**
     * Description 在訪問方法的頭部時被訪問
     * @param
     * @return void
     * @Author dengbp
     * @Date 3:36 PM 4/1/22
     **/
    @Override
    public void visitCode() {
        System.out.println("visitCode method");
        super.visitCode();
    }
    @Override
    protected void onMethodEnter() {
        System.out.println("開始重寫日志級別為："+level);
        System.out.println("----準備修改方法----");
        if (filterAndLog_1.equals(methodName)) {
            modifyLogLevel_1();
        }
        if (filterAndLog_2.equals(methodName)) {
            modifyLogLevel_2();
        }
        if (filterAndLog_0_Or3Plus.equals(methodName)) {
            modifyLogLevel_3();
        }
        System.out.println("重寫日志級別成功....");
    }

Among them modifyLogLevel_1(); modifyLogLevel_2() ;modifyLogLevel_3(); corresponds to the modification of filterAndLog_1, filterAndLog_2, filterAndLog_0_Or3Plus method instructions respectively. Only the implementation of modifyLogLevel_1 is posted below

/**
     * Description 修改目標方法：filterAndLog_1
     * @param
     * @return void
     * @Author dengbp
     * @Date 2:20 PM 3/31/22
     **/
    private void modifyLogLevel_1(){
        Label l0 = new Label();
        mv.visitLabel(l0);
        mv.visitLineNumber(390, l0);
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitLdcInsn(level);
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "ch/qos/logback/classic/Level", "toLevel", "(Ljava/lang/String;)Lch/qos/logback/classic/Level;", false);
        mv.visitFieldInsn(Opcodes.GETFIELD, "ch/qos/logback/classic/Level", "levelInt", "I");
        mv.visitFieldInsn(Opcodes.PUTFIELD, "ch/qos/logback/classic/Logger", "effectiveLevelInt", "I");
        Label l1 = new Label();
        mv.visitLabel(l1);
        mv.visitLineNumber(392, l1);
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitFieldInsn(Opcodes.GETFIELD, "ch/qos/logback/classic/Logger", "loggerContext", "Lch/qos/logback/classic/LoggerContext;");
        mv.visitVarInsn(Opcodes.ALOAD, 2);
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitVarInsn(Opcodes.ALOAD, 3);
        mv.visitVarInsn(Opcodes.ALOAD, 4);
        mv.visitVarInsn(Opcodes.ALOAD, 5);
        mv.visitVarInsn(Opcodes.ALOAD, 6);
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "ch/qos/logback/classic/LoggerContext", "getTurboFilterChainDecision_1", "(Lorg/slf4j/Marker;Lch/qos/logback/classic/Logger;Lch/qos/logback/classic/Level;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Throwable;)Lch/qos/logback/core/spi/FilterReply;", false);
        mv.visitVarInsn(Opcodes.ASTORE, 7);
        Label l2 = new Label();
        mv.visitLabel(l2);
        mv.visitLineNumber(394, l2);
        mv.visitVarInsn(Opcodes.ALOAD, 7);
        mv.visitFieldInsn(Opcodes.GETSTATIC, "ch/qos/logback/core/spi/FilterReply", "NEUTRAL", "Lch/qos/logback/core/spi/FilterReply;");
        Label l3 = new Label();
        mv.visitJumpInsn(Opcodes.IF_ACMPNE, l3);
        Label l4 = new Label();
        mv.visitLabel(l4);
        mv.visitLineNumber(395, l4);
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitFieldInsn(Opcodes.GETFIELD, "ch/qos/logback/classic/Logger", "effectiveLevelInt", "I");
        mv.visitVarInsn(Opcodes.ALOAD, 3);
        mv.visitFieldInsn(Opcodes.GETFIELD, "ch/qos/logback/classic/Level", "levelInt", "I");
        Label l5 = new Label();
        mv.visitJumpInsn(Opcodes.IF_ICMPLE, l5);
        Label l6 = new Label();
        mv.visitLabel(l6);
        mv.visitLineNumber(396, l6);
        mv.visitInsn(Opcodes.RETURN);
        mv.visitLabel(l3);
        mv.visitLineNumber(398, l3);
        mv.visitFrame(Opcodes.F_APPEND, 1, new Object[]{"ch/qos/logback/core/spi/FilterReply"}, 0, null);
        mv.visitVarInsn(Opcodes.ALOAD, 7);
        mv.visitFieldInsn(Opcodes.GETSTATIC, "ch/qos/logback/core/spi/FilterReply", "DENY", "Lch/qos/logback/core/spi/FilterReply;");
        mv.visitJumpInsn(Opcodes.IF_ACMPNE, l5);
        Label l7 = new Label();
        mv.visitLabel(l7);
        mv.visitLineNumber(399, l7);
        mv.visitInsn(Opcodes.RETURN);
        mv.visitLabel(l5);
        mv.visitLineNumber(402, l5);
        mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitVarInsn(Opcodes.ALOAD, 1);
        mv.visitVarInsn(Opcodes.ALOAD, 2);
        mv.visitVarInsn(Opcodes.ALOAD, 3);
        mv.visitVarInsn(Opcodes.ALOAD, 4);
        mv.visitInsn(Opcodes.ICONST_1);
        mv.visitTypeInsn(Opcodes.ANEWARRAY, "java/lang/Object");
        mv.visitInsn(Opcodes.DUP);
        mv.visitInsn(Opcodes.ICONST_0);
        mv.visitVarInsn(Opcodes.ALOAD, 5);
        mv.visitInsn(Opcodes.AASTORE);
        mv.visitVarInsn(Opcodes.ALOAD, 6);
        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "ch/qos/logback/classic/Logger", "buildLoggingEventAndAppend", "(Ljava/lang/String;Lorg/slf4j/Marker;Lch/qos/logback/classic/Level;Ljava/lang/String;[Ljava/lang/Object;Ljava/lang/Throwable;)V", false);
        Label l8 = new Label();
        mv.visitLabel(l8);
        mv.visitLineNumber(403, l8);
        mv.visitInsn(Opcodes.RETURN);
        Label l9 = new Label();
        mv.visitLabel(l9);
        mv.visitLocalVariable("this", "Lch/qos/logback/classic/Logger;", null, l0, l9, 0);
        mv.visitLocalVariable("localFQCN", "Ljava/lang/String;", null, l0, l9, 1);
        mv.visitLocalVariable("marker", "Lorg/slf4j/Marker;", null, l0, l9, 2);
        mv.visitLocalVariable("level", "Lch/qos/logback/classic/Level;", null, l0, l9, 3);
        mv.visitLocalVariable("msg", "Ljava/lang/String;", null, l0, l9, 4);
        mv.visitLocalVariable("param", "Ljava/lang/Object;", null, l0, l9, 5);
        mv.visitLocalVariable("t", "Ljava/lang/Throwable;", null, l0, l9, 6);
        mv.visitLocalVariable("decision", "Lch/qos/logback/core/spi/FilterReply;", null, l2, l9, 7);
        mv.visitMaxs(9, 8);
        mv.visitEnd();
    }

7. Finally, write the loading class to load the attach Agent

import com.sun.tools.attach.VirtualMachine;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

/**
 * @author dengbp
 * @ClassName MyAttachMain
 * @Description jar 執(zhí)行命令：
 * @date 3/25/22 4:12 PM
 */
public class MyAttachMain {
    private static final int ARGS_SIZE = 2;

    public static void main(String[] args) {
        if (args == null || args.length != ARGS_SIZE) {
            System.out.println("請輸入進程id和日志級別(ALL、TRACE、DEBUG、INFO、WARN、ERROR、OFF),如：31722 info");
            return;
        }
        VirtualMachine vm = null;
        try {
            System.out.println("修改的進程id:" + args[0]);
            vm = VirtualMachine.attach(args[0]);
            System.out.println("調整日志級別為：" + args[1]);
            vm.loadAgent(getJar(), args[1]);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (vm != null) {
                try {
                    vm.detach();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    private static String getJar() throws UnsupportedEncodingException {
        String jarFilePath = MyAttachMain.class.getProtectionDomain().getCodeSource().getLocation().getFile();
        jarFilePath = java.net.URLDecoder.decode(jarFilePath, "UTF-8");
        int beginIndex = 0;
        int endIndex = jarFilePath.length();
        if (jarFilePath.contains(".jar")) {
            endIndex = jarFilePath.indexOf(".jar") + 4;
        }
        if (jarFilePath.startsWith("file:")) {
            beginIndex = jarFilePath.indexOf("file:") + 5;
        }
        jarFilePath = jarFilePath.substring(beginIndex, endIndex);
        System.out.println("jar path:" + jarFilePath);
        return jarFilePath;
    }
}

8. Package execution

• Find the target program

##Execute jar

• java  -Xbootclasspath/a:/Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/lib/tools.jar  -cp change-log-agent-1.0.1.jar MyAttachMain 52433  DEBUG

  java  -Xbootclasspath/a:/Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/lib/tools.jar  -cp change-log-agent-1.0.1.jar MyAttachMain 52433 ERROR

  java  -Xbootclasspath/a:/Library/Java/JavaVirtualMachines/jdk1.8.0_191.jdk/Contents/Home/lib/tools.jar  -cp change-log-agent-1.0.1.jar MyAttachMain 52433 INFO

  Effect

  

  

  PS: If verification fails (caused by: java.lang.verifyerror), please provide jvm parameters :-noverify

  The above is the detailed content of Java ASM uses logback log level dynamic switching method. For more information, please follow other related articles on the PHP Chinese website!