pfinder实现原理揭秘

1.引言

在现代软件开发过程中，性能优化和故障排查是保证应用稳定运行的关键任务之一。Java作为一种广泛使用的编程语言，其生态中涌现出了许多优秀的监控和诊断工具，诸如：SkyWalking、Zipkin等，它们帮助开发者和运维人员深入了解应用的运行状态，快速定位和解决问题。在京东内部，则使用的是自研的pfinder。

本文旨在深入探讨pfinder的核心原理和架构设计，揭示它是如何实现应用全链路监控的。我们将从pfinder的基本概念和功能开始讲起，逐步深入到其具体实现机制。

1.pfinder概述

2.1.pfinder简介

PFinder (problem finder) 是UMP团队打造的新一代APM（应用性能追踪）系统，集调用链追踪、应用拓扑、多维监控于一身，无需修改代码，只需要在启动文件增加 2 行脚本，便可实现接入。接入后便会对应用提供可观测能力，目前支持京东主流的中间件，包括：jimdb，jmq，jsf，以及一些常用的开源组件：tomcat、http client，mysql，es等。

2.2.pfinder功能

PFinder 除了具备 ump 现有功能的基础上，增加了以下重磅功能:

•多维监控: 支持按多个维度统计监控指标，按机房、按分组、按JSF别名、按调用方，各种维度随心组合查看

•自动埋点: 自动对 SpringMVC，JSF，MySQL，JMQ 等常用中间件进行性能埋点，无需改动代码，接入即可观测

•应用拓扑: 自动梳理服务的上下游和中间件的依赖拓扑

•调用链追踪: 基于请求的跨服务调用追踪，助你快速分析性能瓶颈

•自动故障分析: 通过AI算法自动分析调用拓扑上所有服务的监控数据，自动判断故障根因

•流量录制回放: 通过录制线上流量，回放至待特定环境（测试、预发），对比回放与录制时产生的差异，帮助用户补全业务场景、完善测试用例

•跨单元逃逸流量监控: 支持 JSF 跨单元流量、逃逸流量监控，单元化应用运行状态一目了然

2.3.APM类组件对比

更重要的一点是：pfinder对京东内部自研组件提供了支持，比如：jsf、jmq、jimdb

1.pfinder背后的秘密

既然pfinder是基于字节码增强实现的，那么讲到pfinder，字节码增强技术自然也是无法避开的话题。这里我将字节码增强技术分两点来说，也是我认为实现字节码增强需要解决的两个关键点：

1.字节码是为了机器设计的，而非人类，字节码可读性极差、修改门槛极高，那么我们如何修改字节码呢？

2.修改后的字节码如何注入运行时JVM中呢？

欲攻善其事，必先利其器，所以下面我们围绕着这两个问题进行展开，当然，对这方面知识已经有所掌握的同学可忽略。

3.1.字节码修改

字节码修改成熟的框架已经很多了，诸如：ASM、javassist、bytebuddy、bytekit，下面我们用这几个字节码修改框架实现一个相同的功能，来对比下这几个框架使用上的区别。现在我们通过字节码修改来实现下面的功能：





1.ASM实现

1   @Override
2        public void visitCode() {
3            super.visitCode();
4            mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
5            mv.visitLdcInsn("start");
6            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
7        }
8        @Override
9        public void visitInsn(int opcode) {
10            if ((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN) || opcode == Opcodes.ATHROW) {
11                //方法在返回之前，打印"end"
12                mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
13                mv.visitLdcInsn("end");
14                mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
15            }
16            mv.visitInsn(opcode);
17        }

1.javassist实现

1        ClassPool cp = ClassPool.getDefault();
2        CtClass cc = cp.get("com.ggc.javassist.HelloWord");
3        CtMethod m = cc.getDeclaredMethod("printHelloWord");
4        m.insertBefore("{ System.out.println("start"); }");
5        m.insertAfter("{ System.out.println("end"); }");
6        Class c = cc.toClass();
7        cc.writeFile("/Users/gonghanglin/workspace/workspace_me/bytecode_enhance/bytecode_enhance_javassist/target/classes/com/ggc/javassist");
8        HelloWord h = (HelloWord)c.newInstance();
9        h.printHelloWord();

