开源诊断利器Arthas ByteKit 深度解读(1)：基本原理介绍

Arthas ByteKit 深度解读(1)：基本原理介绍

前言

本文由整体到局部的思路展开分析Arthas ByteKit 字节码处理框架，结合类图和数据流图，介绍ByteKit字节码处理流程及核心对象。

简介

Arthas ByteKit 为新开发的字节码 工具 库，基于ASM提供更高层的字节码处理能力，面向诊断/APM领域，不是通用的字节码库。ByteKit期望能提供一套简洁的API，让开发人员可以比较轻松的完成字节码增强。

本文主要介绍以下几点：

• ByteKit 基本用法

• ByteKit 字节码处理流程

• 如何解析Interceptor Class

• ByteKit 字节码核心处理逻辑

• LocationMatcher/Location的魔力

• @Binding 原理介绍

基本概念

首先介绍ByteKit的基本概念：

• Target class : 拦截的目标类，本文中为Sample类；

• Interceptor class :  用户定义的拦截器类，定义了目标类的字节码增强逻辑，本文为SampleInterceptor；

• ExceptionSuppressHandler : 拦截器使用的异常处理器，用于捕获处理拦截方法意外抛出的异常；

• ClassNode/MethodNode : 通过Java asm 工具库将二进制的class字节码转换成的结构化对象；

基本用法

为了理解起来更加清晰，对 com.example.ByteKitDemo 进行简单修改，避免内部类造成的干扰，抽取几个独立类如下：

• SampleDemo: 测试入口类

• Sample: 要增强的目标类

• SampleInterceptor: Sample类的拦截器

• PrintExceptionSuppressHandler: 异常处理器

• EnhanceUtil: ByteKit 处理逻辑封装

package com.example;

import com.alibaba.arthas.deps.org.objectweb.asm.tree.ClassNode;
import com.alibaba.arthas.deps.org.objectweb.asm.tree.MethodNode;
import com.taobao.arthas.bytekit.asm.MethodProcessor;
import com.taobao.arthas.bytekit.asm.binding.Binding;
import com.taobao.arthas.bytekit.asm.interceptor.InterceptorProcessor;
import com.taobao.arthas.bytekit.asm.interceptor.annotation.AtEnter;
import com.taobao.arthas.bytekit.asm.interceptor.annotation.AtExceptionExit;
import com.taobao.arthas.bytekit.asm.interceptor.annotation.AtExit;
import com.taobao.arthas.bytekit.asm.interceptor.annotation.ExceptionHandler;
import com.taobao.arthas.bytekit.asm.interceptor.parser.DefaultInterceptorClassParser;
import com.taobao.arthas.bytekit.utils.AgentUtils;
import com.taobao.arthas.bytekit.utils.AsmUtils;
import com.taobao.arthas.bytekit.utils.Decompiler;

import java.util.Arrays;
import java.util.List;


// 要拦截增强的目标类
class Sample {
    private int exceptionCount = 0;

    public String hello(String str, boolean exception) {
        if (exception) {
            exceptionCount++;
            throw new RuntimeException("test exception, str: " + str);
        }
        return "hello " + str;
    }
}

// Sample 类的拦截器
class SampleInterceptor {

    // 拦截方法Entry点进行处理
    @AtEnter(inline = false, suppress = RuntimeException.class, suppressHandler = PrintExceptionSuppressHandler.class)
    public static void atEnter(@Binding.This Object object,
                               @Binding.Class Object clazz,
                               @Binding.Args Object[] args,
                               @Binding.MethodName String methodName,
                               @Binding.MethodDesc String methodDesc) {
        System.out.println("atEnter, args[0]: " + args[0]);
    }

    // 拦截方法正常返回的语句，在返回前进行处理
    @AtExit(inline = true)
    public static void atExit(@Binding.Return Object returnObject) {
        System.out.println("atExit, returnObject: " + returnObject);
    }

    // 拦截方法内部抛出异常点
    @AtExceptionExit(inline = true, onException = RuntimeException.class)
    public static void atExceptionExit(@Binding.Throwable RuntimeException ex,
                                       @Binding.Field(name = "exceptionCount") int exceptionCount) {
        System.out.println("atExceptionExit, ex: " + ex.getMessage() + ", field exceptionCount: " + exceptionCount);
    }
}

