调研字节码插桩技术，用于互联网分布式系统监控设计和实现！

Posted 2021-09-29 小傅哥

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了调研字节码插桩技术，用于互联网分布式系统监控设计和实现！相关的知识，希望对你有一定的参考价值。

沉淀、分享、成长，让自己和他人都能有所收获！😄

一、来自深夜的电话！

咋滴，你那上线的系统是裸奔呢？

周末熟睡的深夜，突然接到老板电话☎的催促。“赶紧看微信、看微信，咋系统出问题了，我们都不知道，还得用户反馈才知道的！！！”深夜爬起来，打开电脑连上 VPN ，打着哈欠、睁开朦胧的眼睛，查查系统日志，原来是系统挂了，赶紧重启恢复！

虽然重启恢复了系统，也重置了老板扭曲的表情。但系统是怎么挂的呢，因为没有一个监控系统，也不知道是流量太大导致，还是因为程序问题引起，通过一片片的日志，也仅能粗略估计出一些打着好像的标签给老板汇报。不过老板也不傻，聊来聊去，让把所有的系统运行状况都监控出来。

双手拖着困倦的脑袋，一时半会也想不出什么好方法，难道在每个方法上都硬编码上执行耗时计算。之后把信息在统一收集起来，展示到一个监控页面呢，监控页面使用阿帕奇的 echarts，别说要是这样显示了，还真能挺好看还好用。

但这么硬编码也不叫玩意呀，这不把我们部门搬砖的码农累岔气呀！再说了，这么干他们肯定瞧不起我。啥架构师，要监控系统，还得硬编码，傻了不是！！！
这么一想整的没法睡觉，得找找资料，明天给老板汇报！

其实一套线上系统是否稳定运行，取决于它的运行健康度，而这包括；调用量、可用率、影响时长以及服务器性能等各项指标的一个综合值。并且在系统出现异常问题时，可以抓取整个业务方法执行链路并输出；当时的入参、出参、异常信息等等。当然还包括一些JVM、Redis、mysql的各项性能指标，以用于快速定位并解决问题。

那么要做到这样的事情有什么处理方案呢，其实做法还是比较多的，比如；

最简单粗暴的就是硬编码在方法中，收取执行耗时以及出入参和异常信息。但这样的编码成本实在太大，而且硬编码完还需要大量回归测试，可能给系统带来一定的风险。万一谁手抖给复制粘贴错了呢！
可以选择切面方式做一套统一监控的组件，相对来说还是好一些的。但也需要硬编码，比如写入注解，同时维护成本也不低。
其实市面上对于这样的监控其实是有整套的非入侵监控方案的，比如；Google Dapper、Zipkin等都可以实现监控系统需求，他们都是基于探针技术非入侵的采用字节码增强的方式采集系统运行信息进行分析和监控运行状态。

好，那么本文就来带着大家来尝试下几种不同方式，监控系统运行状态的实现思路。

二、准备工作

本文会基于 AOP、字节码框架(ASM、Javassist、Byte-Buddy)，分别实现不同的监控实现代码。整个工程结构如下：

MonitorDesign
├── cn-bugstack-middleware-aop
├── cn-bugstack-middleware-asm
├── cn-bugstack-middleware-bytebuddy
├── cn-bugstack-middleware-javassist
├── cn-bugstack-middleware-test
└──	pom.xml

源码地址：https://github.com/fuzhengwei/MonitorDesign
简单介绍：aop、asm、bytebuddy、javassist，分别是四种不同的实现方案。test 是一个基于 SpringBoot 的简单测试工程。
技术使用：SpringBoot、asm、byte-buddy、javassist

cn-bugstack-middleware-test

@RestController
public class UserController {

    private Logger logger = LoggerFactory.getLogger(UserController.class);

    /**
     * 测试：http://localhost:8081/api/queryUserInfo?userId=aaa
     */
    @RequestMapping(path = "/api/queryUserInfo", method = RequestMethod.GET)
    public UserInfo queryUserInfo(@RequestParam String userId) {
        logger.info("查询用户信息，userId：{}", userId);
        return new UserInfo("虫虫:" + userId, 19, "天津市东丽区万科赏溪苑14-0000");
    }

}

接下来的各类监控代码实现，都会以监控 UserController#queryUserInfo 的方法执行信息为主，看看各类技术都是怎么操作的。

三、使用 AOP 做个切面监控

1. 工程结构

