Java Agent COMPUTE_FRAMES Crash on Missing ClassLoader

import java.lang.instrument.Instrumentation;

/**
 * Entry point for a startup-time Java agent.
 *
 * Compile this class, package it in a JAR, and declare it in MANIFEST.MF:
 *   Premain-Class: TimingAgent
 *   Can-Retransform-Classes: true
 *
 * Launch with:
 *   java -javaagent:timing-agent.jar -jar your-app.jar
 */
public class TimingAgent {\n\n    /**\n     * The JVM calls this BEFORE your application's main() method.\n     *\n     * @param agentArgs  Any string args passed after '=' in -javaagent:jar=args\n     * @param instrumentation  The gateway to all bytecode transformation power\n     */\n    public static void premain(String agentArgs, Instrumentation instrumentation) {\n        System.out.println(\"[TimingAgent] Agent loaded. JVM classes currently loaded: \"\n                + instrumentation.getAllLoadedClasses().length);\n\n        // Register our transformer — it will be called for EVERY class the JVM loads\n        // from this point forward, including JDK classes if we don't filter carefully\n        MethodTimingTransformer transformer = new MethodTimingTransformer(agentArgs);\n        instrumentation.addTransformer(transformer, /* canRetransform= */ true);\n\n        System.out.println(\"[TimingAgent] ClassFileTransformer registered. Ready.\");\n    }\n\n    /**\n     * Called when the agent is attached to a RUNNING JVM via the Attach API.\n     * The signature is identical to premain but the JVM lifecycle moment differs.\n     */\n    public static void agentmain(String agentArgs, Instrumentation instrumentation) {\n        // Reuse the same startup logic — safe because we're stateless here\n        premain(agentArgs, instrumentation);\n    }\n}",
        "output": "[TimingAgent] Agent loaded. JVM classes currently loaded: 412\n[TimingAgent] ClassFileTransformer registered. Ready."
      }

Manifest-Version: 1.0
Premain-Class: io.thecodeforge.agent.MyAgent
Agent-Class: io.thecodeforge.agent.MyAgent
Can-Retransform-Classes: true
Can-Redefine-Classes: false

import net.bytebuddy.agent.builder.AgentBuilder;
import net.bytebuddy.asm.Advice;
import net.bytebuddy.matcher.ElementMatchers;
import java.lang.instrument.Instrumentation;

public class ByteBuddyAgent {
    public static void premain(String args, Instrumentation inst) {\n        new AgentBuilder.Default()\n            .type(ElementMatchers.nameStartsWith(\"io.codeforge\"))\n            .transform((builder, type, cl, mod) ->\n                builder.method(ElementMatchers.any())\n                    .intercept(Advice.to(MethodTimer.class)))\n            .installOn(inst);\n    }\n\n    public static class MethodTimer {\n        @Advice.OnMethodEnter\n        static long enter() { return System.nanoTime(); }\n        @Advice.OnMethodExit\n        static void exit(@Advice.Enter long start, @Advice.Origin String method) {\n            System.out.println(method + \" took \" + (System.nanoTime() - start) + \" ns\");\n        }\n    }\n}",
        "output": "// Build dependency: net.bytebuddy:byte-buddy-agent:1.14.12 + byte-buddy:1.14.12\n// Run with -javaagent:bytebuddy-agent.jar\n// Output: io.codeforge.demo.OrderService#processOrder took 4321871 ns"
      }

import org.objectweb.asm.*;
import org.objectweb.asm.commons.AdviceAdapter;
import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;

/**
 * Intercepts class loading and injects timing code into every method
 * of classes whose package matches our target prefix.
 *
 * ASM version: 9.6  (org.ow2.asm:asm-commons:9.6)
 */
public class MethodTimingTransformer implements ClassFileTransformer {

    // Only instrument classes under this package to avoid touching JDK internals
    private final String targetPackagePrefix;

    public MethodTimingTransformer(String agentArgs) {
        // agentArgs might be something like "io/codeforge/demo"
        this.targetPackagePrefix = (agentArgs != null && !agentArgs.isBlank())
                ? agentArgs.replace('.', '/')
                : "io/codeforge"; // default to our own package
    }

    @Override
    public byte[] transform(
            ClassLoader loader,
            String className,           // Internally formatted: "com/example/MyClass"
            Class<?> classBeingRedefined,
            ProtectionDomain protectionDomain,
            byte[] originalClassBytes) {

        // Fast-path: skip anything that's not our target to keep overhead minimal
        if (className == null || !className.startsWith(targetPackagePrefix)) {
            return null; // null = "I didn't change anything, use original bytes"
        }

        try {\n            ClassReader classReader = new ClassReader(originalClassBytes);\n            // COMPUTE_FRAMES tells ASM to recalculate stack frames automatically\n            // This is essential — manual frame calculation is error-prone\n            ClassWriter classWriter = new ClassWriter(\n                    classReader, ClassWriter.COMPUTE_FRAMES);\n\n            // Wrap the writer with our visitor that injects timing into each method\n            TimingClassVisitor timingVisitor = new TimingClassVisitor(\n                    Opcodes.ASM9, classWriter, className);\n\n            // EXPAND_FRAMES is required when using AdviceAdapter with COMPUTE_FRAMES\n            classReader.accept(timingVisitor, ClassReader.EXPAND_FRAMES);\n\n            System.out.println(\"[TimingAgent] Instrumented: \" + className);\n            return classWriter.toByteArray(); // Return the rewritten bytecode\n\n        } catch (Exception transformationError) {\n            // NEVER let a transformer exception crash the JVM — log and return null\n            System.err.println(\"[TimingAgent] Failed to instrument \" + className\n                    + \": \" + transformationError.getMessage());\n            return null; // Fall back to the original unmodified class\n        }\n    }\n\n    // ── Inner class: visits each class and delegates method visiting ─────────\n\n    static class TimingClassVisitor extends ClassVisitor {\n\n        private final String ownerClassName;\n\n        TimingClassVisitor(int api, ClassVisitor delegate, String ownerClassName) {\n            super(api, delegate);\n            this.ownerClassName = ownerClassName;\n        }\n\n        @Override\n        public MethodVisitor visitMethod(\n                int access, String methodName, String descriptor,\n                String signature, String[] exceptions) {\n\n            // Get the default MethodVisitor from the ClassWriter chain\n            MethodVisitor originalVisitor = super.visitMethod(\n                    access, methodName, descriptor, signature, exceptions);\n\n            // Skip abstract and native methods — they have no bytecode body to visit\n            boolean isAbstract = (access & Opcodes.ACC_ABSTRACT) != 0;\n            boolean isNative   = (access & Opcodes.ACC_NATIVE) != 0;\n            if (isAbstract || isNative || originalVisitor == null) {\n                return originalVisitor;\n            }\n\n            // Wrap with our timing advisor\n            return new TimingMethodAdvisor(\n                    Opcodes.ASM9, originalVisitor, access,\n                    methodName, descriptor, ownerClassName);\n        }\n    }\n\n    // ── Inner class: injects nanoTime calls at method entry and exit ──────────\n\n    static class TimingMethodAdvisor extends AdviceAdapter {\n\n        private final String ownerClass;\n        private final String methodName;\n        private int startTimeLocalVarIndex; // index of our injected local variable\n\n        TimingMethodAdvisor(int api, MethodVisitor delegate, int access,\n                            String methodName, String descriptor, String ownerClass) {\n            super(api, delegate, access, methodName, descriptor);\n            this.ownerClass  = ownerClass;\n            this.methodName  = methodName;\n        }\n\n        @Override\n        protected void onMethodEnter() {\n            // Inject: long __startTime = System.nanoTime();\n            // INVOKESTATIC pushes the long result onto the stack\n            mv.visitMethodInsn(\n                    Opcodes.INVOKESTATIC,\n                    \"java/lang/System\",\n                    \"nanoTime\",\n                    \"()J\",\n                    false);\n\n            // Store that long into a new local variable\n            // newLocal() allocates the next available slot in the local variable table\n            startTimeLocalVarIndex = newLocal(Type.LONG_TYPE);\n            mv.visitVarInsn(Opcodes.LSTORE, startTimeLocalVarIndex);\n        }\n\n        @Override\n        protected void onMethodExit(int opcode) {\n            // This is called for EVERY exit: RETURN, IRETURN, ARETURN, ATHROW, etc.\n            // AdviceAdapter handles all the variants — we just implement this once\n\n            // Inject: long __elapsed = System.nanoTime() - __startTime;\n            mv.visitMethodInsn(\n                    Opcodes.INVOKESTATIC, \"java/lang/System\",\n                    \"nanoTime\", \"()J\", false);\n            mv.visitVarInsn(Opcodes.LLOAD, startTimeLocalVarIndex);\n            mv.visitInsn(Opcodes.LSUB); // stack now has elapsed nanoseconds (long)\n\n            // Inject: TimingReporter.record(\"io/codeforge/Foo#doWork\", elapsed);\n            // We push the method label as a constant string first\n            mv.visitLdcInsn(ownerClass + \"#\" + methodName);\n            // Swap so the stack order is (String label, long elapsed) matching the descriptor\n            // Actually we need to restructure: push label first, then elapsed\n            // Easiest: store elapsed, push label, reload elapsed\n            int elapsedLocalVarIndex = newLocal(Type.LONG_TYPE);\n            mv.visitVarInsn(Opcodes.LSTORE, elapsedLocalVarIndex);\n            mv.visitLdcInsn(ownerClass + \"#\" + methodName);\n            mv.visitVarInsn(Opcodes.LLOAD, elapsedLocalVarIndex);\n\n            mv.visitMethodInsn(\n                    Opcodes.INVOKESTATIC,\n                    \"io/codeforge/agent/TimingReporter\",\n                    \"record\",\n                    \"(Ljava/lang/String;J)V\",\n                    false);\n        }\n    }\n}",
        "output": "[TimingAgent] Instrumented: io/codeforge/demo/OrderService\n[TimingAgent] Instrumented: io/codeforge/demo/PaymentGateway\n[TimingAgent] Instrumented: io/codeforge/demo/InventoryRepository\n[TimingReporter] io/codeforge/demo/OrderService#processOrder => 4,312,871 ns (4.3 ms)\n[TimingReporter] io/codeforge/demo/PaymentGateway#charge => 231,048,203 ns (231 ms)\n[TimingReporter] io/codeforge/demo/InventoryRepository#findById => 892,441 ns (0.9 ms)"
      }

import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import java.util.List;

/**
 * Attaches a Java agent to a RUNNING JVM without restarting it.
 *
 * Requires: JDK (not just JRE), and the target JVM must allow self-attach or
 * be a separate process. Run this as a standalone program.
 *
 * Compile: javac --add-exports java.base/sun.nio.ch=ALL-UNNAMED LiveAttachDemo.java
 * Run:     java -cp .:$JAVA_HOME/lib/tools.jar LiveAttachDemo <target-pid> <agent-jar-path>
 *
 * Java 9+ note: tools.jar is gone; the Attach API is in jdk.attach module:
 *   java --add-modules jdk.attach LiveAttachDemo <pid> <agent.jar>
 */
public class LiveAttachDemo {\n\n    public static void main(String[] args) throws Exception {\n        if (args.length < 2) {\n            System.err.println(\"Usage: LiveAttachDemo <target-pid> <path-to-agent.jar>\");\n            System.exit(1);\n        }\n\n        String targetPid   = args[0];\n        String agentJarPath = args[1];\n\n        // List all JVMs on this machine so the user can verify the PID\n        System.out.println(\"\\n=== JVMs currently running on this machine ===\");\n        List<VirtualMachineDescriptor> jvmList = VirtualMachine.list();\n        for (VirtualMachineDescriptor descriptor : jvmList) {\n            System.out.printf(\"  PID: %-8s  Display: %s%n\",\n                    descriptor.id(), descriptor.displayName());\n        }\n        System.out.println();\n\n        // Attach to the target JVM — this opens a socket to its attach listener\n        System.out.println(\"[Attacher] Attaching to PID: \" + targetPid);\n        VirtualMachine targetJvm = VirtualMachine.attach(targetPid);\n\n        try {\n            // The JVM will call agentmain() in our TimingAgent class\n            // The second argument (agentOptions) becomes the agentArgs param in agentmain\n            String agentOptions = \"io/codeforge/demo\"; // package prefix to instrument\n            targetJvm.loadAgent(agentJarPath, agentOptions);\n            System.out.println(\"[Attacher] Agent loaded successfully into PID \" + targetPid);\n\n        } finally {\n            // Always detach to close the socket — a leaked attach can prevent\n            // future attaches and consume file descriptors\n            targetJvm.detach();\n            System.out.println(\"[Attacher] Detached cleanly.\");\n        }\n    }\n}",
        "output": "=== JVMs currently running on this machine ===\n  PID: 18443     Display: io.codeforge.demo.OrderServiceApp\n  PID: 22901     Display: LiveAttachDemo\n  PID: 31042     Display: org.gradle.launcher.daemon.bootstrap.GradleDaemon\n\n[Attacher] Attaching to PID: 18443\n[Attacher] Agent loaded successfully into PID 18443\n[Attacher] Detached cleanly.\n\n--- Output from PID 18443 (the target JVM) ---\n[TimingAgent] Agent loaded. JVM classes currently loaded: 5,847\n[TimingAgent] ClassFileTransformer registered. Ready.\n[TimingAgent] Instrumented: io/codeforge/demo/OrderService\n[TimingReporter] io/codeforge/demo/OrderService#processOrder => 6,102,887 ns (6.1 ms)"
      }

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-shade-plugin</artifactId>
      <version>3.5.0</version>
      <executions>
        <execution>
          <phase>package</phase>
          <goals><goal>shade</goal></goals>
          <configuration>
            <relocations>
              <relocation>
                <pattern>org.objectweb.asm</pattern>
                <shadedPattern>io.thecodeforge.shaded.org.objectweb.asm</shadedPattern>
              </relocation>
            </relocations>
            <filters>
              <filter>
                <artifact>*:*</artifact>
                <excludes>
                  <exclude>META-INF/MANIFEST.MF</exclude>
                </excludes>
              </filter>
            </filters>
          </configuration>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

// io.thecodeforge — java tutorial

import java.lang.instrument.Instrumentation;
import java.lang.management.ManagementFactory;
import com.sun.tools.attach.VirtualMachine;

public class AgentLoadDecision {
    public static void main(String[] args) throws Exception {
        // Check if agent was statically loaded
        boolean staticLoad = System.getProperty("javaagent") != null;
        
        if (!staticLoad) {
            // Dynamically attach to ourselves
            String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
            VirtualMachine vm = VirtualMachine.attach(pid);
            try {
                vm.loadAgent("/path/to/my-agent.jar");
            } finally {
                vm.detach();
            }
        }
        
        System.out.println("Agent attached: " + staticLoad);
    }
}

// io.thecodeforge — java tutorial

import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

public class SafeTransformer implements ClassFileTransformer {
    private final ConcurrentHashMap<String, AtomicInteger> transformCount;
    
    public SafeTransformer() {
        this.transformCount = new ConcurrentHashMap<>();
    }
    
    @Override
    public byte[] transform(
            ClassLoader loader,
            String className,
            Class<?> classBeingRedefined,
            ProtectionDomain protectionDomain,
            byte[] classfileBuffer) {
        
        if (className == null || className.startsWith("java/")) {
            return null;  // Skip JDK classes — no allocation, no delay
        }
        
        // Only transform our target packages
        if (!className.startsWith("com/mycompany/")) {
            return null;
        }
        
        transformCount.computeIfAbsent(className, k -> new AtomicInteger()).incrementAndGet();
        return classfileBuffer;  // Return unchanged for now
    }
}

// io.thecodeforge — java tutorial

import java.io.File;
import java.security.MessageDigest;
import java.util.Base64;

public class AgentSecurityCheck {
    
    // In production, store this hash securely (HSM, vault, etc.)
    private static final String EXPECTED_HASH = "a1b2c3d4e5f6g7h8i9j0klmnop";
    
    public static boolean verifyAgentIntegrity(String agentJarPath) throws Exception {
        File agentFile = new File(agentJarPath);
        if (!agentFile.exists() || !agentFile.isFile()) {
            System.err.println("[SECURITY] Agent JAR not found: " + agentJarPath);
            return false;
        }
        
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest(java.nio.file.Files.readAllBytes(agentFile.toPath()));
        String computedHash = Base64.getEncoder().encodeToString(hash);
        
        if (!EXPECTED_HASH.equals(computedHash)) {
            System.err.println("[SECURITY] Agent tampered! Expected: " + EXPECTED_HASH);
            return false;
        }
        return true;
    }
    
    public static void main(String[] args) throws Exception {
        System.out.println("Agent integrity check: " + 
            verifyAgentIntegrity("/opt/agents/my-agent.jar"));
    }
}

// io.thecodeforge — java tutorial

// Proxy approach: only intercepts Spring beans
public interface Service {
    void execute();
}

// Agent approach: intercepts every Service implementation
// even ones you never compiled
public class MyAgent {
    public static void premain(String args, Instrumentation inst) {
        inst.addTransformer((loader, name, cl, pd, buf) -> {
            // modify bytecode of every class
            return transform(buf);
        });
    }
}

// AspectJ compile-time: requires ajc compiler
// aspect Logging {
//     pointcut call(): execution(* Service.*(..));
//     before(): call() { System.out.println("called"); }
// }

// io.thecodeforge — java tutorial

import java.lang.instrument.*;
import java.util.Map;
import java.util.WeakHashMap;

public class SafeTransformer implements ClassFileTransformer {
    // WeakReference avoids ClassLoader leak
    private final Map<ClassLoader, byte[]> cache = new WeakHashMap<>();

    @Override
    public byte[] transform(ClassLoader l, String name,
                            Class<?> c, ProtectionDomain d, byte[] b) {
        try {
            if (name == null || name.startsWith("java/")) return null;
            // ... transformation logic ...
            return modify(b);
        } catch (Exception e) {
            System.err.println("Agent error on " + name + ": " + e);
            return null; // load original bytecode
        }
    }
}

// io.thecodeforge — java tutorial
// Minimal agent: prints class names as they load
import java.lang.instrument.*;

public class SimpleAgent {
    public static void premain(String args, Instrumentation inst) {
        inst.addTransformer(new ClassFileTransformer() {
            @Override
            public byte[] transform(ClassLoader loader,
                                    String className,
                                    Class<?> classBeingRedefined,
                                    ProtectionDomain protectionDomain,
                                    byte[] classfileBuffer) {
                if (className != null && className.startsWith("com/example")) {
                    System.out.println("Loading: " + className);
                }
                return null; // no modification
            }
        });
    }
}

// io.thecodeforge — java tutorial
// Idempotent transformer: skip already-instrumented classes
public byte[] transform(ClassLoader loader, String className,
                        Class<?> redefining, ProtectionDomain pd,
                        byte[] classBytes) {
    if (className == null || isInstrumented(classBytes)) {
        return null;  // unchanged
    }
    byte[] modified = weaveMetrics(classBytes);
    return modified;
}

private boolean isInstrumented(byte[] bytes) {
    // check for custom marker annotation in class bytes
    return new ClassReader(bytes).getAnnotation("Lcom/agent/Marker;");
}