// 异常处理器
class PrintExceptionSuppressHandler {

    @ExceptionHandler(inline = true)
    public static void onSuppress(@Binding.Throwable Throwable e, @Binding.Class Object clazz) {
        System.out.println("exception handler: " + clazz);
        e.printStackTrace();
    }
}

// ByteKit 处理逻辑封装
class EnhanceUtil {

    public static byte[] enhanceClass(Class targetClass, String[] targetMethodNames, Class interceptorClass) throws Exception {
        // 初始化Instrumentation
        AgentUtils.install();

        // 解析定义的 Interceptor类 和相关的注解
        DefaultInterceptorClassParser interceptorClassParser = new DefaultInterceptorClassParser();
        List<InterceptorProcessor> processors = interceptorClassParser.parse(interceptorClass);

        // 加载字节码
        ClassNode classNode = AsmUtils.loadClass(targetClass);

        List<String> methodNameList = Arrays.asList(targetMethodNames);

        // 对加载到的字节码做增强处理
        for (MethodNode methodNode : classNode.methods) {
            if (methodNameList.contains(methodNode.name)) {
                MethodProcessor methodProcessor = new MethodProcessor(classNode, methodNode);
                for (InterceptorProcessor interceptor : processors) {
                    interceptor.process(methodProcessor);
                }
            }
        }

        // 获取增强后的字节码
        return AsmUtils.toBytes(classNode);
    }

}

//测试入口类
class SampleDemo {

    public static void main(String[] args) throws Exception {

        // 启动Sample
        System.out.println("before retransform ...");
        try {
            Sample sample = new Sample();
            sample.hello("1", false);
            sample.hello("2", true);
        } catch (Exception e) {
            e.printStackTrace(System.out);
        }
        System.out.println();


        // 对Sample类的hello方法进行拦截处理，返回增强后的字节码
        byte[] bytes = EnhanceUtil.enhanceClass(Sample.class, new String[]{"hello"}, SampleInterceptor.class);

        // 查看反编译结果
        //System.out.println(Decompiler.decompile(bytes));

        // 通过 reTransform 增强类
        AgentUtils.reTransform(Sample.class, bytes);


        // 启动Sample
        System.out.println("after retransform ...");
        try {
            Sample sample = new Sample();
            sample.hello("3", false);
            sample.hello("4", true);
        } catch (Exception e) {
            e.printStackTrace(System.out);
        }
    }

}

SampleInterceptor 拦截器类解析

// Sample 类的拦截器
class SampleInterceptor {

    // 拦截方法Entry点进行处理
    @AtEnter(inline = false, suppress = RuntimeException.class, suppressHandler = PrintExceptionSuppressHandler.class)
    public static void atEnter(@Binding.This Object object,
                               @Binding.Class Object clazz,
                               @Binding.Args Object[] args,
                               @Binding.MethodName String methodName,
                               @Binding.MethodDesc String methodDesc) {
        System.out.println("atEnter, args[0]: " + args[0]);
    }

    // 拦截方法正常返回的语句，在返回前进行处理
    @AtExit(inline = true)
    public static void atExit(@Binding.Return Object returnObject) {
        System.out.println("atExit, returnObject: " + returnObject);
    }

    // 拦截方法内部抛出异常点
    @AtExceptionExit(inline = true, onException = RuntimeException.class)
    public static void atExceptionExit(@Binding.Throwable RuntimeException ex,
                                       @Binding.Field(name = "exceptionCount") int exceptionCount) {
        System.out.println("atExceptionExit, ex: " + ex.getMessage() + ", field exceptionCount: " + exceptionCount);
    }
}

• @AtEnter
  @AtExit
  @AtExceptionExit
  

• 用 @Binding.Xxx 注解绑定了不同的参数；

• @AtEnter
  inline = false
  SampleInterceptor.atEnter()
  

• @AtExit
  inline = true
  SampleInterceptor.atExit()
  

• @AtEnter
  suppress = RuntimeException.class
  suppressHandler = PrintExceptionSuppressHandler.class
  try/catch
  

• @AtExceptionExit 在原方法体范围try-catch 指定异常进行处理。

@ExceptionHandler 解析：

在上面的 @AtEnter 配置里，生成的代码会被 try/catch 包围，那么具体的内容是在 PrintExceptionSuppressHandler 里。

