public NapdexHealthZone(TraceTag tag, long invocationCount, HealthRating rating) { this.tag = tag; this.invocationCount = invocationCount; this.rating = rating; if (tag == null) { this.label = "No samples"; } else { this.label = tag.getTag(); } }
public NapdexTraceTagRule(int precedenceOrder, String pattern, long threshold) { setPrecedence(precedenceOrder); setPattern(pattern); setThreshold(threshold); }
@Override public String toString() { return "NapdexTraceTagRule{" + "precedence=" + getPrecedence() + ", keyMatcher=" + getRequiredEndPoint() + ", thresholdMillis=" + getThreshold() + ", frustratedMillis=" + frustratedMillis + '}'; } }
public static SyncTraceTagRuleListCommand getTraceTagCommand() { TraceTagRuleList ttrl = new TraceTagRuleList(); ttrl.addRule(new NapdexTraceTagRule(1, "butter", 344555)); return new SyncTraceTagRuleListCommand(ttrl); }
public synchronized void addRule(TraceTagRule rule) { TraceTagRule exsistingRule = findRuleForPrecedence(rule.getPrecedence()); if (exsistingRule != null) { removeRule(exsistingRule); } this.rules.add(rule); // inefficient to sort all the time, but not a big deal -- shouldn't // be called often or have that many rules. sort(rules, DescendingPrecedenceComparator.INSTANCE); }
public synchronized long findResponseTimeThreshold(Resource resource) { if (!(resource instanceof EndPointAwareResource)) { throw new IllegalArgumentException("Only EndPoint resources have a defined threshold"); } EndPointAwareResource endpoint = (EndPointAwareResource) resource; NapdexTraceTagRule napdexRule = findResponseTimeRule(endpoint.getEndPointName()); return napdexRule.getThreshold(); }
public Set<TraceTag> locateTags (TraceInterface traceAccess, EndPointAwareResource endpoint, boolean hasErrors) { if (traceAccess instanceof TraceTagsCarrier) { TraceTagsCarrier tagsCarrier=(TraceTagsCarrier) traceAccess; if (!tagsCarrier.isTraceTagsAnalysisRequired()) { return tagsCarrier.getTags(); } } return locateTags(new TraceTagRuleContext(traceAccess.asTrace(), endpoint, hasErrors)); }
private void swapPrecedence(TraceTagRule rule1, TraceTagRule rule2) { int tempPrecendence = rule1.getPrecedence(); rule1.setPrecedence(rule2.getPrecedence()); rule2.setPrecedence(tempPrecendence); sort(rules, DescendingPrecedenceComparator.INSTANCE); }
public synchronized boolean demote(TraceTagRule rule) { sort(rules, DescendingPrecedenceComparator.INSTANCE); int index = rules.indexOf(rule); if (index == -1 || index >= rules.size() - 1) { return false; } TraceTagRule swap = rules.get(index + 1); if (swap.getPrecedence() == 0) { return false; } swapPrecedence(rule, swap); return true; }
public Set<TraceTag> locateTags(TraceTagRuleContext context) { Set<TraceTag> tags=tagAnalyzer.locateTags(context); if (logger.isTraceEnabled()) { Trace trace=context.getTrace(); if (ListUtil.size(tags) > 0) { for (TraceTag tag : tags) { logger.trace("locatTags(" + trace + "): " + tag); } } else { logger.trace("locatTags(" + trace + ") no tags"); } } return tags; }
/** * Returns the rule matching the precedence, or null if not found */ public synchronized TraceTagRule findRuleForPrecedence(int precedence) { for (TraceTagRule rule : rules) { if (rule.getPrecedence() == precedence) { return rule; } } return null; }
public static TraceTag valueOf(String tag) { return new TraceTag(tag); }
public synchronized boolean promote(TraceTagRule rule) { int index = rules.indexOf(rule); if (index == -1 || index == 0) { return false; } swapPrecedence(rule, rules.get(index - 1)); return true; }
public long findResponseTimeThreshold(Resource resource) { return getRuleList().findResponseTimeThreshold(resource); } }
public TraceTagRuleList getRuleList() { TraceTagRuleList ruleList = new TraceTagRuleList(); for (PersistedTraceTagRule rule : dao.getRuleList().getRules()) { ruleList.addRule(new NapdexTraceTagRule(rule.getPrecedence(), rule.getPattern(), rule.getThreshold())); } return ruleList; }
@Override public String toString() { return getTag(); }
public int compare(TraceTagRule t1, TraceTagRule t2) { return new Integer(t2.getPrecedence()).compareTo(new Integer(t1.getPrecedence())); } }
/** * Returns a metric key which corresponds to the invocation * count of the given tag. */ public MetricKey getMetricKey() { if (key == null) { key = MetricKey.valueOf("tag." + getTag() + ":type=counter"); } return key; } }
@Override public int hashCode() { return ObjectUtil.hashCode(getTag()); }