cn-bugstack-middleware-aop
└── src
    ├── main
    │   └── java
    │       ├── cn.bugstack.middleware.monitor
    │       │   ├── annotation
    │       │   │   └── DoMonitor.java
    │       │   ├── config
    │       │   │   └── MonitorAutoConfigure.java
    │       │   └── DoJoinPoint.java
    │       └── resources
    │           └── META-INF 
    │               └── spring.factories
    └── test
        └── java
            └── cn.bugstack.middleware.monitor.test
                └── ApiTest.java

基于 AOP 实现的监控系统，核心逻辑的以上工程并不复杂，其核心点在于对切面的理解和运用，以及一些配置项需要按照 SpringBoot 中的实现方式进行开发。

DoMonitor，是一个自定义注解。它作用就是在需要使用到的方法监控接口上，添加此注解并配置必要的信息。
MonitorAutoConfigure，配置下是可以对 SpringBoot yml 文件的使用，可以处理一些 Bean 的初始化操作。
DoJoinPoint，是整个中间件的核心部分，它负责对所有添加自定义注解的方法进行拦截和逻辑处理。

2. 定义监控注解

cn.bugstack.middleware.monitor.annotation.DoMonitor

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DoMonitor {

   String key() default "";
   String desc() default "";

}

@Retention(RetentionPolicy.RUNTIME)，Annotations are to be recorded in the class file by the compiler and retained by the VM at run time, so they may be read reflectively.
@Retention 是注解的注解，也称作元注解。这个注解里面有一个入参信息 RetentionPolicy.RUNTIME 在它的注释中有这样一段描述：Annotations are to be recorded in the class file by the compiler and retained by the VM at run time, so they may be read reflectively. 其实说的就是加了这个注解，它的信息会被带到JVM运行时，当你在调用方法时可以通过反射拿到注解信息。除此之外，RetentionPolicy 还有两个属性 SOURCE、CLASS，其实这三个枚举正式对应了Java代码的加载和运行顺序，Java源码文件 -> .class文件 -> 内存字节码。并且后者范围大于前者，所以一般情况下只需要使用 RetentionPolicy.RUNTIME 即可。
@Target 也是元注解起到标记作用，它的注解名称就是它的含义，目标，也就是我们这个自定义注解 DoWhiteList 要放在类、接口还是方法上。在 JDK1.8 中 ElementType 一共提供了10中目标枚举，TYPE、FIELD、METHOD、PARAMETER、CONSTRUCTOR、LOCAL_VARIABLE、ANNOTATION_TYPE、PACKAGE、TYPE_PARAMETER、TYPE_USE，可以参考自己的自定义注解作用域进行设置
自定义注解 @DoMonitor 提供了监控的 key 和 desc描述，这个主要记录你监控方法的为唯一值配置和对监控方法的文字描述。

3. 定义切面拦截

cn.bugstack.middleware.monitor.DoJoinPoint

@Aspect
public class DoJoinPoint {

    @Pointcut("@annotation(cn.bugstack.middleware.monitor.annotation.DoMonitor)")
    public void aopPoint() {
    }

    @Around("aopPoint() && @annotation(doMonitor)")
    public Object doRouter(ProceedingJoinPoint jp, DoMonitor doMonitor) throws Throwable {
        long start = System.currentTimeMillis();
        Method method = getMethod(jp);
        try {
            return jp.proceed();
        } finally {
            System.out.println("监控 - Begin By AOP");
            System.out.println("监控索引：" + doMonitor.key());
            System.out.println("监控描述：" + doMonitor.desc());
            System.out.println("方法名称：" + method.getName());
            System.out.println("方法耗时：" + (System.currentTimeMillis() - start) + "ms");
            System.out.println("监控 - End\\r\\n");
        }
    }

    private Method getMethod(JoinPoint jp) throws NoSuchMethodException {
        Signature sig = jp.getSignature();
        MethodSignature methodSignature = (MethodSignature) sig;
        return jp.getTarget().getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());
    }

}

使用注解 @Aspect，定义切面类。这是一个非常常用的切面定义方式。
@Pointcut("@annotation(cn.bugstack.middleware.monitor.annotation.DoMonitor)")，定义切点。在 Pointcut 中提供了很多的切点寻找方式，有指定方法名称的、有范围筛选表达式的，也有我们现在通过自定义注解方式的。一般在中间件开发中，自定义注解方式使用的比较多，因为它可以更加灵活的运用到各个业务系统中。
@Around("aopPoint() && @annotation(doMonitor)")，可以理解为是对方法增强的织入动作，有了这个注解的效果就是在你调用已经加了自定义注解 @DoMonitor 的方法时，会先进入到此切点增强的方法。那么这个时候就你可以做一些对方法的操作动作了，比如我们要做一些方法监控和日志打印等。
最后在 doRouter 方法体中获取把方法执行 jp.proceed(); 使用 try finally 包装起来，并打印相关的监控信息。这些监控信息的获取最后都是可以通过异步消息的方式发送给服务端，再由服务器进行处理监控数据和处理展示到监控页面。