将增强后的字节码反编译得到的代码如下，为方便理解加上注释：

   public String hello(String str, boolean exception) {
   
      // @AtEnter 原方法体之前插入拦截代码：inline=false 调用拦截方法SampleInterceptor.atEnter()
      try {
         SampleInterceptor.atEnter(this, Sample.class, new Object[]{str, new Boolean(exception)}, "hello", "(Ljava/lang/String;Z)Ljava/lang/String;");
      } catch (RuntimeException var11) { // suppress 在拦截方法后插入try-catch指定异常
      
         // inline 展开suppressHandler (PrintExceptionSuppressHandler.class)
         Class var6 = Sample.class;
         System.out.println("exception handler: " + var6);
         var11.printStackTrace();
      }

      try {
         // 原hello方法处理逻辑
         if (exception) {// 66
            ++this.exceptionCount;// 67
            throw new RuntimeException("test exception, str: " + str);// 68
         } else {
            String var3 = "hello " + str;// 70
            
            // @AtExit return语句前插入inline 展开SampleInterceptor.atExit()方法内容
            System.out.println("atExit, returnObject: " + var3);
            // 原hello方法的return语句
            return var3;
         }
      } catch (RuntimeException var10) { // @AtExceptionExit 在原方法体范围try-catch指定异常
      
         // inline 展开SampleInterceptor.atExceptionExit()方法内容
         int var9 = this.exceptionCount;
         System.out.println("atExceptionExit, ex: " + var10.getMessage() + ", field exceptionCount: " + var9);
         throw var10;
      }
   }

字节码处理流程

asm字节码处理流程：

目标类 class bytes -> ClassReader解析 -> ClassVisitor增强修改字节码 -> ClassWriter生成增强后的 class bytes -> 通过Instrumentation解析加载为新的Class.

ByteKit 字节码处理流程：

ByteKit对比asm的改进：

• 用户只需要定义Interceptor class 及 Exception handler class，ByteKit自动将拦截方法的代码以字节码形式织入目标类，替代asm的ClassVisitor字节码指令相关处理；

• Interceptor class 及 Exception handler class 完全是 Java 语法，不需要编写任何Java 字节码指令代码，大幅降低使用门槛；

• Interceptor class 支持非常丰富的 @AtXxx 代码拦截点，除了常见的方法进入/退出/异常拦截点外，还包括行号/调用方法/访问字段/同步块等
• 支持丰富的 @Binding 参数绑定，如this对象/Class/返回值/方法入参/局部变量/字段/调用方法的名称/调用方法的参数/行号等

• 支持inline方式将拦截器的代码内联到目标方法中

• invokeOrigin技术，在原方法前后插入代码，直接使用原方法的参数及局部变量！

其它特性，详细内容可以参考ByteKit文档。

从ByteKit的样例代码及上面的处理流程图，我们得知Interceptor class 是最为关键的信息，包含了用户定义的拦截处理逻辑。ByteKit 需要将Interceptor class 转换为程序可以使用的描述性数据结构，然后根据这些描述数据修改目标类的字节码。ByteKit的主要处理步骤：

• 解析Interceptor Class的 @AtXxx , @Binding 等注解，生成InterceptorProcessor对象集合；

• 遍历InterceptorProcessor集合，修改原方法的字节码；

ByteKit 核心类图

橙色的3个类是用户定义的Target类和拦截器，上面已经进行说明。这里列举一下ByteKit核心类及其作用：

• InterceptorClassParser
  DefaultInterceptorClassParser
  @AtXxx
  InterceptorProcessorParser
  

• InterceptorProcessorParser
  @AtXxx
  InterceptorProcessor
  LocationMatcher
  InterceptorMethodConfig
  Binding
  

• InterceptorProcessor : 拦截器字节码处理类，也是用户定义的拦截方法的解析结果，每一个拦截方法生成一个 InterceptorProcessor 实例；
• MethodProcessor : Target方法处理类，包含原始方法的ClassNode和MethodNode；
• InterceptorMethodConfig : 拦截方法的VO类，记录了方法签名及其Binding等信息；

• 

• @AtXxx : 拦截点注解，标记在拦截方法上；

• LocationMatcher
  Location
  @AtXxx
  LocationMatcher
  

