详解分布式链路监控系统

- 0
  - 0.1
    - 0.1.1
    - 0.1.2
      - 0.1.2.1
  - 0.2
    - 0.2.1
  - 0.3
    - 0.3.1
      - 0.3.1.1
    - 0.3.2

java -javaagent:/path/agent.jar=key1=value1,key2=value2 -jar myJar.jar

mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("begin of sayhello().");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);

public interface InstanceMethodsAroundInterceptor {
    // 方法执行前置扩展点
    void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
                      MethodInterceptResult result) throws Throwable;
    // 方法执行后置扩展点
    Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
                       Object ret) throws Throwable;
    // 方法抛出异常时扩展点
    void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments,
                               Class<?>[] argumentsTypes, Throwable t);
}

public static void premain(String agentArgs, Instrumentation instrumentation) throws PluginException {
    // 1. 加载所有的Skywalking插件 
    // 插件实现了Skywalking接口规范，包括需要增强哪个类、需要怎么增强这两个要素
    final PluginFinder  = new PluginFinder(new PluginBootstrap().loadPlugins());

    // 2. 构建ByteBuddy
    // ByteBuddy提供了流式的API来指定ByteBuddy类库的行为（用于各种配置）
    final ByteBuddy byteBuddy = new ByteBuddy().with(TypeValidation.of(Config.Agent.IS_OPEN_DEBUGGING_CLASS));

    // 3. 构建AgentBuilder实例，需要忽略的类
    AgentBuilder agentBuilder = new AgentBuilder.Default(byteBuddy).ignore(
        nameStartsWith("net.bytebuddy.")
        .or(nameStartsWith("org.slf4j."))
        .or(nameStartsWith("org.groovy."))
        .or(nameContains("javassist"))
        .or(nameContains(".asm."))
        .or(nameContains(".reflectasm."))
        .or(nameStartsWith("sun.reflect"))
        .or(nameStartsWith("org.apache.skywalking.")
            .and(not(nameStartsWith("org.apache.skywalking.apm.toolkit."))))
        // 忽略Java中的【Synthetic】
        // Synthetic指所有存在于字节码文件中，但是不存在于源代码中的【构造】，即JVM帮我们生产的东西
        // 比如内部类指向外部类实例的this$0字段；外部类访问内部类的私有变量时JDK帮我们生产的方法等等
        // JDK11后引入了NBAC机制，引入了新的嵌套类组织方式，不再生成Synthetic方法
        .or(ElementMatchers.isSynthetic()));

    // 4. 处理JDK9的module特性，解决跨模块类访问的问题

    // 5. 将AgentBuilder插桩在Instrumentation上
    agentBuilder
        // 根据插件的内容构建需要增强类的匹配器
        .type(pluginFinder.buildMatch())
        // Transformer就是字节码增强逻辑的主要入口
        .transform(new Transformer(pluginFinder))
        // Retransform模式：保留被修改的字节码
        // Redifine模式：覆盖被修改的字节码
        .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
        // 一些监听器
        .with(new RedefinitionListener())
        .with(new Listener())
        // 将AgentBuilder插桩在JVM提供的Instrumentation上
        .installOn(instrumentation);
}

private static class Transformer implements AgentBuilder.Transformer {
    private PluginFinder pluginFinder;

    Transformer(PluginFinder pluginFinder) {
        this.pluginFinder = pluginFinder;
    }

    /**
     * 这个方法在类加载的过程中会由JVM调用（Byte Buddy做了封装）
     * @param builder          原始类的字节码构建器
     * @param typeDescription  类描述信息
     * @param classLoader      这个类的类加载器
     * @param module           jdk9中模块信息
     * @return                 修改后的类的字节码构建器
     */
    @Override
    public DynamicType.Builder<?> transform(final DynamicType.Builder<?> builder,
                                            final TypeDescription typeDescription,
                                            final ClassLoader classLoader,
                                            final JavaModule module) {
        LoadedLibraryCollector.registerURLClassLoader(classLoader);
        // 根据类信息找到针对这个类进行字节码增强的插件，可能有多个
        List<AbstractClassEnhancePluginDefine> pluginDefines = pluginFinder.find(typeDescription);
        if (pluginDefines.size() > 0) {
            DynamicType.Builder<?> newBuilder = builder;
            EnhanceContext context = new EnhanceContext();
            for (AbstractClassEnhancePluginDefine define : pluginDefines) {
                // 调用插件的define方法得到新的字节码
                DynamicType.Builder<?> possibleNewBuilder = define.define(
                    typeDescription, newBuilder, classLoader, context);
                if (possibleNewBuilder != null) {
                    newBuilder = possibleNewBuilder;
                }
            }
            // 返回增强后的字节码给JVM，完成字节码增强
            return newBuilder;
        }
        return builder;
    }
}

