使用Byte-Buddy的Java代理不起作用

Question

I need your help in finding what's wrong with my implementation...

I'm trying to implement a simple JVM runtime profiler using byte-buddy. In general, what I need is that every method call will be logged in a stack which I manage in a separate object.

After reading several posts, I understood that it's better to use the "Advise" approach instead of "MethodDelegation", and here's what I came out with:

Agent.java:

package com.panaya.java.agent;

import net.bytebuddy.agent.builder.AgentBuilder;
import net.bytebuddy.asm.Advice;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.matcher.ElementMatchers;
import net.bytebuddy.utility.JavaModule;

import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

public class Agent {
    private static List<Pattern> pkgIncl = new ArrayList<Pattern>();
    private static List<Pattern> pkgExcl = new ArrayList<Pattern>();

    private static void initMatcherPatterns(String argument) {
        if (argument == null) {
            System.out.println("Missing configuration argument");
            return;
        }

        System.out.println("Argument is: " + argument);

        String[] tokens = argument.split(";");

        if (tokens.length < 1) {
            System.out.println("Missing delimeter ;");
            return;
        }

        for (String token : tokens) {
            String[] args = token.split("=");
            if (args.length < 2) {
                System.out.println("Missing argument delimeter =:" + token);
                return;
            }

            String argtype = args[0];

            if (!argtype.equals("incl") && !argtype.equals("excl")) {
                System.out.println("Wrong argument: " + argtype);
                return;
            }

            String[] patterns = args[1].split(",");

            for (String pattern : patterns) {
                Pattern p = null;
                System.out.println("Compiling " + argtype + " pattern:" + pattern + "$");
                try {
                    p = Pattern.compile(pattern + "$");
                } catch (PatternSyntaxException pse) {
                    System.out.println("pattern: " + pattern + " not valid, ignoring");
                }
                if (argtype.equals("incl"))
                    pkgIncl.add(p);
                else
                    pkgExcl.add(p);
            }
        }

    }

    private static boolean isShouldInstrumentClass(String className) {
        System.out.println("Testing " + className + " for match.");
        boolean match = false;
        String name = className.replace("/", ".");

        for (Pattern p : pkgIncl) {
            Matcher m = p.matcher(name);
            if (m.matches()) {

                match = true;
                break;
            }
        }

        for (Pattern p : pkgExcl) {
            Matcher m = p.matcher(name);
            if (m.matches()) {

                match = false;
                break;
            }
        }

        if (match) {
            System.out.println("Class " + name + "should be instrumented.");
        } else {
            System.out.println("Skipping class: " + name);
        }
        return match;
    }

    public static void premain(String agentArgument, Instrumentation instrumentation) {
        System.out.println("Premain started");
        try {
            initMatcherPatterns(agentArgument);

            new AgentBuilder.Default()
                    .with(AgentBuilder.TypeStrategy.Default.REBASE)
                    .type(new AgentBuilder.RawMatcher() {
                        public boolean matches(TypeDescription typeDescription, ClassLoader classLoader, JavaModule javaModule, Class<?> aClass, ProtectionDomain protectionDomain) {
                            return isShouldInstrumentClass(typeDescription.getActualName());
                        }
                    })
                    .transform((builder, typeDescription, classLoader) -> builder
                            .visit(Advice.to(ProfilingAdvice.class)
                                    .on(ElementMatchers.any()))).installOn(instrumentation);

        } catch (RuntimeException e) {
            System.out.println("Exception instrumenting code : " + e);
            e.printStackTrace();
        }

    }
}

And ProfilingAdvice.java:

package com.panaya.java.agent;

import com.panaya.java.profiler.MethodStackCollector;
import net.bytebuddy.asm.Advice;

public class ProfilingAdvice {
    @Advice.OnMethodEnter
    public static void enter(@Advice.Origin("#t.#m") String signature) {
        System.out.println("OnEnter :" + signature);
        try {
            MethodStackCollector.getInstance().push(signature);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Advice.OnMethodExit
    public static void exit(@Advice.Return long value) {
        System.out.println("OnExit - value = " + value);
        try {
            MethodStackCollector.getInstance().pop();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

For some reason, the "enter" and "exit" methods in ProfilingAdvice class, aren't invoked at all.

What am I doing wrong ?

Thanks, Elad.

Answer 1

I tried your example and after reducing the exit advice to the print commands and your matcher to only match some class foo.Bar :

package foo;
public class Bar {
  public long qux() { return 0L; }
}

the instrumentation works without problem. I find it a bit fishy that your Advice matcher specifies any() while your ProfilingAdvice requires a long return type. Did you try only printing to the console without any annotations in your advice?

You can debug such issues by settting:

new AgentBuilder.Default()
   .with(AgentBuilder.Listener.StreamWriting.toSystemOut());

where potential errors during the instrumentation are printed to the console.

Answer 2

@Advice.Return stands for the return value of the monitor methord.

@Advice.Return is not the return value of the enter(@Advice.Origin("#t.#m") String signature) method.

So, the following code is OK:

public class ProfilerInterceptor {
    public static ThreadLocal<Long> threadLocal = new ThreadLocal();

    @Advice.OnMethodEnter
    public static void enter(@Advice.Origin("#t.#m") String signature) {
        System.out.printf("Enter: %s\n", signature);
        long start = System.currentTimeMillis();
        threadLocal.set(start);
        try {
            MethodStackCollector.getInstance().push(signature);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Advice.OnMethodExit
    public static void exit(@Advice.Origin("#t.#m") String signature) {
        long value = System.currentTimeMillis() - threadLocal.get();
        System.out.printf("Exit: %s\nTime: %d\n\n", signature, value);
        System.out.println("OnExit - value = " + value);
        try {
            MethodStackCollector.getInstance().pop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}