• Location
  @AtXxx
  Location
  

• StackSaver : 将栈数据保存到隐藏变量或者从隐藏局部变量加载到栈上。

• 

• @Binding.Xxx : 拦截方法的参数绑定注解，按用户定义的参数顺序准备相应的数据到栈上；
• XxxBindingParser : @Binding.Xxx 注解的解析类，生成对应的Binding子类；
• Binding : @Binding.Xxx 绑定注解的字节码处理类，每个 @Binding.Xxx 有一个对应的Binding子类，负责@Binding.Xxx 参数的栈数据处理逻辑；

解析Interceptor Class

遍历Interceptor 的静态方法，解析每个方法上的 @AtXxx 注解和@Binding.Xxx注解，生成InterceptorProcessor对象。

public class DefaultInterceptorClassParser implements InterceptorClassParser {

    public List<InterceptorProcessor> parse(Class<?> clazz) {
        final List<InterceptorProcessor> result = new ArrayList<InterceptorProcessor>();

   // 拦截方法回调处理函数
        MethodCallback methodCallback = new MethodCallback() {

            @Override
            public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
           // 枚举拦截方法标记的所有Annatation注解
                for (Annotation onMethodAnnotation : method.getAnnotations()) {
                    for (Annotation onAnnotation : onMethodAnnotation.annotationType().getAnnotations()) {
                      // 找到InterceptorParserHander的子类，即@AtXxx注解
                        if (InterceptorParserHander.class.isAssignableFrom(onAnnotation.annotationType())) {
       // 判断是否为静态方法
                            if (!Modifier.isStatic(method.getModifiers())) {
                                throw new IllegalArgumentException("method must be static. method: " + method);
                            }

       // 找到@AtXxx注解指定的parserHander类并实例化
                            InterceptorParserHander handler = (InterceptorParserHander) onAnnotation;
                            InterceptorProcessorParser interceptorProcessorParser = InstanceUtils
                                    .newInstance(handler.parserHander());
                                    
                            // 调用InterceptorProcessorParser.parse()解析拦截方法生成InterceptorProcessor对象
                            InterceptorProcessor interceptorProcessor = interceptorProcessorParser.parse(method,
                                    onMethodAnnotation);
                            result.add(interceptorProcessor);
                        }
                    }
                }
            }

        };
        
        //枚举拦截器的所有方法
        ReflectionUtils.doWithMethods(clazz, methodCallback);

        return result;
    }
}

结合下面的@AtEnter注解进行理解：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@java.lang.annotation.Target(ElementType.METHOD)
// parserHander属性指定本注解的Parser类为EnterInterceptorProcessorParser.class
@InterceptorParserHander(parserHander = EnterInterceptorProcessorParser.class)
public @interface AtEnter {
    boolean inline() default true;

    Class<? extends Throwable> suppress() default None.class;

    Class<?> suppressHandler() default Void.class;

    class EnterInterceptorProcessorParser implements InterceptorProcessorParser {

        @Override
        public InterceptorProcessor parse(Method method, Annotation annotationOnMethod) {

   // 创建本注解的LocationMatcher实例：EnterLocationMatcher
            LocationMatcher locationMatcher = new EnterLocationMatcher();

   // 创建 InterceptorProcessor
            AtEnter atEnter = (AtEnter) annotationOnMethod;

            return InterceptorParserUtils.createInterceptorProcessor(method,
                    locationMatcher,
                    atEnter.inline(),
                    atEnter.suppress(),
                    atEnter.suppressHandler());

        }

    }
}

@Binding.Xxx解析过程与 @AtXxx 注解类似，这里不再展开说明。

核心处理逻辑

上一小节主要讲解Interceptor class的解析过程，本小节主要是讲解ByteKit怎么实现字节码增强的核心逻辑。 InterceptorProcessor.process() 的字节码处理核心逻辑如下：

此方法为最主要的字节码处理逻辑，这里涉及到ByteKit核心的几个字节码处理类：

• MethodProcessor 实例是原始方法封装对象，可以理解为原材料；

• 各种LocationMatcher、Binding子类可以理解为各种配件；

• InterceptorProcessor 实例可以理解为某个拦截方法的套件工具，对MethodProcessor进行处理后即完成了这个拦截方法的字节码增强；

