[Question] How can I intercept same target method multi times in single transformer ?

Hi! I’m developing a APM system based on byte-buddy. sometimes I may have some different plugin to intercept same target method, and I find out in this situation only one plugin can work.

here is a demo

package com.example.demo;

import net.bytebuddy.agent.ByteBuddyAgent;
import net.bytebuddy.agent.builder.AgentBuilder;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.dynamic.DynamicType;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.implementation.bind.annotation.*;
import net.bytebuddy.utility.JavaModule;

import java.lang.instrument.Instrumentation;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;

import static net.bytebuddy.matcher.ElementMatchers.named;

public class ByteBuddyTest {

    public static void main(String[] args) {

        Instrumentation instrumentation = ByteBuddyAgent.install();
        new AgentBuilder.Default()
                .with(AgentBuilder.RedefinitionStrategy.REDEFINITION)
                .type(named("com.example.demo.ByteBuddyTest$TargetClass"))
                .transform(new AgentBuilder.Transformer() {
                    @Override
                    public DynamicType.Builder<?> transform(DynamicType.Builder<?> builder, TypeDescription typeDescription, ClassLoader classLoader, JavaModule module) {
                        return builder
                                .method(named("targetMethod"))
                                .intercept(MethodDelegation.to(new InvokerA()))
                                .method(named("targetMethod"))
                                .intercept(MethodDelegation.to(new InvokerB()));
                    }
                })
                .installOn(instrumentation);


        TargetClass targetClass = new TargetClass();
        targetClass.targetMethod();

    }


    public static class TargetClass {

        public void targetMethod() {
            System.out.println("targetMethod invoked");
        }

    }

    public static class InvokerA {
        @RuntimeType
        public Object intercept(@This Object obj,
                                @AllArguments Object[] allArguments,
                                @SuperCall Callable<?> origin,
                                @Origin Method method) throws Throwable {

            System.out.println(this.getClass().getSimpleName());

            return origin.call();
        }
    }

    public static class InvokerB {
        @RuntimeType
        public Object intercept(@This Object obj,
                                @AllArguments Object[] allArguments,
                                @SuperCall Callable<?> origin,
                                @Origin Method method) throws Throwable {

            System.out.println(this.getClass().getSimpleName());

            return origin.call();
        }
    }

}

The output I expected :

InvokerB
InvokerA
targetMethod invoked

The actual output :

InvokerB
targetMethod invoked

What should I do to get InvokerA and InvokerB both to work ?

PS: Thanks for the awesome work! byte-buddy has helped me a lot.

[anylain]

I followed your advice and re-implemented my interceptor using Advice + Field. Now the system works very well, thank you very much for your help!

[raphw]

You can use Advice.Local for context passing. If you want to combine several “plugins”, I would suggest you to go for decoration rather than building such a matrix yourself.