io.micrometer.core.instrument.simple.SimpleConfig Java Examples

@Test
void histogramsInStepMode() {
    MockClock clock = new MockClock();
    MeterRegistry registry = new SimpleMeterRegistry(new SimpleConfig() {
        @Override
        public String get(String key) {
            return null;
        }

        @Override
        public CountingMode mode() {
            return CountingMode.STEP;
        }
    }, clock);

    DistributionSummary summary = DistributionSummary.builder("my.summary")
            .serviceLevelObjectives(1.0)
            .register(registry);

    summary.record(1);

    assertThat(summary.takeSnapshot().histogramCounts()).containsExactly(new CountAtBucket(1.0, 1));
    clock.add(SimpleConfig.DEFAULT.step());
    assertThat(summary.takeSnapshot().histogramCounts()).containsExactly(new CountAtBucket(1.0, 0));
}
 

@Test
void uptimeMetricsMock() {
    MeterRegistry registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());
    RuntimeMXBean runtimeMXBean = mock(RuntimeMXBean.class);
    when(runtimeMXBean.getUptime()).thenReturn(1337L);
    when(runtimeMXBean.getStartTime()).thenReturn(4711L);
    new UptimeMetrics(runtimeMXBean, emptyList()).bindTo(registry);

    assertThat(registry.get("process.uptime").timeGauge().value()).isEqualTo(1.337);
    assertThat(registry.get("process.start.time").timeGauge().value()).isEqualTo(4.711);
}
 

@Test
public void queuePollTracksOnNext() {
	//prepare registry with mock clock
	MockClock clock = new MockClock();
	removeRegistry();
	registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock);
	Metrics.globalRegistry.add(registry);

	AssertSubscriber<Integer> testSubscriber = AssertSubscriber.create();
	FluxMetricsFuseable.MetricsFuseableSubscriber<Integer> fuseableSubscriber =
			new FluxMetricsFuseable.MetricsFuseableSubscriber<>(testSubscriber,
					registry, clock, "foo", Tags.empty());

	Fuseable.QueueSubscription<Integer> testQueue = new FluxPeekFuseableTest.AssertQueueSubscription<>();
	testQueue.offer(1);

	fuseableSubscriber.onSubscribe(testQueue);
	clock.add(Duration.ofMillis(200));

	Integer val1 = fuseableSubscriber.poll();
	Integer val2 = fuseableSubscriber.poll();

	assertThat(val1).isEqualTo(1);
	assertThat(val2).isNull();

	//test meters
	Timer nextTimer = registry.find(METER_ON_NEXT_DELAY)
			.timer();

	assertThat(nextTimer).isNotNull();
	assertThat(nextTimer.max(TimeUnit.MILLISECONDS)).as("onNext max delay").isEqualTo(200);
}
 

@Test
public void queuePollSyncTracksOnComplete() {
	//prepare registry with mock clock
	MockClock clock = new MockClock();
	removeRegistry();
	registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock);
	Metrics.globalRegistry.add(registry);

	AssertSubscriber<Integer> testSubscriber = AssertSubscriber.create();
	FluxMetricsFuseable.MetricsFuseableSubscriber<Integer> fuseableSubscriber =
			new FluxMetricsFuseable.MetricsFuseableSubscriber<>(testSubscriber,
					registry, clock, "foo", Tags.empty());

	Fuseable.QueueSubscription<Integer> testQueue = new FluxPeekFuseableTest.AssertQueueSubscription<>();
	testQueue.offer(1);

	fuseableSubscriber.onSubscribe(testQueue);
	fuseableSubscriber.requestFusion(Fuseable.SYNC);

	clock.add(Duration.ofMillis(200));
	Integer val1 = fuseableSubscriber.poll();
	clock.add(Duration.ofMillis(123));
	Integer val2 = fuseableSubscriber.poll();

	assertThat(val1).isEqualTo(1);
	assertThat(val2).isNull();

	//test meters
	Timer terminationTimer = registry.find(METER_FLOW_DURATION)
	                          .tags(Tags.of(TAG_ON_COMPLETE))
	                          .timer();

	assertThat(terminationTimer).isNotNull();
	assertThat(terminationTimer.max(TimeUnit.MILLISECONDS)).as("terminate max delay").isEqualTo(323);
}
 