1.bytebuddy实现

1    // 使用ByteBuddy动态生成一个新的HelloWord类
2        Class<?> dynamicType = new ByteBuddy()
3                .subclass(HelloWord.class) // 指定要修改的类
4                .method(ElementMatchers.named("printHelloWord")) // 指定要拦截的方法名
5                .intercept(MethodDelegation.to(LoggingInterceptor.class)) // 指定拦截器
6                .make()
7                .load(HelloWord.class.getClassLoader()) // 加载生成的类
8                .getLoaded();
9
10        // 创建动态生成类的实例，并调用方法
11        HelloWord dynamicService = (HelloWord) dynamicType.newInstance();
12        dynamicService.printHelloWord();

1public class LoggingInterceptor {
2    @RuntimeType
3    public static Object intercept(@AllArguments Object[] allArguments, @Origin Method method, @SuperCall Callable<?> callable) throws Exception {
4        // 打印start
5        System.out.println("start");
6        try {
7            // 调用原方法
8            Object result = callable.call();
9            // 打印end
10            System.out.println("end");
11            return result;
12        } catch (Exception e) {
13            System.out.println("exception end");
14            throw e;
15        }
16    }
17}

1.bytekit实现

1 // Parse the defined Interceptor class and related annotations
2        DefaultInterceptorClassParser interceptorClassParser = new DefaultInterceptorClassParser();
3        List<InterceptorProcessor> processors = interceptorClassParser.parse(HelloWorldInterceptor.class);
4        // load bytecode
5        ClassNode classNode = AsmUtils.loadClass(HelloWord.class);
6        // Enhanced process of loaded bytecodes
7        for (MethodNode methodNode : classNode.methods) {
8            MethodProcessor methodProcessor = new MethodProcessor(classNode, methodNode);
9            for (InterceptorProcessor interceptor : processors) {
10                interceptor.process(methodProcessor);
11            }
12        }

1public class HelloWorldInterceptor {
2    @AtEnter(inline = true)
3    public static void atEnter() {
4        System.out.println("start");
5    }
6
7    @AtExit(inline = true)
8    public static void atEit() {
9        System.out.println("end");
10    }
11}

3.2.字节码注入

相信大家经常使用idea去debug我们写的代码，我们是否想过debug是如何实现的呢？暂时先卖个关子。

1.JVMTIAgent

JVM在设计之初就考虑到了对JVM运行时内存、线程等指标的监控和分析和代码debug功能的实现，基于这两点，早在JDK5之前，JVM规范就定义了JVMPI（JVM分析接口)和JVMDI(JVM调试接口)，JDK5之后，这两个规范就合并成为了JVMTI（JVM工具接口）。JVMTI其实是一种JVM规范，每个JVM厂商都有不同的实现，另外，JVMTI接口需使用C语言开发，以动态链接的形式加载并运行。

其实idea的debug功能便是借助JVMTI实现的，具体说是利用了jre内置的jdwp agent来实现的。我们在idea中debug程序时，控制台命令如下：





这里agentlib参数就是用来跟要加载的agent的名字，比如这里的jdwp(不过这不是动态库的名字，而JVM是会做一些名称上的扩展，比如在MACOS下会去找libjdwp.dylib的动态库进行加载，也就是在名字的基础上加前缀lib,再加后缀.dylib)。

1.instrument

上面说到JVMTIAgent基于C语言开发，以动态链接的形式加载并运行，这对java开发者不太友好。在JDK5之后，JDK开始提供java.lang.instrument.Instrumentation接口，让开发者可以使用Java语言编写Agent。其实，instrument也是基于JVMTI实现的，在MACOS下instrument动态库名为libinstrument.dylib。

1.instrument和ByteBuddy实现javaagent打印方法耗时

