renamings

Author: niesfisch

README.md

@@ -176,12 +176,12 @@ If your main question is only "Was this path hit at least once?", you can report
 
 Processor flags:
 
-- `processor.reportAllStacks`
-  - `true` (default): report every captured event
-  - `false`: report only first-seen stack hashes within the current dedup window
-- `processor.stackHashResetIntervalMillis`
+- `processor.enableStackDeduplication`
+  - `true`: report only first-seen stack hashes within the current dedup window
+  - `false` (default): report every captured event
+- `processor.dedupResetIntervalMillis`
   - Periodically clears remembered stack hashes to cap memory usage in long-running JVMs
-  - In dedup mode (`reportAllStacks: false`): if missing, JCT logs a warning and uses `30000` (30 seconds)
+  - In dedup mode (`enableStackDeduplication: true`): if missing, JCT logs a warning and uses `30000` (30 seconds)
 
 Example: report only new stacks (good for high-traffic legacy systems)
 
@@ -190,8 +190,8 @@ processor:
   fullQualifiedClass: de.marcelsauer.profiler.processor.udp.AsyncUdpStackProcessor
   udpHost: localhost
   udpPort: 9999
-  reportAllStacks: false
-  stackHashResetIntervalMillis: 300000
+  enableStackDeduplication: true
+  dedupResetIntervalMillis: 300000
 ```
 
 Example: report all stacks (full event stream)
@@ -200,7 +200,7 @@ Example: report all stacks (full event stream)
 processor:
   fullQualifiedClass: de.marcelsauer.profiler.processor.file.AsyncFileWritingStackProcessor
   stackFolderName: /tmp/stacks/
-  reportAllStacks: true
+  enableStackDeduplication: false
 ```
 
 ## Message Format

doc/config-sample-file.yaml

@@ -10,7 +10,7 @@ classes:
 processor:
     fullQualifiedClass: de.marcelsauer.profiler.processor.file.AsyncFileWritingStackProcessor
     stackFolderName: /tmp/stacks/
-    # true = report every captured stack event
-    reportAllStacks: true
-    # used in dedup mode (reportAllStacks: false) to reset remembered hashes
-    stackHashResetIntervalMillis: 300000
+    # true = enable stack deduplication (only report unique stacks)
+    enableStackDeduplication: false
+    # used in dedup mode (enableStackDeduplication: true) to reset remembered hashes
+    dedupResetIntervalMillis: 300000

doc/config-sample-helloworld-file.yaml

@@ -7,5 +7,5 @@ classes:
 processor:
     fullQualifiedClass: de.marcelsauer.profiler.processor.file.AsyncFileWritingStackProcessor
     stackFolderName: /tmp/stacks/
-    reportAllStacks: true
-    stackHashResetIntervalMillis: 300000
+    enableStackDeduplication: false
+    dedupResetIntervalMillis: 300000

doc/config-sample-helloworld-tcp.yaml

@@ -11,7 +11,7 @@ processor:
     tcpConnectTimeoutMillis: 1000
     tcpReconnectDelayMillis: 1000
     # true = report every captured stack event
-    reportAllStacks: true
-    # used in dedup mode (reportAllStacks: false)
-    stackHashResetIntervalMillis: 300000
+    enableStackDeduplication: false
+    # used in dedup mode (enableStackDeduplication: true)
+    dedupResetIntervalMillis: 300000
 

doc/config-sample-helloworld-udp.yaml

@@ -9,6 +9,6 @@ processor:
     udpHost: localhost
     udpPort: 9999
     # report only first-seen stacks in a time window
-    reportAllStacks: false
+    enableStackDeduplication: true
     # reset dedup hashes every 5 minutes to cap memory usage
-    stackHashResetIntervalMillis: 300000
+    dedupResetIntervalMillis: 300000

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

