[pinpoint-apm#12238] Add virtual TimeseriesWindows to TimeWindow

Author: emeroad

commons-server/src/main/java/com/navercorp/pinpoint/common/server/util/timewindow/TimeSeriesIterator.java

@@ -0,0 +1,45 @@
+package com.navercorp.pinpoint.common.server.util.timewindow;
+
+import org.springframework.util.Assert;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/**
+ * @author emeroad
+ */
+public class TimeSeriesIterator implements Iterator<Long> {
+    private final int size;
+    private final long start;
+    private final long increment;
+
+    private int index = 0;
+
+    public TimeSeriesIterator(int size, long start, long increment) {
+        Assert.isTrue(size >= 0, "negative size");
+        this.size = size;
+        this.start = start;
+        this.increment = increment;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return index < size;
+    }
+
+    @Override
+    public Long next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        return get(index++);
+    }
+
+    private long get(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+        }
+        return start + (index * increment);
+    }
+}
+

commons-server/src/main/java/com/navercorp/pinpoint/common/server/util/timewindow/TimeSeriesVirtualList.java

@@ -0,0 +1,41 @@
+package com.navercorp.pinpoint.common.server.util.timewindow;
+
+import org.springframework.util.Assert;
+
+import java.util.AbstractList;
+import java.util.Iterator;
+
+/**
+ * A virtual list that represents a time series.
+ * @author emeroad
+ */
+public class TimeSeriesVirtualList extends AbstractList<Long> {
+    private final int size;
+    private final long start;
+    private final long increment;
+
+    public TimeSeriesVirtualList(int size, long start, long increment) {
+        Assert.isTrue(size >= 0, "negative size");
+        this.size = size;
+        this.start = start;
+        this.increment = increment;
+    }
+
+    @Override
+    public Long get(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+        }
+        return start + (index * increment);
+    }
+
+    @Override
+    public Iterator<Long> iterator() {
+        return new TimeSeriesIterator(this.size, this.start, this.increment);
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+}

commons-server/src/main/java/com/navercorp/pinpoint/common/server/util/timewindow/TimeWindow.java

@@ -20,20 +20,17 @@
 
 import java.time.Instant;
 import java.util.Iterator;
