Java Code Examples for io.micrometer.core.instrument.Counter#increment()

@Override
protected void afterExecute(Runnable task, Throwable throwable) {
   Instant start = taskExecutionTimer.get();
   Timer timer = meterRegistry.timer(meterName("task.time"));
   timer.record(Duration.between(start, Instant.now()));

   super.afterExecute(task, throwable);
   if (throwable == null && task instanceof Future<?> && ((Future<?>) task).isDone()) {
      try {
         ((Future<?>) task).get();
      } catch (CancellationException ce) {
         throwable = ce;
      } catch (ExecutionException ee) {
         throwable = ee.getCause();
      } catch (InterruptedException ie) {
         Thread.currentThread().interrupt();
      }
   }
   if (throwable != null) {
      Counter failedTasksCounter = meterRegistry.counter(meterName("failed.tasks"));
      failedTasksCounter.increment();
   } else {
      Counter successfulTasksCounter = meterRegistry.counter(meterName("successful.tasks"));
      successfulTasksCounter.increment();
   }
}
 

@Test
void indexTemplateShouldApply() throws Throwable {
    String response = sendHttpGet(host);
    String versionNumber = JsonPath.parse(response).read("$.version.number");
    assertThat(versionNumber).isEqualTo(getVersion());

    Counter counter = registry.counter("test.counter");
    counter.increment();

    registry.publish();

    String indexName = registry.indexName();
    String mapping = sendHttpGet(host + "/" + indexName + "/_mapping");
    String countType = JsonPath.parse(mapping).read(getCountTypePath(indexName));
    assertThat(countType).isEqualTo("double");
}
 

@ParameterizedTest
@EnumSource(StatsdProtocol.class)
void receiveMetricsSuccessfully(StatsdProtocol protocol) throws InterruptedException {
    serverLatch = new CountDownLatch(3);
    server = startServer(protocol, 0);

    final int port = server.address().getPort();

    meterRegistry = new StatsdMeterRegistry(getUnbufferedConfig(protocol, port), Clock.SYSTEM);
    startRegistryAndWaitForClient();
    Counter counter = Counter.builder("my.counter").register(meterRegistry);
    counter.increment();
    counter.increment();
    counter.increment();
    assertThat(serverLatch.await(3, TimeUnit.SECONDS)).isTrue();
}
 

@ParameterizedTest
@EnumSource(StatsdProtocol.class)
@Issue("#1676")
void stopAndStartMeterRegistrySendsMetrics(StatsdProtocol protocol) throws InterruptedException {
    serverLatch = new CountDownLatch(3);
    server = startServer(protocol, 0);

    final int port = server.address().getPort();

    meterRegistry = new StatsdMeterRegistry(getUnbufferedConfig(protocol, port), Clock.SYSTEM);
    startRegistryAndWaitForClient();
    Counter counter = Counter.builder("my.counter").register(meterRegistry);
    counter.increment();
    await().until(() -> serverLatch.getCount() == 2);
    meterRegistry.stop();
    await().until(this::clientIsDisposed);
    // These increments shouldn't be sent
    IntStream.range(0, 3).forEach(i -> counter.increment());
    startRegistryAndWaitForClient();
    assertThat(serverLatch.getCount()).isEqualTo(2);
    counter.increment();
    counter.increment();
    assertThat(serverLatch.await(1, TimeUnit.SECONDS)).isTrue();
}
 

@Test
@Issue("#1676")
void stopAndStartMeterRegistryWithLineSink() throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(3);
    meterRegistry = StatsdMeterRegistry.builder(StatsdConfig.DEFAULT).lineSink(s -> latch.countDown()).build();
    Counter counter = Counter.builder("my.counter").register(meterRegistry);
    counter.increment();
    meterRegistry.stop();
    // These increments shouldn't be processed
    IntStream.range(0, 3).forEach(i -> counter.increment());
    meterRegistry.start();
    assertThat(latch.getCount()).isEqualTo(2);
    counter.increment();
    counter.increment();
    assertThat(latch.await(1, TimeUnit.SECONDS)).isTrue();
}
 

@Override
public Long publishSync(String channelName, BsonObject event) {
    Long evtNum = impl.publishSync(channelName,event);
    Counter ctr = syncCounters.computeIfAbsent( channelName, s -> createCounter(SYNC,channelName));
    ctr.increment();
    return evtNum;
}
 

