云社区 博客 博客详情

带你轻松学 java-agent

技术火炬手 发表于 2021-04-22 09:03:51 2021-04-22
0
0

【摘要】 java-agent是应用于java的trace工具,核心是对JVMTI(JVM Tool Interface)的调用。

动态trace技术是在应用部署之后监控程序的调用,获取其中的变量内容,甚至可以插入或替换部分代码。业界的trace工具很多,ptracestraceeBPFbtracejava-agent等等。这次应用的目的是监控kafka服务中publishconsume的调用,获取依赖关系。鉴于kafka是通过Scala语言编写,所以采用了java-agent技术。

java-agent是应用于javatrace工具,核心是对JVMTIJVM Tool Interface)的调用。JVMTIjava虚拟机对外开放的一系列接口函数,通过JVMTI可以获取java虚拟机当前运行的状态。java-agent程序运行时会在java虚拟机中挂载一个agent进程,通过JVMTI监控所挂载的java应用。通过agent程序可以完成java代码的热替换,类加载的过程监控等功能。

java-agent的挂载方式有两种,一种是静态挂载,一种是动态挂载。静态挂载中,agentjava应用一起启动,在java应用初始化前agent就已经挂载完成,并开始监控java应用。动态挂载则是在应用运行过程中,通过进程ID确定挂载对象,动态的将agent挂载在目标进程上。

静态挂载

首先编写java-agent的监控程序,静态挂载的入口函数为premainpremain函数有两种,区别是传入参数不同。通常选择带有Instrumentation参数,可以使用该变量完成代码的热替换。

public static void premain(String agentArgs, Instrumentation inst);
public static void premain(String agentArgs);

下面是一个简单的例子。在premain函数中,使用Instrumentation增加一个transformer。当监控的java应用每次加载class的时候都会调用transformerDefineTransformer是一个transformer,是ClassFileTransformer的实现。在它的transform函数的入参中会给出当前加载的类名,类加载器等信息。样例中我们只是打印了加载的类名。

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import javassist.*;
 
 
public class PreMain {
 
    public static void premain(String agentArgs, Instrumentation inst) {
        System.out.println("agentArgs : " + agentArgs);
        inst.addTransformer(new DefineTransformer(), true);
    }
 
    static class DefineTransformer implements ClassFileTransformer{
 
        @Override
        public byte[] transform(ClassLoader loader,
                                String className,
                                Class<?> classBeingRedefined,
                                ProtectionDomain protectionDomain,
                                byte[] classfileBuffer){
            System.out.println("premain load Class:" + className);
            return classfileBuffer;
        }
    }
}

运行java-agent需要将上述程序打包成一个jar文件,在jar文件的MANIFEST.MF中需要包含以下几项

Can-Redefine-Classes: true
Can-Retransform-Classes: true
Premain-Class: com.huawei.PreMain

Premain-Class声明了这个jarpremain函数所在的类,java-agent加载jar包时会在PreMain类中寻找premainCan-Redefine-ClassesCan-Retransform-Classes声明为true,表示允许这段程序修改java应用的代码。

如果你是使用Maven的项目,可以使用增加下面的插件来自动添加MANIFEST.MF

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <appendAssemblyId>false</appendAssemblyId>
    <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
    </descriptorRefs>
    <archive>
        <manifest>
            <addClasspath>true</addClasspath>
        </manifest>
        <manifestEntries>
            <Premain-Class>com.huawei.PreMain</Premain-Class>
            <Can-Redefine-Classes>true</Can-Redefine-Classes>
            <Can-Retransform-Classes>true</Can-Retransform-Classes>
        </manifestEntries>
    </archive>
    </configuration>
    <executions>
    <execution>
        <id>assemble-all</id>
        <phase>package</phase>
        <goals>
        <goal>single</goal>
        </goals>
    </execution>
    </executions>
</plugin>

输出jar文件之后,编写一个hello worldjava应用编译为hello.class,在启动应用时使用如下命令

java -javaagent:/root/Java-Agent-Project-Path/target/JavaAgentTest-1.0-SNAPSHOT.jar hello

在执行中就可以打印java虚拟机在运行hello.class所加载的所有类。

java-agent的功能不仅限于输出类的加载过程,通过下面这个样例可以实现代码的热替换。首先编写一个测试类。

