Merge pull request #15 from FeatureProbe/metric_dev

jianggang · web-flow · commit 626511a92902 · 2022-07-05T15:46:44.000+08:00
feat: Add delete flag to variation
diff --git a/src/main/java/com/featureprobe/api/model/VariationAccessCounter.java b/src/main/java/com/featureprobe/api/model/VariationAccessCounter.java
@@ -24,11 +24,14 @@ public class VariationAccessCounter {
     @NotNull
     private Integer index;
 
+    private Boolean deleted;
 
     public VariationAccessCounter(String value, Long count) {
         this.value = value;
         this.count = count;
+        this.deleted = false;
     }
 
 
+
 }
diff --git a/src/main/java/com/featureprobe/api/repository/EnvironmentRepository.java b/src/main/java/com/featureprobe/api/repository/EnvironmentRepository.java
@@ -11,8 +11,6 @@
 @Repository
 public interface EnvironmentRepository extends JpaRepository<Environment, Long> {
 
-    Optional<Environment> findByKey(String key);
-
     List<Environment> findAllByProjectKey(String projectKey);
 
     Optional<Environment> findByServerSdkKey(String serverSdkKey);
diff --git a/src/main/java/com/featureprobe/api/service/MetricService.java b/src/main/java/com/featureprobe/api/service/MetricService.java
@@ -4,11 +4,16 @@
 import com.featureprobe.api.dto.MetricResponse;
 import com.featureprobe.api.entity.Environment;
 import com.featureprobe.api.entity.Event;
+import com.featureprobe.api.entity.Targeting;
 import com.featureprobe.api.entity.VariationHistory;
+import com.featureprobe.api.mapper.TargetingVersionMapper;
 import com.featureprobe.api.model.AccessEventPoint;
+import com.featureprobe.api.model.TargetingContent;
+import com.featureprobe.api.model.Variation;
 import com.featureprobe.api.model.VariationAccessCounter;
 import com.featureprobe.api.repository.EnvironmentRepository;
 import com.featureprobe.api.repository.EventRepository;
+import com.featureprobe.api.repository.TargetingRepository;
 import com.featureprobe.api.repository.VariationHistoryRepository;
 import com.google.common.collect.Lists;
 import lombok.AllArgsConstructor;
@@ -35,6 +40,7 @@ public class MetricService {
     private EnvironmentRepository environmentRepository;
     private EventRepository eventRepository;
     private VariationHistoryRepository variationHistoryRepository;
+    private TargetingRepository targetingRepository;
 
     private static final int MAX_QUERY_HOURS = 12 * 24;
     private static final int MAX_QUERY_POINT_COUNT = 12;
@@ -51,7 +57,12 @@ public MetricResponse query(String projectKey, String environmentKey, String tog
         List<AccessEventPoint> aggregatedAccessEventPoints = aggregatePointByMetricType(variationVersionMap,
                 accessEventPoints, metricType);
 
-        return new MetricResponse(accessEventPoints, summaryAccessEvents(aggregatedAccessEventPoints));
+        List<VariationAccessCounter> accessCounters = summaryAccessEvents(aggregatedAccessEventPoints);
+        Targeting latestTargeting = targetingRepository.findByProjectKeyAndEnvironmentKeyAndToggleKey(projectKey,
+                environmentKey, toggleKey).get();
+        appendLatestVariations(accessCounters, latestTargeting, metricType);
+
+        return new MetricResponse(accessEventPoints, accessCounters);
     }
 
     private Map<String, VariationHistory> buildVariationVersionMap(String projectKey, String environmentKey,
@@ -63,7 +74,7 @@ private Map<String, VariationHistory> buildVariationVersionMap(String projectKey
         return variationHistories.stream().collect(Collectors.toMap(this::toIndexValue, Function.identity()));
     }
 
-    private List<AccessEventPoint> aggregatePointByMetricType(Map<String, VariationHistory> variationVersionMap,
+    protected List<AccessEventPoint> aggregatePointByMetricType(Map<String, VariationHistory> variationVersionMap,
                                                               List<AccessEventPoint> accessEventPoints,
                                                               MetricType metricType) {
 
@@ -74,22 +85,22 @@ private List<AccessEventPoint> aggregatePointByMetricType(Map<String, VariationH
                 VariationHistory variationHistory = variationVersionMap.get(variationAccessCounter.getValue());
                 if (variationHistory != null) {
                     variationAccessCounter.setValue(metricType.isNameType()
-                            ?  variationHistory.getName() : variationHistory.getValue());
+                            ? variationHistory.getName() : variationHistory.getValue());
                 }
             });
             Map<String, Long> variationCounts =
                     accessEventPoint.getValues().stream().collect(Collectors.toMap(VariationAccessCounter::getValue,
                             VariationAccessCounter::getCount, Long::sum));
 
             List<VariationAccessCounter> values = variationCounts.entrySet().stream().map(e ->
-                            new VariationAccessCounter(e.getKey(), e.getValue(), null, null))
+                            new VariationAccessCounter(e.getKey(), e.getValue()))
                     .collect(Collectors.toList());
             accessEventPoint.setValues(values);
         });
         return accessEventPoints;
     }
 