@Test
public void givenCounter_whenIncrement_thenValueChanged() {
    SimpleMeterRegistry registry = new SimpleMeterRegistry();
    Counter counter = Counter
      .builder("objects.instance")
      .description("indicates instance count of the object")
      .tags("dev", "performance")
      .register(registry);

    counter.increment(2.0);
    assertTrue(counter.count() == 2);

    counter.increment(-1);
    assertTrue(counter.count() == 2);
}
 

@Override
public void merge(String streamSegmentName, long dataLength, int numOfEvents, long txnCreationTime) {
    Counter eventCounter = registry.counter(SEGMENT_WRITE_EVENTS, segmentTags(streamSegmentName));
    Counter byteCounter = registry.counter(SEGMENT_WRITE_BYTES, segmentTags(streamSegmentName));
    references.add(eventCounter);
    references.add(byteCounter);
    eventCounter.increment(numOfEvents);
    byteCounter.increment(dataLength);
}
 

@Override
public void recordAppend(String streamSegmentName, long dataLength, int numOfEvents, Duration elapsed) {
    if (!NameUtils.isTransactionSegment(streamSegmentName)) {
        Counter eventCounter = registry.counter(SEGMENT_WRITE_EVENTS, segmentTags(streamSegmentName));
        Counter byteCounter = registry.counter(SEGMENT_WRITE_BYTES, segmentTags(streamSegmentName));
        references.add(eventCounter);
        references.add(byteCounter);
        eventCounter.increment(numOfEvents);
        byteCounter.increment(dataLength);
    }
}
 

@Override
public void incrementErrorsCount(SocketAddress remoteAddress, String uri) {
	Counter errors = errorsCache.computeIfAbsent(new MeterKey(uri, null, null, null),
			key -> filter(errorsBuilder.tags(URI, uri)
			                           .register(REGISTRY)));
	if (errors != null) {
		errors.increment();
	}
}
 

@Override
public void incrementErrorsCount(SocketAddress remoteAddress, String uri) {
	String address = Metrics.formatSocketAddress(remoteAddress);
	Counter errors = errorsCache.computeIfAbsent(new MeterKey(uri, address, null, null),
			key -> filter(errorsBuilder.tags(REMOTE_ADDRESS, address, URI, uri)
			                           .register(REGISTRY)));
	if (errors != null) {
		errors.increment();
	}
}
 

@Override
public void incrementErrorsCount(SocketAddress remoteAddress) {
	String address = reactor.netty.Metrics.formatSocketAddress(remoteAddress);
	Counter c = errorsCache.computeIfAbsent(address,
			key -> filter(errorCountBuilder.tag(REMOTE_ADDRESS, address)
			                               .register(REGISTRY)));
	if (c != null) {
		c.increment();
	}
}
 

@Override
public CompletableFuture<Long> publishAsync(String channelName, BsonObject event) {
    CompletableFuture<Long> evtFut = impl.publishAsync(channelName,event);
    Counter ctr = asyncCounters.computeIfAbsent(channelName, s -> createCounter(ASYNC,channelName));
    ctr.increment();
    return evtFut;
}
 

private void updateCounter(Map<String, Counter> map, String queueName) {
  Counter counter = map.get(queueName);
  if (counter == null) {
    return;
  }
  counter.increment();
}
 

@ParameterizedTest
@EnumSource(StatsdProtocol.class)
void whenBackendInitiallyDown_metricsSentAfterBackendStarts(StatsdProtocol protocol) throws InterruptedException {
    AtomicInteger writeCount = new AtomicInteger();
    serverLatch = new CountDownLatch(3);
    // start server to secure an open port
    server = startServer(protocol, 0);
    final int port = server.address().getPort();
    server.disposeNow();
    meterRegistry = new StatsdMeterRegistry(getUnbufferedConfig(protocol, port), Clock.SYSTEM);
    meterRegistry.start();
    trackWritesForUdpClient(protocol, writeCount);
    Counter counter = Counter.builder("my.counter").register(meterRegistry);
    IntStream.range(1, 4).forEach(counter::increment);
    if (protocol == StatsdProtocol.UDP) {
        await().until(() -> writeCount.get() == 3);
    }
    server = startServer(protocol, port);
    if (protocol == StatsdProtocol.TCP) {
        // client is null until TcpClient first connects
        await().until(() -> meterRegistry.client.get() != null);
        // TcpClient may take some time to reconnect to the server
        await().until(() -> !clientIsDisposed());
    }
    assertThat(serverLatch.getCount()).isEqualTo(3);

    if (protocol == StatsdProtocol.UDP) {
        // Note that this guarantees this test to be passed.
        // For UDP, the first change seems to be lost frequently somehow.
        Counter.builder("another.counter").register(meterRegistry).increment();
    }

    counter.increment();
    counter.increment();
    counter.increment();
    assertThat(serverLatch.await(1, TimeUnit.SECONDS)).isTrue();
}
 

