CannotCompileException while Instrumenting Java code with using Java Assist, cannot find class

Question

I'm trying create a generic Java Agent to instrument any Java application's methods. I've followed this tutorial https://javapapers.com/core-java/java-instrumentation/ and created a java agent. The java agent is supposed to look for a particular class ( I'm restricting it to one class now since it's not working for me) Once the class is found, I'm using JavaAssist API to add a local variable to the beginning of each method and capture the current time. In the end of the method I'd like to simply print the time it took for the method to execute. (Pretty much following all the typical examples about Java agent.

I run my test application ( a web server using Vert.x ) with --javaagent flag pointing to the Java agent jar file I created ( the code is down below).

This works just fine for methods that either don't have return value and no parameters or return/take a primitive type.

However when a method is returning or taking a parameter that is an object from a another class (that has not been loaded yet I think) I get a CannotCompileException exception with the message that that class which is in the parameters list or in the return statement is not found. For example the instrumentation for this method works:

@Override
public void start() throws Exception {
    logger.debug("started thread {}", Thread.currentThread().getName());
    for (int port : ports) {
        HttpServer httpServer = getVertx().createHttpServer(httpServerOptions);
        Router router = setupRoutes();
        httpServer.requestHandler(router::accept);
        logger.info("Listening on port {}", port);
        httpServer.listen(port);
    }
}

However for this method that returns io.vertx.ext.web.Router:

private Router setupRoutes() {
    Router router = Router.router(getVertx());
    router.get(STATUS_PATH).handler(this::statusHandler);
    router.route().handler(BodyHandler.create());
    router.post().handler(this::handleBidRequest);
    router.put().handler(this::handleBidRequest);
    router.get(SLEEP_CONTROLLER_PATH).handler(this::sleepControllerHandler);
    return router;
}

I get an exception and the output of my java agent is :

Instrumenting method rubiconproject.com.WebServerVerticle.setupRoutes()
Could not instrument method setupRoutes error: cannot find io.vertx.ext.web.Router

This the code for my java agent:

import java.lang.instrument.Instrumentation;
import transformers.TimeMeasuringTransformer;

public class TimeCapturerAgent {
public static void premain(String agentArgs, Instrumentation inst) {
    System.out.println(TimeCapturerAgent.class.getCanonicalName() + " is loaded...... ");
    inst.addTransformer(new TimeMeasuringTransformer());
}}

package transformers;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;

public class TimeMeasuringTransformer implements ClassFileTransformer {

public TimeMeasuringTransformer() {
    System.out.println("TimeMeasuringTransformer added ");
}

@Override
public byte[] transform(ClassLoader loader,
        String className,
        Class<?> classBeingRedefined,
        ProtectionDomain protectionDomain,
        byte[] classfileBuffer) throws IllegalClassFormatException {


    if(className != null && className.contains("WebServerVerticle")) {
        System.out.println("Instrumenting class " + className);
        return modifyClass(classfileBuffer);
    }

    return null;

}

private byte[] modifyClass(byte[] originalClassfileBuffer)  {
    ClassPool classPool = ClassPool.getDefault();
    CtClass compiledClass;
    try {

        compiledClass = classPool.makeClass(new ByteArrayInputStream(originalClassfileBuffer));
        System.out.println("Created new compiled Class " + compiledClass.getName());

    } catch (IOException e) {
        e.printStackTrace();
        return null;
    }

    instrumentMethods(compiledClass);

    byte [] newClassByteCode =  createNewClassByteArray(compiledClass);
    compiledClass.detach();
    return newClassByteCode;
}

private byte[] createNewClassByteArray(CtClass compiledClass) {
    byte[] newClassByteArray = null;
    try {
        newClassByteArray = compiledClass.toBytecode();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (CannotCompileException e) {
        e.printStackTrace();
    } finally {
        return newClassByteArray;
    }
}

private void instrumentMethods(CtClass compiledClass) {
    CtMethod[] methods = compiledClass.getDeclaredMethods();
    System.out.println("Class has " + methods.length + " methods");
    for (CtMethod method : methods) {
        try {
            System.out.println("Instrumenting method " + method.getLongName());
            method.addLocalVariable("startTime", CtClass.longType);
            method.insertBefore("startTime = System.nanoTime();");
            method.insertAfter("System.out.println(\"Execution Duration "
                    + "(nano sec): \"+ (System.nanoTime() - startTime) );");
        } catch (CannotCompileException e) {
            System.out.println("Could not instrument method " + method.getName()+" error: " + e.getMessage());
            continue;
        }
    }
}}