@Override public void add(final double delta) { dataStore.addToCounter(this, delta); }
public CassandraLeafCounter sync(final M2AwareStatisticalSummary newStats, final int newConcurrency) { super.update(newStats, newConcurrency); return this; }
public CollectorCounter(final Key key) { this.key = key; reset(); }
long n = current.getHits(); double min = current.getMin(); double sum = current.getSum(); double max = current.getMax(); double m2 = current.getSecondMoment(); double mean = current.getMean(); while (iterator.hasNext()) { current = iterator.next(); if (current.getMin() < min || Double.isNaN(min)) { min = current.getMin(); if (current.getMax() > max || Double.isNaN(max)) { max = current.getMax(); sum += current.getSum(); final double oldN = n; final double curN = current.getHits(); n += curN; final double meanDiff = current.getMean() - mean; mean = sum / n; m2 = m2 + current.getSecondMoment() + meanDiff * meanDiff * oldN * curN / n;
public void update() { final Lock workLock = lock.writeLock(); workLock.lock(); try { final Collection<LeafCollectorCounter> counters = aggregation.values(); statistics = Aggregators.aggregate(counters); concurrency.set(computeConcurrency(counters)); updateConcurrency(concurrency.get()); } finally { workLock.unlock(); } }
@Override // TODO: see if we shouldn't store it or if aggregation can be done on java side public Collection<Counter> getCounters() { final Map<Counter.Key, Map<String, LeafCollectorCounter>> counters = new HashMap<Counter.Key, Map<String, LeafCollectorCounter>>(); for (final String marker : markers()) { for (final LeafCollectorCounter c : getCounters(marker)) { Map<String, LeafCollectorCounter> values = counters.get(c.getKey()); if (values == null) { values = new HashMap<String, LeafCollectorCounter>(); counters.put(c.getKey(), values); } values.put(marker, c); } } final Collection<Counter> c = new LinkedList<Counter>(); for (final Map.Entry<Counter.Key, Map<String, LeafCollectorCounter>> entry : counters.entrySet()) { c.add(new AggregatedCollectorCounter(entry.getKey(), entry.getValue())); } return c; }
public AggregatedCollectorCounter(final Key key, final Map<String, LeafCollectorCounter> counters) { super(key); aggregation.putAll(counters); update(); }
private static int computeConcurrency(final Collection<LeafCollectorCounter> counters) { int i = 0; for (final LeafCollectorCounter counter : counters) { i += counter.currentConcurrency().get(); } return i; }
public void update(final M2AwareStatisticalSummary newStats, final int newConcurrency) { final Lock workLock = lock.writeLock(); workLock.lock(); try { concurrency.set(newConcurrency); updateConcurrency(newConcurrency); statistics = newStats; } finally { workLock.unlock(); } } }
@Override // TODO: see if we shouldn't store it or if aggregation can be done on java side public AggregatedCollectorCounter getOrCreateCounter(final Counter.Key key) { final Map<String, LeafCollectorCounter> counters = new HashMap<String, LeafCollectorCounter>(); for (final String marker : markers()) { final LeafCollectorCounter c = getOrCreateCounter(key, marker); counters.put(marker, c); } return new AggregatedCollectorCounter(key, counters); }
public void add(final double delta, Unit unit) { add(key.getRole().getUnit().convert(delta, unit)); }
@Override public void update(final M2AwareStatisticalSummary newStats, final int newConcurrency) { super.update(newStats, newConcurrency); store.save(this, marker); }
@Override protected void pushCountersByBatch(final Collection<Counter> instances) { for (final Counter counter : instances) { delegate.getOrCreateCounter(counter.getKey(), marker) .update(new M2AwareStatisticalSummary( counter.getMean(), counter.getVariance(), counter.getHits(), counter.getMax(), counter.getMin(), counter.getSum(), counter.getSecondMoment()), counter.currentConcurrency().get()); } }