-import java.util.NoSuchElementException;
+import java.util.List;
 import java.util.Objects;
 
 /**
  * 
  * @author netspider
- * 
  */
 public class TimeWindow implements Iterable<Long>, TimeWindowFunction {
 
     private final long windowSlotSize;
 
-    private final Range range;
-
     private final Range windowRange;
 
     private final int windowRangeCount;
@@ -43,10 +40,10 @@ public TimeWindow(Range range) {
     }
 
     public TimeWindow(Range range, TimeWindowSampler sampler) {
-        this.range = Objects.requireNonNull(range, "range");
+        Objects.requireNonNull(range, "range");
         Objects.requireNonNull(sampler, "sampler");
         this.windowSlotSize = sampler.getWindowSize(range);
-        this.windowRange = createWindowRange();
+        this.windowRange = createWindowRange(range);
         this.windowRangeCount = computeWindowRangeCount(windowRange.durationMillis(), windowSlotSize);
     }
 
@@ -58,8 +55,19 @@ private static int computeWindowRangeCount(long duration, long slotSize) {
         return Math.toIntExact(count);
     }
 
+    @Override
     public Iterator<Long> iterator() {
-        return new Itr();
+        final int size = this.getWindowRangeCount();
+        final long start = windowRange.getFrom();
+        final long increment = getWindowSlotSize();
+        return new TimeSeriesIterator(size, start, increment);
+    }
+
+    public List<Long> getTimeseriesWindows() {
+        final int size = this.getWindowRangeCount();
+        final long start = windowRange.getFrom();
+        final long increment = getWindowSlotSize();
+        return new TimeSeriesVirtualList(size, start, increment);
     }
 
     /**
@@ -91,45 +99,15 @@ public Range getWindowSlotRange() {
         return  Range.between(scanFrom, Instant.ofEpochMilli(scanTo));
     }
 
-    private Range createWindowRange() {
+    private Range createWindowRange(Range range) {
         long from = refineTimestamp(range.getFrom());
         long to = refineTimestamp(range.getTo());
         return Range.between(from, to);
     }
 
     public int getWindowIndex(long time) {
         long index = (time - windowRange.getFrom()) / this.windowSlotSize;
-        return (int)index;
+        return (int) index;
     }
 
-    private class Itr implements Iterator<Long> {
-
-        private long cursor;
-        private final long end;
-
-        public Itr() {
-            this.cursor = windowRange.getFrom();
-            this.end = windowRange.getTo();
-        }
-
-        @Override
-        public boolean hasNext() {
-            return cursor <= end;
-        }
-
-        @Override
-        public Long next() {
-            long current = cursor;
-            if (hasNext()) {
-                cursor += windowSlotSize;
-                return current;
-            }
-            throw new NoSuchElementException();
-        }
-
-        @Override
-        public void remove() {
-            throw new UnsupportedOperationException();
-        }
-    }
 }

commons-server/src/test/java/com/navercorp/pinpoint/common/server/util/timewindow/TimeSeriesVirtualListTest.java

@@ -0,0 +1,23 @@
+package com.navercorp.pinpoint.common.server.util.timewindow;
+
+import com.google.common.collect.ImmutableList;
+import com.navercorp.pinpoint.common.server.util.time.Range;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+class TimeSeriesVirtualListTest {
+
+    @Test
+    void list() {
+        TimeWindowSampler sampler = new FixedTimeWindowSampler(100);
+        TimeWindow timeWindow = new TimeWindow(Range.between(0L, 10000L), sampler);
+        List<Long> timeWindowList = ImmutableList.copyOf(timeWindow.iterator());
+
+        List<Long> list = new TimeSeriesVirtualList(timeWindow.getWindowRangeCount(), 0, timeWindow.getWindowSlotSize());
+
+        assertThat(list).isEqualTo(timeWindowList);
+    }
+}

commons-server/src/test/java/com/navercorp/pinpoint/common/server/util/timewindow/TimeWindowTest.java

@@ -23,58 +23,74 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
-import java.util.Iterator;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 /**
  * @author emeroad
  */
-public class TimeWindowTest {
+class TimeWindowTest {
     private final Logger logger = LogManager.getLogger(this.getClass());
 
 
     @Test
-    public void testGetNextWindowFirst() {
+    void testGetTimeseriesWindows() {
         TimeWindow window = new TimeWindow(Range.between(0L, 1000));
         logger.debug("{}", window.getWindowRange());
-        Iterator<Long> iterator = window.iterator();
-        Assertions.assertEquals(0L, iterator.next());
+        List<Long> timeWindows = window.getTimeseriesWindows();
 
-        Assertions.assertThrows(Exception.class, iterator::next);
+        assertThat(timeWindows).hasSize(1)
+                .containsExactly(0L);
+    }
 
+    @Test
+    void testTimestampWindows2() {
         TimeWindow window2 = new TimeWindow(Range.between(0L, TimeUnit.MINUTES.toMillis(1)));
         logger.debug("{}", window2.getWindowRange());
-        Iterator<Long> iterator2 = window2.iterator();
-        Assertions.assertEquals(0L, iterator2.next());
-        Assertions.assertEquals(1000*60L, iterator2.next());
-        Assertions.assertThrows(Exception.class, iterator2::next);
+        List<Long> timeWindows2 = window2.getTimeseriesWindows();
+        assertThat(timeWindows2).hasSize(2)
+                .containsExactly(0L, 1000 * 60L);
     }
 
+
     @Test
-    public void testGetNextWindow() {
+    void testTimestampWindowsSize() {
         Range range = Range.between(0L, TimeUnit.MINUTES.toMillis(1));
         TimeWindow window = new TimeWindow(range);
-        ImmutableList<Long> longs = ImmutableList.copyOf(window.iterator());
-        Assertions.assertEquals(2, longs.size());
+        List<Long> timestamps = window.getTimeseriesWindows();
+        Assertions.assertEquals(2, timestamps.size());
         Assertions.assertEquals(2, window.getWindowRangeCount());
     }
 
     @Test
-    public void testGetNextWindow2() {
+    void testTimestampWindowsSize2() {
         Range range = Range.between(1L, TimeUnit.MINUTES.toMillis(1));
         TimeWindow window = new TimeWindow(range);
-        ImmutableList<Long> longs = ImmutableList.copyOf(window.iterator());
-        Assertions.assertEquals(2, longs.size());
+        List<Long> timestamps = window.getTimeseriesWindows();
+        Assertions.assertEquals(2, timestamps.size());
         Assertions.assertEquals(2, window.getWindowRangeCount());
     }
 
     @Test
-    public void testRefineTimestamp() {
+    void testGetNextWindow_iter() {
+        Range range = Range.between(1L, TimeUnit.MINUTES.toMillis(1));
+        TimeWindow window = new TimeWindow(range);
+
+        List<Long> iter = ImmutableList.copyOf(window.iterator());
+        List<Long> timestamps = window.getTimeseriesWindows();
+        assertThat(timestamps)
+                .isEqualTo(iter);
+    }
+
+    @Test
+    void testRefineTimestamp() {
 
     }
 
     @Test
-    public void testGetWindowSize() {
+    void testGetWindowSize() {
         testWindowSize(0, TimeUnit.MINUTES.toMillis(1));
         testWindowSize(0, TimeUnit.HOURS.toMillis(1));
         testWindowSize(0, TimeUnit.HOURS.toMillis(23));
@@ -88,8 +104,8 @@ private void testWindowSize(long start, long end) {
     }
 
     @Test
-    public void refineRange() {
-        Range range = Range.between(1L, TimeUnit.MINUTES.toMillis(1)+1);
+    void refineRange() {
+        Range range = Range.between(1L, TimeUnit.MINUTES.toMillis(1) + 1);
         TimeWindow window = new TimeWindow(range);
         Range windowRange = window.getWindowRange();
         // 1 should be replace by 0.
@@ -100,7 +116,7 @@ public void refineRange() {
     }
 
     @Test
-    public void testGetWindowRangeLength() {
+    void testGetWindowRangeLength() {
         Range range = Range.between(1L, 2L);
         TimeWindow window = new TimeWindow(range);
         int windowRangeLength = window.getWindowRangeCount();
@@ -110,26 +126,26 @@ public void testGetWindowRangeLength() {
     }
 
     @Test
-    public void testGetWindowRangeLength2() {
-        Range range = Range.between(1L, 1000*60L + 1);
+    void testGetWindowRangeLength2() {
+        Range range = Range.between(1L, 1000 * 60L + 1);
         TimeWindow window = new TimeWindow(range);
         int windowRangeLength = window.getWindowRangeCount();
         logger.debug("{}", windowRangeLength);
         Assertions.assertEquals(2, windowRangeLength);
     }
 
     @Test
-     public void testRefineIndex1() {
-        Range range = Range.between(1L, 1000*60L);
+    void testRefineIndex1() {
+        Range range = Range.between(1L, 1000 * 60L);
         TimeWindow window = new TimeWindow(range);
         long index = window.getWindowIndex(2);
         logger.debug("{}", index);
         Assertions.assertEquals(0, index);
     }
 
     @Test
-     public void testRefineIndex2() {
-        Range range = Range.between(1L, 1000*60L);
+    void testRefineIndex2() {
+        Range range = Range.between(1L, 1000 * 60L);
         TimeWindow window = new TimeWindow(range);
         long index = window.getWindowIndex(1000 * 60L);
         logger.debug("{}", index);

exceptiontrace/exceptiontrace-web/src/main/java/com/navercorp/pinpoint/exceptiontrace/web/util/TimeSeriesUtils.java

@@ -19,7 +19,6 @@
 import com.navercorp.pinpoint.exceptiontrace.web.model.ExceptionChartGroup;
 import com.navercorp.pinpoint.exceptiontrace.web.view.ExceptionChartValueView;
 import com.navercorp.pinpoint.exceptiontrace.web.view.ExceptionChartView;
-import com.navercorp.pinpoint.metric.common.util.TimeUtils;
 import com.navercorp.pinpoint.metric.web.view.TimeSeriesValueView;
 import com.navercorp.pinpoint.metric.web.view.TimeseriesValueGroupView;
 
@@ -48,7 +47,7 @@ public static ExceptionChartView newChartView(
         Objects.requireNonNull(timeWindow, "timeWindow");
         Objects.requireNonNull(exceptionChartValueViews, "exceptionTraceValueViews");
 
-        List<Long> timestampList = TimeUtils.createTimeStampList(timeWindow);
+        List<Long> timestampList = timeWindow.getTimeseriesWindows();
         List<TimeseriesValueGroupView> timeSeriesValueGroupViews = new ArrayList<>();
         timeSeriesValueGroupViews.add(
                 newGroupFromValueViews(groupName, exceptionChartValueViews)