1.agent包MANIFEST.MF配置（maven插件）

1<archive>
2   <manifestEntries>
3       // 指定premain()的所在方法
4       <Agent-CLass>com.ggc.agent.GhlAgent</Agent-CLass>
5       <Premain-Class>com.ggc.agent.GhlAgent</Premain-Class>
6       <Can-Redefine-Classes>true</Can-Redefine-Classes>
7       <Can-Retransform-Classes>true</Can-Retransform-Classes>
8   </manifestEntries>
9</archive>  	           

2.agen主类

1public class GhlAgent {
2    public static Logger log = LoggerFactory.getLogger(GhlAgent.class);
3
4    public static void agentmain(String agentArgs, Instrumentation instrumentation) {
5        log.info("agentmain方法");
6        boot(instrumentation);
7    }
8    public static void premain(String agentArgs, Instrumentation instrumentation) {
9        log.info("premain方法");
10        boot(instrumentation);
11    }
12    private static void boot(Instrumentation instrumentation) {
13        //创建一个代理增强对象
14        new AgentBuilder.Default().type(ElementMatchers.nameStartsWith("com.jd.aviation.performance.service.impl"))//拦截指定的类
15                .transform((builder, typeDescription, classLoader, javaModule) ->
16                        builder.method(ElementMatchers.isMethod().and(ElementMatchers.isPublic())
17                                ).intercept(MethodDelegation.to(TimingInterceptor.class))
18                ).installOn(instrumentation);
19    }
20}

3.拦截器

1public class TimingInterceptor {
2    public static Logger log = LoggerFactory.getLogger(TimingInterceptor.class);
3    @RuntimeType
4    public static Object intercept(@SuperCall Callable<?> callable) throws Exception {
5        long start = System.currentTimeMillis();
6        try {
7            // 原方法调用
8            return callable.call();
9        } finally {
10            long end = System.currentTimeMillis();
11            log.info("Method call took {} ms",(end - start));
12        }
13    }
14}

4.效果





1.pfinder实现原理

4.1.pfinder应用架构





1.pfinder agent启动时首先加载META-INF/pfinder/service.addon和META-INF/pfinder/plugin.addon配置文件中的服务和插件。2.根据加载的插件做字节码增强。3.使用JMTP将服务和插件产生的数据（trace、指标等）进行上报。

4.2.pfinder插件增强代码解析

1.service加载





创建SimplePFinderServiceLoader实例，在profilerBootstrap.boot(serviceLoaders)方法中加载配置文件中的service。





使用创建的SimplePFinderServiceLoader实例加载service，并返回一个service工厂的迭代器。





真正的加载走的是AddonLoader中的load方法。service加载完成后，继续看bootService方法：





bootService中完成创建service实例、注册service、初始化service，service的加载至此就完成了。

1.plugin加载&字节码增强

在介绍插件加载前，我们先了解下插件的包含了哪些信息。





增强拦截器：这个类里面放了具体的增强逻辑

增强点类型：增强时根据不同类型走不同逻辑

增强类/方法匹配器：用于匹配需要增强的类/方法

InterceptPoint是个数组，增强点可以配置多个。

plugin的加载和字节码增强发生在初始化service过程中，具体地说发生在com.jd.pfinder.profiler.service.impl.PluginRegistrar这个service初始化的过程中了。

