diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/ActiveTraceSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/ActiveTraceSampler.java
index 5221999132bf..b6f8da989bd7 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/ActiveTraceSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/ActiveTraceSampler.java
@@ -20,7 +20,9 @@
 import com.navercorp.pinpoint.common.server.bo.stat.ActiveTraceHistogram;
 import com.navercorp.pinpoint.common.trace.BaseHistogramSchema;
 import com.navercorp.pinpoint.common.trace.HistogramSchema;
+import com.navercorp.pinpoint.common.trace.HistogramSlot;
 import com.navercorp.pinpoint.common.util.CollectionUtils;
+import com.navercorp.pinpoint.web.vo.chart.Point;
 import com.navercorp.pinpoint.web.vo.stat.chart.DownSampler;
 import com.navercorp.pinpoint.web.vo.stat.chart.DownSamplers;
 import com.navercorp.pinpoint.web.vo.stat.SampledActiveTrace;
@@ -45,28 +47,30 @@ public SampledActiveTrace sampleDataPoints(int timeWindowIndex, long timestamp,
 
         final HistogramSchema schema = BaseHistogramSchema.getDefaultHistogramSchemaByTypeCode(dataPoints.get(0).getHistogramSchemaType());
         if (schema == null) {
-            SampledActiveTrace sampledActiveTrace = new SampledActiveTrace();
-            sampledActiveTrace.setFastCounts(SampledActiveTrace.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp));
-            sampledActiveTrace.setNormalCounts(SampledActiveTrace.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp));
-            sampledActiveTrace.setSlowCounts(SampledActiveTrace.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp));
-            sampledActiveTrace.setVerySlowCounts(SampledActiveTrace.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp));
-            return sampledActiveTrace;
+            return newUnSampledActiveTrace(timestamp);
         }
 
-        SampledActiveTrace sampledActiveTrace = new SampledActiveTrace();
-        List<Integer> fastCounts = filterActiveTraceBoList(dataPoints, ActiveTraceHistogram::getFastCount);
-        sampledActiveTrace.setFastCounts(createSampledTitledPoint(schema.getFastSlot().getSlotName(), timestamp, fastCounts));
+        AgentStatPoint<Integer> fast = newAgentStatPoint(schema.getFastSlot(), timestamp, dataPoints, ActiveTraceHistogram::getFastCount);
+        AgentStatPoint<Integer> normal = newAgentStatPoint(schema.getNormalSlot(), timestamp, dataPoints, ActiveTraceHistogram::getNormalCount);
+        AgentStatPoint<Integer> slow = newAgentStatPoint(schema.getSlowSlot(), timestamp, dataPoints, ActiveTraceHistogram::getSlowCount);
+        AgentStatPoint<Integer> verySlow = newAgentStatPoint(schema.getVerySlowSlot(), timestamp, dataPoints, ActiveTraceHistogram::getVerySlowCount);
+        SampledActiveTrace sampledActiveTrace = new SampledActiveTrace(fast, normal, slow, verySlow);
 
-        List<Integer> normalCounts = filterActiveTraceBoList(dataPoints, ActiveTraceHistogram::getNormalCount);
-        sampledActiveTrace.setNormalCounts(createSampledTitledPoint(schema.getNormalSlot().getSlotName(), timestamp, normalCounts));
-
-        List<Integer> slowCounts = filterActiveTraceBoList(dataPoints, ActiveTraceHistogram::getSlowCount);
-        sampledActiveTrace.setSlowCounts(createSampledTitledPoint(schema.getSlowSlot().getSlotName(), timestamp, slowCounts));
+        return sampledActiveTrace;
+    }
 
-        List<Integer> verySlowCounts = filterActiveTraceBoList(dataPoints, ActiveTraceHistogram::getVerySlowCount);
-        sampledActiveTrace.setVerySlowCounts(createSampledTitledPoint(schema.getVerySlowSlot().getSlotName(), timestamp, verySlowCounts));
+    private SampledActiveTrace newUnSampledActiveTrace(long timestamp) {
+        Point.UncollectedPointCreator<AgentStatPoint<Integer>> uncollected = SampledActiveTrace.UNCOLLECTED_POINT_CREATOR;
+        AgentStatPoint<Integer> fast = uncollected.createUnCollectedPoint(timestamp);
+        AgentStatPoint<Integer> normal = uncollected.createUnCollectedPoint(timestamp);
+        AgentStatPoint<Integer> slow = uncollected.createUnCollectedPoint(timestamp);
+        AgentStatPoint<Integer> verySlow = uncollected.createUnCollectedPoint(timestamp);
+        return new SampledActiveTrace(fast, normal, slow, verySlow);
+    }
 