@@ -9,16 +9,16 @@ public class Processor {
     public String fullQualifiedClass;
 
     /**
-     * true: report every captured stack event
-     * false: report only first-seen stack hashes until periodic reset
+     * true: report only first-seen stack hashes until periodic reset
+     * false: report every captured stack event
      */
-    public boolean reportAllStacks = true;
+    public boolean enableStackDeduplication = false;
 
     /**
      * reset interval for remembered stack hashes in dedup mode to cap memory usage
      * null means not explicitly configured
      */
-    public Long stackHashResetIntervalMillis;
+    public Long dedupResetIntervalMillis;
 
     public String udpHost = "localhost";
     public int udpPort = 9999;

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

@@ -21,8 +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;
+    private static final long DEFAULT_DEDUP_RESET_INTERVAL_MILLIS = 300_000L;
+    private static final long DEFAULT_DEDUP_RESET_INTERVAL_IN_DEDUP_MODE_MILLIS = 30_000L;
 
     /**
      * counters
@@ -35,7 +35,7 @@ public abstract class AbstractAsyncStackProcessor implements StackProcessor {
     private final List<RecordingEvent> drainBuffer = new ArrayList<>(DRAIN_BATCH_SIZE);
     private final List<RecordingEvent> dedupBuffer = new ArrayList<>(DRAIN_BATCH_SIZE);
     private final Set<Integer> seenStackHashes = new HashSet<>();
-    private long nextStackHashResetAtMillis = 0L;
+    private long nextDedupResetAtMillis = 0L;
     private boolean warnedMissingDedupResetInterval;
 
     /**
@@ -145,7 +145,7 @@ private Collection<RecordingEvent> drainNextBatch() {
     }
 
     private Collection<RecordingEvent> filterReportableStacks(Collection<RecordingEvent> snapshot) {
-        if (isReportAllStacks()) {
+        if (!isStackDeduplicationEnabled()) {
             return snapshot;
         }
 
@@ -162,44 +162,44 @@ private Collection<RecordingEvent> filterReportableStacks(Collection<RecordingEv
 
     private void maybeResetSeenStackHashes() {
         long now = currentTimeMillis();
-        if (now < nextStackHashResetAtMillis) {
+        if (now < nextDedupResetAtMillis) {
             return;
         }
 
         int clearedCount = seenStackHashes.size();
         seenStackHashes.clear();
-        nextStackHashResetAtMillis = now + getStackHashResetIntervalMillis();
-        logger.info(String.format("dedup cache purged: cleared %d stack hash(es), next reset in %dms", clearedCount, getStackHashResetIntervalMillis()));
+        nextDedupResetAtMillis = now + getDedupResetIntervalMillis();
+        logger.info(String.format("dedup cache purged: cleared %d stack hash(es), next reset in %dms", clearedCount, getDedupResetIntervalMillis()));
     }
 
     private void resetDedupWindow() {
         seenStackHashes.clear();
-        nextStackHashResetAtMillis = currentTimeMillis() + getStackHashResetIntervalMillis();
+        nextDedupResetAtMillis = currentTimeMillis() + getDedupResetIntervalMillis();
     }
 
-    protected boolean isReportAllStacks() {
-        return Config.get().processor.reportAllStacks;
+    protected boolean isStackDeduplicationEnabled() {
+        return Config.get().processor.enableStackDeduplication;
     }
 
-    protected long getStackHashResetIntervalMillis() {
-        Long configuredInterval = getConfiguredStackHashResetIntervalMillis();
+    protected long getDedupResetIntervalMillis() {
+        Long configuredInterval = getConfiguredDedupResetIntervalMillis();
         if (configuredInterval != null) {
             return Math.max(1_000L, configuredInterval);
         }
 
-        if (!isReportAllStacks()) {
+        if (isStackDeduplicationEnabled()) {
             if (!warnedMissingDedupResetInterval) {
-                logger.warn("processor.stackHashResetIntervalMillis is not set while processor.reportAllStacks=false. using default 30000ms");
+                logger.warn("processor.dedupResetIntervalMillis is not set while processor.enableStackDeduplication=true. using default 30000ms");
                 warnedMissingDedupResetInterval = true;
             }
-            return DEFAULT_STACK_HASH_RESET_INTERVAL_IN_DEDUP_MODE_MILLIS;
+            return DEFAULT_DEDUP_RESET_INTERVAL_IN_DEDUP_MODE_MILLIS;
         }
 
-        return DEFAULT_STACK_HASH_RESET_INTERVAL_MILLIS;
+        return DEFAULT_DEDUP_RESET_INTERVAL_MILLIS;
     }
 
-    protected Long getConfiguredStackHashResetIntervalMillis() {
-        return Config.get().processor.stackHashResetIntervalMillis;
+    protected Long getConfiguredDedupResetIntervalMillis() {
+        return Config.get().processor.dedupResetIntervalMillis;
     }
 
     protected long currentTimeMillis() {

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

@@ -45,7 +45,7 @@ public void thatQueueIsDrainedInBatchesWithoutLosingEvents() {
 
     @Test
     public void thatOnlyNewStacksAreReportedWhenDedupModeIsEnabled() {
-        TestProcessor processor = new TestProcessor(false, 60_000L);
+        TestProcessor processor = new TestProcessor(true, 60_000L);
         processor.start();
 
         processor.process(newEvent("m1"));
@@ -60,7 +60,7 @@ public void thatOnlyNewStacksAreReportedWhenDedupModeIsEnabled() {
 
     @Test
     public void thatSeenHashesAreResetAfterConfiguredInterval() throws InterruptedException {
-        TestProcessor processor = new TestProcessor(false, 1000L);
+        TestProcessor processor = new TestProcessor(true, 1000L);
         processor.start();
 
         processor.process(newEvent("m1"));
@@ -77,7 +77,7 @@ public void thatSeenHashesAreResetAfterConfiguredInterval() throws InterruptedEx
 
     @Test
     public void thatMissingDedupIntervalFallsBackToThirtySeconds() throws InterruptedException {
-        TestProcessor processor = new TestProcessor(false, null);
+        TestProcessor processor = new TestProcessor(true, null);
         processor.start();
 
         processor.process(newEvent("m1"));
@@ -98,19 +98,19 @@ private RecordingEvent newEvent(String methodName) {
     }
 
     private static class TestProcessor extends AbstractAsyncStackProcessor {
-        private final boolean reportAllStacks;
-        private final Long configuredStackHashResetIntervalMillis;
+        private final boolean enableStackDeduplication;
+        private final Long configuredDedupResetIntervalMillis;
         private long nowMillis;
         private final AtomicInteger processedCount = new AtomicInteger();
         private final List<Integer> batchSizes = Collections.synchronizedList(new ArrayList<Integer>());
 
         TestProcessor() {
-            this(true, 300_000L);
+            this(false, 300_000L);
         }
 
-        TestProcessor(boolean reportAllStacks, Long stackHashResetIntervalMillis) {
-            this.reportAllStacks = reportAllStacks;
-            this.configuredStackHashResetIntervalMillis = stackHashResetIntervalMillis;
+        TestProcessor(boolean enableStackDeduplication, Long dedupResetIntervalMillis) {
+            this.enableStackDeduplication = enableStackDeduplication;
+            this.configuredDedupResetIntervalMillis = dedupResetIntervalMillis;
         }
 
         @Override
@@ -130,13 +130,13 @@ protected void doProcess(Collection<RecordingEvent> snapshots) {
         }
 
         @Override
-        protected boolean isReportAllStacks() {
-            return reportAllStacks;
+        protected boolean isStackDeduplicationEnabled() {
+            return enableStackDeduplication;
         }
 
         @Override
-        protected Long getConfiguredStackHashResetIntervalMillis() {
-            return configuredStackHashResetIntervalMillis;
+        protected Long getConfiguredDedupResetIntervalMillis() {
+            return configuredDedupResetIntervalMillis;
         }
 
         @Override