@Test
public void queuePollError() {
	//prepare registry with mock clock
	MockClock clock = new MockClock();
	removeRegistry();
	registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock);
	Metrics.globalRegistry.add(registry);

	AssertSubscriber<Integer> testSubscriber = AssertSubscriber.create();
	FluxMetricsFuseable.MetricsFuseableSubscriber<Integer> fuseableSubscriber =
			new FluxMetricsFuseable.MetricsFuseableSubscriber<>(testSubscriber,
					registry, clock, "foo", Tags.empty());

	FluxPeekFuseableTest.AssertQueueSubscription<Integer> testQueue = new FluxPeekFuseableTest.AssertQueueSubscription<>();
	testQueue.setCompleteWithError(true);
	testQueue.offer(1);

	fuseableSubscriber.onSubscribe(testQueue);
	fuseableSubscriber.requestFusion(Fuseable.SYNC);

	clock.add(Duration.ofMillis(200));
	Integer val1 = fuseableSubscriber.poll();
	assertThat(val1).isEqualTo(1);

	clock.add(Duration.ofMillis(123));
	assertThatIllegalStateException().isThrownBy(fuseableSubscriber::poll)
	                                 .withMessage("AssertQueueSubscriber poll error");

	//test meters
	Timer terminationTimer = registry.find(METER_FLOW_DURATION)
	                          .tags(Tags.of(TAG_ON_ERROR))
	                          .timer();

	assertThat(terminationTimer).isNotNull();
	assertThat(terminationTimer.max(TimeUnit.MILLISECONDS)).as("terminate max delay").isEqualTo(323);
}
 

@Test
public void queuePollDoesntTrackOnNext() {
	//prepare registry with mock clock
	MockClock clock = new MockClock();
	removeRegistry();
	registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock);
	Metrics.globalRegistry.add(registry);

	AssertSubscriber<Integer> testSubscriber = AssertSubscriber.create();
	MetricsFuseableSubscriber<Integer> fuseableSubscriber =
			new MetricsFuseableSubscriber<>(testSubscriber,
					registry, clock, Tags.empty());

	Fuseable.QueueSubscription<Integer> testQueue = new FluxPeekFuseableTest.AssertQueueSubscription<>();
	testQueue.offer(1);

	fuseableSubscriber.onSubscribe(testQueue);
	clock.add(Duration.ofMillis(200));

	Integer val1 = fuseableSubscriber.poll();
	Integer val2 = fuseableSubscriber.poll();

	assertThat(val1).isEqualTo(1);
	assertThat(val2).isNull();

	//test meters
	Timer nextTimer = registry.find(METER_ON_NEXT_DELAY)
			.timer();

	assertThat(nextTimer).as("no onNext delay meter for Mono").isNull();
}
 

@Test
public void queuePollSyncTracksOnComplete() {
	//prepare registry with mock clock
	MockClock clock = new MockClock();
	removeRegistry();
	registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock);
	Metrics.globalRegistry.add(registry);

	AssertSubscriber<Integer> testSubscriber = AssertSubscriber.create();
	MetricsFuseableSubscriber<Integer> fuseableSubscriber =
			new MetricsFuseableSubscriber<>(testSubscriber,
					registry, clock, Tags.empty());

	Fuseable.QueueSubscription<Integer> testQueue = new FluxPeekFuseableTest.AssertQueueSubscription<>();
	testQueue.offer(1);

	fuseableSubscriber.onSubscribe(testQueue);
	fuseableSubscriber.requestFusion(Fuseable.SYNC);

	clock.add(Duration.ofMillis(200));
	Integer val1 = fuseableSubscriber.poll();
	clock.add(Duration.ofMillis(123));
	Integer val2 = fuseableSubscriber.poll();

	assertThat(val1).isEqualTo(1);
	assertThat(val2).isNull();

	//test meters
	Timer terminationTimer = registry.find(METER_FLOW_DURATION)
	                          .tags(Tags.of(TAG_ON_COMPLETE))
	                          .timer();

	assertThat(terminationTimer).isNotNull();
	assertThat(terminationTimer.max(TimeUnit.MILLISECONDS)).as("terminate max delay").isEqualTo(200);
}
 