-    private List<AccessEventPoint> queryAccessEventPoints(String serverSdkKey, String toggleKey, int lastHours) {
+    protected List<AccessEventPoint> queryAccessEventPoints(String serverSdkKey, String toggleKey, int lastHours) {
         int pointIntervalCount = getPointIntervalCount(lastHours);
         int pointCount = lastHours / pointIntervalCount;
 
@@ -142,7 +153,7 @@ private List<VariationAccessCounter> queryAccessEvents(String serverSdkKey,
         return toAccessEvent(currentPointEvents);
     }
 
-    private List<VariationAccessCounter> toAccessEvent(List<Event> events) {
+    protected List<VariationAccessCounter> toAccessEvent(List<Event> events) {
         if (CollectionUtils.isEmpty(events)) {
             return Collections.emptyList();
         }
@@ -199,6 +210,41 @@ protected List<VariationAccessCounter> summaryAccessEvents(List<AccessEventPoint
         return summaryEvents;
     }
 
+    protected void appendLatestVariations(List<VariationAccessCounter> accessCounters, Targeting latestTargeting,
+                                        MetricType metricType) {
+        TargetingContent targetingContent = TargetingVersionMapper.INSTANCE.toTargetingContent(
+                latestTargeting.getContent());
+
+        if (CollectionUtils.isEmpty(targetingContent.getVariations())) {
+            return;
+        }
+        List<String> latestVariations = targetingContent.getVariations()
+                .stream()
+                .map(metricType.isNameType() ? Variation::getName : Variation::getValue)
+                .collect(Collectors.toList());
+
+        setVariationDeletedIfNotInLatest(accessCounters, latestVariations);
+        appendVariationIfInLatest(accessCounters, latestVariations);
+    }
+
+    private void setVariationDeletedIfNotInLatest(List<VariationAccessCounter> accessCounters,
+                                                  List<String> namesOrValues) {
+        accessCounters.stream()
+                .filter(accessCounter -> !namesOrValues.contains(accessCounter.getValue()))
+                .forEach(accessCounter -> accessCounter.setDeleted(true));
+    }
+
+    private void appendVariationIfInLatest(List<VariationAccessCounter> accessCounters, List<String> namesOrValues) {
+        namesOrValues.forEach(value -> {
+            if (!accessCounters.stream()
+                    .filter(accessCounter -> StringUtils.equals(accessCounter.getValue(), value))
+                    .findFirst()
+                    .isPresent()) {
+                accessCounters.add(new VariationAccessCounter(value, 0L));
+            }
+        });
+    }
+
     private String queryEnvironmentServerSdkKey(String projectKey, String environmentKey) {
         Environment environment = this.environmentRepository.findByProjectKeyAndKey(projectKey, environmentKey).get();
         return environment.getServerSdkKey();
diff --git a/src/test/groovy/com/featureprobe/api/service/MetricServiceSpec.groovy b/src/test/groovy/com/featureprobe/api/service/MetricServiceSpec.groovy
@@ -1,10 +1,18 @@
 package com.featureprobe.api.service
 
+import com.featureprobe.api.base.constants.MetricType
+import com.featureprobe.api.dto.MetricResponse
+import com.featureprobe.api.entity.Environment
 import com.featureprobe.api.entity.Event
+import com.featureprobe.api.entity.Targeting
+import com.featureprobe.api.entity.VariationHistory
 import com.featureprobe.api.model.AccessEventPoint
+import com.featureprobe.api.model.TargetingContent
+import com.featureprobe.api.model.Variation
 import com.featureprobe.api.model.VariationAccessCounter
 import com.featureprobe.api.repository.EnvironmentRepository
 import com.featureprobe.api.repository.EventRepository
+import com.featureprobe.api.repository.TargetingRepository
 import com.featureprobe.api.repository.VariationHistoryRepository
 import spock.lang.Specification
 
@@ -17,12 +25,95 @@ class MetricServiceSpec extends Specification {
     EnvironmentRepository environmentRepository
     EventRepository eventRepository
     VariationHistoryRepository variationHistoryRepository
+    TargetingRepository targetingRepository
 
     def setup() {
         environmentRepository = Mock(EnvironmentRepository)
         eventRepository = Mock(EventRepository)
         variationHistoryRepository = Mock(VariationHistoryRepository)
-        metricService = new MetricService(environmentRepository, eventRepository, variationHistoryRepository)
+        targetingRepository = Mock(TargetingRepository)
+        metricService = new MetricService(environmentRepository, eventRepository, variationHistoryRepository,
+                targetingRepository)
+    }
+
+    def "test find the last 3 hours of data by metric type"() {
+        given:
+        def toggleKey = "myToggle"
+        def envKey = "test"
+        def projectKey = "prj-key"
+        def serverSdkKey = "sdkKey-001"
+
+        when:
+        MetricResponse response = metricService.query("prj-key",
+                "test", "myToggle", MetricType.NAME, 3)
+
+        then:
+        1 * environmentRepository.findByProjectKeyAndKey(projectKey, envKey) >> Optional.of(new Environment(serverSdkKey: serverSdkKey))
+        3 * eventRepository.findBySdkKeyAndToggleKeyAndStartDateGreaterThanEqualAndEndDateLessThanEqual(serverSdkKey, toggleKey,
+                _, _) >> []
+        1 * variationHistoryRepository.findByProjectKeyAndEnvironmentKeyAndToggleKey(projectKey, envKey, toggleKey) >> []
+        1 * targetingRepository.findByProjectKeyAndEnvironmentKeyAndToggleKey(projectKey, envKey, toggleKey) >> Optional.of(new Targeting(content: "{}"))
+
+        0 == response.summary.size()
+    }
+
+    def "test query access event points when event is empty"() {
+        given:
+        def lastHours = 10
+
+        when:
+        List<AccessEventPoint> accessEventPoints = metricService.queryAccessEventPoints("test-sdk-key",
+                "my_toggle1", lastHours)
+
+        then:
+        10 * eventRepository.findBySdkKeyAndToggleKeyAndStartDateGreaterThanEqualAndEndDateLessThanEqual(_, _, _, _) >> []
+        lastHours == accessEventPoints.size()
+    }
+
+    def "test append latest variations"() {
+        given:
+        List<VariationAccessCounter> accessCounters = [
+                new VariationAccessCounter("red", 10),
+                new VariationAccessCounter("blue", 10)
+        ]
+        Targeting latestTargeting = new Targeting(content: new TargetingContent(variations: [new Variation(name: "red"),
+                                                                                             new Variation(name: "green")]).toJson())
+
+        when:
+        metricService.appendLatestVariations(accessCounters, latestTargeting, MetricType.NAME)
+
+        then:
+        3 == accessCounters.size()
+    }
+
+    def "test event entities convert to access counter"() {
+        when:
+        def accessCounters = metricService.toAccessEvent([
+                new Event(valueIndex: 0, toggleVersion: 10, count: 10),
+                new Event(valueIndex: 1, toggleVersion: 11, count: 20),
+                new Event(valueIndex: 0, toggleVersion: 10, count: 30)
+        ])
+
+        then:
+        2 == accessCounters.size()
+        with(accessCounters.find { it.value == '10_0' }) {
+            40 == count
+        }
+    }
+
+    def "test aggregate point by metric type "() {
+        when:
+        List<AccessEventPoint> accessEventPoints = metricService.aggregatePointByMetricType([
+                "1_10": new VariationHistory(id: 3, name: "blue"),
+                "1_11": new VariationHistory(id: 3, name: "blue")],
+                [new AccessEventPoint("10", [new VariationAccessCounter(value: "1_10", count: 15),
+                                             new VariationAccessCounter(value: "1_11", count: 5)])], MetricType.NAME)
+
+        then:
+        1 == accessEventPoints.size()
+        "blue" == accessEventPoints[0].values[0].value
+        20 == accessEventPoints[0].values[0].count
+
     }
 
     def "test `isGroupByDay`"() {

Original file line number	Diff line number	Diff line change
`@@ -24,11 +24,14 @@ public class VariationAccessCounter {`
`24`	`24`	`@NotNull`
`25`	`25`	`private Integer index;`
`26`	`26`
	`27`	`+ private Boolean deleted;`
`27`	`28`
`28`	`29`	`public VariationAccessCounter(String value, Long count) {`
`29`	`30`	`this.value = value;`
`30`	`31`	`this.count = count;`
	`32`	`+ this.deleted = false;`
`31`	`33`	`}`
`32`	`34`
`33`	`35`
	`36`	`+`
`34`	`37`	`}`