/** Returns the 95th-percentile latency seen by this * {@link PerformanceMonitor} for successful requests. * @return latency in milliseconds */ public long get95thPercentileSuccessLatencyLifetime() { return lifetimeSuccessLatencyQuantile.getPercentile(95); }
long getPercentile(int i, long now) { return getQuantile(i, 100, now); }
void addSample(long l, long now) { samplesSeen.getAndIncrement(); updateWindowSegments(now); if (samples.size() < maxSamples) { samples.add(new Sample(l, now)); return; } if (rand.nextDouble() < maxSamples * 1.0 / getEffectiveSamplesSeen()) { int idx = rand.nextInt(maxSamples); samples.set(idx, new Sample(l, now)); } }
/** * Reports a sample measurement to be included in the quantile * calculations. * * @param l specific measurement */ public void addSample(long l) { addSample(l, System.currentTimeMillis()); }
long getQuantile(int k, int q, long now) { if (k <= 0 || k >= q) throw new QuantileOutOfBoundsException(); List<Sample> validSamples = getValidSamples(now); if (validSamples.size() == 0) return 0; Collections.sort(validSamples); double targetIndex = (validSamples.size() * k) / (q * 1.0); if (validSamples.size() % 2 == 1) { return validSamples.get((int)Math.ceil(targetIndex) - 1).data; } int i0 = (int)Math.floor(targetIndex) - 1; return (validSamples.get(i0).data + validSamples.get(i0+1).data) / 2; }
SampledQuantile(int maxSamples, long windowLength, TimeUnit units, long now) { this.maxSamples = maxSamples; setWindowMillis(windowLength, units); windowSegments = new LinkedList<Sample>(); windowSegments.offer(new Sample(samplesSeen.get(), now)); }
private void recordFailure(LatencyTracker latencyTracker) { long failureMillis = latencyTracker.getLastFailureMillis(); averageFailureLatencyLastMinute.update(failureMillis); averageFailureLatencyLastHour.update(failureMillis); averageFailureLatencyLastDay.update(failureMillis); lifetimeFailureLatencyQuantile.addSample(failureMillis); failureLatencyQuantileLastMinute.addSample(failureMillis); failureLatencyQuantileLastHour.addSample(failureMillis); failureLatencyQuantileLastDay.addSample(failureMillis); lifetimeMaxFailureMillis = (failureMillis > lifetimeMaxFailureMillis) ? failureMillis : lifetimeMaxFailureMillis; recordRequest(); }
/** Returns the median latency seen by this {@link * PerformanceMonitor} for successful requests over the * last minute. * @return latency in milliseconds */ public long getMedianPercentileSuccessLatencyLastMinute() { return successLatencyQuantileLastMinute.getPercentile(50); }
private void recordSuccess(LatencyTracker latencyTracker) { long successMillis = latencyTracker.getLastSuccessMillis(); averageSuccessLatencyLastMinute.update(successMillis); averageSuccessLatencyLastHour.update(successMillis); averageSuccessLatencyLastDay.update(successMillis); lifetimeSuccessLatencyQuantile.addSample(successMillis); successLatencyQuantileLastMinute.addSample(successMillis); successLatencyQuantileLastHour.addSample(successMillis); successLatencyQuantileLastDay.addSample(successMillis); lifetimeMaxSuccessMillis = (successMillis > lifetimeMaxSuccessMillis) ? successMillis : lifetimeMaxSuccessMillis; recordRequest(); }
/** * Returns the <code>k</code>th <code>q</code>-quantile of the samples * seen thus far. * * @param q must be >= 2 * @param k must be 0 < k < q * @return k-th q-quantile, or 0 if there is no data * @throws QuantileOutOfBoundsException if k <= 0 or k >= q */ public long getQuantile(int k, int q) { return getQuantile(k, q, System.currentTimeMillis()); }
/** Returns the 95th-percentile latency seen by this {@link * PerformanceMonitor} for successful requests over the last * minute. * @return latency in milliseconds */ public long get95thPercentileSuccessLatencyLastMinute() { return successLatencyQuantileLastMinute.getPercentile(95); }
/** Returns the median latency seen by this {@link * PerformanceMonitor} for failed requests over the * last minute. * @return latency in milliseconds */ public long getMedianPercentileFailureLatencyLastMinute() { return failureLatencyQuantileLastMinute.getPercentile(50); }
/** Returns the 99th-percentile latency seen by this {@link * PerformanceMonitor} for failed requests over the last * hour. * @return latency in milliseconds */ public long get99thPercentileFailureLatencyLastHour() { return failureLatencyQuantileLastHour.getPercentile(99); }
/** Returns the 99th-percentile latency seen by this {@link * PerformanceMonitor} for failed requests. * @return latency in milliseconds */ public long get99thPercentileFailureLatencyLifetime() { return lifetimeFailureLatencyQuantile.getPercentile(99); }
/** Returns the 95th-percentile latency seen by this {@link * PerformanceMonitor} for failed requests over the last * minute. * @return latency in milliseconds */ public long get95thPercentileFailureLatencyLastMinute() { return failureLatencyQuantileLastMinute.getPercentile(95); }
/** Returns the 95th-percentile latency seen by this {@link * PerformanceMonitor} for failed requests over the last * day. * @return latency in milliseconds */ public long get95thPercentileFailureLatencyLastDay() { return failureLatencyQuantileLastDay.getPercentile(95); }
/** Returns the 99th-percentile latency seen by this {@link * PerformanceMonitor} for failed requests over the last * hour. * @return latency in milliseconds */ public long get99thPercentileFailureLatencyLastDay() { return failureLatencyQuantileLastDay.getPercentile(99); }
/** Returns the 99th-percentile latency seen by this * {@link PerformanceMonitor} for successful requests. * @return latency in milliseconds */ public long get99thPercentileSuccessLatencyLifetime() { return lifetimeSuccessLatencyQuantile.getPercentile(99); }
/** Returns the 95th-percentile latency seen by this {@link * PerformanceMonitor} for failed requests. * @return latency in milliseconds */ public long get95thPercentileFailureLatencyLifetime() { return lifetimeFailureLatencyQuantile.getPercentile(95); }
/** Returns the 99th-percentile latency seen by this {@link * PerformanceMonitor} for failed requests over the last * minute. * @return latency in milliseconds */ public long get99thPercentileFailureLatencyLastMinute() { return failureLatencyQuantileLastMinute.getPercentile(99); }