private Subscription sub(int i) { return new Subscription() .withId("" + i) .withExpression("name," + i + ",:eq,:sum") .withFrequency(60000); }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Subscription that = (Subscription) o; return frequency == that.frequency && equalsOrNull(id, that.id) && equalsOrNull(expression, that.expression) && equalsOrNull(expr, that.expr); }
@Override public int hashCode() { int result = hashCodeOrZero(id); result = 31 * result + hashCodeOrZero(expression); result = 31 * result + (int) (frequency ^ (frequency >>> 32)); result = 31 * result + hashCodeOrZero(expr); return result; }
@Test public void removeSub() { List<Subscription> subs = new ArrayList<>(); subs.add(new Subscription().withId("sum").withExpression(":true,:sum")); subs.add(new Subscription().withId("max").withExpression(":true,:max")); Evaluator evaluator = new Evaluator().addGroupSubscriptions("local", subs); evaluator.removeGroupSubscriptions("local"); EvalPayload payload = evaluator.eval("test", 0L, Collections.emptyList()); EvalPayload expected = new EvalPayload(0L, Collections.emptyList()); Assertions.assertEquals(expected, payload); }
@Test public void dataExpr() { Subscription sub = new Subscription().withExpression(":true,:sum"); Assertions.assertEquals(new DataExpr.Sum(Query.TRUE), sub.dataExpr()); }
/** * Evaluate expressions for all subscriptions associated with the specified group using * the provided data. * * @param group * Name of the group. At Netflix this is typically the cluster that includes * the instance reporting data. * @param timestamp * Timestamp to use for the payload response. * @param vs * Set of values received for the group for the current time period. * @return * Payload that can be encoded and sent to Atlas streaming evaluation cluster. */ public EvalPayload eval(String group, long timestamp, List<TagsValuePair> vs) { List<Subscription> subs = subscriptions.getOrDefault(group, Collections.emptyList()); List<EvalPayload.Metric> metrics = new ArrayList<>(); for (Subscription s : subs) { DataExpr expr = s.dataExpr(); for (TagsValuePair pair : expr.eval(vs)) { EvalPayload.Metric m = new EvalPayload.Metric(s.getId(), pair.tags(), pair.value()); metrics.add(m); } } return new EvalPayload(timestamp, metrics); } }
@Test public void dataExprInvalid() { Assertions.assertThrows(IllegalArgumentException.class, () -> new Subscription().withExpression(":true")); } }
/** Set the expression for the subscription. */ public Subscription withExpression(String expression) { setExpression(expression); return this; }
private Subscriptions filterByStep(Subscriptions subs) { List<Subscription> subscriptions = subs .getExpressions() .stream() .filter(s -> s.getFrequency() == stepMillis) .collect(Collectors.toList()); return new Subscriptions().withExpressions(subscriptions); } }
@Test public void sumAndMaxForGroup() { List<Subscription> subs = new ArrayList<>(); subs.add(new Subscription().withId("sum").withExpression(":true,:sum")); subs.add(new Subscription().withId("max").withExpression(":true,:max")); Evaluator evaluator = new Evaluator().addGroupSubscriptions("local", subs); EvalPayload payload = evaluator.eval("local", 0L, data("foo", 1.0, 2.0, 3.0)); List<EvalPayload.Metric> metrics = new ArrayList<>(); metrics.add(new EvalPayload.Metric("sum", Collections.emptyMap(), 6.0)); metrics.add(new EvalPayload.Metric("max", Collections.emptyMap(), 3.0)); EvalPayload expected = new EvalPayload(0L, metrics); Assertions.assertEquals(expected, payload); }
private Subscription newSub(String id, String expr, long freq) { return new Subscription().withId(id).withExpression(expr).withFrequency(freq); }
@Test public void updateSub() { // Eval with sum List<Subscription> sumSub = new ArrayList<>(); sumSub.add(new Subscription().withId("sum").withExpression(":true,:sum")); Evaluator evaluator = new Evaluator().addGroupSubscriptions("local", sumSub); EvalPayload payload = evaluator.eval("local", 0L, data("foo", 1.0, 2.0, 3.0)); List<EvalPayload.Metric> metrics = new ArrayList<>(); metrics.add(new EvalPayload.Metric("sum", Collections.emptyMap(), 6.0)); EvalPayload expected = new EvalPayload(0L, metrics); Assertions.assertEquals(expected, payload); // Update to use max instead List<Subscription> maxSub = new ArrayList<>(); maxSub.add(new Subscription().withId("sum").withExpression(":true,:max")); evaluator.addGroupSubscriptions("local", maxSub); payload = evaluator.eval("local", 0L, data("foo", 1.0, 2.0, 3.0)); metrics = new ArrayList<>(); metrics.add(new EvalPayload.Metric("sum", Collections.emptyMap(), 3.0)); expected = new EvalPayload(0L, metrics); Assertions.assertEquals(expected, payload); } }