public abstract class AbstractClassEnhancePluginDefine {
    public DynamicType.Builder<?> define(TypeDescription typeDescription, DynamicType.Builder<?> builder,
                                         ClassLoader classLoader, EnhanceContext context) throws PluginException {
        // witness机制
        WitnessFinder finder = WitnessFinder.INSTANCE;

        //通过类加载器找witness类，没有就直接返回，不进行字节码的改造
        String[] witnessClasses = witnessClasses();
        if (witnessClasses != null) {
            for (String witnessClass : witnessClasses) {
                if (!finder.exist(witnessClass, classLoader)) {
                    return null;
                }
            }
        }

        //通过类加载器找witness方法，没有就直接返回，不进行字节码的改造
        List<WitnessMethod> witnessMethods = witnessMethods();
        if (!CollectionUtil.isEmpty(witnessMethods)) {
            for (WitnessMethod witnessMethod : witnessMethods) {
                if (!finder.exist(witnessMethod, classLoader)) {
                    return null;
                }
            }
        }

        // enhance开始修改字节码
        DynamicType.Builder<?> newClassBuilder = this.enhance(typeDescription, builder, classLoader, context);

        // 修改完成，返回新的字节码
        context.initializationStageCompleted();
        return newClassBuilder;
    }

    protected DynamicType.Builder<?> enhance(TypeDescription typeDescription, DynamicType.Builder<?> newClassBuilder,
                                             ClassLoader classLoader, EnhanceContext context) throws PluginException {
        // 增强静态方法
        newClassBuilder = this.enhanceClass(typeDescription, newClassBuilder, classLoader);
        // 增强实例方法& 构造方法
        newClassBuilder = this.enhanceInstance(typeDescription, newClassBuilder, classLoader, context);
        return newClassBuilder;
    }
}       

