perf: optimize Java tracing agent serialization and writes

- Reuse ThreadLocal Kryo Output buffers (eliminates #1 allocation hotspot)
- Fast-path inline serialization for safe arg types (bypasses executor)
- Skip verification roundtrip for known-safe containers (ArrayList, HashMap, etc.)
- Batch SQLite inserts (256/txn) with permanent autocommit-off
- Switch to ArrayBlockingQueue (no per-element Node allocation)
- Add opt-in in-memory SQLite mode (VACUUM INTO at shutdown), enabled in CI
- Add timing instrumentation (onEntry, serialization, writes, dump)
- Add ProfilingWorkload fixture for benchmarking

Benchmark (50k captures): onEntry 5200ms→1200ms (4.3x), avg/capture
0.43ms→0.02ms (21x), writes 3200ms→900ms (3.5x) with in-memory mode.

Author: KRRT7

codeflash-java-runtime/src/main/java/com/codeflash/Serializer.java

@@ -6,7 +6,6 @@
 import com.esotericsoftware.kryo.util.DefaultInstantiatorStrategy;
 import org.objenesis.strategy.StdInstantiatorStrategy;
 
-import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.lang.reflect.Field;
@@ -36,7 +35,11 @@ public final class Serializer {
     private static final int MAX_COLLECTION_SIZE = 1000;
     private static final int BUFFER_SIZE = 4096;
 
-    // Thread-local Kryo instances (Kryo is not thread-safe)
+    // Thread-local Kryo, Output, and IdentityHashMap instances for reuse
+    private static final ThreadLocal<Output> OUTPUT = ThreadLocal.withInitial(() -> new Output(BUFFER_SIZE, -1));
+    private static final ThreadLocal<IdentityHashMap<Object, Object>> SEEN =
+        ThreadLocal.withInitial(IdentityHashMap::new);
+
     private static final ThreadLocal<Kryo> KRYO = ThreadLocal.withInitial(() -> {
         Kryo kryo = new Kryo();
         kryo.setRegistrationRequired(false);
@@ -89,10 +92,78 @@ private Serializer() {
      * @return Serialized bytes (may contain KryoPlaceholder for unserializable parts)
      */
     public static byte[] serialize(Object obj) {
-        Object processed = recursiveProcess(obj, new IdentityHashMap<>(), 0, "");
+        // Fast path: if args are all safe types, skip recursive processing entirely
+        if (obj instanceof Object[] && isSafeArgs((Object[]) obj)) {
+            return directSerialize(obj);
+        }
+
+        IdentityHashMap<Object, Object> seen = SEEN.get();
+        seen.clear();
+        Object processed = recursiveProcess(obj, seen, 0, "");
         return directSerialize(processed);
     }
 
+    /**
+     * Attempt fast-path serialization for args that are all known-safe types.
+     * Returns serialized bytes if all args are safe, or null if the slow path is needed.
+     * Callers can use this to avoid executor submission overhead for simple arguments.
+     */
+    public static byte[] serializeFast(Object obj) {
+        if (obj instanceof Object[] && isSafeArgs((Object[]) obj)) {
+            return directSerialize(obj);
+        }
+        return null;
+    }
+
+    /**
+     * Check if all elements of an args array can be serialized directly without recursive processing.
+     */
+    private static boolean isSafeArgs(Object[] args) {
+        for (Object arg : args) {
+            if (!isSafeForDirectSerialization(arg)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Check if an object is safe to serialize directly without recursive processing.
+     * Covers: null, simple types, primitive arrays, and safe containers (up to 3 levels deep).
+     */
+    private static boolean isSafeForDirectSerialization(Object obj) {
+        return isSafeForDirectSerialization(obj, 3);
+    }
+
+    private static boolean isSafeForDirectSerialization(Object obj, int depthLeft) {
+        if (obj == null || isSimpleType(obj)) {
+            return true;
+        }
+        if (depthLeft <= 0) {
+            return false;
+        }
+        Class<?> clazz = obj.getClass();
+        if (clazz.isArray() && clazz.getComponentType().isPrimitive()) {
+            return true;
+        }
+        if (isSafeContainerType(clazz)) {
+            if (obj instanceof Collection) {
+                for (Object item : (Collection<?>) obj) {
+                    if (!isSafeForDirectSerialization(item, depthLeft - 1)) return false;
+                }
+                return true;
+            }
+            if (obj instanceof Map) {
+                for (Map.Entry<?, ?> e : ((Map<?, ?>) obj).entrySet()) {
+                    if (!isSafeForDirectSerialization(e.getKey(), depthLeft - 1) ||
+                        !isSafeForDirectSerialization(e.getValue(), depthLeft - 1)) return false;
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * Deserialize bytes back to an object.
      * The returned object may contain KryoPlaceholder instances for parts
@@ -141,14 +212,15 @@ public static byte[] serializeException(Throwable error) {
 
     /**
      * Direct serialization without recursive processing.
+     * Reuses a ThreadLocal Output buffer to avoid per-call allocation.
      */
     private static byte[] directSerialize(Object obj) {
         Kryo kryo = KRYO.get();
-        ByteArrayOutputStream baos = new ByteArrayOutputStream(BUFFER_SIZE);
-        try (Output output = new Output(baos)) {
-            kryo.writeClassAndObject(output, obj);
-        }
-        return baos.toByteArray();
+        Output output = OUTPUT.get();
+        output.reset();
+        kryo.writeClassAndObject(output, obj);
+        output.flush();
+        return output.toBytes();
     }
 
     /**
@@ -201,37 +273,23 @@ private static Object recursiveProcess(Object obj, IdentityHashMap<Object, Objec
             // unserializable types, recursively process to catch and replace unserializable objects.
             if (obj instanceof Map) {
                 Map<?, ?> map = (Map<?, ?>) obj;
-                if (containsOnlySimpleTypes(map)) {
-                    // Simple map - try direct serialization to preserve full size
-                    byte[] serialized = tryDirectSerialize(obj);
-                    if (serialized != null) {
-                        try {
-                            deserialize(serialized);
-                            return obj; // Success - return original
-                        } catch (Exception e) {
-                            // Fall through to recursive handling
-                        }
-                    }
+                if (isSafeContainerType(clazz) && containsOnlySimpleTypes(map)) {
+                    return obj;
                 }
                 return handleMap(map, seen, depth, path);
             }
             if (obj instanceof Collection) {
                 Collection<?> collection = (Collection<?>) obj;
-                if (containsOnlySimpleTypes(collection)) {
-                    // Simple collection - try direct serialization to preserve full size
-                    byte[] serialized = tryDirectSerialize(obj);
-                    if (serialized != null) {
-                        try {
-                            deserialize(serialized);
-                            return obj; // Success - return original
-                        } catch (Exception e) {
-                            // Fall through to recursive handling
-                        }
-                    }
+                if (isSafeContainerType(clazz) && containsOnlySimpleTypes(collection)) {
+                    return obj;
                 }
                 return handleCollection(collection, seen, depth, path);
             }
             if (clazz.isArray()) {
+                // Primitive arrays (int[], double[], etc.) are directly serializable by Kryo
+                if (clazz.getComponentType().isPrimitive()) {
+                    return obj;
+                }
                 return handleArray(obj, seen, depth, path);
             }
 
@@ -255,6 +313,19 @@ private static Object recursiveProcess(Object obj, IdentityHashMap<Object, Objec
         }
     }
 
+    /**
+     * Check if a container type is known to round-trip safely through Kryo without verification.
+     * Only includes types registered with Kryo that are known to serialize/deserialize correctly.
+     */
+    private static boolean isSafeContainerType(Class<?> clazz) {
+        return clazz == ArrayList.class ||
+               clazz == LinkedList.class ||
+               clazz == HashMap.class ||
+               clazz == LinkedHashMap.class ||
+               clazz == HashSet.class ||
+               clazz == LinkedHashSet.class;
+    }
+
     /**
      * Check if a class is known to be unserializable.
      */

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

@@ -12,6 +12,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 public final class TraceRecorder {
 
@@ -23,6 +24,8 @@ public final class TraceRecorder {
     private final TraceWriter writer;
     private final ConcurrentHashMap<String, AtomicInteger> functionCounts = new ConcurrentHashMap<>();
     private final AtomicInteger droppedCaptures = new AtomicInteger(0);
+    private final AtomicLong totalOnEntryNs = new AtomicLong(0);
+    private final AtomicLong totalSerializationNs = new AtomicLong(0);
     private final int maxFunctionCount;
     private final ExecutorService serializerExecutor;
 
@@ -31,7 +34,7 @@ public final class TraceRecorder {
 
     private TraceRecorder(TracerConfig config) {
         this.config = config;
-        this.writer = new TraceWriter(config.getDbPath());
+        this.writer = new TraceWriter(config.getDbPath(), config.isInMemoryDb());
         this.maxFunctionCount = config.getMaxFunctionCount();
         this.serializerExecutor = Executors.newCachedThreadPool(r -> {
             Thread t = new Thread(r, "codeflash-serializer");
@@ -68,6 +71,8 @@ public void onEntry(String className, String methodName, String descriptor,
 
     private void onEntryImpl(String className, String methodName, String descriptor,
                              int lineNumber, String sourceFile, Object[] args) {
+        long entryStart = System.nanoTime();
+
         String qualifiedName = className + "." + methodName + descriptor;
 
         // Check per-method count limit
@@ -76,30 +81,38 @@ private void onEntryImpl(String className, String methodName, String descriptor,
             return;
         }
 
-        // Serialize args with timeout to prevent deep object graph traversal from blocking
+        // Serialize args — try inline fast path first, fall back to async with timeout
         byte[] argsBlob;
-        Future<byte[]> future = serializerExecutor.submit(() -> Serializer.serialize(args));
-        try {
-            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;
+        long serStart = System.nanoTime();
+        argsBlob = Serializer.serializeFast(args);
+        if (argsBlob == null) {
+            // Slow path: async serialization with timeout for complex/unknown types
+            Future<byte[]> future = serializerExecutor.submit(() -> Serializer.serialize(args));
+            try {
+                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;
+            }
         }
+        totalSerializationNs.addAndGet(System.nanoTime() - serStart);
 
         long timeNs = System.nanoTime();
         count.incrementAndGet();
 
         writer.recordFunctionCall("call", methodName, className, sourceFile,
                 lineNumber, descriptor, timeNs, argsBlob);
+
+        totalOnEntryNs.addAndGet(System.nanoTime() - entryStart);
     }
 
     public void flush() {
@@ -126,5 +139,16 @@ public void flush() {
         System.err.println("[codeflash-tracer] Captured " + totalCaptures
                 + " invocations across " + functionCounts.size() + " methods"
                 + (dropped > 0 ? " (" + dropped + " dropped due to serialization timeout/failure)" : ""));
+
+        // Timing summary
+        long onEntryMs = totalOnEntryNs.get() / 1_000_000;
+        long serMs = totalSerializationNs.get() / 1_000_000;
+        String writerSummary = writer.getTimingSummary();
+        System.err.println("[codeflash-tracer] Timing: onEntry=" + onEntryMs + "ms"
+                + " (serialization=" + serMs + "ms)"
+                + (totalCaptures > 0
+                    ? " avg=" + String.format("%.2f", (double) onEntryMs / totalCaptures) + "ms/capture"
+                    : "")
+                + " " + writerSummary);
     }
 }