@Test
@DisplayName("increment by a non-negative amount")
default void incrementAmount(MeterRegistry registry) {
    Counter c = registry.counter("myCounter");
    c.increment(2);
    c.increment(0);
    clock(registry).add(step());

    assertEquals(2L, c.count());
}
 

@DisplayName("multiple increments are maintained")
@Test
default void increment(MeterRegistry registry) {
    Counter c = registry.counter("myCounter");
    c.increment();
    clock(registry).add(step());
    assertThat(c.count()).isEqualTo(1.0, offset(1e-12));
    c.increment();
    c.increment();
    clock(registry).add(step());

    // in the case of a step aggregating system will be 2, otherwise 3
    assertThat(c.count()).isGreaterThanOrEqualTo(2.0);
}
 

@ParameterizedTest
@EnumSource(StatsdProtocol.class)
void resumeSendingMetrics_whenServerIntermittentlyFails(StatsdProtocol protocol) throws InterruptedException {
    serverLatch = new CountDownLatch(1);
    AtomicInteger writeCount = new AtomicInteger();
    server = startServer(protocol, 0);

    final int port = server.address().getPort();

    meterRegistry = new StatsdMeterRegistry(getUnbufferedConfig(protocol, port), Clock.SYSTEM);
    startRegistryAndWaitForClient();
    trackWritesForUdpClient(protocol, writeCount);
    Counter counter = Counter.builder("my.counter").register(meterRegistry);
    counter.increment(1);
    assertThat(serverLatch.await(5, TimeUnit.SECONDS)).isTrue();

    Disposable firstClient = meterRegistry.client.get();

    server.disposeNow();
    serverLatch = new CountDownLatch(3);
    // client will try to send but server is down
    IntStream.range(2, 5).forEach(counter::increment);
    if (protocol == StatsdProtocol.UDP) {
        await().until(() -> writeCount.get() == 4);
    }
    server = startServer(protocol, port);
    assertThat(serverLatch.getCount()).isEqualTo(3);

    await().until(() -> bound);

    // Note that this guarantees this test to be passed.
    // For TCP, this will help trigger replacing client. If this triggered replacing, this change will be lost.
    // For UDP, the first change seems to be lost frequently somehow.
    Counter.builder("another.counter").register(meterRegistry).increment();

    if (protocol == StatsdProtocol.TCP) {
        await().until(() -> meterRegistry.client.get() != firstClient);
    }

    counter.increment(5);
    counter.increment(6);
    counter.increment(7);
    assertThat(serverLatch.await(3, TimeUnit.SECONDS)).isTrue();
}
 

protected void incrementMetricCounter(String metric, String... tags) {
    Counter counter = Metrics.counter(metric, tags);
    counter.increment();
}
 

public static void main(String[] args) throws InterruptedException {
    MeterRegistry registry = new JmxMeterRegistry(new JmxConfig() {
        @Override
        public Duration step() {
            return Duration.ofSeconds(1);
        }

        @Override
        public String get(String s) {
            return null;
        }
    }, Clock.SYSTEM);

    Counter counter = Counter
            .builder("my.counter")
            .description("counts something important")
            .tag("environment", "test")
            .tag("region", "us-east")
            .register(registry);

    counter.increment();
    counter.increment(2.5);

    Timer timer = Timer.builder("my.timer").register(registry);

    timer.record(() -> {
        System.out.println("sleeping");
        try {
            Thread.sleep(550);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    timer.record(Duration.ofMillis(3));

    // Wait some time before application exit
    // This gives some time to use JConsole to connect to the
    // application and inspect the metrics
    System.out.println("Keeping application alive");
    Thread.sleep(240000);
    System.out.println("done");
}