public class App 
{
    public static void main( String[] args )
    {
        try{
            System.out.println( "main start!" );
 
            App test = new App();
            int x1 = 1;
            int x2 = 2;
            while(true){
                System.out.println(Integer.toString(test.add(x1, x2)));
                Thread.sleep(2000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("main end");
        }
 
    }
 
    private int add(int x1, int x2){
        return x1+x2;
    }
}

然后我们修改PreMain类中transformer,并通过Instrumentation添加这个transformer。与DefineTransformer一样。

 static class MyClassTransformer implements ClassFileTransformer {
        @Override
        public byte[] transform(final ClassLoader loader,
                                final String className,
                                final Class<?> classBeingRedefined,
                                final ProtectionDomain protectionDomain,
                                final byte[] classfileBuffer) {
            // 如果当前加载的类是我们编写的测试类,进入修改。
            if ("com/huawei/App".equals(className)) {
                try {
                    // 从ClassPool获得CtClass对象
                    final ClassPool classPool = ClassPool.getDefault();
                    final CtClass clazz = classPool.get("com.huawei.App");
 
                    //打印App类中的所有成员函数
                    CtMethod[] methodList = clazz.getDeclaredMethods();
                    for(CtMethod method: methodList){
                        System.out.println("premain method: "+ method.getName());
                    }
 
                    // 获取add函数并替换,$1表示函数的第一个入参
                    CtMethod convertToAbbr = clazz.getDeclaredMethod("add");
                    String methodBody = "{return $1 + $2 + 11;}";
                    convertToAbbr.setBody(methodBody);
 
                    // 在add函数体之前增加一段代码,同理也可以在函数尾部添加
                    String methodBody = "System.out.println(Integer.toString($1));";
                    convertToAbbr.insertBefore(methodBody);
 
                    // 返回字节码,并且detachCtClass对象
                    byte[] byteCode = clazz.toBytecode();
                    //detach的意思是将内存中曾经被javassist加载过的Date对象移除,如果下次有需要在内存中找不到会重新走javassist加载
                    clazz.detach();
                    return byteCode;
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            // 如果返回null则字节码不会被修改
            return null;
        }
    }

之后的步骤与之前相同,运行会发现add函数的逻辑已经被替换了。

动态挂载

动态挂载是在应用运行过程中动态的添加agent。技术原理是通过socket与目标进程通讯,发送load指令在目标进程挂载指定jar文件。agent执行过程中的功能与静态过载是完全相同的。在实施过程中,有几点不同。首先入口函数名不同,动态挂载的函数名是agentmain。与premain类似,有两种格式。但通常采用带有Instrumentation的那种。如下例所示

public class AgentMain {
 
    public static void agentmain(String agentArgs, Instrumentation instrumentation) throws UnmodifiableClassException {
        instrumentation.addTransformer(new MyClassTransformer(), true);
        instrumentation.retransformClasses(com.huawei.Test.class);
    }
 
    static class MyClassTransformer implements ClassFileTransformer {
        @Override
        public byte[] transform(final ClassLoader loader,
                                final String className,
                                final Class<?> classBeingRedefined,
                                final ProtectionDomain protectionDomain,
                                final byte[] classfileBuffer) {
            // 如果当前加载的类是我们编写的测试类,进入修改。
            if ("com/huawei/App".equals(className)) {
                try {
                    // 从ClassPool获得CtClass对象
                    final ClassPool classPool = ClassPool.getDefault();
                    final CtClass clazz = classPool.get("com.huawei.App");
 
                    //打印App类中的所有成员函数
                    CtMethod[] methodList = clazz.getDeclaredMethods();
                    for(CtMethod method: methodList){
                        System.out.println("premain method: "+ method.getName());
                    }
 
                    // 获取add函数并替换,$1表示函数的第一个入参
                    CtMethod convertToAbbr = clazz.getDeclaredMethod("add");
                    String methodBody = "{return $1 + $2 + 11;}";
                    convertToAbbr.setBody(methodBody);
 
                    // 返回字节码,并且detachCtClass对象
                    byte[] byteCode = clazz.toBytecode();
                    //detach的意思是将内存中曾经被javassist加载过的Date对象移除,如果下次有需要在内存中找不到会重新走javassist加载
                    clazz.detach();
                    return byteCode;
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            // 如果返回null则字节码不会被修改
            return null;
        }
    }
}

功能与静态加载相同。需要注意的是,Instrumentation增加了transformer之后,调用了retransformClasses函数。这是由于transformer只有在Java虚拟机加载class时才会调用。如果是通过动态加载的方式,需要监控的class文件可能已经加载完成了。所以需要调用retransformClasses重新加载。

另外一点不同是MANIFEST.MF文件需要添加Agent-Class,如下所示

Can-Redefine-Classes: true
Can-Retransform-Classes: true
Premain-Class: com.huawei.PreMain
Agent-Class: com.huawei.AgentMain

最后一点不同是加载方式不同。动态挂载需要编写一个加载脚本。如下所示,在这段脚本中,首先遍历所有的java进程,通过启动类名辨识需要监控的进程。通过进程id获取VirtualMachine实例,并加载agentmainjar文件。

import com.sun.tools.attach.*;
import java.io.IOException;
import java.util.List;
 
public class TestAgentMain {
 
    public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException{
        //获取当前系统中所有 运行中的 虚拟机
        System.out.println("running JVM start ");
        List<VirtualMachineDescriptor> list = VirtualMachine.list();
        for (VirtualMachineDescriptor vmd : list) {
 
            System.out.println(vmd.displayName());
            String aim = "com.huawei.App";
            if (vmd.displayName().endsWith(aim)) {
                System.out.println(String.format("find %s, process id %s", vmd.displayName(), vmd.id()));
                VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
                virtualMachine.loadAgent("/root/Java-Agent-Project-Path/target/JavaAgentTest-1.0-SNAPSHOT.jar");
                virtualMachine.detach();
            }
        }
    }
}

Scala程序监控

ScalaJava兼容性很好,所以使用java-agent监控scala应用也是可行的。但是仍然需要注意一些问题。第一点是程序替换只对class有作用,对object是无效的。第二个问题是,动态替换中是将程序编译为字节码之后再去替换的。java-agent使用的是java的编译规则,所以替换程序要使用java的语言规则,否则会出现编译错误。例如示例中使用System.out.println输出参数信息,如果使用scalaprintln会出现编译错误。

参考资料:
Java 动态调试技术原理及实践
javaagent使用指南

登录后可下载附件,请登录或者注册

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区),文章链接,文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件至:huaweicloud.bbs@huawei.com进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容。
评论文章 //点赞 收藏 0
点赞
分享文章到微博
分享文章到朋友圈

上一篇:【华为云社区内容共创者火热招募中】第三弹:最美人间四月天,共创学习好时节!

下一篇:三色标记原理,我给应聘者问懵了...

评论 (0)


登录后可评论,请 登录注册

评论