4. 初始化切面类

cn.bugstack.middleware.monitor.config.MonitorAutoConfigure

@Configuration
public class MonitorAutoConfigure {

    @Bean
    @ConditionalOnMissingBean
    public DoJoinPoint point(){
        return new DoJoinPoint();
    }

}

@Configuration，可以算作是一个组件注解，在 SpringBoot 启动时可以进行加载创建出 Bean 文件。因为 @Configuration 注解有一个 @Component 注解
MonitorAutoConfigure 可以处理自定义在 yml 中的配置信息，也可以用于初始化 Bean 对象，比如在这里我们实例化了 DoJoinPoint 切面对象。

5. 运行测试

5.1 引入 POM 配置

<!-- 监控方式：AOP -->
<dependency>
    <groupId>cn.bugstack.middleware</groupId>
    <artifactId>cn-bugstack-middleware-aop</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

5.2 方法上配置监控注册

@DoMonitor(key = "cn.bugstack.middleware.UserController.queryUserInfo", desc = "查询用户信息")
@RequestMapping(path = "/api/queryUserInfo", method = RequestMethod.GET)
public UserInfo queryUserInfo(@RequestParam String userId) {
    logger.info("查询用户信息，userId：{}", userId);
    return new UserInfo("虫虫:" + userId, 19, "天津市东丽区万科赏溪苑14-0000");
}

在通过 POM 引入自己的开发的组件后，就可以通过自定义的注解，拦截方法获取监控信息。

5.3 测试结果

2021-07-04 23:21:10.710  INFO 19376 --- [nio-8081-exec-1] c.b.m.test.interfaces.UserController     : 查询用户信息，userId：aaa
监控 - Begin By AOP
监控索引：cn.bugstack.middleware.UserController.queryUserInfo
监控描述：查询用户信息
方法名称：queryUserInfo
方法耗时：6ms
监控 - End

通过启动 SpringBoot 程序，在网页中打开 URL 地址：http://localhost:8081/api/queryUserInfo?userId=aaa，可以看到已经可以把监控信息打印到控制台了。
此种通过自定义注解的配置方式，能解决一定的硬编码工作，但如果在方法上大量的添加注解，也是需要一定的开发工作的。

接下来我们开始介绍关于使用字节码插桩非入侵的方式进行系统监控，关于字节码插桩常用的有三个组件，包括：ASM、Javassit、Byte-Buddy，接下来我们分别介绍它们是如何使用的。

四、ASM

ASM 是一个 Java 字节码操控框架。它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件，也可以在类被加载入 Java 虚拟机之前动态改变类行为。Java class 被存储在严格格式定义的 .class 文件里，这些类文件拥有足够的元数据来解析类中的所有元素：类名称、方法、属性以及 Java 字节码（指令）。ASM 从类文件中读入信息后，能够改变类行为，分析类信息，甚至能够根据用户要求生成新类。

1. 先来个测试

cn.bugstack.middleware.monitor.test.ApiTest

private static byte[] generate() {
    ClassWriter classWriter = new ClassWriter(0);
    // 定义对象头；版本号、修饰符、全类名、签名、父类、实现的接口
    classWriter.visit(Opcodes.V1_7, Opcodes.ACC_PUBLIC, "cn/bugstack/demo/asm/AsmHelloWorld", null, "java/lang/Object", null);
    // 添加方法；修饰符、方法名、描述符、签名、异常
    MethodVisitor methodVisitor = classWriter.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
    // 执行指令；获取静态属性
    methodVisitor.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
    // 加载常量 load constant
    methodVisitor.visitLdcInsn("Hello World ASM!");
    // 调用方法
    methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
    // 返回
    methodVisitor.visitInsn(Opcodes.RETURN);
    // 设置操作数栈的深度和局部变量的大小
    methodVisitor.visitMaxs(2, 1);
    // 方法结束
    methodVisitor.visitEnd();
    // 类完成
    classWriter.visitEnd();
    // 生成字节数组
    return classWriter.toByteArray();
}