每个InterceptorProcessor实例的处理过程：

1. 通过LocationMatcher计算得到Location集合；

2. 遍历Location集合进行处理；

3. 根据需要使用StackSaver保存当前栈数据到隐藏变量，某些Binding会从隐藏变量加载数据；

4. 遍历处理Binding集合，本拦截方法的每个@Binding.Xxx参数都需要依次处理；

5. 插入拦截方法调用指令，如SampleInterceptor.atEnter()；

6. 根据需要处理拦截方法的返回值，支持使用拦截方法返回值替换修改原方法return值或者丢弃多余的拦截方法返回值；

7. 拦截方法的supress异常处理；

8. 如果拦截方法注解配置 inline=true ，则展开拦截方法的内容，替换掉前面(5)插入的拦截方法调用指令；

9. 处理下一个Location；

LocationMatcher/Location 的魔力

学习ByteKit框架时，一直有一个问题困扰着我：

LocationMatcher/Location 这个是什么？与 @AtXxx 注解有什么关系？

单从字面理解LocationMatcher/Location有困难，那么我们顺着ByteKit处理字节码的思路来推导一下。

ByteKit 处理流程与传统asm ClassVisitor不同：

• ClassVisitor是在遍历原始方法指令时修改插入新增的指令；

• ByteKit是遍历Interceptor拦截方法，将每个拦截方法的增强逻辑应用于原始方法上；

两者指令定位的差异：

• ClassVisitor在visitXxx方法中进行判断是否遇到期望的指令，如方法调用指令、return指令等；

• ByteKit也需要定位每个拦截方法的开始指令，这个就是通过LocationMatcher来实现；

ByteKit 指令定位过程

1.解析Interceptor class生成定位规则

• 预处理解析Interceptor class时，没有Target class的信息，不可能产生Target class相关的字节码数据，所以此时ByteKit 生成了LocationMatcher实例和Binding实例。Binding是参数绑定的规则，LocationMatcher则是指令定位规则。

• 不同的拦截注解 @AtXxx 的定位规则不同，所以会有对应的LocationMatcher子类；

2.通过定位规则计算定位点

• LocationMatcher 对MethodProcessor实例计算处理后，生成Location实例集合。Location 即指令定位点，记录了当前拦截方法指令处理的 开始指令 。

• 这里体现了asm指令列表InsnList的双向链表的妙处，通过某个指令可以很方便地前或者往后遍历或者插入新的指令，即使这个指令前后多次修改插入其它指令，仍然可以正确定位！

问题答案：LocationMatcher 为拦截方法 @AtXxx 注解的定位规则，Location 为具体的指令定位点。

LocationMatcher分析

1.EnterLocationMatcher 将原始方法体开始的第一条有效指令enterInsnNode封装为EnterLocation。

public class EnterLocationMatcher implements LocationMatcher {

    @Override
    public List<Location> match(MethodProcessor methodProcessor) {
        List<Location> locations = new ArrayList<Location>();
        AbstractInsnNode enterInsnNode = methodProcessor.getEnterInsnNode();

        LocationFilter locationFilter = methodProcessor.getLocationFilter();
        if (locationFilter.allow(enterInsnNode, LocationType.ENTER, true)) {
            EnterLocation enterLocation = new EnterLocation(enterInsnNode);
            locations.add(enterLocation);
        }
        return locations;
    }
}

2.ExitLocationMatcher

一个LocationMatcher可能计算产生多个Location实例，比如@AtExit的ExitLocationMatcher 会查找到原始方法中所有return指令，为每个return指令生成一个ExitLocation。

public class ExitLocationMatcher implements LocationMatcher {

    @Override
    public List<Location> match(MethodProcessor methodProcessor) {
        List<Location> locations = new ArrayList<Location>();
        AbstractInsnNode insnNode = methodProcessor.getEnterInsnNode();

        while (insnNode != null) {
            if (insnNode instanceof InsnNode) {
                InsnNode node = (InsnNode) insnNode;
                // 判断是否某种return指令
                if (matchExit(node)) {
                    LocationFilter locationFilter = methodProcessor.getLocationFilter();
                    // 检查是否为允许的Location，主要是防止重复增强字节码
                    if (locationFilter.allow(node, LocationType.EXIT, false)) {
                    // 创建Location
                        ExitLocation ExitLocation = new ExitLocation(node);
                        locations.add(ExitLocation);
                    }
                }
            }
            insnNode = insnNode.getNext();
        }

        return locations;
    }