-        return sampledActiveTrace;
+    private AgentStatPoint<Integer> newAgentStatPoint(HistogramSlot slot, long timestamp, List<ActiveTraceBo> dataPoints, ToIntFunction<ActiveTraceHistogram> counter) {
+        List<Integer> fastCounts = filterActiveTraceBoList(dataPoints, counter);
+        return createSampledTitledPoint(slot.getSlotName(), timestamp, fastCounts);
     }
 
     private List<Integer> filterActiveTraceBoList(List<ActiveTraceBo> dataPoints, ToIntFunction<ActiveTraceHistogram> counter) {
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/CpuLoadSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/CpuLoadSampler.java
index c8db878b9aa1..e7ec3ae2f999 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/CpuLoadSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/CpuLoadSampler.java
@@ -25,6 +25,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.ToDoubleFunction;
 
 /**
  * @author HyunGil Jeong
@@ -37,32 +38,40 @@ public class CpuLoadSampler implements AgentStatSampler<CpuLoadBo, SampledCpuLoa
 
     @Override
     public SampledCpuLoad sampleDataPoints(int timeWindowIndex, long timestamp, List<CpuLoadBo> dataPoints, CpuLoadBo previousDataPoint) {
-        List<Double> jvmCpuLoads = new ArrayList<>(dataPoints.size());
-        List<Double> systemCpuLoads = new ArrayList<>(dataPoints.size());
+        final AgentStatPoint<Double> jvmCpuLoad = newAgentStatPoint(timestamp, dataPoints, CpuLoadBo::getJvmCpuLoad);
+        final AgentStatPoint<Double> systemCpuLoad = newAgentStatPoint(timestamp, dataPoints, CpuLoadBo::getSystemCpuLoad);
+
+        SampledCpuLoad sampledCpuLoad = new SampledCpuLoad(jvmCpuLoad, systemCpuLoad);
+        return sampledCpuLoad;
+    }
+
+    private AgentStatPoint<Double> newAgentStatPoint(long timestamp, List<CpuLoadBo> dataPoints, ToDoubleFunction<CpuLoadBo> filter) {
+        List<Double> jvmCpuLoads = filter(dataPoints, filter);
+        return createPoint(timestamp, jvmCpuLoads);
+    }
+
+    private List<Double> filter(List<CpuLoadBo> dataPoints, ToDoubleFunction<CpuLoadBo> filter) {
+        final List<Double> result = new ArrayList<>(dataPoints.size());
         for (CpuLoadBo cpuLoadBo : dataPoints) {
-            if (cpuLoadBo.getJvmCpuLoad() != CpuLoadBo.UNCOLLECTED_VALUE) {
-                jvmCpuLoads.add(cpuLoadBo.getJvmCpuLoad() * 100);
-            }
-            if (cpuLoadBo.getSystemCpuLoad() != CpuLoadBo.UNCOLLECTED_VALUE) {
-                systemCpuLoads.add(cpuLoadBo.getSystemCpuLoad() * 100);
+            final double apply = filter.applyAsDouble(cpuLoadBo);
+            if (apply != CpuLoadBo.UNCOLLECTED_VALUE) {
+                result.add(apply * 100);
             }
         }
-        SampledCpuLoad sampledCpuLoad = new SampledCpuLoad();
-        sampledCpuLoad.setJvmCpuLoad(createPoint(timestamp, jvmCpuLoads));
-        sampledCpuLoad.setSystemCpuLoad(createPoint(timestamp, systemCpuLoads));
-        return sampledCpuLoad;
+        return result;
     }
 
     private AgentStatPoint<Double> createPoint(long timestamp, List<Double> values) {
         if (values.isEmpty()) {
             return SampledCpuLoad.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp);
-        } else {
-            return new AgentStatPoint<>(
-                    timestamp,
-                    DOUBLE_DOWN_SAMPLER.sampleMin(values),
-                    DOUBLE_DOWN_SAMPLER.sampleMax(values),
-                    DOUBLE_DOWN_SAMPLER.sampleAvg(values),
-                    DOUBLE_DOWN_SAMPLER.sampleSum(values));
         }
+
+        return new AgentStatPoint<>(
+                timestamp,
+                DOUBLE_DOWN_SAMPLER.sampleMin(values),
+                DOUBLE_DOWN_SAMPLER.sampleMax(values),
+                DOUBLE_DOWN_SAMPLER.sampleAvg(values),
+                DOUBLE_DOWN_SAMPLER.sampleSum(values));
+
     }
 }
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/DeadlockSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/DeadlockSampler.java
index 5cf9b937c61d..8a8d873d1c99 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/DeadlockSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/DeadlockSampler.java
@@ -36,29 +36,34 @@ public class DeadlockSampler implements AgentStatSampler<DeadlockBo, SampledDead
 
     @Override
     public SampledDeadlock sampleDataPoints(int index, long timestamp, List<DeadlockBo> deadlockBoList, DeadlockBo previousDataPoint) {
+        List<Integer> deadlockedThreadCountList = filter(deadlockBoList);
+
+        AgentStatPoint<Integer> point = createPoint(timestamp, deadlockedThreadCountList);
+        SampledDeadlock sampledDeadlock = new SampledDeadlock(point);
+
+        return sampledDeadlock;
+    }
+
+    public List<Integer> filter(List<DeadlockBo> deadlockBoList) {
         List<Integer> deadlockedThreadCountList = new ArrayList<>(deadlockBoList.size());
 
         for (DeadlockBo deadlockBo : deadlockBoList) {
             deadlockedThreadCountList.add(deadlockBo.getDeadlockedThreadCount());
         }
-
-        SampledDeadlock sampledDeadlock = new SampledDeadlock();
-        sampledDeadlock.setDeadlockedThreadCount(createPoint(timestamp, deadlockedThreadCountList));
-
-        return sampledDeadlock;
+        return deadlockedThreadCountList;
     }
 
     private AgentStatPoint<Integer> createPoint(long timestamp, List<Integer> values) {
         if (values.isEmpty()) {
             return SampledDeadlock.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp);
-        } else {
-            return new AgentStatPoint<>(
-                    timestamp,
-                    INTEGER_DOWN_SAMPLER.sampleMin(values),
-                    INTEGER_DOWN_SAMPLER.sampleMax(values),
-                    INTEGER_DOWN_SAMPLER.sampleAvg(values),
-                    INTEGER_DOWN_SAMPLER.sampleSum(values));
         }
+
+        return new AgentStatPoint<>(
+                timestamp,
+                INTEGER_DOWN_SAMPLER.sampleMin(values),
+                INTEGER_DOWN_SAMPLER.sampleMax(values),
+                INTEGER_DOWN_SAMPLER.sampleAvg(values),
+                INTEGER_DOWN_SAMPLER.sampleSum(values));
     }
 
 }
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinActiveTraceSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinActiveTraceSampler.java
index 2137b78bf029..384228e87e45 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinActiveTraceSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinActiveTraceSampler.java
@@ -17,6 +17,7 @@
 
 import com.navercorp.pinpoint.common.server.bo.stat.join.JoinActiveTraceBo;
 import com.navercorp.pinpoint.web.vo.stat.AggreJoinActiveTraceBo;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
@@ -29,7 +30,7 @@ public class JoinActiveTraceSampler implements ApplicationStatSampler<JoinActive
 
     @Override
     public AggreJoinActiveTraceBo sampleDataPoints(int index, long timestamp, List<JoinActiveTraceBo> joinActiveTraceBoList, JoinActiveTraceBo previousDataPoint) {
-        if (joinActiveTraceBoList.size() == 0) {
+        if (CollectionUtils.isEmpty(joinActiveTraceBoList)) {
             return AggreJoinActiveTraceBo.createUncollectedObject(timestamp);
         }
 
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinCpuLoadSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinCpuLoadSampler.java
index 44b9a39b0b3c..b602b6b4bf84 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinCpuLoadSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinCpuLoadSampler.java
@@ -17,6 +17,7 @@
 
 import com.navercorp.pinpoint.common.server.bo.stat.join.JoinCpuLoadBo;
 import com.navercorp.pinpoint.web.vo.stat.AggreJoinCpuLoadBo;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.stereotype.Component;
 
 import java.math.BigDecimal;
@@ -31,7 +32,7 @@ public class JoinCpuLoadSampler implements ApplicationStatSampler<JoinCpuLoadBo>
 
     @Override
     public AggreJoinCpuLoadBo sampleDataPoints(int timeWindowIndex, long timestamp, List<JoinCpuLoadBo> joinCpuLoadBoList, JoinCpuLoadBo previousDataPoint) {
-        if (joinCpuLoadBoList.size() == 0) {
+        if (CollectionUtils.isEmpty(joinCpuLoadBoList)) {
             return AggreJoinCpuLoadBo.createUncollectedObject(timestamp);
         }
 
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinDataSourceSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinDataSourceSampler.java
index b997a0151fed..8f08ab2bccf6 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinDataSourceSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinDataSourceSampler.java
@@ -15,12 +15,11 @@
  */
 package com.navercorp.pinpoint.web.mapper.stat.sampling.sampler;
 
-import com.navercorp.pinpoint.common.server.bo.stat.join.JoinCpuLoadBo;
 import com.navercorp.pinpoint.common.server.bo.stat.join.JoinDataSourceBo;
 import com.navercorp.pinpoint.common.server.bo.stat.join.JoinDataSourceListBo;
 import com.navercorp.pinpoint.web.vo.stat.AggreJoinDataSourceBo;
 import com.navercorp.pinpoint.web.vo.stat.AggreJoinDataSourceListBo;
-import com.navercorp.pinpoint.web.vo.stat.AggregationStatData;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
@@ -34,20 +33,26 @@ public class JoinDataSourceSampler implements ApplicationStatSampler<JoinDataSou
 
     @Override
     public AggreJoinDataSourceListBo sampleDataPoints(int index, long timestamp, List<JoinDataSourceListBo> joinDataSourceListBoList, JoinDataSourceListBo previousJoinDataSourceListBo) {
-        if (joinDataSourceListBoList.size() == 0) {
+        if (CollectionUtils.isEmpty(joinDataSourceListBoList)) {
             return AggreJoinDataSourceListBo.createUncollectedObject(timestamp);
         }
 
         JoinDataSourceListBo joinDataSourceListBo = JoinDataSourceListBo.joinDataSourceListBoList(joinDataSourceListBoList, timestamp);
         String id = joinDataSourceListBo.getId();
         List<JoinDataSourceBo> joinDataSourceBoList = joinDataSourceListBo.getJoinDataSourceBoList();
-        List<JoinDataSourceBo> aggreJoinDataSourceBoList = new ArrayList<>(joinDataSourceBoList.size());
-
-        for (JoinDataSourceBo joinDataSourceBo : joinDataSourceBoList) {
-            aggreJoinDataSourceBoList.add(new AggreJoinDataSourceBo(joinDataSourceBo.getServiceTypeCode(), joinDataSourceBo.getUrl(), joinDataSourceBo.getAvgActiveConnectionSize(), joinDataSourceBo.getMinActiveConnectionSize(), joinDataSourceBo.getMinActiveConnectionAgentId(), joinDataSourceBo.getMaxActiveConnectionSize(), joinDataSourceBo.getMaxActiveConnectionAgentId(), timestamp));
-        }
+        List<JoinDataSourceBo> aggreJoinDataSourceBoList = getJoinDataSourceBoList(timestamp, joinDataSourceBoList);
 
         AggreJoinDataSourceListBo aggreJoinDataSourceListBo = new AggreJoinDataSourceListBo(id, aggreJoinDataSourceBoList, timestamp);
         return aggreJoinDataSourceListBo;
     }
+
+    public List<JoinDataSourceBo> getJoinDataSourceBoList(long timestamp, List<JoinDataSourceBo> joinDataSourceBoList) {
+        List<JoinDataSourceBo> aggreJoinDataSourceBoList = new ArrayList<>(joinDataSourceBoList.size());
+        for (JoinDataSourceBo ds : joinDataSourceBoList) {
+            AggreJoinDataSourceBo dataSourceBo = new AggreJoinDataSourceBo(ds.getServiceTypeCode(), ds.getUrl(), ds.getAvgActiveConnectionSize(),
+                    ds.getMinActiveConnectionSize(), ds.getMinActiveConnectionAgentId(), ds.getMaxActiveConnectionSize(), ds.getMaxActiveConnectionAgentId(), timestamp);
+            aggreJoinDataSourceBoList.add(dataSourceBo);
+        }
+        return aggreJoinDataSourceBoList;
+    }
 }
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinMemorySampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinMemorySampler.java
index 2fc544a14784..b12abd00a17f 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinMemorySampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinMemorySampler.java
@@ -17,6 +17,7 @@
 
 import com.navercorp.pinpoint.common.server.bo.stat.join.JoinMemoryBo;
 import com.navercorp.pinpoint.web.vo.stat.AggreJoinMemoryBo;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
@@ -29,7 +30,7 @@ public class JoinMemorySampler implements ApplicationStatSampler<JoinMemoryBo> {
 
     @Override
     public AggreJoinMemoryBo sampleDataPoints(int index, long timestamp, List<JoinMemoryBo> joinMemoryBoList, JoinMemoryBo previousDataPoint) {
-        if (joinMemoryBoList.size() == 0) {
+        if (CollectionUtils.isEmpty(joinMemoryBoList)) {
             return AggreJoinMemoryBo.createUncollectedObject(timestamp);
         }
 
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinResponseTimeSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinResponseTimeSampler.java
index db5088724da5..941ac78d5ee3 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinResponseTimeSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinResponseTimeSampler.java
@@ -17,6 +17,7 @@
 
 import com.navercorp.pinpoint.common.server.bo.stat.join.JoinResponseTimeBo;
 import com.navercorp.pinpoint.web.vo.stat.AggreJoinResponseTimeBo;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
@@ -29,7 +30,7 @@ public class JoinResponseTimeSampler implements ApplicationStatSampler<JoinRespo
 
     @Override
     public AggreJoinResponseTimeBo sampleDataPoints(int index, long timestamp, List<JoinResponseTimeBo> joinResponseTimeBoList, JoinResponseTimeBo previousDataPoint) {
-        if (joinResponseTimeBoList.size() == 0) {
+        if (CollectionUtils.isEmpty(joinResponseTimeBoList)) {
             return AggreJoinResponseTimeBo.createUncollectedObject(timestamp);
         }
 
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinTransactionSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinTransactionSampler.java
index 309a9a0877b3..e9337fc3858d 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinTransactionSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JoinTransactionSampler.java
@@ -17,6 +17,7 @@
 
 import com.navercorp.pinpoint.common.server.bo.stat.join.JoinTransactionBo;
 import com.navercorp.pinpoint.web.vo.stat.AggreJoinTransactionBo;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
@@ -29,7 +30,7 @@ public class JoinTransactionSampler implements ApplicationStatSampler<JoinTransa
 
     @Override
     public AggreJoinTransactionBo sampleDataPoints(int index, long timestamp, List<JoinTransactionBo> joinTransactionBoList, JoinTransactionBo previousDataPoint) {
-        if (joinTransactionBoList.size() == 0) {
+        if (CollectionUtils.isEmpty(joinTransactionBoList)) {
             return AggreJoinTransactionBo.createUncollectedObject(timestamp);
         }
 
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JvmGcDetailedSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JvmGcDetailedSampler.java
index 775060cf2abf..1ccd677bf4d4 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JvmGcDetailedSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/JvmGcDetailedSampler.java
@@ -25,6 +25,8 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToLongFunction;
 
 /**
  * @author HyunGil Jeong
@@ -38,75 +40,79 @@ public class JvmGcDetailedSampler implements AgentStatSampler<JvmGcDetailedBo, S
 
     @Override
     public SampledJvmGcDetailed sampleDataPoints(int timeWindowIndex, long timestamp, List<JvmGcDetailedBo> dataPoints, JvmGcDetailedBo previousDataPoint) {
-        List<Long> gcNewCounts = new ArrayList<>(dataPoints.size());
-        List<Long> gcNewTimes = new ArrayList<>(dataPoints.size());
-        List<Double> codeCacheUseds = new ArrayList<>(dataPoints.size());
-        List<Double> newGenUseds = new ArrayList<>(dataPoints.size());
-        List<Double> oldGenUseds = new ArrayList<>(dataPoints.size());
-        List<Double> survivorSpaceUseds = new ArrayList<>(dataPoints.size());
-        List<Double> permGenUseds = new ArrayList<>(dataPoints.size());
-        List<Double> metaspaceUseds = new ArrayList<>(dataPoints.size());
+        AgentStatPoint<Long> gcNewCounts = newLongPoint(timestamp, dataPoints, JvmGcDetailedBo::getGcNewCount);
+        AgentStatPoint<Long> gcNewTimes = newLongPoint(timestamp, dataPoints, JvmGcDetailedBo::getGcNewTime);
+        AgentStatPoint<Double> codeCacheUseds = newDoublePoint(timestamp, dataPoints, JvmGcDetailedBo::getCodeCacheUsed);
+        AgentStatPoint<Double> newGenUseds = newDoublePoint(timestamp, dataPoints, JvmGcDetailedBo::getNewGenUsed);
+        AgentStatPoint<Double> oldGenUseds = newDoublePoint(timestamp, dataPoints, JvmGcDetailedBo::getOldGenUsed);
+        AgentStatPoint<Double> survivorSpaceUseds = newDoublePoint(timestamp, dataPoints, JvmGcDetailedBo::getSurvivorSpaceUsed);
+        AgentStatPoint<Double> permGenUseds = newDoublePoint(timestamp, dataPoints, JvmGcDetailedBo::getPermGenUsed);
+        AgentStatPoint<Double> metaspaceUseds = newDoublePoint(timestamp, dataPoints, JvmGcDetailedBo::getMetaspaceUsed);
+
+        SampledJvmGcDetailed sampledJvmGcDetailed = new SampledJvmGcDetailed(gcNewCounts, gcNewTimes, codeCacheUseds, newGenUseds,
+                oldGenUseds, survivorSpaceUseds, permGenUseds, metaspaceUseds);
+        return sampledJvmGcDetailed;
+    }
+
+    private AgentStatPoint<Long> newLongPoint(long timestamp, List<JvmGcDetailedBo> dataPoints, ToLongFunction<JvmGcDetailedBo> filter) {
+        List<Long> filteredList = longFilter(dataPoints, filter);
+        return createLongPoint(timestamp, filteredList);
+    }
+
+    private List<Long> longFilter(List<JvmGcDetailedBo> dataPoints, ToLongFunction<JvmGcDetailedBo> filter) {
+        final List<Long> result = new ArrayList<>(dataPoints.size());
         for (JvmGcDetailedBo jvmGcDetailedBo : dataPoints) {
-            if (jvmGcDetailedBo.getGcNewCount() != JvmGcDetailedBo.UNCOLLECTED_VALUE) {
-                gcNewCounts.add(jvmGcDetailedBo.getGcNewCount());
-            }
-            if (jvmGcDetailedBo.getGcNewTime() != JvmGcDetailedBo.UNCOLLECTED_VALUE) {
-                gcNewTimes.add(jvmGcDetailedBo.getGcNewTime());
-            }
-            if (jvmGcDetailedBo.getCodeCacheUsed() != JvmGcDetailedBo.UNCOLLECTED_PERCENTAGE) {
-                codeCacheUseds.add(jvmGcDetailedBo.getCodeCacheUsed() * 100);
-            }
-            if (jvmGcDetailedBo.getNewGenUsed() != JvmGcDetailedBo.UNCOLLECTED_PERCENTAGE) {
-                newGenUseds.add(jvmGcDetailedBo.getNewGenUsed() * 100);
-            }
-            if (jvmGcDetailedBo.getOldGenUsed() != JvmGcDetailedBo.UNCOLLECTED_PERCENTAGE) {
-                oldGenUseds.add(jvmGcDetailedBo.getOldGenUsed() * 100);
-            }
-            if (jvmGcDetailedBo.getSurvivorSpaceUsed() != JvmGcDetailedBo.UNCOLLECTED_PERCENTAGE) {
-                survivorSpaceUseds.add(jvmGcDetailedBo.getSurvivorSpaceUsed() * 100);
-            }
-            if (jvmGcDetailedBo.getPermGenUsed() != JvmGcDetailedBo.UNCOLLECTED_PERCENTAGE) {
-                permGenUseds.add(jvmGcDetailedBo.getPermGenUsed() * 100);
+            final long apply = filter.applyAsLong(jvmGcDetailedBo);
+            if (apply != JvmGcDetailedBo.UNCOLLECTED_VALUE) {
+                result.add(apply);
             }
-            if (jvmGcDetailedBo.getMetaspaceUsed() != JvmGcDetailedBo.UNCOLLECTED_PERCENTAGE) {
-                metaspaceUseds.add(jvmGcDetailedBo.getMetaspaceUsed() * 100);
+        }
+        return result;
+    }
+
+    private AgentStatPoint<Double> newDoublePoint(long timestamp, List<JvmGcDetailedBo> dataPoints, ToDoubleFunction<JvmGcDetailedBo> filter) {
+        List<Double> filteredList = doubleFilter(dataPoints, filter);
+        return createDoublePoint(timestamp, filteredList);
+    }
+
+    private List<Double> doubleFilter(List<JvmGcDetailedBo> dataPoints, ToDoubleFunction<JvmGcDetailedBo> filter) {
+        final List<Double> result = new ArrayList<>(dataPoints.size());
+        for (JvmGcDetailedBo jvmGcDetailedBo : dataPoints) {
+            final double apply = filter.applyAsDouble(jvmGcDetailedBo);
+            if (apply != JvmGcDetailedBo.UNCOLLECTED_PERCENTAGE) {
+                final double percentage = apply * 100;
+                result.add(percentage);
             }
         }
-        SampledJvmGcDetailed sampledJvmGcDetailed = new SampledJvmGcDetailed();
-        sampledJvmGcDetailed.setGcNewCount(createLongPoint(timestamp, gcNewCounts));
-        sampledJvmGcDetailed.setGcNewTime(createLongPoint(timestamp, gcNewTimes));
-        sampledJvmGcDetailed.setCodeCacheUsed(createDoublePoint(timestamp, codeCacheUseds));
-        sampledJvmGcDetailed.setNewGenUsed(createDoublePoint(timestamp, newGenUseds));
-        sampledJvmGcDetailed.setOldGenUsed(createDoublePoint(timestamp, oldGenUseds));
-        sampledJvmGcDetailed.setSurvivorSpaceUsed(createDoublePoint(timestamp, survivorSpaceUseds));
-        sampledJvmGcDetailed.setPermGenUsed(createDoublePoint(timestamp, permGenUseds));
-        sampledJvmGcDetailed.setMetaspaceUsed(createDoublePoint(timestamp, metaspaceUseds));
-        return sampledJvmGcDetailed;
+        return result;
     }
 
+
     private AgentStatPoint<Long> createLongPoint(long timestamp, List<Long> values) {
         if (values.isEmpty()) {
             return SampledJvmGcDetailed.UNCOLLECTED_VALUE_POINT_CREATOR.createUnCollectedPoint(timestamp);
-        } else {
-            return new AgentStatPoint<>(
-                    timestamp,
-                    LONG_DOWN_SAMPLER.sampleMin(values),
-                    LONG_DOWN_SAMPLER.sampleMax(values),
-                    LONG_DOWN_SAMPLER.sampleAvg(values, 0),
-                    LONG_DOWN_SAMPLER.sampleSum(values));
         }
+
+        return new AgentStatPoint<>(
+                timestamp,
+                LONG_DOWN_SAMPLER.sampleMin(values),
+                LONG_DOWN_SAMPLER.sampleMax(values),
+                LONG_DOWN_SAMPLER.sampleAvg(values, 0),
+                LONG_DOWN_SAMPLER.sampleSum(values));
+
     }
 
     private AgentStatPoint<Double> createDoublePoint(long timestamp, List<Double> values) {
         if (values.isEmpty()) {
             return SampledJvmGcDetailed.UNCOLLECTED_PERCENTAGE_POINT_CREATOR.createUnCollectedPoint(timestamp);
-        } else {
-            return new AgentStatPoint<>(
-                    timestamp,
-                    DOUBLE_DOWN_SAMPLER.sampleMin(values),
-                    DOUBLE_DOWN_SAMPLER.sampleMax(values),
-                    DOUBLE_DOWN_SAMPLER.sampleAvg(values),
-                    DOUBLE_DOWN_SAMPLER.sampleSum(values));
         }
+
+        return new AgentStatPoint<>(
+                timestamp,
+                DOUBLE_DOWN_SAMPLER.sampleMin(values),
+                DOUBLE_DOWN_SAMPLER.sampleMax(values),
+                DOUBLE_DOWN_SAMPLER.sampleAvg(values),
+                DOUBLE_DOWN_SAMPLER.sampleSum(values));
+
     }
 }
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/ResponseTimeSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/ResponseTimeSampler.java
index be83b27e64fa..bdf478fb5bdd 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/ResponseTimeSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/ResponseTimeSampler.java
@@ -36,27 +36,33 @@ public class ResponseTimeSampler implements AgentStatSampler<ResponseTimeBo, Sam
 
     @Override
     public SampledResponseTime sampleDataPoints(int timeWindowIndex, long timestamp, List<ResponseTimeBo> dataPoints, ResponseTimeBo previousDataPoint) {
+        List<Long> avgs = getAvg(dataPoints);
+        AgentStatPoint<Long> avg = createPoint(timestamp, avgs);
+
+        SampledResponseTime sampledResponseTime = new SampledResponseTime(avg);
+        return sampledResponseTime;
+    }
+
+    private List<Long> getAvg(List<ResponseTimeBo> dataPoints) {
         List<Long> avgs = new ArrayList<>(dataPoints.size());
         for (ResponseTimeBo responseTimeBo : dataPoints) {
             avgs.add(responseTimeBo.getAvg());
         }
-
-        SampledResponseTime sampledResponseTime = new SampledResponseTime();
-        sampledResponseTime.setAvg(createPoint(timestamp, avgs));
-        return sampledResponseTime;
+        return avgs;
     }
 
     private AgentStatPoint<Long> createPoint(long timestamp, List<Long> values) {
         if (values.isEmpty()) {
             return SampledResponseTime.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp);
-        } else {
-            return new AgentStatPoint<>(
-                    timestamp,
-                    LONG_DOWN_SAMPLER.sampleMin(values),
-                    LONG_DOWN_SAMPLER.sampleMax(values),
-                    LONG_DOWN_SAMPLER.sampleAvg(values),
-                    LONG_DOWN_SAMPLER.sampleSum(values));
         }
+
+        return new AgentStatPoint<>(
+                timestamp,
+                LONG_DOWN_SAMPLER.sampleMin(values),
+                LONG_DOWN_SAMPLER.sampleMax(values),
+                LONG_DOWN_SAMPLER.sampleAvg(values),
+                LONG_DOWN_SAMPLER.sampleSum(values));
+
     }
 
 }
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/TransactionSampler.java b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/TransactionSampler.java
index 7259caacc2cf..dff555d27227 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/TransactionSampler.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/mapper/stat/sampling/sampler/TransactionSampler.java
@@ -27,6 +27,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.ToLongFunction;
 
 /**
  * @author HyunGil Jeong
@@ -39,52 +40,80 @@ public class TransactionSampler implements AgentStatSampler<TransactionBo, Sampl
 
     @Override
     public SampledTransaction sampleDataPoints(int timeWindowIndex, long timestamp, List<TransactionBo> dataPoints, TransactionBo previousDataPoint) {
-        List<Double> sampledNews = new ArrayList<>(dataPoints.size());
-        List<Double> sampledContinuations = new ArrayList<>(dataPoints.size());
-        List<Double> unsampledNews = new ArrayList<>(dataPoints.size());
-        List<Double> unsampledContinuations = new ArrayList<>(dataPoints.size());
-        List<Double> totals = new ArrayList<>(dataPoints.size());
+
+        final AgentStatPoint<Double> sampledNew = newAgentStatPoint(timestamp, dataPoints, TransactionBo::getSampledNewCount);
+        final AgentStatPoint<Double> sampledContinuation = newAgentStatPoint(timestamp, dataPoints, TransactionBo::getSampledContinuationCount);
+        final AgentStatPoint<Double> unsampledNew = newAgentStatPoint(timestamp, dataPoints, TransactionBo::getUnsampledNewCount);
+        final AgentStatPoint<Double> unsampledContinuation = newAgentStatPoint(timestamp, dataPoints, TransactionBo::getUnsampledContinuationCount);
+
+        final List<Double> totals = calculateTotalTps(dataPoints);
+        AgentStatPoint<Double> total = createPoint(timestamp, totals);
+
+        SampledTransaction sampledTransaction = new SampledTransaction(sampledNew, sampledContinuation, unsampledNew, unsampledContinuation, total);
+        return sampledTransaction;
+    }
+
+    private AgentStatPoint<Double> newAgentStatPoint(long timestamp, List<TransactionBo> dataPoints, ToLongFunction<TransactionBo> function) {
+        final List<Double> sampledNews = calculateTps(dataPoints, function);
+        return createPoint(timestamp, sampledNews);
+    }
+
+    private List<Double> calculateTotalTps(List<TransactionBo> dataPoints) {
+        final List<Double> result = new ArrayList<>(dataPoints.size());
         for (TransactionBo transactionBo : dataPoints) {
-            long collectInterval = transactionBo.getCollectInterval();
+            final Double total = getTotalTps(transactionBo);
+            if (total != null) {
+                result.add(total);
+            }
+        }
+        return result;
+    }
+
+    private Double getTotalTps(TransactionBo transactionBo) {
+        final long collectInterval = transactionBo.getCollectInterval();
+        if (collectInterval > 0) {
+            boolean isTransactionCollected = false;
+            long totalCount = 0;
+            final long sampledNewCount = transactionBo.getSampledNewCount();
+            if (sampledNewCount != TransactionBo.UNCOLLECTED_VALUE) {
+                isTransactionCollected = true;
+                totalCount += sampledNewCount;
+            }
+            final long sampledContinuationCount = transactionBo.getSampledContinuationCount();
+            if (sampledContinuationCount != TransactionBo.UNCOLLECTED_VALUE) {
+                isTransactionCollected = true;
+                totalCount += sampledContinuationCount;
+            }
+            final long unsampledNewCount = transactionBo.getUnsampledNewCount();
+            if (unsampledNewCount != TransactionBo.UNCOLLECTED_VALUE) {
+                isTransactionCollected = true;
+                totalCount += unsampledNewCount;
+            }
+            final long unsampledContinuationCount = transactionBo.getUnsampledContinuationCount();
+            if (unsampledContinuationCount != TransactionBo.UNCOLLECTED_VALUE) {
+                isTransactionCollected = true;
+                totalCount += unsampledContinuationCount;
+            }
+            if (isTransactionCollected) {
+                return calculateTps(totalCount, collectInterval);
+            }
+        }
+        return null;
+    }
+
+    private List<Double> calculateTps(List<TransactionBo> dataPoints, ToLongFunction<TransactionBo> function) {
+        final List<Double> result = new ArrayList<>(dataPoints.size());
+        for (TransactionBo transactionBo : dataPoints) {
+            final long collectInterval = transactionBo.getCollectInterval();
             if (collectInterval > 0) {
-                boolean isTransactionCollected = false;
-                long totalCount = 0;
-                if (transactionBo.getSampledNewCount() != TransactionBo.UNCOLLECTED_VALUE) {
-                    isTransactionCollected = true;
-                    long sampledNewCount = transactionBo.getSampledNewCount();
-                    sampledNews.add(calculateTps(sampledNewCount, collectInterval));
-                    totalCount += sampledNewCount;
-                }
-                if (transactionBo.getSampledContinuationCount() != TransactionBo.UNCOLLECTED_VALUE) {
-                    isTransactionCollected = true;
-                    long sampledContinuationCount = transactionBo.getSampledContinuationCount();
-                    sampledContinuations.add(calculateTps(sampledContinuationCount, collectInterval));
-                    totalCount += sampledContinuationCount;
-                }
-                if (transactionBo.getUnsampledNewCount() != TransactionBo.UNCOLLECTED_VALUE) {
-                    isTransactionCollected = true;
-                    long unsampledNewCount = transactionBo.getUnsampledNewCount();
-                    unsampledNews.add(calculateTps(unsampledNewCount, collectInterval));
-                    totalCount += unsampledNewCount;
-                }
-                if (transactionBo.getUnsampledContinuationCount() != TransactionBo.UNCOLLECTED_VALUE) {
-                    isTransactionCollected = true;
-                    long unsampledContinuationCount = transactionBo.getUnsampledContinuationCount();
-                    unsampledContinuations.add(calculateTps(unsampledContinuationCount, collectInterval));
-                    totalCount += unsampledContinuationCount;
-                }
-                if (isTransactionCollected) {
-                    totals.add(calculateTps(totalCount, collectInterval));
+                final long count = function.applyAsLong(transactionBo);
+                if (count != TransactionBo.UNCOLLECTED_VALUE) {
+                    final double tps = calculateTps(count, collectInterval);
+                    result.add(tps);
                 }
             }
         }
-        SampledTransaction sampledTransaction = new SampledTransaction();
-        sampledTransaction.setSampledNew(createPoint(timestamp, sampledNews));
-        sampledTransaction.setSampledContinuation(createPoint(timestamp, sampledContinuations));
-        sampledTransaction.setUnsampledNew(createPoint(timestamp, unsampledNews));
-        sampledTransaction.setUnsampledContinuation(createPoint(timestamp, unsampledContinuations));
-        sampledTransaction.setTotal(createPoint(timestamp, totals));
-        return sampledTransaction;
+        return result;
     }
 
     private double calculateTps(long count, long intervalMs) {
@@ -94,13 +123,13 @@ private double calculateTps(long count, long intervalMs) {
     private AgentStatPoint<Double> createPoint(long timestamp, List<Double> values) {
         if (values.isEmpty()) {
             return SampledCpuLoad.UNCOLLECTED_POINT_CREATOR.createUnCollectedPoint(timestamp);
-        } else {
-            return new AgentStatPoint<>(
+        }
+
+        return new AgentStatPoint<>(
                     timestamp,
                     DOUBLE_DOWN_SAMPLER.sampleMin(values),
                     DOUBLE_DOWN_SAMPLER.sampleMax(values),
                     DOUBLE_DOWN_SAMPLER.sampleAvg(values),
                     DOUBLE_DOWN_SAMPLER.sampleSum(values));
-        }
     }
 }
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledActiveTrace.java b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledActiveTrace.java
index ddb6b060c409..9ed57a4ae33f 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledActiveTrace.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledActiveTrace.java
@@ -19,6 +19,8 @@
 import com.navercorp.pinpoint.web.vo.chart.Point;
 import com.navercorp.pinpoint.web.vo.stat.chart.agent.AgentStatPoint;
 
+import java.util.Objects;
+
 /**
  * @author HyunGil Jeong
  */
@@ -32,43 +34,35 @@ public AgentStatPoint<Integer> createUnCollectedPoint(long xVal) {
         }
     };
 
-    private AgentStatPoint<Integer> fastCounts;
-    private AgentStatPoint<Integer> normalCounts;
-    private AgentStatPoint<Integer> slowCounts;
-    private AgentStatPoint<Integer> verySlowCounts;
+    private final AgentStatPoint<Integer> fastCounts;
+    private final AgentStatPoint<Integer> normalCounts;
+    private final AgentStatPoint<Integer> slowCounts;
+    private final AgentStatPoint<Integer> verySlowCounts;
 
-    public AgentStatPoint<Integer> getFastCounts() {
-        return fastCounts;
+    public SampledActiveTrace(AgentStatPoint<Integer> fastCounts, AgentStatPoint<Integer> normalCounts, AgentStatPoint<Integer> slowCounts, AgentStatPoint<Integer> verySlowCounts) {
+        this.fastCounts = Objects.requireNonNull(fastCounts, "fastCounts must not be null");
+        this.normalCounts = Objects.requireNonNull(normalCounts, "normalCounts must not be null");
+        this.slowCounts = Objects.requireNonNull(slowCounts, "slowCounts must not be null");
+        this.verySlowCounts = Objects.requireNonNull(verySlowCounts, "verySlowCounts must not be null");
     }
 
-    public void setFastCounts(AgentStatPoint<Integer> fastCounts) {
-        this.fastCounts = fastCounts;
+    public AgentStatPoint<Integer> getFastCounts() {
+        return fastCounts;
     }
 
     public AgentStatPoint<Integer> getNormalCounts() {
         return normalCounts;
     }
 
-    public void setNormalCounts(AgentStatPoint<Integer> normalCounts) {
-        this.normalCounts = normalCounts;
-    }
-
     public AgentStatPoint<Integer> getSlowCounts() {
         return slowCounts;
     }
 
-    public void setSlowCounts(AgentStatPoint<Integer> slowCounts) {
-        this.slowCounts = slowCounts;
-    }
 
     public AgentStatPoint<Integer> getVerySlowCounts() {
         return verySlowCounts;
     }
 
-    public void setVerySlowCounts(AgentStatPoint<Integer> verySlowCounts) {
-        this.verySlowCounts = verySlowCounts;
-    }
-
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledCpuLoad.java b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledCpuLoad.java
index 8e0c5d8deead..b76f107242e5 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledCpuLoad.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledCpuLoad.java
@@ -19,6 +19,8 @@
 import com.navercorp.pinpoint.web.vo.chart.Point;
 import com.navercorp.pinpoint.web.vo.stat.chart.agent.AgentStatPoint;
 
+import java.util.Objects;
+
 /**
  * @author HyunGil Jeong
  */
@@ -32,43 +34,23 @@ public AgentStatPoint<Double> createUnCollectedPoint(long xVal) {
         }
     };
 
-    private AgentStatPoint<Double> jvmCpuLoad;
-    private AgentStatPoint<Double> systemCpuLoad;
+    private final AgentStatPoint<Double> jvmCpuLoad;
+    private final AgentStatPoint<Double> systemCpuLoad;
+
+    public SampledCpuLoad(AgentStatPoint<Double> jvmCpuLoad, AgentStatPoint<Double> systemCpuLoad) {
+        this.jvmCpuLoad = Objects.requireNonNull(jvmCpuLoad, "jvmCpuLoad must not be null");
+        this.systemCpuLoad = Objects.requireNonNull(systemCpuLoad, "systemCpuLoad must not be null");
+    }
 
     public AgentStatPoint<Double> getJvmCpuLoad() {
         return jvmCpuLoad;
     }
 
-    public void setJvmCpuLoad(AgentStatPoint<Double> jvmCpuLoad) {
-        this.jvmCpuLoad = jvmCpuLoad;
-    }
 
     public AgentStatPoint<Double> getSystemCpuLoad() {
         return systemCpuLoad;
     }
 
-    public void setSystemCpuLoad(AgentStatPoint<Double> systemCpuLoad) {
-        this.systemCpuLoad = systemCpuLoad;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        SampledCpuLoad that = (SampledCpuLoad) o;
-
-        if (jvmCpuLoad != null ? !jvmCpuLoad.equals(that.jvmCpuLoad) : that.jvmCpuLoad != null) return false;
-        return systemCpuLoad != null ? systemCpuLoad.equals(that.systemCpuLoad) : that.systemCpuLoad == null;
-    }
-
-    @Override
-    public int hashCode() {
-        int result = jvmCpuLoad != null ? jvmCpuLoad.hashCode() : 0;
-        result = 31 * result + (systemCpuLoad != null ? systemCpuLoad.hashCode() : 0);
-        return result;
-    }
-
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder("SampledCpuLoad{");
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledDeadlock.java b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledDeadlock.java
index a0fd974d845f..b3eadfe80ac0 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledDeadlock.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledDeadlock.java
@@ -19,6 +19,8 @@
 import com.navercorp.pinpoint.web.vo.chart.Point;
 import com.navercorp.pinpoint.web.vo.stat.chart.agent.AgentStatPoint;
 
+import java.util.Objects;
+
 /**
  * @author Taejin Koo
  */
@@ -32,15 +34,16 @@ public AgentStatPoint<Integer> createUnCollectedPoint(long xVal) {
         }
     };
 
-    private AgentStatPoint<Integer> deadlockedThreadCount;
+    private final AgentStatPoint<Integer> deadlockedThreadCount;
+
+    public SampledDeadlock(AgentStatPoint<Integer> deadlockedThreadCount) {
+        this.deadlockedThreadCount = Objects.requireNonNull(deadlockedThreadCount, "deadlockedThreadCount must not be null");
+    }
 
     public AgentStatPoint<Integer> getDeadlockedThreadCount() {
         return deadlockedThreadCount;
     }
 
-    public void setDeadlockedThreadCount(AgentStatPoint<Integer> deadlockedThreadCount) {
-        this.deadlockedThreadCount = deadlockedThreadCount;
-    }
 
     @Override
     public boolean equals(Object o) {
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledJvmGcDetailed.java b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledJvmGcDetailed.java
index c7209d32b113..652f83f982fe 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledJvmGcDetailed.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledJvmGcDetailed.java
@@ -19,6 +19,8 @@
 import com.navercorp.pinpoint.web.vo.chart.Point;
 import com.navercorp.pinpoint.web.vo.stat.chart.agent.AgentStatPoint;
 
+import java.util.Objects;
+
 /**
  * @author HyunGil Jeong
  */
@@ -39,79 +41,59 @@ public AgentStatPoint<Double> createUnCollectedPoint(long xVal) {
         }
     };
 
-    private AgentStatPoint<Long> gcNewCount;
-    private AgentStatPoint<Long> gcNewTime;
-    private AgentStatPoint<Double> codeCacheUsed;
-    private AgentStatPoint<Double> newGenUsed;
-    private AgentStatPoint<Double> oldGenUsed;
-    private AgentStatPoint<Double> survivorSpaceUsed;
-    private AgentStatPoint<Double> permGenUsed;
-    private AgentStatPoint<Double> metaspaceUsed;
+    private final AgentStatPoint<Long> gcNewCount;
+    private final AgentStatPoint<Long> gcNewTime;
+    private final AgentStatPoint<Double> codeCacheUsed;
+    private final AgentStatPoint<Double> newGenUsed;
+    private final AgentStatPoint<Double> oldGenUsed;
+    private final AgentStatPoint<Double> survivorSpaceUsed;
+    private final AgentStatPoint<Double> permGenUsed;
+    private final AgentStatPoint<Double> metaspaceUsed;
+
+    public SampledJvmGcDetailed(AgentStatPoint<Long> gcNewCount, AgentStatPoint<Long> gcNewTime, AgentStatPoint<Double> codeCacheUsed, AgentStatPoint<Double> newGenUsed,
+                                AgentStatPoint<Double> oldGenUsed, AgentStatPoint<Double> survivorSpaceUsed, AgentStatPoint<Double> permGenUsed, AgentStatPoint<Double> metaspaceUsed) {
+        this.gcNewCount = Objects.requireNonNull(gcNewCount, "gcNewCount must not be null");
+        this.gcNewTime = Objects.requireNonNull(gcNewTime, "gcNewTime must not be null");
+        this.codeCacheUsed = Objects.requireNonNull(codeCacheUsed, "codeCacheUsed must not be null");
+        this.newGenUsed = Objects.requireNonNull(newGenUsed, "newGenUsed must not be null");
+        this.oldGenUsed = Objects.requireNonNull(oldGenUsed, "oldGenUsed must not be null");
+        this.survivorSpaceUsed = Objects.requireNonNull(survivorSpaceUsed, "survivorSpaceUsed must not be null");
+        this.permGenUsed = Objects.requireNonNull(permGenUsed, "permGenUsed must not be null");
+        this.metaspaceUsed = Objects.requireNonNull(metaspaceUsed, "metaspaceUsed must not be null");
+    }
 
     public AgentStatPoint<Long> getGcNewCount() {
         return gcNewCount;
     }
 
-    public void setGcNewCount(AgentStatPoint<Long> gcNewCount) {
-        this.gcNewCount = gcNewCount;
-    }
-
     public AgentStatPoint<Long> getGcNewTime() {
         return gcNewTime;
     }
 
-    public void setGcNewTime(AgentStatPoint<Long> gcNewTime) {
-        this.gcNewTime = gcNewTime;
-    }
-
     public AgentStatPoint<Double> getCodeCacheUsed() {
         return codeCacheUsed;
     }
 
-    public void setCodeCacheUsed(AgentStatPoint<Double> codeCacheUsed) {
-        this.codeCacheUsed = codeCacheUsed;
-    }
-
     public AgentStatPoint<Double> getNewGenUsed() {
         return newGenUsed;
     }
 
-    public void setNewGenUsed(AgentStatPoint<Double> newGenUsed) {
-        this.newGenUsed = newGenUsed;
-    }
-
     public AgentStatPoint<Double> getOldGenUsed() {
         return oldGenUsed;
     }
 
-    public void setOldGenUsed(AgentStatPoint<Double> oldGenUsed) {
-        this.oldGenUsed = oldGenUsed;
-    }
-
     public AgentStatPoint<Double> getSurvivorSpaceUsed() {
         return survivorSpaceUsed;
     }
 
-    public void setSurvivorSpaceUsed(AgentStatPoint<Double> survivorSpaceUsed) {
-        this.survivorSpaceUsed = survivorSpaceUsed;
-    }
-
     public AgentStatPoint<Double> getPermGenUsed() {
         return permGenUsed;
     }
 
-    public void setPermGenUsed(AgentStatPoint<Double> permGenUsed) {
-        this.permGenUsed = permGenUsed;
-    }
-
     public AgentStatPoint<Double> getMetaspaceUsed() {
         return metaspaceUsed;
     }
 
-    public void setMetaspaceUsed(AgentStatPoint<Double> metaspaceUsed) {
-        this.metaspaceUsed = metaspaceUsed;
-    }
-
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledResponseTime.java b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledResponseTime.java
index 3233071d3abf..7a8ad9593348 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledResponseTime.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledResponseTime.java
@@ -19,6 +19,8 @@
 import com.navercorp.pinpoint.web.vo.chart.Point;
 import com.navercorp.pinpoint.web.vo.stat.chart.agent.AgentStatPoint;
 
+import java.util.Objects;
+
 /**
  * @author Taejin Koo
  */
@@ -32,15 +34,16 @@ public AgentStatPoint<Long> createUnCollectedPoint(long xVal) {
         }
     };
 
-    private AgentStatPoint<Long> avg;
+    private final AgentStatPoint<Long> avg;
+
+    public SampledResponseTime(AgentStatPoint<Long> avg) {
+        this.avg = Objects.requireNonNull(avg, "avg must not be null");
+    }
 
     public AgentStatPoint<Long> getAvg() {
         return avg;
     }
 
-    public void setAvg(AgentStatPoint<Long> avg) {
-        this.avg = avg;
-    }
 
     @Override
     public boolean equals(Object o) {
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledTransaction.java b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledTransaction.java
index e41009979f92..c7bb35c984f0 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledTransaction.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/SampledTransaction.java
@@ -19,6 +19,8 @@
 import com.navercorp.pinpoint.web.vo.chart.Point;
 import com.navercorp.pinpoint.web.vo.stat.chart.agent.AgentStatPoint;
 
+import java.util.Objects;
+
 /**
  * @author HyunGil Jeong
  */
@@ -32,51 +34,45 @@ public AgentStatPoint<Double> createUnCollectedPoint(long xVal) {
         }
     };
 
-    private AgentStatPoint<Double> sampledNew;
-    private AgentStatPoint<Double> sampledContinuation;
-    private AgentStatPoint<Double> unsampledNew;
-    private AgentStatPoint<Double> unsampledContinuation;
-    private AgentStatPoint<Double> total;
+    private final AgentStatPoint<Double> sampledNew;
+    private final AgentStatPoint<Double> sampledContinuation;
+    private final AgentStatPoint<Double> unsampledNew;
+    private final AgentStatPoint<Double> unsampledContinuation;
+    private final AgentStatPoint<Double> total;
+
+    public SampledTransaction(AgentStatPoint<Double> sampledNew, AgentStatPoint<Double> sampledContinuation, AgentStatPoint<Double> unsampledNew, AgentStatPoint<Double> unsampledContinuation, AgentStatPoint<Double> total) {
+        this.sampledNew = Objects.requireNonNull(sampledNew, "sampledNew must not be null");
+        this.sampledContinuation = Objects.requireNonNull(sampledContinuation, "sampledContinuation must not be null");
+        this.unsampledNew = Objects.requireNonNull(unsampledNew, "unsampledNew must not be null");
+        this.unsampledContinuation = Objects.requireNonNull(unsampledContinuation, "unsampledContinuation must not be null");
+        this.total = Objects.requireNonNull(total, "total must not be null");
+    }
 
     public AgentStatPoint<Double> getSampledNew() {
         return sampledNew;
     }
 
-    public void setSampledNew(AgentStatPoint<Double> sampledNew) {
-        this.sampledNew = sampledNew;
-    }
+
 
     public AgentStatPoint<Double> getSampledContinuation() {
         return sampledContinuation;
     }
 
-    public void setSampledContinuation(AgentStatPoint<Double> sampledContinuation) {
-        this.sampledContinuation = sampledContinuation;
-    }
 
     public AgentStatPoint<Double> getUnsampledNew() {
         return unsampledNew;
     }
 
-    public void setUnsampledNew(AgentStatPoint<Double> unsampledNew) {
-        this.unsampledNew = unsampledNew;
-    }
 
     public AgentStatPoint<Double> getUnsampledContinuation() {
         return unsampledContinuation;
     }
 
-    public void setUnsampledContinuation(AgentStatPoint<Double> unsampledContinuation) {
-        this.unsampledContinuation = unsampledContinuation;
-    }
 
     public AgentStatPoint<Double> getTotal() {
         return total;
     }
 
-    public void setTotal(AgentStatPoint<Double> total) {
-        this.total = total;
-    }
 
     @Override
     public boolean equals(Object o) {
diff --git a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/chart/agent/DataSourceChart.java b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/chart/agent/DataSourceChart.java
index 9f64577fabd2..502726762c27 100644
--- a/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/chart/agent/DataSourceChart.java
+++ b/web/src/main/java/com/navercorp/pinpoint/web/vo/stat/chart/agent/DataSourceChart.java
@@ -17,6 +17,7 @@
 package com.navercorp.pinpoint.web.vo.stat.chart.agent;
 
 import com.google.common.collect.ImmutableMap;
+import com.navercorp.pinpoint.common.annotations.VisibleForTesting;
 import com.navercorp.pinpoint.common.service.ServiceTypeRegistryService;
 import com.navercorp.pinpoint.rpc.util.ListUtils;
 import com.navercorp.pinpoint.web.util.TimeWindow;
@@ -28,7 +29,6 @@
 import com.navercorp.pinpoint.web.vo.stat.chart.StatChartGroup;
 import org.apache.commons.collections.CollectionUtils;
 
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -43,8 +43,31 @@ public class DataSourceChart implements StatChart {
     private final DataSourceChartGroup dataSourceChartGroup;
 
     public DataSourceChart(TimeWindow timeWindow, List<SampledDataSource> sampledDataSources, ServiceTypeRegistryService serviceTypeRegistryService) {
-        this.dataSourceChartGroup = new DataSourceChartGroup(timeWindow, sampledDataSources, serviceTypeRegistryService);
+        this.dataSourceChartGroup = newDataSourceChartGroup(timeWindow, sampledDataSources, serviceTypeRegistryService);
     }
+
+    @VisibleForTesting
+    static DataSourceChartGroup newDataSourceChartGroup(TimeWindow timeWindow, List<SampledDataSource> sampledDataSources, ServiceTypeRegistryService serviceTypeRegistryService) {
+        Objects.requireNonNull(timeWindow, "timeWindow must not be null");
+
+        if (CollectionUtils.isEmpty(sampledDataSources)) {
+            final Integer uncollectedValue = SampledDataSource.UNCOLLECTED_VALUE;
+            // TODO avoid null
+            final String uncollectedString = SampledDataSource.UNCOLLECTED_STRING;
+            return new DataSourceChartGroup(timeWindow, Collections.emptyMap(), uncollectedValue, uncollectedString,
+                    uncollectedString, uncollectedString);
+        }
+        Map<StatChartGroup.ChartType, Chart<? extends Point>> chartTypeChartMap = newDatasourceChart(timeWindow, sampledDataSources);
+        SampledDataSource latestSampledDataSource = ListUtils.getLast(sampledDataSources);
+
+        int id = latestSampledDataSource.getId();
+        String serviceTypeName = serviceTypeRegistryService.findServiceType(latestSampledDataSource.getServiceTypeCode()).getName();
+        String databaseName = latestSampledDataSource.getDatabaseName();
+        String jdbcUrl = latestSampledDataSource.getJdbcUrl();
+        return new DataSourceChartGroup(timeWindow, chartTypeChartMap, id, serviceTypeName, databaseName, jdbcUrl);
+
+    }
+
     @Override
     public StatChartGroup getCharts() {
         return dataSourceChartGroup;
@@ -66,6 +89,20 @@ public String getJdbcUrl() {
         return dataSourceChartGroup.getJdbcUrl();
     }
 
+    @VisibleForTesting
+    static Map<StatChartGroup.ChartType, Chart<? extends Point>> newDatasourceChart(TimeWindow timeWindow, List<SampledDataSource> sampledDataSourceList) {
+        Chart<AgentStatPoint<Integer>> activeConnectionChart = newChart(timeWindow, sampledDataSourceList, SampledDataSource::getActiveConnectionSize);
+        Chart<AgentStatPoint<Integer>> maxConnectionChart = newChart(timeWindow, sampledDataSourceList, SampledDataSource::getMaxConnectionSize);
+
+        return ImmutableMap.of(DataSourceChartGroup.DataSourceChartType.ACTIVE_CONNECTION_SIZE, activeConnectionChart, DataSourceChartGroup.DataSourceChartType.MAX_CONNECTION_SIZE, maxConnectionChart);
+    }
+
+    @VisibleForTesting
+    static Chart<AgentStatPoint<Integer>> newChart(TimeWindow timeWindow, List<SampledDataSource> sampledDataSourceList, Function<SampledDataSource, AgentStatPoint<Integer>> filter) {
+        TimeSeriesChartBuilder<AgentStatPoint<Integer>> builder = new TimeSeriesChartBuilder<>(timeWindow, SampledDataSource.UNCOLLECTED_POINT_CREATOR);
+        return builder.build(sampledDataSourceList, filter);
+    }
+
     public static class DataSourceChartGroup implements StatChartGroup {
 
         private final TimeWindow timeWindow;
@@ -82,38 +119,16 @@ public enum DataSourceChartType implements AgentChartType {
             MAX_CONNECTION_SIZE
         }
 
-        public DataSourceChartGroup(TimeWindow timeWindow, List<SampledDataSource> sampledDataSourceList, ServiceTypeRegistryService serviceTypeRegistryService) {
+        public DataSourceChartGroup(TimeWindow timeWindow, Map<ChartType, Chart<? extends Point>> dataSourceCharts, int id, String serviceTypeName, String databaseName, String jdbcUrl) {
             this.timeWindow = Objects.requireNonNull(timeWindow, "timeWindow must not be null");
-
-
-            this.dataSourceCharts = newDatasourceChart(sampledDataSourceList);
-
-            if (CollectionUtils.isEmpty(sampledDataSourceList)) {
-                this.id = SampledDataSource.UNCOLLECTED_VALUE;
-                this.serviceTypeName = SampledDataSource.UNCOLLECTED_STRING;
-                this.databaseName = SampledDataSource.UNCOLLECTED_STRING;
-                this.jdbcUrl = SampledDataSource.UNCOLLECTED_STRING;
-            } else {
-                SampledDataSource latestSampledDataSource = ListUtils.getLast(sampledDataSourceList);
-
-                this.id = latestSampledDataSource.getId();
-                this.serviceTypeName = serviceTypeRegistryService.findServiceType(latestSampledDataSource.getServiceTypeCode()).getName();
-                this.databaseName = latestSampledDataSource.getDatabaseName();
-                this.jdbcUrl = latestSampledDataSource.getJdbcUrl();
-            }
+            this.dataSourceCharts = dataSourceCharts;
+            this.id = id;
+            this.serviceTypeName = serviceTypeName;
+            this.databaseName = databaseName;
+            this.jdbcUrl = jdbcUrl;
         }
 
-        private Map<ChartType, Chart<? extends Point>> newDatasourceChart(List<SampledDataSource> sampledDataSourceList) {
-            Chart<AgentStatPoint<Integer>> activeConnectionChart = newChart(sampledDataSourceList, SampledDataSource::getActiveConnectionSize);
-            Chart<AgentStatPoint<Integer>> maxConnectionChart = newChart(sampledDataSourceList, SampledDataSource::getMaxConnectionSize);
-
-            return ImmutableMap.of(DataSourceChartType.ACTIVE_CONNECTION_SIZE, activeConnectionChart, DataSourceChartType.MAX_CONNECTION_SIZE, maxConnectionChart);
-        }
 
-        private Chart<AgentStatPoint<Integer>> newChart(List<SampledDataSource> sampledDataSourceList, Function<SampledDataSource, AgentStatPoint<Integer>> filter) {
-            TimeSeriesChartBuilder<AgentStatPoint<Integer>> builder = new TimeSeriesChartBuilder<>(timeWindow, SampledDataSource.UNCOLLECTED_POINT_CREATOR);
-            return builder.build(sampledDataSourceList, filter);
-        }
 
         @Override
         public TimeWindow getTimeWindow() {
diff --git a/web/src/test/java/com/navercorp/pinpoint/web/vo/stat/chart/agent/DataSourceChartGroupTest.java b/web/src/test/java/com/navercorp/pinpoint/web/vo/stat/chart/agent/DataSourceChartGroupTest.java
index 46464de0e157..c1cf12f6c353 100644
--- a/web/src/test/java/com/navercorp/pinpoint/web/vo/stat/chart/agent/DataSourceChartGroupTest.java
+++ b/web/src/test/java/com/navercorp/pinpoint/web/vo/stat/chart/agent/DataSourceChartGroupTest.java
@@ -67,7 +67,7 @@ public void basicFunctionTest1() throws Exception {
         TimeWindow timeWindow = new TimeWindow(new Range(currentTimeMillis - 300000, currentTimeMillis));
 
         List<SampledDataSource> sampledDataSourceList = createSampledDataSourceList(timeWindow);
-        StatChartGroup dataSourceChartGroup = new DataSourceChart.DataSourceChartGroup(timeWindow, sampledDataSourceList, serviceTypeRegistryService);
+        StatChartGroup dataSourceChartGroup = DataSourceChart.newDataSourceChartGroup(timeWindow, sampledDataSourceList, serviceTypeRegistryService);
 
         assertEquals(sampledDataSourceList, dataSourceChartGroup);
     }