@TearDown(Level.Trial) public void tearDown(Blackhole hole) { for (io.micrometer.core.instrument.Meter m : registry.getMeters()) { if (m instanceof io.micrometer.core.instrument.Counter) { hole.consume(((io.micrometer.core.instrument.Counter) m).count()); } } } }
@Test public void countsSubscriptionsFuseable() { Mono<Integer> source = Mono.just(10); Mono<Integer> test = new MonoMetricsFuseable<>(source, registry); test.subscribe(); Counter meter = registry.find(METER_SUBSCRIBED) .counter(); assertThat(meter).isNotNull(); assertThat(meter.count()).as("after 1s subscribe").isEqualTo(1); test.subscribe(); test.subscribe(); assertThat(meter.count()).as("after more subscribe").isEqualTo(3); }
@Test public void malformedOnComplete() { TestPublisher<Integer> testPublisher = TestPublisher.createNoncompliant(CLEANUP_ON_TERMINATE); Mono<Integer> source = testPublisher.mono().hide(); new MonoMetrics<>(source, registry) .subscribe(v -> assertThat(v).isEqualTo(1), e -> assertThat(e).hasMessage("malformedOnComplete")); testPublisher.error(new IllegalStateException("malformedOnComplete")) .complete(); Counter malformedMeter = registry .find(METER_MALFORMED) .counter(); assertThat(malformedMeter).isNotNull(); assertThat(malformedMeter.count()).isEqualTo(1); }
@Test public void countsSubscriptions() { Mono<Integer> source = Mono.just(1) .hide(); Mono<Integer> test = new MonoMetrics<>(source, registry); test.subscribe(); Counter meter = registry.find(METER_SUBSCRIBED) .counter(); assertThat(meter).isNotNull(); assertThat(meter.count()).as("after 1s subscribe").isEqualTo(1); test.subscribe(); test.subscribe(); assertThat(meter.count()).as("after more subscribe").isEqualTo(3); }
@Test public void countsSubscriptionsFuseable() { Flux<Integer> source = Flux.range(1, 10); Flux<Integer> test = new FluxMetricsFuseable<>(source, registry); test.subscribe(); Counter meter = registry.find(METER_SUBSCRIBED) .counter(); assertThat(meter).isNotNull(); assertThat(meter.count()).as("after 1s subscribe").isEqualTo(1); test.subscribe(); test.subscribe(); assertThat(meter.count()).as("after more subscribe").isEqualTo(3); }
@Test public void malformedOnComplete() { TestPublisher<Integer> testPublisher = TestPublisher.createNoncompliant(CLEANUP_ON_TERMINATE); Flux<Integer> source = testPublisher.flux().hide(); new FluxMetrics<>(source, registry) .subscribe(v -> assertThat(v).isEqualTo(1), e -> assertThat(e).hasMessage("malformedOnComplete")); testPublisher.next(1) .error(new IllegalStateException("malformedOnComplete")) .complete(); Counter malformedMeter = registry .find(METER_MALFORMED) .counter(); assertThat(malformedMeter).isNotNull(); assertThat(malformedMeter.count()).isEqualTo(1); }
@Test public void countsSubscriptions() { Flux<Integer> source = Flux.range(1, 10) .hide(); Flux<Integer> test = new FluxMetrics<>(source, registry); test.subscribe(); Counter meter = registry.find(METER_SUBSCRIBED) .counter(); assertThat(meter).isNotNull(); assertThat(meter.count()).as("after 1s subscribe").isEqualTo(1); test.subscribe(); test.subscribe(); assertThat(meter.count()).as("after more subscribe").isEqualTo(3); }
@Test public void malformedOnNext() { TestPublisher<Integer> testPublisher = TestPublisher.createNoncompliant(CLEANUP_ON_TERMINATE); Mono<Integer> source = testPublisher.mono().hide(); new MonoMetrics<>(source, registry) .subscribe(); testPublisher.complete() .next(2); Counter malformedMeter = registry .find(METER_MALFORMED) .counter(); assertThat(malformedMeter).isNotNull(); assertThat(malformedMeter.count()).isEqualTo(1); }
@Test public void malformedOnError() { AtomicReference<Throwable> errorDropped = new AtomicReference<>(); Hooks.onErrorDropped(errorDropped::set); Exception dropError = new IllegalStateException("malformedOnError"); try { TestPublisher<Integer> testPublisher = TestPublisher.createNoncompliant(CLEANUP_ON_TERMINATE); Mono<Integer> source = testPublisher.mono().hide(); new MonoMetrics<>(source, registry) .subscribe(); testPublisher.complete() .error(dropError); Counter malformedMeter = registry .find(METER_MALFORMED) .counter(); assertThat(malformedMeter).isNotNull(); assertThat(malformedMeter.count()).isEqualTo(1); assertThat(errorDropped).hasValue(dropError); } finally{ Hooks.resetOnErrorDropped(); } }
@Test public void malformedOnNext() { TestPublisher<Integer> testPublisher = TestPublisher.createNoncompliant(CLEANUP_ON_TERMINATE); Flux<Integer> source = testPublisher.flux().hide(); new FluxMetrics<>(source, registry) .subscribe(); testPublisher.next(1) .complete() .next(2); Counter malformedMeter = registry .find(METER_MALFORMED) .counter(); assertThat(malformedMeter).isNotNull(); assertThat(malformedMeter.count()).isEqualTo(1); }
@Test public void malformedOnError() { AtomicReference<Throwable> errorDropped = new AtomicReference<>(); Hooks.onErrorDropped(errorDropped::set); Exception dropError = new IllegalStateException("malformedOnError"); try { TestPublisher<Integer> testPublisher = TestPublisher.createNoncompliant(CLEANUP_ON_TERMINATE); Flux<Integer> source = testPublisher.flux().hide(); new FluxMetrics<>(source, registry) .subscribe(); testPublisher.next(1) .complete() .error(dropError); Counter malformedMeter = registry .find(METER_MALFORMED) .counter(); assertThat(malformedMeter).isNotNull(); assertThat(malformedMeter.count()).isEqualTo(1); assertThat(errorDropped).hasValue(dropError); } finally{ Hooks.resetOnErrorDropped(); } }
@DisplayName("metadataPush gathers metrics") @Test void metadataPush() { Payload payload = DefaultPayload.create("test-metadata", "test-data"); when(delegate.metadataPush(payload)).thenReturn(Mono.empty()); new MicrometerRSocket(delegate, meterRegistry, Tag.of("test-key", "test-value")) .metadataPush(payload) .as(StepVerifier::create) .verifyComplete(); assertThat(findCounter("metadata.push", SignalType.ON_COMPLETE).count()).isEqualTo(1); }
@DisplayName("fireAndForget gathers metrics") @Test void fireAndForget() { Payload payload = DefaultPayload.create("test-metadata", "test-data"); when(delegate.fireAndForget(payload)).thenReturn(Mono.empty()); new MicrometerRSocket(delegate, meterRegistry, Tag.of("test-key", "test-value")) .fireAndForget(payload) .as(StepVerifier::create) .verifyComplete(); assertThat(findCounter("request.fnf", SignalType.ON_COMPLETE).count()).isEqualTo(1); }
@DisplayName("requestChannel gathers metrics") @Test void requestChannel() { Mono<Payload> payload = Mono.just(DefaultPayload.create("test-metadata", "test-data")); when(delegate.requestChannel(payload)).thenReturn(Flux.empty()); new MicrometerRSocket(delegate, meterRegistry, Tag.of("test-key", "test-value")) .requestChannel(payload) .as(StepVerifier::create) .verifyComplete(); assertThat(findCounter("request.channel", SignalType.ON_COMPLETE).count()).isEqualTo(1); }
@DisplayName("requestStream gathers metrics") @Test void requestStream() { Payload payload = DefaultPayload.create("test-metadata", "test-data"); when(delegate.requestStream(payload)).thenReturn(Flux.empty()); new MicrometerRSocket(delegate, meterRegistry, Tag.of("test-key", "test-value")) .requestStream(payload) .as(StepVerifier::create) .verifyComplete(); assertThat(findCounter("request.stream", SignalType.ON_COMPLETE).count()).isEqualTo(1); }
assertThat(findCounter(SERVER, CANCEL).count()).isEqualTo(1); assertThat(findCounter(SERVER, COMPLETE).count()).isEqualTo(1); assertThat(findCounter(SERVER, ERROR).count()).isEqualTo(1); assertThat(findCounter(SERVER, KEEPALIVE).count()).isEqualTo(1); assertThat(findCounter(SERVER, LEASE).count()).isEqualTo(1); assertThat(findCounter(SERVER, METADATA_PUSH).count()).isEqualTo(1); assertThat(findCounter(SERVER, REQUEST_CHANNEL).count()).isEqualTo(1); assertThat(findCounter(SERVER, REQUEST_FNF).count()).isEqualTo(1); assertThat(findCounter(SERVER, REQUEST_N).count()).isEqualTo(1); assertThat(findCounter(SERVER, REQUEST_RESPONSE).count()).isEqualTo(1); assertThat(findCounter(SERVER, REQUEST_STREAM).count()).isEqualTo(1); assertThat(findCounter(SERVER, RESUME).count()).isEqualTo(1); assertThat(findCounter(SERVER, RESUME_OK).count()).isEqualTo(1); assertThat(findCounter(SERVER, SETUP).count()).isEqualTo(1);
.verifyComplete(); assertThat(findCounter(CLIENT, CANCEL).count()).isEqualTo(1); assertThat(findCounter(CLIENT, COMPLETE).count()).isEqualTo(1); assertThat(findCounter(CLIENT, ERROR).count()).isEqualTo(1); assertThat(findCounter(CLIENT, KEEPALIVE).count()).isEqualTo(1); assertThat(findCounter(CLIENT, LEASE).count()).isEqualTo(1); assertThat(findCounter(CLIENT, METADATA_PUSH).count()).isEqualTo(1); assertThat(findCounter(CLIENT, REQUEST_CHANNEL).count()).isEqualTo(1); assertThat(findCounter(CLIENT, REQUEST_FNF).count()).isEqualTo(1); assertThat(findCounter(CLIENT, REQUEST_N).count()).isEqualTo(1); assertThat(findCounter(CLIENT, REQUEST_RESPONSE).count()).isEqualTo(1); assertThat(findCounter(CLIENT, REQUEST_STREAM).count()).isEqualTo(1); assertThat(findCounter(CLIENT, RESUME).count()).isEqualTo(1); assertThat(findCounter(CLIENT, RESUME_OK).count()).isEqualTo(1); assertThat(findCounter(CLIENT, SETUP).count()).isEqualTo(1);
@DisplayName("onClose gathers metrics") @Test void onClose() { when(delegate.onClose()).thenReturn(Mono.empty()); new MicrometerDuplexConnection( CLIENT, delegate, meterRegistry, Tag.of("test-key", "test-value")) .onClose() .subscribe(Operators.drainSubscriber()); assertThat( meterRegistry .get("rsocket.duplex.connection.close") .tag("connection.type", CLIENT.name()) .tag("test-key", "test-value") .counter() .count()) .isEqualTo(1); }
@DisplayName("dispose gathers metrics") @Test void dispose() { new MicrometerDuplexConnection( CLIENT, delegate, meterRegistry, Tag.of("test-key", "test-value")) .dispose(); assertThat( meterRegistry .get("rsocket.duplex.connection.dispose") .tag("connection.type", CLIENT.name()) .tag("test-key", "test-value") .counter() .count()) .isEqualTo(1); }
.tag("name", "queue") .tag("result", "success") .counter().count()).isEqualTo(1);