fix: capture real line numbers in tracer and track dropped captures (TODO-34, TODO-38)

TODO-34: TracingClassVisitor hardcoded line number to 0 because ASM's
visitMethod() doesn't provide line info. Added a pre-scan pass in
TracingTransformer.instrumentClass() that collects first line numbers
via visitLineNumber() before the instrumentation pass.

TODO-38: Serialization timeouts/failures silently dropped captures with
no visibility. Added AtomicInteger droppedCaptures counter and included
it in flush() metadata output.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mohamedashrraf222

codeflash-java-runtime/src/main/java/com/codeflash/tracer/TraceRecorder.java

@@ -22,6 +22,7 @@ public final class TraceRecorder {
     private final TracerConfig config;
     private final TraceWriter writer;
     private final ConcurrentHashMap<String, AtomicInteger> functionCounts = new ConcurrentHashMap<>();
+    private final AtomicInteger droppedCaptures = new AtomicInteger(0);
     private final int maxFunctionCount;
     private final ExecutorService serializerExecutor;
 
@@ -82,11 +83,13 @@ private void onEntryImpl(String className, String methodName, String descriptor,
             argsBlob = future.get(SERIALIZATION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
         } catch (TimeoutException e) {
             future.cancel(true);
+            droppedCaptures.incrementAndGet();
             System.err.println("[codeflash-tracer] Serialization timed out for " + className + "."
                     + methodName);
             return;
         } catch (Exception e) {
             Throwable cause = e.getCause() != null ? e.getCause() : e;
+            droppedCaptures.incrementAndGet();
             System.err.println("[codeflash-tracer] Serialization failed for " + className + "."
                     + methodName + ": " + cause.getClass().getSimpleName() + ": " + cause.getMessage());
             return;
@@ -113,11 +116,15 @@ public void flush() {
         }
         metadata.put("totalCaptures", String.valueOf(totalCaptures));
 
+        int dropped = droppedCaptures.get();
+        metadata.put("droppedCaptures", String.valueOf(dropped));
+
         writer.writeMetadata(metadata);
         writer.flush();
         writer.close();
 
         System.err.println("[codeflash-tracer] Captured " + totalCaptures
-                + " invocations across " + functionCounts.size() + " methods");
+                + " invocations across " + functionCounts.size() + " methods"
+                + (dropped > 0 ? " (" + dropped + " dropped due to serialization timeout/failure)" : ""));
     }
 }

codeflash-java-runtime/src/main/java/com/codeflash/tracer/TracingClassVisitor.java

@@ -4,14 +4,20 @@
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 
+import java.util.Collections;
+import java.util.Map;
+
 public class TracingClassVisitor extends ClassVisitor {
 
     private final String internalClassName;
+    private final Map<String, Integer> methodLineNumbers;
     private String sourceFile;
 
-    public TracingClassVisitor(ClassVisitor classVisitor, String internalClassName) {
+    public TracingClassVisitor(ClassVisitor classVisitor, String internalClassName,
+                               Map<String, Integer> methodLineNumbers) {
         super(Opcodes.ASM9, classVisitor);
         this.internalClassName = internalClassName;
+        this.methodLineNumbers = methodLineNumbers != null ? methodLineNumbers : Collections.emptyMap();
     }
 
     @Override
@@ -37,7 +43,8 @@ public MethodVisitor visitMethod(int access, String name, String descriptor,
             return mv;
         }
 
+        int lineNumber = methodLineNumbers.getOrDefault(name + descriptor, 0);
         return new TracingMethodAdapter(mv, access, name, descriptor,
-                internalClassName, 0, sourceFile != null ? sourceFile : "");
+                internalClassName, lineNumber, sourceFile != null ? sourceFile : "");
     }
 }

codeflash-java-runtime/src/main/java/com/codeflash/tracer/TracingTransformer.java

@@ -1,10 +1,16 @@
 package com.codeflash.tracer;
 
 import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
 
 import java.lang.instrument.ClassFileTransformer;
 import java.security.ProtectionDomain;
+import java.util.HashMap;
+import java.util.Map;
 
 public class TracingTransformer implements ClassFileTransformer {
 
@@ -46,14 +52,38 @@ public byte[] transform(ClassLoader loader, String className,
 
     private byte[] instrumentClass(String internalClassName, byte[] bytecode) {
         ClassReader cr = new ClassReader(bytecode);
+
+        // Pre-scan: collect the first source line number for each method.
+        // ASM's visitMethod() doesn't provide line info — it arrives later via visitLineNumber().
+        // We do a lightweight read pass first so the instrumentation pass has accurate line numbers.
+        Map<String, Integer> methodLineNumbers = new HashMap<>();
+        cr.accept(new ClassVisitor(Opcodes.ASM9) {
+            @Override
+            public MethodVisitor visitMethod(int access, String name, String descriptor,
+                                             String signature, String[] exceptions) {
+                String key = name + descriptor;
+                return new MethodVisitor(Opcodes.ASM9) {
+                    private boolean captured = false;
+
+                    @Override
+                    public void visitLineNumber(int line, Label start) {
+                        if (!captured) {
+                            methodLineNumbers.put(key, line);
+                            captured = true;
+                        }
+                    }
+                };
+            }
+        }, ClassReader.SKIP_FRAMES);
+
         // Use COMPUTE_MAXS only (not COMPUTE_FRAMES) to preserve original stack map frames.
         // COMPUTE_FRAMES recomputes all frames and calls getCommonSuperClass() which either
         // triggers classloader deadlocks or produces incorrect frames when returning "java/lang/Object".
         // With COMPUTE_MAXS + ClassReader passed to constructor, ASM copies original frames and
         // adjusts offsets for injected code. Our AdviceAdapter only injects at method entry
         // (before any branch points), so existing frames remain valid.
         ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
-        TracingClassVisitor cv = new TracingClassVisitor(cw, internalClassName);
+        TracingClassVisitor cv = new TracingClassVisitor(cw, internalClassName, methodLineNumbers);
         cr.accept(cv, ClassReader.EXPAND_FRAMES);
         return cw.toByteArray();
     }