    public boolean matchExit(InsnNode node) {
        switch (node.getOpcode()) {
        case Opcodes.RETURN: // empty stack
        case Opcodes.IRETURN: // 1 before n/a after
        case Opcodes.FRETURN: // 1 before n/a after
        case Opcodes.ARETURN: // 1 before n/a after
        case Opcodes.LRETURN: // 2 before n/a after
        case Opcodes.DRETURN: // 2 before n/a after
            return true;
        }
        return false;
    }
}

@Binding 原理介绍

SampleInterceptor中通过 @Binding.MethodName String methodName 绑定了方法名参数，在运行时这个methodName参数就真的被填充了数据，我们来看一下到底是怎么实现这个呢？

public class MethodNameBinding extends Binding {

 @Override
 public void pushOntoStack(InsnList instructions, BindingContext bindingContext) {
  MethodProcessor methodProcessor = bindingContext.getMethodProcessor();
  AsmOpUtils.ldc(instructions, methodProcessor.getMethodNode().name);
 }

 @Override
 public Type getType(BindingContext bindingContext) {
  return Type.getType(String.class);
 }

}

这个 MethodNameBinding 实现逻辑挺简单的，插入一条 ldc method_name 指令就搞定了。

反编译的代码，第4个参数"hello"即是方法名称：

SampleInterceptor.atEnter(this, Sample.class, new Object[]{str, new Boolean(exception)}, "hello", "(Ljava/lang/String;Z)Ljava/lang/String;");

javap -v 查看字节码：

23: ldc           #25                 // String hello
25: ldc           #26                 // String (Ljava/lang/String;Z)Ljava/lang/String;
27: invokestatic  #32                 // Method com/example/SampleInterceptor.atEnter:(Ljava/lang/Object;Ljava/lang/Object;[Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V

这里涉及到方法调用指令 invokestatic 的使用方法：

invokestatic 用于调用静态方法，将方法的参数从左至右依次压入栈，调用静态方法时将全部参数弹出栈，然后将方法的返回值重新放入栈顶。

第23行 ldc #25 // String hello 的作用是加载常量表 Constant pool 中的 #25 常量压入栈，这个常量就是字符串"hello"。下面是常量表：

Constant pool:
  #1 = Utf8               com/example/Sample
  #2 = Class              #1             // com/example/Sample
  ...
  #16 = Utf8               hello
  #17 = Utf8               (Ljava/lang/String;Z)Ljava/lang/String;
  ...
  #25 = String             #16            // hello
  #26 = String             #17            // (Ljava/lang/String;Z)Ljava/lang/String;

简单来说，在调用 SampleInterceptor.atEnter 拦截方法前，需要将它的参数依次入栈，调用拦截方法前的参数准备工作由Binding类完成，即 Binding的作用就是将绑定参数的值依序放入栈中 。

下面介绍几种不同类型的参数绑定处理方式：

• @Binding.MethodName String methodName 这个绑定参数方法名为常量值，直接从常量表加载入栈即可。
• @Binding.Args Object[] args 这个绑定参数为拦截的目标方法的调用参数，则需要从方法的局部变量表 LocalVariableTable 中加载，并构造一个Object[]数组对象入栈，具体实现逻辑请查看《Arthas ByteKit 深度解读(2)：本地变量及参数绑定》。
• @Binding.InvokeArgs Object[] invokeArgs 这个绑定参数为目标方法中调用其它方法的参数列表，绑定的处理更加复杂，需要创建StackSaver处理栈数据保存及恢复。大概的处理流程：在调用某个方法前将当前栈数据保存起来，然后调用拦截方法，拦截方法返回之后需要恢复栈数据，最后调用原来的方法。

总结

本文介绍了Arthas ByteKit字节码框架的基本原理，通过Interceptor class/ @AtXxx 注解/ @Binding.Xxx 注解等组件简化了Java class字节码增强的编码逻辑，不需要编写Java字节码级别的处理代码，大幅降低使用门槛。各种组件职责清晰，搭配使用灵活性高，可以满足类似APM/Spy诊断等场景下的应用需要。