1 protected boolean doInitialize(ProfilerContext profilerContext) {
2     AgentEnvService agentEnvService = (AgentEnvService)profilerContext.getService(AgentEnvService.class);
3     Instrumentation instrumentation = agentEnvService.instrumentation();
4     if (instrumentation == null) {
5       LOGGER.info("Instrumentation missing, PFinder PluginRegistrar enhance ignored!");
6       return false;
7     }
8     this.pluginLoaders = profilerContext.getAllService(PluginLoader.class);
9     this.enhanceHandler = new EnhancePluginHandler(profilerContext);
10     ElementMatcher.Junction<TypeDescription> typeMatcherChain = null;
11     for (PluginLoader pluginLoader : this.pluginLoaders) {
12       pluginLoader.loadPlugins(profilerContext);
13
14       for (ElementMatcher.Junction<TypeDescription> typeMatcher : (Iterable<ElementMatcher.Junction<TypeDescription>>)pluginLoader.typeMatchers()) {
15         if (typeMatcherChain == null) {
16           typeMatcherChain = typeMatcher; continue;
17         }
18         typeMatcherChain = typeMatcherChain.or((ElementMatcher)typeMatcher);
19       }
20     }
21     if (typeMatcherChain == null) {
22       LOGGER.warn("no any enhance-point. pfinder enhance will be ignore.");
23       return false;
24     }
25     ConfigurationService configurationService = (ConfigurationService)profilerContext.getService(ConfigurationService.class);
26     String enhanceExcludePolicy = (String)configurationService.get(ConfigKey.PLUGIN_ENHANCE_EXCLUDE);
27
28     LoadedClassSummaryHandler loadedClassSummaryHandler = null;
29     if (((Boolean)configurationService.get(ConfigKey.LOADED_CLASSES_SUMMARY_ENABLED, Boolean.valueOf(false))).booleanValue()) {
30       loadedClassSummaryHandler = new LoadedClassSummaryHandler.DefaultImpl(configurationService, ((ScheduledService)profilerContext.getService(ScheduledService.class)).getDefault());
31     }
32
33     (new AgentBuilder.Default())
34
35       .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
36       .with(AgentBuilder.RedefinitionStrategy.REDEFINITION)
37       .with(new AgentBuilder.RedefinitionStrategy.Listener()
38         {
39           public void onBatch(int index, List<Class<?>> batch, List<Class<?>> types) {}
40           public Iterable<? extends List<Class<?>>> onError(int index, List<Class<?>> batch, Throwable throwable, List<Class<?>> types) {
41             return Collections.emptyList();
42           }
43           public void onComplete(int amount, List<Class<?>> types, Map<List<Class<?>>, Throwable> failures) {
44             for (Map.Entry<List<Class<?>>, Throwable> entry : failures.entrySet()) {
45               for (Class<?> aClass : entry.getKey()) {
46                 PluginRegistrar.LOGGER.warn("Redefine class: {} failure! ignored!", new Object[] { aClass.getName(), entry.getValue() });
47               }
48
49             }
50           }
51         }).ignore((ElementMatcher)ElementMatchers.nameStartsWith("org.groovy.")
52         .or((ElementMatcher)ElementMatchers.nameStartsWith("jdk.nashorn."))
53         .or((ElementMatcher)ElementMatchers.nameStartsWith("javax.script."))
54         .or((ElementMatcher)ElementMatchers.nameContains("javassist"))
55         .or((ElementMatcher)ElementMatchers.nameContains(".asm."))
56         .or((ElementMatcher)ElementMatchers.nameContains("$EnhancerBySpringCGLIB$"))
57         .or((ElementMatcher)ElementMatchers.nameStartsWith("sun.reflect"))
58         .or((ElementMatcher)ElementMatchers.nameStartsWith("org.apache.jasper"))
59         .or((ElementMatcher)pfinderIgnoreMather())
60         .or((ElementMatcher)Matchers.forPatternLine(enhanceExcludePolicy))
61         .or((ElementMatcher)ElementMatchers.isSynthetic()))
62
63       .type((ElementMatcher)typeMatcherChain)
64       .transform(this)
65       .with(new Listener(loadedClassSummaryHandler))
66       .installOn(instrumentation);
67     return true;
68   }

第8行，先从上下文中取出注册的PluginLoader（插件加载器），第12行遍历插件加载器加载插件，插件加载逻辑其实和service一样，使用的都是AddonLoader中的load方法。插件加载完成之后被插件加载器持有，第14-19行则收集插件中增强类的匹配器，用于AgentBuilder的创建。AgentBuilder的创建标志着字节码增强的开始，具体的逻辑在transform的实例方法中。