public abstract class ClassEnhancePluginDefine extends AbstractClassEnhancePluginDefine {
    protected DynamicType.Builder<?> enhanceInstance(TypeDescription typeDescription,
                                                     DynamicType.Builder<?> newClassBuilder, ClassLoader classLoader,
                                                     EnhanceContext context) throws PluginException {
        // 获取插件定义的构造方法拦截点ConstructorInterceptPoint
        ConstructorInterceptPoint[] constructorInterceptPoints = getConstructorsInterceptPoints();
        // 获取插件定义的实例方法拦截点InstanceMethodsInterceptPoint
        InstanceMethodsInterceptPoint[] instanceMethodsInterceptPoints = getInstanceMethodsInterceptPoints();
        String enhanceOriginClassName = typeDescription.getTypeName();
        // 非空校验
        boolean existedConstructorInterceptPoint = false;
        if (constructorInterceptPoints != null && constructorInterceptPoints.length > 0) {
            existedConstructorInterceptPoint = true;
        }
        boolean existedMethodsInterceptPoints = false;
        if (instanceMethodsInterceptPoints != null && instanceMethodsInterceptPoints.length > 0) {
            existedMethodsInterceptPoints = true;
        }
        if (!existedConstructorInterceptPoint && !existedMethodsInterceptPoints) {
            return newClassBuilder;
        }

        // 这里就是之前提到的让类实现EnhancedInstance接口，并添加_$EnhancedClassField_ws字段
        if (!typeDescription.isAssignableTo(EnhancedInstance.class)) {
            if (!context.isObjectExtended()) {
                // Object类型、private volatie修饰符、提供方法进行访问
                newClassBuilder = newClassBuilder.defineField(
                    "_$EnhancedClassField_ws", Object.class, ACC_PRIVATE | ACC_VOLATILE)
                    .implement(EnhancedInstance.class)
                    .intercept(FieldAccessor.ofField("_$EnhancedClassField_ws"));
                context.extendObjectCompleted();
            }
        }

        // 构造方法增强
        if (existedConstructorInterceptPoint) {
            for (ConstructorInterceptPoint constructorInterceptPoint : constructorInterceptPoints) {
                // jdk核心类
                if (isBootstrapInstrumentation()) {
                    newClassBuilder = newClassBuilder.constructor(constructorInterceptPoint.getConstructorMatcher())
                        .intercept(SuperMethodCall.INSTANCE.andThen(MethodDelegation.withDefaultConfiguration()
                                                                    .to(BootstrapInstrumentBoost
                                                                    .forInternalDelegateClass(constructorInterceptPoint
                                                                                              // 非jdk核心类                                                                                                         .getConstructorInterceptor()))));
                } else {
                    // 找到对应的构造方法，并通过插件自定义的InstanceConstructorInterceptor进行增强
                    newClassBuilder = newClassBuilder.constructor(constructorInterceptPoint.getConstructorMatcher())
                        .intercept(SuperMethodCall.INSTANCE.andThen(MethodDelegation.withDefaultConfiguration()
                                                                    .to(new ConstructorInter(constructorInterceptPoint
                                                                                             .getConstructorInterceptor(), classLoader))));
                }
            }
        }

        // 实例方法增强
        if (existedMethodsInterceptPoints) {
            for (InstanceMethodsInterceptPoint instanceMethodsInterceptPoint : instanceMethodsInterceptPoints) {
                // 找到插件自定义的实例方法拦截器InstanceMethodsAroundInterceptor
                String interceptor = instanceMethodsInterceptPoint.getMethodsInterceptor();
                // 这里在插件自定义的匹配条件上加了一个【不为静态方法】的条件
                ElementMatcher.Junction<MethodDescription> junction = not(isStatic()).and(instanceMethodsInterceptPoint.getMethodsMatcher());

                // 需要重写入参
                if (instanceMethodsInterceptPoint.isOverrideArgs()) {
                    // jdk核心类
                    if (isBootstrapInstrumentation()) {
                        newClassBuilder = newClassBuilder.method(junction)
                            .intercept(MethodDelegation.withDefaultConfiguration()
                                       .withBinders(Morph.Binder.install(OverrideCallable.class))
                                       .to(BootstrapInstrumentBoost.forInternalDelegateClass(interceptor)));
                    // 非jdk核心类 
                    } else {
                            newClassBuilder = newClassBuilder.method(junction)
                                .intercept(MethodDelegation.withDefaultConfiguration()
                                           .withBinders(Morph.Binder.install(OverrideCallable.class))
                                           .to(new InstMethodsInterWithOverrideArgs(interceptor, classLoader)));
                    }
                // 不需要重写入参
                } else {
                    // jdk核心类    
                    if (isBootstrapInstrumentation()) {
                            newClassBuilder = newClassBuilder.method(junction)
                                .intercept(MethodDelegation.withDefaultConfiguration()
                                           .to(BootstrapInstrumentBoost.forInternalDelegateClass(interceptor)));
                    // 非jdk核心类                                                                  
                    } else {
                        // 找到对应的实例方法，并通过插件自定义的InstanceMethodsAroundInterceptor进行增强
                        newClassBuilder = newClassBuilder.method(junction)
                                .intercept(MethodDelegation.withDefaultConfiguration()
                                           .to(new InstMethodsInter(interceptor, classLoader)));
                    }
                }
            }
        }

        return newClassBuilder;
    }
}    

public class InstMethodsInter {
    private static final ILog LOGGER = LogManager.getLogger(InstMethodsInter.class);

    // 用户在插件中定义的实例方法拦截器
    private InstanceMethodsAroundInterceptor interceptor;

    public InstMethodsInter(String instanceMethodsAroundInterceptorClassName, ClassLoader classLoader) {
        try {
            // 加载用户在插件中定义的实例方法拦截器
            interceptor = InterceptorInstanceLoader.load(instanceMethodsAroundInterceptorClassName, classLoader);
        } catch (Throwable t) {
            throw new PluginException("Can't create InstanceMethodsAroundInterceptor.", t);
        }
    }

    /**
     * 当执行被增强方法时，会执行该intercept方法
     *
     * @param obj          实例对象（this）
     * @param allArguments 方法入参
     * @param method       参数描述
     * @param zuper        原方法调用的句柄
    *  @param method       被增强后的方法的引用 
     * @return             方法返回值
     */
    @RuntimeType
    public Object intercept(@This Object obj, @AllArguments Object[] allArguments, @SuperCall Callable<?> zuper,
        @Origin Method method) throws Throwable {
        EnhancedInstance targetObject = (EnhancedInstance) obj;

        MethodInterceptResult result = new MethodInterceptResult();
        try {
            // 拦截器前置逻辑
            interceptor.beforeMethod(targetObject, method, allArguments, method.getParameterTypes(), result);
        } catch (Throwable t) {
            LOGGER.error(t, "class[{}] before method[{}] intercept failure", obj.getClass(), method.getName());
        }

        Object ret = null;
        try {
            // 是否中断方法执行
            if (!result.isContinue()) {
                ret = result._ret();
            } else {
                // 执行原方法
                ret = zuper.call();
                // 为什么不能走method.invoke？因为method已经是被增强后方法，调用就死循环了！
                // 可以回到之前的字节码文件查看原因，看一下该intercept执行的时机
            }
        } catch (Throwable t) {
            try {
                 // 拦截器异常时逻辑
                interceptor.handleMethodException(targetObject, method, allArguments, method.getParameterTypes(), t);
            } catch (Throwable t2) {
                LOGGER.error(t2, "class[{}] handle method[{}] exception failure", obj.getClass(), method.getName());
            }
            throw t;
        } finally {
            try {
                // 拦截器后置逻辑
                ret = interceptor.afterMethod(targetObject, method, allArguments, method.getParameterTypes(), ret);
            } catch (Throwable t) {
                LOGGER.error(t, "class[{}] after method[{}] intercept failure", obj.getClass(), method.getName());
            }
        }
        return ret;
    }
}