@Test
public void queuePollError() {
	//prepare registry with mock clock
	MockClock clock = new MockClock();
	removeRegistry();
	registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock);
	Metrics.globalRegistry.add(registry);

	AssertSubscriber<Integer> testSubscriber = AssertSubscriber.create();
	MetricsFuseableSubscriber<Integer> fuseableSubscriber =
			new MetricsFuseableSubscriber<>(testSubscriber,
					registry, clock, Tags.empty());

	FluxPeekFuseableTest.AssertQueueSubscription<Integer> testQueue = new FluxPeekFuseableTest.AssertQueueSubscription<>();
	testQueue.setCompleteWithError(true);
	testQueue.offer(1);

	fuseableSubscriber.onSubscribe(testQueue);
	fuseableSubscriber.requestFusion(Fuseable.SYNC);

	clock.add(Duration.ofMillis(200));
	Integer val1 = fuseableSubscriber.poll();
	assertThat(val1).isEqualTo(1);

	clock.add(Duration.ofMillis(123));
	assertThatIllegalStateException().isThrownBy(fuseableSubscriber::poll)
	                                 .withMessage("AssertQueueSubscriber poll error");

	//test meters
	Timer terminationTimer = registry.find(METER_FLOW_DURATION)
	                          .tags(Tags.of(TAG_ON_ERROR))
	                          .timer();

	assertThat(terminationTimer).isNotNull();
	assertThat(terminationTimer.max(TimeUnit.MILLISECONDS)).as("terminate max delay").isEqualTo(323);
}
 

@Test
@DisplayName("supports sending histograms of active task duration")
void histogram() {
    MeterRegistry registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());

    LongTaskTimer t = LongTaskTimer.builder("my.timer")
            .serviceLevelObjectives(Duration.ofSeconds(10), Duration.ofSeconds(40), Duration.ofMinutes(1))
            .register(registry);

    List<Integer> samples = Arrays.asList(48, 42, 40, 35, 22, 16, 13, 8, 6, 4, 2);
    int prior = samples.get(0);
    for (Integer value : samples) {
        clock(registry).add(prior - value, TimeUnit.SECONDS);
        t.start();
        prior = value;
    }
    clock(registry).add(samples.get(samples.size() - 1), TimeUnit.SECONDS);

    CountAtBucket[] countAtBuckets = t.takeSnapshot().histogramCounts();

    assertThat(countAtBuckets[0].bucket(TimeUnit.SECONDS)).isEqualTo(10);
    assertThat(countAtBuckets[0].count()).isEqualTo(4);

    assertThat(countAtBuckets[1].bucket(TimeUnit.SECONDS)).isEqualTo(40);
    assertThat(countAtBuckets[1].count()).isEqualTo(9);

    assertThat(countAtBuckets[2].bucket(TimeUnit.MINUTES)).isEqualTo(1);
    assertThat(countAtBuckets[2].count()).isEqualTo(11);
}
 

@Test
@Issue("#119")
void increment() {
    SimpleMeterRegistry simple = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());
    CompositeMeterRegistry registry = new CompositeMeterRegistry();
    registry.add(simple);

    registry.counter("counter").increment(2.0);

    assertThat(simple.get("counter").counter().count()).isEqualTo(2.0);
}
 

@Test
void histogramConfigDefaultIsNotAffectedByComposite() {
    composite.add(simple);

    // the expiry on this timer is determined by the simple registry's default histogram config
    Timer t = Timer.builder("my.timer")
            .distributionStatisticBufferLength(1)
            .register(composite);

    t.record(1, TimeUnit.SECONDS);
    assertThat(t.max(TimeUnit.SECONDS)).isEqualTo(1.0);

    clock.add(SimpleConfig.DEFAULT.step());
    assertThat(t.max(TimeUnit.SECONDS)).isEqualTo(0.0);
}
 

@Test
void metricCanBeCreatedBeforeStaticRegistryIsConfigured() {
    // doesn't blow up
    Counter counter = Metrics.counter("counter");
    counter.increment();

    SimpleMeterRegistry simple = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());
    Metrics.addRegistry(simple);
    counter.increment();

    assertThat(Metrics.globalRegistry.get("counter").counter().count()).isEqualTo(1.0);
}
 

@Test
void uptimeMetricsRuntime() {
    MeterRegistry registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());
    new UptimeMetrics().bindTo(registry);

    registry.get("process.uptime").timeGauge();
    registry.get("process.start.time").timeGauge();
}
 

@BeforeEach
void setup() {
    MockitoAnnotations.initMocks(this);
    when(engine.getSession()).thenReturn(session);

    registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());

    Iterable<Tag> tags = Tags.of("id", "0");
    sslHandshakeMetrics = new JettySslHandshakeMetrics(registry, tags);
}
 

