dedup

Author: niesfisch

README.md

@@ -181,7 +181,7 @@ Processor flags:
   - `false`: report only first-seen stack hashes within the current dedup window
 - `processor.stackHashResetIntervalMillis`
   - Periodically clears remembered stack hashes to cap memory usage in long-running JVMs
-  - Default: `300000` (5 minutes)
+  - In dedup mode (`reportAllStacks: false`): if missing, JCT logs a warning and uses `30000` (30 seconds)
 
 Example: report only new stacks (good for high-traffic legacy systems)
 

src/main/java/de/marcelsauer/profiler/config/Processor.java

@@ -16,8 +16,9 @@ public class Processor {
 
     /**
      * reset interval for remembered stack hashes in dedup mode to cap memory usage
+     * null means not explicitly configured
      */
-    public long stackHashResetIntervalMillis = 300_000L;
+    public Long stackHashResetIntervalMillis;
 
     public String udpHost = "localhost";
     public int udpPort = 9999;

src/main/java/de/marcelsauer/profiler/processor/AbstractAsyncStackProcessor.java

@@ -21,6 +21,8 @@ public abstract class AbstractAsyncStackProcessor implements StackProcessor {
     private static final String JCA_PROCESSOR_THREAD = "jca-processor-thread";
     private static final int CAPACITY = 100_000;
     private static final int DRAIN_BATCH_SIZE = 2048;
+    private static final long DEFAULT_STACK_HASH_RESET_INTERVAL_MILLIS = 300_000L;
+    private static final long DEFAULT_STACK_HASH_RESET_INTERVAL_IN_DEDUP_MODE_MILLIS = 30_000L;
 
     /**
      * counters
@@ -34,6 +36,7 @@ public abstract class AbstractAsyncStackProcessor implements StackProcessor {
     private final List<RecordingEvent> dedupBuffer = new ArrayList<>(DRAIN_BATCH_SIZE);
     private final Set<Integer> seenStackHashes = new HashSet<>();
     private long nextStackHashResetAtMillis = 0L;
+    private boolean warnedMissingDedupResetInterval;
 
     /**
      * acting like cron
@@ -177,7 +180,24 @@ protected boolean isReportAllStacks() {
     }
 
     protected long getStackHashResetIntervalMillis() {
-        return Math.max(1_000L, Config.get().processor.stackHashResetIntervalMillis);
+        Long configuredInterval = getConfiguredStackHashResetIntervalMillis();
+        if (configuredInterval != null) {
+            return Math.max(1_000L, configuredInterval);
+        }
+
+        if (!isReportAllStacks()) {
+            if (!warnedMissingDedupResetInterval) {
+                logger.warn("processor.stackHashResetIntervalMillis is not set while processor.reportAllStacks=false. using default 30000ms");
+                warnedMissingDedupResetInterval = true;
+            }
+            return DEFAULT_STACK_HASH_RESET_INTERVAL_IN_DEDUP_MODE_MILLIS;
+        }
+
+        return DEFAULT_STACK_HASH_RESET_INTERVAL_MILLIS;
+    }
+
+    protected Long getConfiguredStackHashResetIntervalMillis() {
+        return Config.get().processor.stackHashResetIntervalMillis;
     }
 
     protected long currentTimeMillis() {

src/test/java/de/marcelsauer/profiler/processor/AbstractAsyncStackProcessorTest.java

@@ -75,14 +75,31 @@ public void thatSeenHashesAreResetAfterConfiguredInterval() throws InterruptedEx
         assertEquals(2, processor.getProcessedCount());
     }
 
+    @Test
+    public void thatMissingDedupIntervalFallsBackToThirtySeconds() throws InterruptedException {
+        TestProcessor processor = new TestProcessor(false, null);
+        processor.start();
+
+        processor.process(newEvent("m1"));
+        Thread.sleep(1200L);
+
+        processor.advanceClockMillis(31_000L);
+        processor.process(newEvent("m1"));
+        Thread.sleep(1200L);
+
+        processor.stop();
+
+        assertEquals(2, processor.getProcessedCount());
+    }
+
     private RecordingEvent newEvent(String methodName) {
         Stack.StackEntry entry = new Stack.StackEntry(methodName, 1L, 0);
         return new RecordingEvent(new Stack(Collections.singletonList(entry)));
     }
 
     private static class TestProcessor extends AbstractAsyncStackProcessor {
         private final boolean reportAllStacks;
-        private final long stackHashResetIntervalMillis;
+        private final Long configuredStackHashResetIntervalMillis;
         private long nowMillis;
         private final AtomicInteger processedCount = new AtomicInteger();
         private final List<Integer> batchSizes = Collections.synchronizedList(new ArrayList<Integer>());
@@ -91,9 +108,9 @@ private static class TestProcessor extends AbstractAsyncStackProcessor {
             this(true, 300_000L);
         }
 
-        TestProcessor(boolean reportAllStacks, long stackHashResetIntervalMillis) {
+        TestProcessor(boolean reportAllStacks, Long stackHashResetIntervalMillis) {
             this.reportAllStacks = reportAllStacks;
-            this.stackHashResetIntervalMillis = stackHashResetIntervalMillis;
+            this.configuredStackHashResetIntervalMillis = stackHashResetIntervalMillis;
         }
 
         @Override
@@ -118,8 +135,8 @@ protected boolean isReportAllStacks() {
         }
 
         @Override
-        protected long getStackHashResetIntervalMillis() {
-            return stackHashResetIntervalMillis;
+        protected Long getConfiguredStackHashResetIntervalMillis() {
+            return configuredStackHashResetIntervalMillis;
         }
 
         @Override