How to decorate a constructor?

[ignasi35]

I am trying to decorate both the constructor and the copy operations of a Scala case class.
So far, intercepting the copy was easy enough, but I'm finding the constructor part is proving more difficult. The problem I'm stuck in at the moment is that bytecode produced appears to be invalid.
I'm rather noob to ByteBuddy so I could use some direction. I searched around the documentation and even the tests but couldn't find an answer.

TL;DR: I just want to log the arguments of the constructor.

Here's what I'm doing:

1. Here's the PreMain code of the agent:

// packaged as an UberJar with the ByteBuddy library. Used via `java -javaagent:` syntax
public class BBMain {
  public static void premain(String arguments, Instrumentation instrumentation) throws IOException {
    new AgentBuilder.Default()
        .with(AgentBuilder.Listener.StreamWriting.toSystemError().withTransformationsOnly())
        .with(AgentBuilder.InstallationListener.StreamWriting.toSystemError())
        .type(ElementMatchers.isAnnotatedWith(WithTracking.class))
        .transform((builder, type, classLoader, module, protectionDomain) ->
            builder.method(ElementMatchers.named("copy"))
                .intercept(MethodDelegation.to(ContextualInterceptor.class))
        )
        .transform((builder, type, classLoader, module, protectionDomain) ->
            builder.constructor(ElementMatchers.isConstructor())
                .intercept(MethodDelegation.to(ContextualInterceptor.class))
        ).installOn(instrumentation);
  }
}

2. This is the code of the interceptor:

package example;

import net.bytebuddy.implementation.bind.annotation.AllArguments;
import net.bytebuddy.implementation.bind.annotation.Origin;
import net.bytebuddy.implementation.bind.annotation.RuntimeType;
import net.bytebuddy.implementation.bind.annotation.SuperCall;

import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.stream.Collectors;

public class ContextualInterceptor {

  // this is interceptor for the constructor. 
  @RuntimeType
  static Object intercept(
      @AllArguments Object[] allArguments,
      @Origin Class<?> clazz,
      @Origin Constructor<?> constructor
  ) throws Exception {
    return constructor.newInstance(allArguments);
  }

  @RuntimeType
  static Object intercept(
      @AllArguments Object[] allArguments,
      @Origin Class<?> clazz,
      @Origin Method method,
      @SuperCall Callable<?> zuper
  ) throws Exception {

    String stack =
        Arrays.stream(
                new RuntimeException()
                    .getStackTrace())
            // must be at least 3: this interceptor, the decorating class, and the actual
            // class. But can be longer to gain more context
            .limit(5)
            .map(x -> x.getFileName() + ":" + x.getLineNumber())
            .collect(Collectors.joining(" / "));

    String classDetails = clazz.getName();

    String methodDetails = method.getName();
    var args =
        Arrays.stream(allArguments)
            .map(Object::toString)
            .collect(Collectors.toList());
    var fields =
        Arrays
            .stream(clazz.getDeclaredFields())
            .map(Field::getName)
            .collect(Collectors.toList());
    List<String> arguments = new ArrayList<String>(args.size());
    for (int i = 0; i < args.size(); i++) {
      arguments.add(fields.get(i) + "=" + args.get(i));
    }

    var namedArguments = String.join(", ", arguments);
    System.out.println("Intercepted: " + classDetails + "#" + methodDetails + "\n  Values: " + namedArguments + "\n   Stack: " + stack);
    return zuper.call();
  }

}

3. The sample code to test it all out:

object Hello extends App {
  val ign = Person("Ignasi", "Marimon", 45)
  val ign = jp.copy(givenName = "Ignasi2")
  val ign = jp.copy(givenName = "Ignasi3")
  println(greeting + " " + ign2 )
  println(greeting + " " + ign)
}

@WithTracking
case class Person(givenName:String, familyName: String, age: Int)

/*
@Retention(RetentionPolicy.RUNTIME)
@interface WithTracking { }
*/

4. Here's the output I'm seeing:

[Byte Buddy] BEFORE_INSTALL net.bytebuddy.agent.builder.AgentBuilder$Default$ExecutingTransformer$ByteBuddy$ModuleSupport@15a34df2 on sun.instrument.InstrumentationImpl@5b38c1ec
[Byte Buddy] INSTALL net.bytebuddy.agent.builder.AgentBuilder$Default$ExecutingTransformer$ByteBuddy$ModuleSupport@15a34df2 on sun.instrument.InstrumentationImpl@5b38c1ec
[Byte Buddy] TRANSFORM example.Person [jdk.internal.loader.ClassLoaders$AppClassLoader@3b192d32, unnamed module @6155d082, Thread[main,5,main], loaded=false]
Exception in thread "main" java.lang.VerifyError: Constructor must call super() or this() before return
Exception Details:
  Location:
    example/Person.<init>(Ljava/lang/String;Ljava/lang/String;I)V @28: return
  Reason:
    Error exists in the bytecode
  Bytecode:
    0000000: 06bd 0004 5903 2b53 5904 2c53 5905 1db8
    0000010: 00a1 5312 02b2 00a5 b800 ab57 b1

        at example.Hello$.delayedEndpoint$example$Hello$1(Hello.scala:8)
        at example.Hello$delayedInit$body.apply(Hello.scala:3)

Any pointers on how to fix the code or a link to a Gist or test solving this same problem would be great.

[ignasi35]

Turns out that for my use-case I didn't need to decorate or replace code. Just using the .visit and the Advice APIs I could solve my problem:

    new AgentBuilder.Default()
        .with(AgentBuilder.Listener.StreamWriting.toSystemError().withTransformationsOnly())
        .with(AgentBuilder.InstallationListener.StreamWriting.toSystemError())
        .type(
            ElementMatchers.isAnnotatedWith(WithTracking.class)
        )
        .transform((builder, type, classLoader, module, protectionDomain) ->
            builder.method(ElementMatchers.named("copy"))
                .intercept(MethodDelegation.to(ContextualInterceptor.class))
        )
        .transform((builder, type, classLoader, module, protectionDomain) ->
// I needed this portion below
            builder.visit(
                Advice
                    .to(MyVisitor.class)
                    .on(
                        ElementMatchers.isConstructor()
                    )
            )
        )
    .installOn(instrumentation);
  }

And the visitor code:

package example;

import net.bytebuddy.asm.Advice;
import net.bytebuddy.implementation.bind.annotation.AllArguments;

import java.lang.reflect.Executable;
import java.lang.reflect.Parameter;
import java.util.Arrays;
import java.util.stream.Collectors;

final class MyVisitor {

  @Advice.OnMethodEnter
  public static void intercept(
      @Advice.Origin Executable methodOrConstructor,
      @Advice.AllArguments Object[] allArguments
  ) {
    var clazz = methodOrConstructor.getDeclaringClass();
    Parameter[] parameters = methodOrConstructor.getParameters();
    var nameArgs = "";
    for (int i = 0; i < parameters.length; i++) {
      nameArgs += parameters[i].getName();
      nameArgs += ": ";
      nameArgs += parameters[i].getType().getName();
      nameArgs += " = ";
      nameArgs += allArguments[i].toString();
      if (i != parameters.length - 1)
        nameArgs += ", ";
    }

    System.out.println("Intercepted: " + clazz.getName() + "#" + methodOrConstructor.getName() + " - Values: " + nameArgs);
  }

}