@BeforeEach
void setup() {
    this.registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());
    this.timedHandler = new TimedHandler(registry, Tags.empty());

    this.server = new Server();
    this.connector = new LocalConnector(server);
    server.addConnector(connector);

    latchHandler = new LatchHandler();

    server.setHandler(latchHandler);
    latchHandler.setHandler(timedHandler);
}
 

@BeforeEach
void setup() throws Exception {
    registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());

    Iterable<Tag> tags = Collections.singletonList(Tag.of("id", "0"));
    QueuedThreadPool threadPool = new InstrumentedQueuedThreadPool(registry, tags);
    threadPool.setMinThreads(32);
    threadPool.setMaxThreads(100);
    server = new Server(threadPool);
    ServerConnector connector = new ServerConnector(server);
    server.setConnectors(new Connector[] { connector });
    server.start();
}
 

@Test
void histogramsInCumulativeMode() {
    MockClock clock = new MockClock();
    MeterRegistry registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock);
    DistributionSummary summary = DistributionSummary.builder("my.summary")
            .serviceLevelObjectives(1.0)
            .register(registry);

    summary.record(1);

    // Histogram bucket counts DO roll over at the step interval, so decay.
    assertThat(summary.takeSnapshot().histogramCounts()).containsExactly(new CountAtBucket(1.0, 1));
    clock.add(SimpleConfig.DEFAULT.step());
    assertThat(summary.takeSnapshot().histogramCounts()).containsExactly(new CountAtBucket(1.0, 0));
}
 

@Test
public void addMetricsCapability() {
  SimpleMeterRegistry registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());

  final SimpleSource source = Feign.builder()
      .client(new MockClient()
          .ok(HttpMethod.GET, "/get", "1234567890abcde"))
      .addCapability(new MicrometerCapability(registry))
      .target(new MockTarget<>(MicrometerCapabilityTest.SimpleSource.class));

  source.get("0x3456789");

  List<Meter> metrics = new ArrayList<>();
  registry.forEachMeter(metrics::add);
  metrics.removeIf(meter -> !meter.getId().getName().startsWith("feign."));

  metrics.forEach(meter -> assertThat(
      "Expect all metric names to include client name:" + meter.getId(),
      meter.getId().getTag("client"),
      equalTo("feign.micrometer.MicrometerCapabilityTest$SimpleSource")));
  metrics.forEach(meter -> assertThat(
      "Expect all metric names to include method name:" + meter.getId(),
      meter.getId().getTag("method"),
      equalTo("get")));
  metrics.forEach(meter -> assertThat(
      "Expect all metric names to include host name:" + meter.getId(),
      meter.getId().getTag("host"),
      // hostname is blank due to feign-mock shortfalls
      equalTo("")));
}
 

@Override
public MeterRegistry registry() {
    return new CompositeMeterRegistry(new MockClock()) {{
        add(new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock));
    }};
}
 

@Bean
@ConditionalOnMissingBean
public SimpleMeterRegistry simpleMeterRegistry(SimpleConfig config, Clock clock) {
	return new SimpleMeterRegistry(config, clock);
}
 

@Bean
@ConditionalOnMissingBean
public SimpleConfig simpleConfig() {
	return key -> null;
}
 

@BeforeEach
public void before() {
  clock = new MockClock();
  meterRegistry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock);
  registry = new MicrometerRegistry(meterRegistry);
}
 

@BeforeEach
void beforeMethod() {
  meterRegistry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock);
  timedAspect = new MolgenisTimedAspect(meterRegistry);
}
 

public MicrometerCapability() {
  this(new SimpleMeterRegistry(SimpleConfig.DEFAULT, Clock.SYSTEM));
  Metrics.addRegistry(meterRegistry);
}
 

@BeforeMethod
public void setup() {
  registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());
}
 

@BeforeMethod
public void setup() {
  registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());
}
 

@BeforeMethod
public void setup() {
  registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());
}
 

@BeforeMethod
public void setup() {
  registry = new SimpleMeterRegistry(SimpleConfig.DEFAULT, new MockClock());
  executorServiceWrapper = new MeteredExecutorServiceWrapper(registry);
}
 

@Override
public Duration step() {
    return SimpleConfig.DEFAULT.step();
}
 

@Override
public Duration step() {
    return get(SimpleProperties::getStep, SimpleConfig.super::step);
}