transform方法中遍历插件，enhance方法中对各个插件做增强。





enhance方法中遍历各个插件的增强点数组走enhanceInterceptPoint方法做增强。





enhanceInterceptPoint方法中根据增强点类型做增强。





上图是以Advice方式增强实例方法，传递了interceptorFieldAppender和methodCacheFieldAppender两个参数，并使用AdviceMethodEnhanceInvoker访问并修改待增强的类和方法。AdviceMethodEnhanceInvoker中有onMethodEnter、onMethodExit两个方法，分别表示进入方法后和退出方法前。









AdviceMethodEnhanceInvoker中onMethodEnter、onMethodExit两个方法还会调用插件中配置interceptor对应的onMethodEnter、onMethodExit、onException方法，至此插件字节码增强就结束了。

1.我的思考

5.1.多线程traceId丢失问题

pfinder目前已经将traceId放到了MDC中，我们通过在日志配置文件中添加[%X{PFTID}]便能在日志中打印traceId。但是我们知道MDC使用的是ThreadLocal去保存的traceId，在跨线程时会出现线程丢失的情况。pfinder在这方面做了字节码增强，无论使用线程池还是@Async，都不会存在traceId丢失的问题。

1 public class TracingRunnable
2   implements PfinderWrappedRunnable
3 {
4   private final Runnable origin;
5   private final TracingSnapshot<?> snapshot;
6   private final Component component;
7   private final String operationName;
8   private final String interceptorName;
9   private final InterceptorClassLoader interceptorClassLoader;
10
11   public TracingRunnable(Runnable origin, TracingSnapshot<?> snapshot, Component component, String operationName, String interceptorName, InterceptorClassLoader interceptorClassLoader) {
12     this.origin = origin;
13     this.snapshot = snapshot;
14     this.component = component;
15     this.operationName = operationName;
16     this.interceptorClassLoader = interceptorClassLoader;
17     this.interceptorName = interceptorName;
18   }
19   public void run() {
20     TracingContext tracingContext = ContextManager.tracingContext();
21     if (tracingContext.isTracing() && tracingContext.traceId().equals(this.snapshot.getTraceId())) {
22       this.origin.run();
23       return;
24     }
25     LowLevelAroundTracingContext context = SpringAsyncTracingContext.create(this.operationName, this.interceptorName, this.snapshot, this.interceptorClassLoader, this.component);
26     context.onMethodEnter();
27     try {
28       this.origin.run();
29     } catch (RuntimeException ex) {
30       context.onException(ex);
31       throw ex;
32     } finally {
33       context.onMethodExit();
34     }
35   }
36   public Runnable getOrigin() {
37     return this.origin;
38   }
39   public String toString() {
40     return "TracingRunnable{origin=" + this.origin + ", snapshot=" + this.snapshot + ", component=" + this.component + ", operationName='" + this.operationName + ''' + '}';
41   }
42 }

拿线程池执行Runnable任务来说，pfinder通过TracingRunnable包装我们的Runnable的实现，利用构造函数将主线程的traceId通过snapshot参数传给TracingRunnable，在run方法中将参数snapshot放到上下文中，最后从上下文中取出放到子线程的MDC中，从而实现traceId跨线程传递。

5.2.热部署

既然javaagent能做字节码增强，也能实现热部署，此外， pfinder客户端和服务端通过jmtp有命令的交互，可以通过服务端向agent发送命令来实现类搜索、反编译、热更新等功能，笔者基于这一想法粗略实现了一个在线热部署的功能，具体如下：

类搜索：





反编译：





热更新：





上述只是笔者做的一个简单的实现，还有很多不足的地方：

1.对于Spring XML、MyBatis XML的支持。

2.Instrumentation的局限性：由于jvm基于安全考虑，不允许改类结构，比如新增字段，新增方法和修改类的父类等。想要突破这种局限，就需要使用Dcevm（Java Hostspot的补丁）了。

欢迎有兴趣的同学一起学习交流。