以上这段代码就是基于 ASM 编写的 HelloWorld，整个过程包括：定义一个类的生成 ClassWriter、设定版本、修饰符、全类名、签名、父类、实现的接口，其实也就是那句；public class HelloWorld
类型描述符：

Java 类型类型描述符
boolean Z
char C
byte B
short S
int I
float F
long J
double D
Object Ljava/lang/Object;
int[] [I
Object[][] [[Ljava/lang/Object;
方法描述符：

源文件中的方法声明方法描述符
void m(int i, float f) (IF)V
int m(Object o) (Ljava/lang/Object;)I
int[] m(int i, String s) (ILjava/lang/String;)[I
Object m(int[] i) ([I)Ljava/lang/Object;
执行指令；获取静态属性。主要是获得 System.out
加载常量 load constant，输出我们的HelloWorld methodVisitor.visitLdcInsn("Hello World");
最后是调用输出方法并设置空返回，同时在结尾要设置操作数栈的深度和局部变量的大小。
这样输出一个 HelloWorld 是不还是蛮有意思的，虽然你可能觉得这编码起来实在太难了吧，也非常难理解。不过你可以安装一个 ASM 在 IDEA 中的插件 ASM Bytecode Outline，能更加方便的查看一个普通的代码在使用 ASM 的方式该如何处理。
另外以上这段代码的测试结果，主要是生成一个 class 文件和输出 Hello World ASM! 结果。

Java 类型	类型描述符
boolean	Z
char	C
byte	B
short	S
int	I
float	F
long	J
double	D
Object	Ljava/lang/Object;
int[]	[I
Object[][]	[[Ljava/lang/Object;

源文件中的方法声明	方法描述符
void m(int i, float f)	(IF)V
int m(Object o)	(Ljava/lang/Object;)I
int[] m(int i, String s)	(ILjava/lang/String;)[I
Object m(int[] i)	([I)Ljava/lang/Object;

2. 监控设计工程结构

cn-bugstack-middleware-asm
└── src
    ├── main
    │   ├── java
    │   │   └── cn.bugstack.middleware.monitor
    │   │       ├── config
    │   │       │   ├── MethodInfo.java
    │   │       │   └── ProfilingFilter.java
    │   │       ├── probe
    │   │       │   ├── ProfilingAspect.java
    │   │       │   ├── ProfilingClassAdapter.java
    │   │       │   ├── ProfilingMethodVisitor.java
    │   │       │   └── ProfilingTransformer.java
    │   │       └── PreMain.java
    │   └── resources	
    │       └── META_INF
    │           └── MANIFEST.MF
    └── test
        └── java
            └── cn.bugstack.middleware.monitor.test
                └── ApiTest.java

以上工程结构是使用 ASM 框架给系统方法做增强操作，也就是相当于通过框架完成硬编码写入方法前后的监控信息。不过这个过程转移到了 Java 程序启动时在 Javaagent#premain 进行处理。

MethodInfo 是方法的定义，主要是描述类名、方法名、描述、入参、出参信息。
ProfilingFilter 是监控的配置信息，主要是过滤一些不需要字节码增强操作的方法，比如main、hashCode、javax/等
ProfilingAspect、ProfilingClassAdapter、ProfilingMethodVisitor、ProfilingTransformer，这四个类主要是完成字节码插装操作和输出监控结果的类。
PreMain 提供了 Javaagent 的入口，JVM 首先尝试在代理类上调用 premain 方法。
MANIFEST.MF 是配置信息，主要是找到 Premain-Class Premain-Class: cn.bugstack.middleware.monitor.PreMain

3. 监控类入口

cn.bugstack.middleware.monitor.PreMain

public class PreMain {

    //JVM 首先尝试在代理类上调用以下方法
    public static void premain(String agentArgs, Instrumentation inst) {
        inst.addTransformer(new ProfilingTransformer());
    }

    //如果代理类没有实现上面的方法，那么 JVM 将尝试调用该方法
    public static void premain(String agentArgs) {
    }

}

这个是 Javaagent 技术的固定入口方法类，同时还需要把这个类的路径配置到 MANIFEST.MF 中。

4. 字节码方法处理

cn.bugstack.middleware.monitor.probe.ProfilingTransformer

public class ProfilingTransformer implements ClassFileTransformer {

    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
        try {
            if (ProfilingFilter.isNotNeedInject(className)) {
                return classfileBuffer;
            }
            return getBytes(loader, className, classfileBuffer);
        } catch (Throwable e) {
            System.out.println(e.getMessage());
        }
        return classfileBuffer;
    }

    private byte[] getBytes(ClassLoader loader, String className, byte[] classfileBuffer) {
        ClassReader cr = new ClassReader(classfileBuffer);
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
        ClassVisitor cv = new ProfilingClassAdapter(cw, className);
        cr.accept(cv, ClassReader.EXPAND_FRAMES);
        return cw.toByteArray();
    }

}

使用 ASM 核心类 ClassReader、ClassWriter、ClassVisitor，处理传入进行的类加载器、类名、字节码等，负责字节码的增强操作。
此处主要是关于 ASM 的操作类，ClassReader、ClassWriter、ClassVisitor，关于字节码编程的文章：ASM、Javassist、Byte-bu 系列文章

5.字节码方法解析

cn.bugstack.middleware.monitor.probe.ProfilingMethodVisitor

public class ProfilingMethodVisitor extends AdviceAdapter {

    private List<String> parameterTypeList = new ArrayList<>();
    private int parameterTypeCount = 0;     // 参数个数
    private int startTimeIdentifier;        // 启动时间标记
    private int parameterIdentifier;        // 入参内容标记
    private int methodId = -1;              // 方法全局唯一标记
    private int currentLocal = 0;           // 当前局部变量值
    private final boolean isStaticMethod;   // true；静态方法，false；非静态方法
    private final String className;

    protected ProfilingMethodVisitor(int access, String methodName, String desc, MethodVisitor mv, String className, String fullClassName, String simpleClassName) {
        super(ASM5, mv, access, methodName, desc);
        this.className = className;
        // 判断是否为静态方法，非静态方法中局部变量第一个值是this，静态方法是第一个入参参数
        isStaticMethod = 0 != (access & ACC_STATIC);
        //(String var1,Object var2,String var3,int var4,long var5,int[] var6,Object[][] var7,Req var8)=="(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;IJ[I[[Ljava/lang/Object;Lorg/itstack/test/Req;)V"
        Matcher matcher = Pattern.compile("(L.*?;|\\\\[{0,2}L.*?;|[ZCBSIFJD]|\\\\[{0,2}[ZCBSIFJD]{1})").matcher(desc.substring(0, desc.lastIndexOf(')') + 1));
        while (matcher.find()) {
            parameterTypeList.add(matcher.group(1));
        }
        parameterTypeCount = parameterTypeList.size();
        methodId = ProfilingAspect.generateMethodId(new MethodInfo(fullClassName, simpleClassName, methodName, desc, parameterTypeList, desc.substring(desc.lastIndexOf(')') + 1)));
    }     

    //... 一些字节码插桩操作 
}

当程序启动加载的时候，每个类的每一个方法都会被监控到。类的名称、方法的名称、方法入参出参的描述等，都可以在这里获取。
为了可以在后续监控处理不至于每一次都去传参（方法信息）浪费消耗性能，一般这里都会给每个方法生产一个全局防重的 id ，通过这个 id 就可以查询到对应的方法。
另外从这里可以看到的方法的入参和出参被描述成一段指定的码，(II)Ljava/lang/String; ，为了我们后续对参数进行解析，那么需要将这段字符串进行拆解。

6. 运行测试

6.1 配置 VM 参数 Javaagent

-javaagent:E:\\itstack\\git\\github.com\\MonitorDesign\\cn-bugstack-middleware-asm\\target\\cn-bugstack-middleware-asm.jar

IDEA 运行时候配置到 VM options 中，jar包地址按照自己的路径进行配置。

6.2 测试结果

监控 - Begin By ASM
方法：cn.bugstack.middleware.test.interfaces.UserController$$EnhancerBySpringCGLIB$$8f5a18ca.queryUserInfo
入参：null 入参类型：["Ljava/lang/String;"] 入数[值]：["aaa"]
出参：Lcn/bugstack/middleware/test/interfaces/dto/UserInfo;以上是关于调研字节码插桩技术，用于互联网分布式系统监控设计和实现！的主要内容，如果未能解决你的问题，请参考以下文章 
 调研字节码插桩技术，用于系统监控设计和实现
 字节码Javassist 通过字节码插桩监控方法采集运行时入参 出参和异常信息
 字节码插桩AOP 技术 ( “字节码插桩“ 技术简介 | AspectJ 插桩工具 | ASM 插桩工具 )
 ASM 字节码插桩：监控大图加载
 ASM 字节码插桩：监控大图加载
 Java 字节码插桩技术