bridge41

package comet.agent;



import net.bytebuddy.agent.builder.AgentBuilder;

import net.bytebuddy.asm.Advice;

import net.bytebuddy.description.type.TypeDescription;

import net.bytebuddy.dynamic.DynamicType;

import net.bytebuddy.matcher.ElementMatchers;

import net.bytebuddy.utility.JavaModule;

import java.lang.instrument.Instrumentation;

import java.io.*;

import java.nio.file.*;

import java.util.*;

import java.util.concurrent.*;

import java.util.concurrent.atomic.LongAdder;

import java.text.SimpleDateFormat;

import java.util.jar.JarFile;



public class ProfilerAgent {

    // MUST BE PUBLIC: To be seen by instrumented classes

    public static final ConcurrentHashMap<String, Stats> metrics = new ConcurrentHashMap<>();

    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");



    public static void agentmain(String agentArgs, Instrumentation inst) {

        try {

            File agentJar = new File(ProfilerAgent.class.getProtectionDomain()

                    .getCodeSource().getLocation().toURI());

            if (agentJar.exists()) {

                inst.appendToBootstrapClassLoaderSearch(new JarFile(agentJar));

            }

        } catch (Exception e) {

            System.err.println("PROFILER: Bootstrap injection failed: " + e.getMessage());

        }

        premain(agentArgs, inst);

    }



    public static void premain(String agentArgs, Instrumentation inst) {

        List<String> targetClasses = loadClasses("profiler_targets.txt");

        startReporter(60, ".");



        new AgentBuilder.Default()

            .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)

            // Manual Circularity Lock to avoid the "Symbol Not Found" error

            .with(new AgentBuilder.CircularityLock() {

                private final ThreadLocal<Boolean> lock = new ThreadLocal<Boolean>() {

                    @Override protected Boolean initialValue() { return false; }

                };

                @Override public boolean acquire() { if (lock.get()) return false; lock.set(true); return true; }

                @Override public void release() { lock.set(false); }

            })

            .ignore(ElementMatchers.none())

            .type(builder -> {

                String name = builder.getName();

                if (name.startsWith("comet.agent.") || name.startsWith("net.bytebuddy.")) return false;

                return targetClasses.contains(name);

            })

            .transform((builder, typeDescription, classLoader, module) ->

                builder.method(ElementMatchers.any()

                        .and(ElementMatchers.not(ElementMatchers.isAbstract()))

                        .and(ElementMatchers.not(ElementMatchers.isNative())))

                        .intercept(Advice.to(ProfilerAdvice.class))

            )

            .installOn(inst);

    }



    private static List<String> loadClasses(String path) {

        try { return Files.readAllLines(Paths.get(path)); }

        catch (Exception e) { return Collections.emptyList(); }

    }



    public static class ProfilerAdvice {

        // MUST BE PUBLIC: This was causing your "tried to access field" crash

        public static final Set<String> seenMethods = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());



        @Advice.OnMethodEnter

        static long enter(@Advice.Origin("#t.#m") String methodName) {

            // Use absolute path so the inlined code knows exactly where to look

            if (comet.agent.ProfilerAgent.ProfilerAdvice.seenMethods.add(methodName)) {

                System.out.println(">>> HEARTBEAT: First call in " + methodName);

                System.out.flush();

            }

            return System.nanoTime();

        }



        @Advice.OnMethodExit(onThrowable = Throwable.class)

        static void exit(@Advice.Enter long start, @Advice.Origin("#t.#m") String methodName) {

            if (start == 0L) return;

            long duration = System.nanoTime() - start;



            // Use absolute paths for metrics and Stats

            comet.agent.ProfilerAgent.Stats s = comet.agent.ProfilerAgent.metrics.get(methodName);

            if (s == null) {

                comet.agent.ProfilerAgent.metrics.putIfAbsent(methodName, new comet.agent.ProfilerAgent.Stats());

                s = comet.agent.ProfilerAgent.metrics.get(methodName);

            }

            s.record(duration);

        }

    }



    // MUST BE PUBLIC

    public static class Stats {

        public final LongAdder count = new LongAdder();

        public final LongAdder totalTime = new LongAdder();

        public void record(long nanos) {

            count.increment();

            totalTime.add(nanos);

        }

    }



    private static void startReporter(int seconds, String outputDir) {

        Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> {

            String timestamp = sdf.format(new Date());

            File csvFile = new File(outputDir, "profiler_report.csv");

            try (PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(csvFile, true)))) {

                metrics.forEach((method, stats) -> {

                    long c = stats.count.sumThenReset();

                    long t = stats.totalTime.sumThenReset();

                    if (c > 0) {

                        pw.printf("%s,%s,%d,%.4f,%.2f%n", timestamp, method, c, (t/(double)c)/1000000.0, t/1000000.0);

                    }

                });

                pw.flush();

                System.out.println("PROFILER: Report flushed at " + timestamp);

                System.out.flush();

            } catch (Exception e) { e.printStackTrace(); }

        }, seconds, seconds, TimeUnit.SECONDS);

    }

}