Stabilize java dedup coverage collection

Signed-off-by: Asish Kumar <officialasishkumar@gmail.com>

Author: officialasishkumar

README.md

@@ -73,7 +73,10 @@ KeployDedupAgent.start();
 
 ### 3. Run the App with the JaCoCo Java Agent
 
-The dedup agent reads coverage in-process via JaCoCo's runtime API (`org.jacoco.agent.rt.RT.getAgent()`), so all you need is to attach the JaCoCo Java agent — no TCP server flags, no port choices:
+The dedup agent reads coverage in-process via JaCoCo's runtime API (`org.jacoco.agent.rt.RT.getAgent()`), so attaching the JaCoCo Java agent is the only runtime requirement in the common cases below:
+
+- Maven/Gradle dev runs where application classes are under `target/classes` or `build/classes/java/main`
+- packaged `java -jar` runs where the application classes live inside the executable jar
 
 ```bash
 java -javaagent:/path/to/jacocoagent.jar -jar your-app.jar
@@ -112,13 +115,9 @@ keploy dedup --rm
 
 ## Docker and Restricted Docker
 
-Java dedup works in native, Docker, and restricted Docker environments as long as the following conditions are met:
-
-- host `/tmp` is bind-mounted into the container as `/tmp`
-- `/tmp` remains writable so the Unix sockets can be created
-- if the SDK falls back to TCP, the JaCoCo TCP port is reachable from the Java process
+Java dedup works in native, Docker, and restricted Docker environments as long as `/tmp` is shared and writable between Keploy Enterprise and the Java process. In Docker Compose flows, Enterprise can inject that shared `/tmp` mount when it rewrites the Compose file for replay.
 
-The `/tmp` bind mount is required because Keploy Enterprise and the Java SDK communicate over these Unix sockets:
+Keploy Enterprise and the Java SDK communicate over these Unix sockets:
 
 - `/tmp/coverage_control.sock`
 - `/tmp/coverage_data.sock`
@@ -129,8 +128,8 @@ Without a shared `/tmp`, dedup will not work inside containers because Enterpris
 
 - `KEPLOY_JACOCO_HOST`: JaCoCo TCP host used when the in-process runtime API is unavailable. Default: `127.0.0.1`
 - `KEPLOY_JACOCO_PORT`: JaCoCo TCP port used when the in-process runtime API is unavailable. Default: `36320`
-- `KEPLOY_JAVA_CLASS_DIRS`: optional comma-separated class or jar locations to analyze for executed lines
-- `KEPLOY_JAVA_CLASSPATH_FALLBACK`: scans classpath directories and jars if no class roots are found. Default: `false`
+- `KEPLOY_JAVA_CLASS_DIRS`: optional comma-separated class or jar locations to analyze for executed lines when your build output lives outside the standard locations
+- `KEPLOY_JAVA_CLASSPATH_FALLBACK`: scans the full classpath if standard class roots and the executable jar do not provide application classes. Default: `false`
 - `KEPLOY_JAVA_DEDUP_DISABLED`: disables the Java dedup agent when set to `true`, `1`, or `yes`
 
 ## Sample

keploy-sdk/src/main/java/io/keploy/dedup/KeployDedupAgent.java

@@ -41,9 +41,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
@@ -197,7 +194,6 @@ private static final class CommandServer implements Runnable, Closeable {
 
         private final CoverageCollector collector;
         private final CoveragePublisher publisher;
-        private final ExecutorService workers;
         private final AtomicBoolean running = new AtomicBoolean(true);
         private final Object testCaseLock = new Object();
         private volatile AFUNIXServerSocket serverSocket;
@@ -206,7 +202,6 @@ private static final class CommandServer implements Runnable, Closeable {
         CommandServer(CoverageCollector collector, CoveragePublisher publisher) {
             this.collector = collector;
             this.publisher = publisher;
-            this.workers = Executors.newCachedThreadPool(new NamedDaemonFactory("keploy-java-dedup-worker"));
         }
 
         @Override
@@ -221,13 +216,7 @@ public void run() {
 
                 while (running.get()) {
                     try {
-                        final Socket socket = localServer.accept();
-                        workers.execute(new Runnable() {
-                            @Override
-                            public void run() {
-                                handle(socket);
-                            }
-                        });
+                        handle(localServer.accept());
                     } catch (IOException e) {
                         if (running.get()) {
                             log(Level.SEVERE, "Failed to accept Java dedup coverage command", e);
@@ -238,7 +227,6 @@ public void run() {
                 STARTED.set(false);
                 log(Level.SEVERE, "Java dedup control socket server is unavailable", t);
             } finally {
-                workers.shutdownNow();
                 deleteSocketFile(controlSocket);
             }
         }
@@ -269,6 +257,7 @@ private void dispatch(CoverageCommand command, OutputStream outputStream) throws
                 if (command.action == CommandAction.START) {
                     activeTestId = command.testId;
                     collector.reset();
+                    writeAck(outputStream);
                     return;
                 }
 
@@ -317,7 +306,6 @@ public void close() {
                     log(Level.FINE, "Failed to close Java dedup control socket", e);
                 }
             }
-            workers.shutdownNow();
         }
     }
 
@@ -578,18 +566,54 @@ private InProcessAgent(Object agent, Method getExecutionData, Method reset) {
         }
 
         static InProcessAgent locate() throws ReflectiveOperationException {
-            Class<?> rtClass = Class.forName("org.jacoco.agent.rt.RT");
+            ReflectiveOperationException firstFailure = null;
+            for (ClassLoader loader : candidateLoaders()) {
+                try {
+                    InProcessAgent agent = locateWithLoader(loader);
+                    if (agent != null) {
+                        return agent;
+                    }
+                } catch (ReflectiveOperationException e) {
+                    if (firstFailure == null) {
+                        firstFailure = e;
+                    }
+                }
+            }
+
+            if (firstFailure != null) {
+                throw firstFailure;
+            }
+            throw new ClassNotFoundException("org.jacoco.agent.rt.RT");
+        }
+
+        private static InProcessAgent locateWithLoader(ClassLoader loader) throws ReflectiveOperationException {
+            Class<?> rtClass = Class.forName("org.jacoco.agent.rt.RT", true, loader);
             Object resolved = rtClass.getMethod("getAgent").invoke(null);
             if (resolved == null) {
                 return null;
             }
+
             Method getExecutionData = resolved.getClass().getMethod("getExecutionData", boolean.class);
             Method reset = resolved.getClass().getMethod("reset");
             getExecutionData.setAccessible(true);
             reset.setAccessible(true);
             return new InProcessAgent(resolved, getExecutionData, reset);
         }
 
+        private static List<ClassLoader> candidateLoaders() {
+            List<ClassLoader> loaders = new ArrayList<>(3);
+            addLoader(loaders, ClassLoader.getSystemClassLoader());
+            addLoader(loaders, Thread.currentThread().getContextClassLoader());
+            addLoader(loaders, KeployDedupAgent.class.getClassLoader());
+            return loaders;
+        }
+
+        private static void addLoader(List<ClassLoader> loaders, ClassLoader candidate) {
+            if (candidate != null && !loaders.contains(candidate)) {
+                loaders.add(candidate);
+            }
+        }
+
         byte[] getExecutionData(boolean resetCounters) throws IOException {
             try {
                 return (byte[]) getExecutionData.invoke(agent, resetCounters);
@@ -643,6 +667,9 @@ private List<ClassEntry> entries() {
         private List<ClassEntry> loadEntries() {
             LinkedHashMap<String, ClassEntry> collected = new LinkedHashMap<>();
             scanRoots(applicationRoots(), collected);
+            if (collected.isEmpty()) {
+                scanRoots(executableArchiveRoots(), collected);
+            }
             if (collected.isEmpty() && isClasspathFallbackEnabled()) {
                 scanRoots(classpathRoots(), collected);
             }
@@ -679,6 +706,25 @@ private boolean isClasspathFallbackEnabled() {
                     "keploy.java.classpath.fallback", "false"));
         }
 
+        private List<File> executableArchiveRoots() {
+            LinkedHashSet<File> roots = new LinkedHashSet<>();
+            String classpath = System.getProperty("java.class.path", "");
+            if (classpath.trim().isEmpty()) {
+                return new ArrayList<>(roots);
+            }
+
+            String[] parts = classpath.split(Pattern.quote(File.pathSeparator));
+            if (parts.length != 1) {
+                return new ArrayList<>(roots);
+            }
+
+            File file = new File(parts[0].trim());
+            if (file.isFile() && file.getName().endsWith(".jar")) {
+                roots.add(file);
+            }
+            return new ArrayList<>(roots);
+        }
+
         private String[] configuredRoots(String configured) {
             if (configured.indexOf(',') >= 0) {
                 return configured.split(",");
@@ -841,21 +887,4 @@ private ClassEntry(String className, String location, byte[] bytes) {
         }
     }
 
-    private static final class NamedDaemonFactory implements ThreadFactory {
-
-        private final String prefix;
-        private int counter;
-
-        private NamedDaemonFactory(String prefix) {
-            this.prefix = prefix;
-        }
-
-        @Override
-        public synchronized Thread newThread(Runnable runnable) {
-            counter++;
-            Thread thread = new Thread(runnable, prefix + "-" + counter);
-            thread.setDaemon(true);
-            return thread;
-        }
-    }
 }