/** * Constructs an instance with all counts initialized to zero. */ public ConcurrentStatsCounter() { hitCount = new LongAdder(); missCount = new LongAdder(); loadSuccessCount = new LongAdder(); loadFailureCount = new LongAdder(); totalLoadTime = new LongAdder(); evictionCount = new LongAdder(); evictionWeight = new LongAdder(); }
static final void instrument() { seekCount = new LongAdder(); }
public LongAdder initializeAndGetReadLatencyForTable(String tableName) { LongAdder initLatency = new LongAdder(); this.perTableReadLatency.put(tableName, initLatency); return initLatency; }
public AbstractCacheableDataStatistics(Supplier<Region> regionSupplier) { final Region region = regionSupplier.get(); if ( region == null ) { this.cacheRegionName = null; this.cacheHitCount = null; this.cacheMissCount = null; this.cachePutCount = null; } else { this.cacheRegionName = region.getName(); this.cacheHitCount = new LongAdder(); this.cacheMissCount = new LongAdder(); this.cachePutCount = new LongAdder(); } }
public StatsBuckets(long... boundaries) { checkArgument(boundaries.length > 0); checkArgument(isSorted(boundaries), "Boundaries array must be sorted"); this.boundaries = boundaries; this.sumCounter = new LongAdder(); this.buckets = new LongAdder[boundaries.length + 1]; for (int i = 0; i < buckets.length; i++) { buckets[i] = new LongAdder(); } this.values = new long[buckets.length]; }
protected MutableFastCounter(MetricsInfo info, long iVal) { super(info); counter = new LongAdder(); counter.add(iVal); }
public RetryImpl(String name, RetryConfig config){ this.name = name; this.config = config; this.maxAttempts = config.getMaxAttempts(); this.intervalFunction = config.getIntervalFunction(); this.exceptionPredicate = config.getExceptionPredicate(); this.resultPredicate = config.getResultPredicate(); this.metrics = this.new RetryMetrics(); this.eventProcessor = new RetryEventProcessor(); succeededAfterRetryCounter = new LongAdder(); failedAfterRetryCounter = new LongAdder(); succeededWithoutRetryCounter = new LongAdder(); failedWithoutRetryCounter = new LongAdder(); }
public AsyncRetryImpl(String name, RetryConfig config) { this.config = config; this.name = name; this.maxAttempts = config.getMaxAttempts(); this.intervalFunction = config.getIntervalFunction(); this.exceptionPredicate = config.getExceptionPredicate(); this.resultPredicate = config.getResultPredicate(); this.metrics = this.new AsyncRetryMetrics(); succeededAfterRetryCounter = new LongAdder(); failedAfterRetryCounter = new LongAdder(); succeededWithoutRetryCounter = new LongAdder(); failedWithoutRetryCounter = new LongAdder(); this.eventProcessor = new RetryEventProcessor(); }
CircuitBreakerMetrics(int ringBufferSize, RingBitSet sourceSet) { this.ringBufferSize = ringBufferSize; if(sourceSet != null) { this.ringBitSet = new RingBitSet(this.ringBufferSize, sourceSet); }else{ this.ringBitSet = new RingBitSet(this.ringBufferSize); } this.numberOfNotPermittedCalls = new LongAdder(); }
JCacheProfiler() { random = new Random(); count = new LongAdder(); CachingProvider provider = Caching.getCachingProvider(CaffeineCachingProvider.class.getName()); CacheManager cacheManager = provider.getCacheManager( provider.getDefaultURI(), provider.getDefaultClassLoader()); cache = cacheManager.createCache("profiler", new MutableConfiguration<>()); executor = Executors.newCachedThreadPool(new ThreadFactoryBuilder() .setPriority(Thread.MIN_PRIORITY).setDaemon(true).build()); }
@Test public void subscribeOnNextOnErrorErrorsOnAllRails() { LongAdder valueAdder = new LongAdder(); LongAdder errorAdder = new LongAdder(); Flux.range(1, 3) .concatWith(Mono.error(new IllegalStateException("boom"))) .parallel(2) .subscribe(v -> valueAdder.increment(), e -> errorAdder.increment()); assertThat(valueAdder.intValue()).isEqualTo(3); assertThat(errorAdder.intValue()).isEqualTo(2); }
@Test public void onSuccessOrErrorCallbackFailureInterruptsOnNext() { LongAdder invoked = new LongAdder(); StepVerifier.create(Mono.just("foo") .doOnSuccessOrError((v, t) -> { invoked.increment(); throw new IllegalArgumentException(v); })) .expectErrorMessage("foo") .verify(); assertEquals(1, invoked.intValue()); }
@Test public void onSuccessCallbackFailureInterruptsOnNext() { LongAdder invoked = new LongAdder(); StepVerifier.create(Mono.just("foo") .doOnSuccess(s -> { invoked.increment(); throw new IllegalArgumentException(s); })) .expectErrorMessage("foo") .verify(); assertEquals(1, invoked.intValue()); }
@Test public void afterTerminateForEmpty() { LongAdder invoked = new LongAdder(); StepVerifier.create(Mono.<String>empty() .doAfterTerminate(() -> { invoked.increment(); })) .expectComplete() .verify(); assertEquals(1, invoked.intValue()); }
@Test public void onSuccessNotCalledOnError() { LongAdder invoked = new LongAdder(); IllegalArgumentException err = new IllegalArgumentException("boom"); StepVerifier.create(Mono.error(err) .doOnSuccess(v -> invoked.increment())) .expectErrorMessage("boom") .verify(); assertEquals(0, invoked.intValue()); }
@Test public void apiCall() { LongAdder rCount = new LongAdder(); final Flux<Integer> source = Flux.range(1, 100) .doOnRequest(rCount::add); StepVerifier.create(source.limitRequest(3)) .expectNext(1, 2, 3) .verifyComplete(); assertThat(rCount.longValue()).isEqualTo(3); }
/** * KeySetView.spliterator returns spliterator over the elements in this set */ public void testKeySetSpliterator() { LongAdder adder = new LongAdder(); ConcurrentMap map = map5(); Set set = map.keySet(); Spliterator<Integer> sp = set.spliterator(); checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL); assertEquals(sp.estimateSize(), map.size()); Spliterator<Integer> sp2 = sp.trySplit(); sp.forEachRemaining((Integer x) -> adder.add(x.longValue())); long v = adder.sumThenReset(); sp2.forEachRemaining((Integer x) -> adder.add(x.longValue())); long v2 = adder.sum(); assertEquals(v + v2, 15); }
@Test public void testThenConsumeWhileWithConsumer() { LongAdder count = new LongAdder(); StepVerifier.create(Flux.range(3, 8)) .expectNextMatches(first -> first == 3) .thenConsumeWhile(v -> v < 9, v -> count.increment()) .expectNext(9) .expectNext(10) .expectComplete() .log() .verify(); assertThat(count.intValue()).isEqualTo(5); }
@Test public void afterTerminateForOnError() { LongAdder invoked = new LongAdder(); IllegalArgumentException err = new IllegalArgumentException("boom"); StepVerifier.create(Mono.<String>error(err) .doAfterTerminate(invoked::increment)) .expectErrorMessage("boom") .verify(); assertEquals(1, invoked.intValue()); }