Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
DropwizardFunctionTimer extends AbstractMeter implements FunctionTimer { @Override public double totalTime(TimeUnit unit) { T obj2 = ref.get(); if (obj2 != null) { lastTime = TimeUtils.convert(totalTimeFunction.applyAsDouble(obj2), totalTimeFunctionUnit, baseTimeUnit()); } return TimeUtils.convert(lastTime, baseTimeUnit(), unit); } DropwizardFunctionTimer(Meter.Id id, Clock clock, T obj, ToLongFunction<T> countFunction, ToDoubleFunction<T> totalTimeFunction, TimeUnit totalTimeFunctionUnit, TimeUnit registryBaseTimeUnit); Timer getDropwizardMeter(); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }
@Test void totalTimeWhenStateObjectChangedToNullShouldWorkWithChangedTimeUnit() { DropwizardFunctionTimer<Object> functionTimer = new DropwizardFunctionTimer<>( null, new MockClock(), new Object(), (o) -> 1L, (o) -> 1d, TimeUnit.SECONDS, TimeUnit.SECONDS); assertThat(functionTimer.totalTime(TimeUnit.SECONDS)).isEqualTo(1d); assertThat(functionTimer.totalTime(TimeUnit.MILLISECONDS)).isEqualTo(1000d); System.gc(); assertThat(functionTimer.totalTime(TimeUnit.MILLISECONDS)).isEqualTo(1000d); assertThat(functionTimer.totalTime(TimeUnit.SECONDS)).isEqualTo(1d); }
DropwizardFunctionTimer extends AbstractMeter implements FunctionTimer { public Timer getDropwizardMeter() { return dropwizardMeter; } DropwizardFunctionTimer(Meter.Id id, Clock clock, T obj, ToLongFunction<T> countFunction, ToDoubleFunction<T> totalTimeFunction, TimeUnit totalTimeFunctionUnit, TimeUnit registryBaseTimeUnit); Timer getDropwizardMeter(); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }
@Test void getDropwizardMeterGetSnapshotGetMeanShouldReturnNanoseconds() { DropwizardFunctionTimer<Object> functionTimer = new DropwizardFunctionTimer<>( null, new MockClock(), new Object(), (o) -> 1L, (o) -> 1d, TimeUnit.SECONDS, TimeUnit.SECONDS); assertThat(functionTimer.getDropwizardMeter().getSnapshot().getMean()).isEqualTo(1000_000_000d); }
DropwizardMeterRegistry extends MeterRegistry { public MetricRegistry getDropwizardRegistry() { return registry; } DropwizardMeterRegistry(DropwizardConfig config, MetricRegistry registry, HierarchicalNameMapper nameMapper, Clock clock); MetricRegistry getDropwizardRegistry(); }
@Issue("#1038") @Test void removeShouldWork() { Counter counter = registry.counter("test"); assertThat(registry.getDropwizardRegistry().getMeters()).hasSize(1); registry.remove(counter); assertThat(registry.getDropwizardRegistry().getMeters()).isEmpty(); }
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeCounter(Counter counter) { return writeCounter(counter, counter.count()); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Test void writeCounter() { Counter counter = Counter.builder("myCounter").register(registry); counter.increment(); clock.add(config.step()); assertThat(registry.writeCounter(counter)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:01:00.001Z\",\"name\":\"myCounter\",\"type\":\"counter\",\"count\":1.0}"); }
Metrics { public static Counter counter(String name, Iterable<Tag> tags) { return globalRegistry.counter(name, tags); } static void addRegistry(MeterRegistry registry); static void removeRegistry(MeterRegistry registry); static Counter counter(String name, Iterable<Tag> tags); static Counter counter(String name, String... tags); static DistributionSummary summary(String name, Iterable<Tag> tags); static DistributionSummary summary(String name, String... tags); static Timer timer(String name, Iterable<Tag> tags); static Timer timer(String name, String... tags); static More more(); @Nullable static T gauge(String name, Iterable<Tag> tags, T obj, ToDoubleFunction<T> valueFunction); @Nullable static T gauge(String name, Iterable<Tag> tags, T number); @Nullable static T gauge(String name, T number); @Nullable static T gauge(String name, T obj, ToDoubleFunction<T> valueFunction); @Nullable static T gaugeCollectionSize(String name, Iterable<Tag> tags, T collection); @Nullable static T gaugeMapSize(String name, Iterable<Tag> tags, T map); static final CompositeMeterRegistry globalRegistry; }
@Test void staticMetricsAreInitiallyNoop() { Metrics.counter("counter").increment(); }
LoggingMeterRegistry extends StepMeterRegistry { private Function<Meter, String> defaultMeterIdPrinter() { return (meter) -> getConventionName(meter.getId()) + getConventionTags(meter.getId()).stream() .map(t -> t.getKey() + "=" + t.getValue()) .collect(joining(",", "{", "}")); } LoggingMeterRegistry(); LoggingMeterRegistry(LoggingRegistryConfig config, Clock clock); private LoggingMeterRegistry(LoggingRegistryConfig config, Clock clock, ThreadFactory threadFactory, Consumer<String> loggingSink, @Nullable Function<Meter, String> meterIdPrinter); static Builder builder(LoggingRegistryConfig config); }
@Test void defaultMeterIdPrinter() { LoggingMeterRegistry registry = LoggingMeterRegistry.builder(LoggingRegistryConfig.DEFAULT) .build(); Counter counter = registry.counter("my.gauage", "tag-1", "tag-2"); LoggingMeterRegistry.Printer printer = registry.new Printer(counter); assertThat(printer.id()).isEqualTo("my.gauage{tag-1=tag-2}"); }
LoggingMeterRegistry extends StepMeterRegistry { public static Builder builder(LoggingRegistryConfig config) { return new Builder(config); } LoggingMeterRegistry(); LoggingMeterRegistry(LoggingRegistryConfig config, Clock clock); private LoggingMeterRegistry(LoggingRegistryConfig config, Clock clock, ThreadFactory threadFactory, Consumer<String> loggingSink, @Nullable Function<Meter, String> meterIdPrinter); static Builder builder(LoggingRegistryConfig config); }
@Test void customMeterIdPrinter() { LoggingMeterRegistry registry = LoggingMeterRegistry.builder(LoggingRegistryConfig.DEFAULT) .meterIdPrinter(meter -> meter.getId().getName()) .build(); Counter counter = registry.counter("my.gauage", "tag-1", "tag-2"); LoggingMeterRegistry.Printer printer = registry.new Printer(counter); assertThat(printer.id()).isEqualTo("my.gauage"); } @Test void humanReadableByteCount() { LoggingMeterRegistry.Printer printer = registry.new Printer(DistributionSummary.builder("my.summary") .baseUnit(BaseUnits.BYTES) .register(registry)); assertThat(printer.humanReadableBaseUnit(Double.NaN)).isEqualTo("NaN B"); assertThat(printer.humanReadableBaseUnit(1.0)).isEqualTo("1 B"); assertThat(printer.humanReadableBaseUnit(1024)).isEqualTo("1 KiB"); assertThat(printer.humanReadableBaseUnit(1024 * 1024 * 2.5678976654)).isEqualTo("2.567898 MiB"); } @Test void otherUnit() { LoggingMeterRegistry.Printer printer = registry.new Printer(DistributionSummary.builder("my.summary") .baseUnit("things") .register(registry)); assertThat(printer.humanReadableBaseUnit(1.0)).isEqualTo("1 things"); assertThat(printer.humanReadableBaseUnit(1024)).isEqualTo("1024 things"); }
NoopGauge extends NoopMeter implements Gauge { @Override public double value() { return 0; } NoopGauge(Id id); @Override double value(); }
@Test void returnsValueAsZero() { assertThat(gauge.value()).isEqualTo(0d); }
NoopLongTaskTimer extends NoopMeter implements LongTaskTimer { @Override public Sample start() { return new NoopSample(); } NoopLongTaskTimer(Id id); @Override Sample start(); @Override double duration(TimeUnit unit); @Override int activeTasks(); @Override double max(TimeUnit unit); @Override HistogramSnapshot takeSnapshot(); @Override TimeUnit baseTimeUnit(); }
@Test void returnsStart() { assertThat(timer.start()).isNotNull(); }
NoopLongTaskTimer extends NoopMeter implements LongTaskTimer { @Override public double duration(TimeUnit unit) { return 0; } NoopLongTaskTimer(Id id); @Override Sample start(); @Override double duration(TimeUnit unit); @Override int activeTasks(); @Override double max(TimeUnit unit); @Override HistogramSnapshot takeSnapshot(); @Override TimeUnit baseTimeUnit(); }
@Test void returnsDuration() { assertThat(timer.duration(TimeUnit.MINUTES)).isEqualTo(0); }
NoopLongTaskTimer extends NoopMeter implements LongTaskTimer { @Override public int activeTasks() { return 0; } NoopLongTaskTimer(Id id); @Override Sample start(); @Override double duration(TimeUnit unit); @Override int activeTasks(); @Override double max(TimeUnit unit); @Override HistogramSnapshot takeSnapshot(); @Override TimeUnit baseTimeUnit(); }
@Test void returnsActiveTasks() { assertThat(timer.activeTasks()).isEqualTo(0); }
NoopFunctionTimer extends NoopMeter implements FunctionTimer { @Override public double count() { return 0; } NoopFunctionTimer(Id id); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }
@Test void returnsCountAsZero() { assertThat(timer.count()).isEqualTo(0d); }
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeFunctionCounter(FunctionCounter counter) { return writeCounter(counter, counter.count()); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Test void writeFunctionCounter() { FunctionCounter counter = FunctionCounter.builder("myCounter", 123.0, Number::doubleValue).register(registry); clock.add(config.step()); assertThat(registry.writeFunctionCounter(counter)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:01:00.001Z\",\"name\":\"myCounter\",\"type\":\"counter\",\"count\":123.0}"); }
SignalFxMeterRegistry extends StepMeterRegistry { Stream<SignalFxProtocolBuffers.DataPoint.Builder> addLongTaskTimer(LongTaskTimer longTaskTimer) { return Stream.of( addDatapoint(longTaskTimer, GAUGE, "activeTasks", longTaskTimer.activeTasks()), addDatapoint(longTaskTimer, COUNTER, "duration", longTaskTimer.duration(getBaseTimeUnit())) ); } SignalFxMeterRegistry(SignalFxConfig config, Clock clock); SignalFxMeterRegistry(SignalFxConfig config, Clock clock, ThreadFactory threadFactory); }
@Test void addLongTaskTimer() { LongTaskTimer longTaskTimer = LongTaskTimer.builder("my.long.task.timer").register(this.registry); assertThat(this.registry.addLongTaskTimer(longTaskTimer)).hasSize(2); }
NoopFunctionTimer extends NoopMeter implements FunctionTimer { @Override public double totalTime(TimeUnit unit) { return 0; } NoopFunctionTimer(Id id); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }
@Test void returnsTotalTimeAsZero() { assertThat(timer.totalTime(TimeUnit.NANOSECONDS)).isEqualTo(0d); }
NoopFunctionTimer extends NoopMeter implements FunctionTimer { @Override public TimeUnit baseTimeUnit() { return TimeUnit.NANOSECONDS; } NoopFunctionTimer(Id id); @Override double count(); @Override double totalTime(TimeUnit unit); @Override TimeUnit baseTimeUnit(); }
@Test void returnsNanosAsTimeUnit() { assertThat(timer.baseTimeUnit()).isEqualTo(TimeUnit.NANOSECONDS); }
NoopTimer extends NoopMeter implements Timer { @Override public void record(long amount, TimeUnit unit) { } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }
@Test void recordSupplier() { String expectedResult = "value"; Supplier<String> supplier = () -> expectedResult; assertThat(timer.record(supplier)).isEqualTo(expectedResult); } @Test void recordRunnable() { Runnable runnable = mock(Runnable.class); timer.record(runnable); verify(runnable).run(); }
NoopTimer extends NoopMeter implements Timer { @Override public <T> T recordCallable(Callable<T> f) throws Exception { return f.call(); } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }
@Test void recordCallable() throws Exception { String expectedResult = "value"; Callable<String> callable = () -> expectedResult; assertThat(timer.recordCallable(callable)).isEqualTo(expectedResult); }
NoopTimer extends NoopMeter implements Timer { @Override public long count() { return 0; } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }
@Test void returnsCountAsZero() { assertThat(timer.count()).isEqualTo(0L); }
NoopTimer extends NoopMeter implements Timer { @Override public double totalTime(TimeUnit unit) { return 0; } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }
@Test void returnsTotalTimeAsZero() { assertThat(timer.totalTime(TimeUnit.SECONDS)).isEqualTo(0L); }
NoopTimer extends NoopMeter implements Timer { @Override public double max(TimeUnit unit) { return 0; } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }
@Test void returnsMaxAsZero() { assertThat(timer.max(TimeUnit.SECONDS)).isEqualTo(0L); }
NoopTimer extends NoopMeter implements Timer { @Override public TimeUnit baseTimeUnit() { return TimeUnit.SECONDS; } NoopTimer(Id id); @Override void record(long amount, TimeUnit unit); @Override T record(Supplier<T> f); @Override T recordCallable(Callable<T> f); @Override void record(Runnable f); @Override long count(); @Override double totalTime(TimeUnit unit); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }
@Test void returnsBaseTimeUnit() { assertThat(timer.baseTimeUnit()).isEqualTo(TimeUnit.SECONDS); }
NoopDistributionSummary extends NoopMeter implements DistributionSummary { @Override public long count() { return 0; } NoopDistributionSummary(Id id); @Override void record(double amount); @Override long count(); @Override double totalAmount(); @Override double max(); @Override HistogramSnapshot takeSnapshot(); }
@Test void returnsCountAsZero() { assertThat(distributionSummary.count()).isEqualTo(0L); }
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeGauge(Gauge gauge) { double value = gauge.value(); if (Double.isFinite(value)) { return Optional.of(writeDocument(gauge, builder -> { builder.append(",\"value\":").append(value); })); } return Optional.empty(); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Test void writeGauge() { Gauge gauge = Gauge.builder("myGauge", 123.0, Number::doubleValue).register(registry); assertThat(registry.writeGauge(gauge)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"myGauge\",\"type\":\"gauge\",\"value\":123.0}"); }
NoopDistributionSummary extends NoopMeter implements DistributionSummary { @Override public double totalAmount() { return 0; } NoopDistributionSummary(Id id); @Override void record(double amount); @Override long count(); @Override double totalAmount(); @Override double max(); @Override HistogramSnapshot takeSnapshot(); }
@Test void returnsTotalAmountAsZero() { assertThat(distributionSummary.totalAmount()).isEqualTo(0L); }
NoopDistributionSummary extends NoopMeter implements DistributionSummary { @Override public double max() { return 0; } NoopDistributionSummary(Id id); @Override void record(double amount); @Override long count(); @Override double totalAmount(); @Override double max(); @Override HistogramSnapshot takeSnapshot(); }
@Test void returnsMaxAsZero() { assertThat(distributionSummary.max()).isEqualTo(0L); }
NoopCounter extends NoopMeter implements Counter { @Override public double count() { return 0; } NoopCounter(Id id); @Override void increment(double amount); @Override double count(); }
@Test void returnsCountAsZero() { assertThat(counter.count()).isEqualTo(0L); }
NoopMeter extends AbstractMeter { @Override public List<Measurement> measure() { return emptyList(); } NoopMeter(Id id); @Override List<Measurement> measure(); }
@Test void returnsMeasureAsEmptyList() { assertThat(meter.measure()).isEqualTo(Collections.emptyList()); }
NoopFunctionCounter extends NoopMeter implements FunctionCounter { @Override public double count() { return 0; } NoopFunctionCounter(Id id); @Override double count(); }
@Test void returnsCountAsZero() { assertThat(counter.count()).isEqualTo(0L); }
NoopTimeGauge extends NoopMeter implements TimeGauge { @Override public double value() { return 0; } NoopTimeGauge(Id id); @Override TimeUnit baseTimeUnit(); @Override double value(); }
@Test void returnsValueAsZero() { assertThat(timeGauge.value()).isEqualTo(0d); }
NoopTimeGauge extends NoopMeter implements TimeGauge { @Override public TimeUnit baseTimeUnit() { return TimeUnit.NANOSECONDS; } NoopTimeGauge(Id id); @Override TimeUnit baseTimeUnit(); @Override double value(); }
@Test void returnsBaseTimeUnit() { assertThat(timeGauge.baseTimeUnit()).isEqualTo(TimeUnit.NANOSECONDS); }
Tags implements Iterable<Tag> { private void dedup() { int n = tags.length; if (n == 0 || n == 1) { last = n; return; } int j = 0; for (int i = 0; i < n - 1; i++) if (!tags[i].getKey().equals(tags[i + 1].getKey())) tags[j++] = tags[i]; tags[j++] = tags[n - 1]; last = j; } private Tags(Tag[] tags); Tags and(String key, String value); Tags and(@Nullable String... keyValues); Tags and(@Nullable Tag... tags); Tags and(@Nullable Iterable<? extends Tag> tags); @Override Iterator<Tag> iterator(); Stream<Tag> stream(); @Override int hashCode(); @Override boolean equals(@Nullable Object obj); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable Iterable<Tag> otherTags); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable String... keyValues); static Tags of(@Nullable Iterable<? extends Tag> tags); static Tags of(String key, String value); static Tags of(@Nullable String... keyValues); static Tags of(@Nullable Tag... tags); static Tags empty(); @Override String toString(); }
@Test void dedup() { assertThat(Tags.of("k1", "v1", "k2", "v2")).containsExactly(Tag.of("k1", "v1"), Tag.of("k2", "v2")); assertThat(Tags.of("k1", "v1", "k1", "v2")).containsExactly(Tag.of("k1", "v2")); assertThat(Tags.of("k1", "v1", "k1", "v2", "k3", "v3")).containsExactly(Tag.of("k1", "v2"), Tag.of("k3", "v3")); assertThat(Tags.of("k1", "v1", "k2", "v2", "k2", "v3")).containsExactly(Tag.of("k1", "v1"), Tag.of("k2", "v3")); }
Tags implements Iterable<Tag> { public Stream<Tag> stream() { return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator(), Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.NONNULL | Spliterator.SORTED), false); } private Tags(Tag[] tags); Tags and(String key, String value); Tags and(@Nullable String... keyValues); Tags and(@Nullable Tag... tags); Tags and(@Nullable Iterable<? extends Tag> tags); @Override Iterator<Tag> iterator(); Stream<Tag> stream(); @Override int hashCode(); @Override boolean equals(@Nullable Object obj); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable Iterable<Tag> otherTags); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable String... keyValues); static Tags of(@Nullable Iterable<? extends Tag> tags); static Tags of(String key, String value); static Tags of(@Nullable String... keyValues); static Tags of(@Nullable Tag... tags); static Tags empty(); @Override String toString(); }
@Test void stream() { Tags tags = Tags.of(Tag.of("k1", "v1"), Tag.of("k1", "v1"), Tag.of("k2", "v2")); assertThat(tags.stream()).hasSize(2); }
Tags implements Iterable<Tag> { public static Tags of(@Nullable Iterable<? extends Tag> tags) { if (tags == null || !tags.iterator().hasNext()) { return Tags.empty(); } else if (tags instanceof Tags) { return (Tags) tags; } else if (tags instanceof Collection) { Collection<? extends Tag> tagsCollection = (Collection<? extends Tag>) tags; return new Tags(tagsCollection.toArray(new Tag[0])); } else { return new Tags(StreamSupport.stream(tags.spliterator(), false).toArray(Tag[]::new)); } } private Tags(Tag[] tags); Tags and(String key, String value); Tags and(@Nullable String... keyValues); Tags and(@Nullable Tag... tags); Tags and(@Nullable Iterable<? extends Tag> tags); @Override Iterator<Tag> iterator(); Stream<Tag> stream(); @Override int hashCode(); @Override boolean equals(@Nullable Object obj); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable Iterable<Tag> otherTags); static Tags concat(@Nullable Iterable<? extends Tag> tags, @Nullable String... keyValues); static Tags of(@Nullable Iterable<? extends Tag> tags); static Tags of(String key, String value); static Tags of(@Nullable String... keyValues); static Tags of(@Nullable Tag... tags); static Tags empty(); @Override String toString(); }
@Test void tagsEquality() { Tags tags = Tags.of(Tag.of("k1", "v1"), Tag.of("k1", "v1"), Tag.of("k2", "v2")); Tags tags2 = Tags.of(Tag.of("k1", "v1"), Tag.of("k2", "v2")); assertThat(tags).isEqualTo(tags2); } @Test void createsListWithSingleTag() { Iterable<Tag> tags = Tags.of("k1", "v1"); assertThat(tags).containsExactly(Tag.of("k1", "v1")); } @Test void zipOnTwoTagsWithSameKeyAreMergedIntoOneTag() { Iterable<Tag> tags = Tags.of("k", "v1", "k", "v2"); assertThat(tags).containsExactly(Tag.of("k", "v2")); } @Test @Deprecated void zipShouldReturnNewInstanceWithTags() { Tags tags = Tags.of("t1", "v1", "t2", "v2"); assertTags(tags, "t1", "v1", "t2", "v2"); } @Test void ofIterableShouldReturnNewInstanceWithTags() { Tags tags = Tags.of(Collections.singleton(Tag.of("t1", "v1"))); assertTags(tags, "t1", "v1"); } @Test void ofIterableWhenIterableIsTagsShouldReturnSameInstance() { Tags source = Tags.of("t1", "v1"); Tags tags = Tags.of(source); assertThat(tags).isSameAs(source); } @Test void ofKeyValueShouldReturnNewInstance() { Tags tags = Tags.of("t1", "v1"); assertTags(tags, "t1", "v1"); } @Test void ofKeyValuesShouldReturnNewInstance() { Tags tags = Tags.of("t1", "v1", "t2", "v2"); assertTags(tags, "t1", "v1", "t2", "v2"); }
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeTimeGauge(TimeGauge gauge) { double value = gauge.value(getBaseTimeUnit()); if (Double.isFinite(value)) { return Optional.of(writeDocument(gauge, builder -> { builder.append(",\"value\":").append(value); })); } return Optional.empty(); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Test void writeTimeGauge() { TimeGauge gauge = TimeGauge.builder("myGauge", 123.0, TimeUnit.MILLISECONDS, Number::doubleValue).register(registry); assertThat(registry.writeTimeGauge(gauge)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"myGauge\",\"type\":\"gauge\",\"value\":123.0}"); }
CompositeCounter extends AbstractCompositeMeter<Counter> implements Counter { @Override public void increment(double amount) { forEachChild(c -> c.increment(amount)); } CompositeCounter(Meter.Id id); @Override void increment(double amount); @Override double count(); }
@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); }
CompositeMeterRegistry extends MeterRegistry { public CompositeMeterRegistry add(MeterRegistry registry) { lock(registriesLock, () -> { forbidSelfContainingComposite(registry); if (registry instanceof CompositeMeterRegistry) { ((CompositeMeterRegistry) registry).addParent(this); } if (registries.add(registry)) { updateDescendants(); } }); return this; } CompositeMeterRegistry(); CompositeMeterRegistry(Clock clock); CompositeMeterRegistry(Clock clock, Iterable<MeterRegistry> registries); CompositeMeterRegistry add(MeterRegistry registry); CompositeMeterRegistry remove(MeterRegistry registry); Set<MeterRegistry> getRegistries(); @Override void close(); }
@DisplayName("base units on meters that support them are passed through underlying registries") @Test void baseUnitsPreserved() { composite.add(simple); Counter.builder("counter").baseUnit(BaseUnits.BYTES).register(composite); DistributionSummary.builder("summary").baseUnit(BaseUnits.BYTES).register(composite); Gauge.builder("gauge", new AtomicInteger(0), AtomicInteger::get).baseUnit(BaseUnits.BYTES).register(composite); assertThat(simple.get("counter").counter().getId().getBaseUnit()).isEqualTo(BaseUnits.BYTES); assertThat(simple.get("summary").summary().getId().getBaseUnit()).isEqualTo(BaseUnits.BYTES); assertThat(simple.get("gauge").gauge().getId().getBaseUnit()).isEqualTo(BaseUnits.BYTES); } @DisplayName("metrics that are created before a registry is added are later added to that registry") @Test void metricBeforeRegistryAdd() { Counter compositeCounter = composite.counter("counter"); compositeCounter.increment(); assertThat(compositeCounter.count()).isEqualTo(0); composite.add(simple); compositeCounter.increment(); assertThat(compositeCounter.count()).isEqualTo(1); assertThat(simple.get("counter").counter().count()).isEqualTo(1.0); } @DisplayName("metrics that are created after a registry is added to that registry") @Test void registryBeforeMetricAdd() { composite.add(simple); composite.counter("counter").increment(); assertThat(simple.get("counter").counter().count()).isEqualTo(1.0); } @DisplayName("metrics follow the naming convention of each registry in the composite") @Test void namingConventions() { simple.config().namingConvention(NamingConvention.camelCase); composite.add(simple); composite.counter("my.counter").increment(); assertThat(simple.get("my.counter").counter().count()).isEqualTo(1.0); } @DisplayName("common tags added to the composite affect meters registered with registries in the composite") @Test void commonTags() { simple.config().commonTags("instance", "local"); simple.config().commonTags("region", "us-west-1"); composite.config().commonTags("region", "us-east-1"); composite.add(simple); composite.config().commonTags("stack", "test"); composite.counter("counter").increment(); simple.get("counter").tags("region", "us-east-1", "stack", "test", "instance", "local").counter(); } @DisplayName("function timer base units are delegated to registries in the composite") @Test void functionTimerUnits() { composite.add(simple); Object o = new Object(); composite.more().timer("function.timer", emptyList(), o, o2 -> 1, o2 -> 1, TimeUnit.MILLISECONDS); FunctionTimer functionTimer = simple.get("function.timer").functionTimer(); assertThat(functionTimer.count()).isEqualTo(1); assertThat(functionTimer.totalTime(TimeUnit.MILLISECONDS)).isEqualTo(1); } @Issue("#255") @Test void castingFunctionCounter() { SimpleMeterRegistry registry = new SimpleMeterRegistry(); CompositeMeterRegistry compositeMeterRegistry = new CompositeMeterRegistry(); FunctionCounter.builder("foo", 1L, x -> x) .register(compositeMeterRegistry); compositeMeterRegistry.add(registry); } @Test void differentFiltersForCompositeAndChild() { composite.add(simple); simple.config().meterFilter(MeterFilter.denyNameStartsWith("deny.child")); composite.config().meterFilter(MeterFilter.denyNameStartsWith("deny.composite")); composite.counter("deny.composite"); composite.counter("deny.child"); assertThat(simple.find("deny.composite").meter()).isNull(); assertThat(composite.find("deny.composite").meter()).isNull(); assertThat(simple.find("deny.child").meter()).isNull(); composite.get("deny.child").meter(); simple.counter("deny.composite"); simple.get("deny.composite").meter(); } @Test void histogramConfigDefaultIsNotAffectedByComposite() { composite.add(simple); 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 compositePauseDetectorConfigOverridesChild() { composite.add(simple); CountDownLatch count = new CountDownLatch(1); composite.config().pauseDetector(new ClockDriftPauseDetector(Duration.ofSeconds(1), Duration.ofSeconds(1)) { @Override public Duration getPauseThreshold() { count.countDown(); return super.getPauseThreshold(); } }); composite.timer("my.timer"); assertThat(count.getCount()).isEqualTo(0); } @Issue("#546") @Test void metricsOnlyUpdatedOnceWhenChildIsPresentInCompositeHierarchyTwice() { composite.add(simple); CompositeMeterRegistry nested = new CompositeMeterRegistry(); CompositeMeterRegistry nested2 = new CompositeMeterRegistry(); nested2.add(simple); nested.add(nested2); nested.add(simple); composite.add(nested); Counter counter = composite.counter("my.counter"); counter.increment(); assertThat(counter.count()).isEqualTo(1); } @Test void addRegistryInfluencesCompositeAncestry() { CompositeMeterRegistry nested = new CompositeMeterRegistry(); CompositeMeterRegistry nested2 = new CompositeMeterRegistry(); nested.add(nested2); composite.add(nested); nested2.add(simple); assertThat(composite.nonCompositeDescendants).containsExactly(simple); }
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeLongTaskTimer(LongTaskTimer timer) { return Optional.of(writeDocument(timer, builder -> { builder.append(",\"activeTasks\":").append(timer.activeTasks()); builder.append(",\"duration\":").append(timer.duration(getBaseTimeUnit())); })); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Test void writeLongTaskTimer() { LongTaskTimer timer = LongTaskTimer.builder("longTaskTimer").register(registry); assertThat(registry.writeLongTaskTimer(timer)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"longTaskTimer\",\"type\":\"long_task_timer\",\"activeTasks\":0,\"duration\":0.0}"); }
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeSummary(DistributionSummary summary) { HistogramSnapshot histogramSnapshot = summary.takeSnapshot(); return Optional.of(writeDocument(summary, builder -> { builder.append(",\"count\":").append(histogramSnapshot.count()); builder.append(",\"sum\":").append(histogramSnapshot.total()); builder.append(",\"mean\":").append(histogramSnapshot.mean()); builder.append(",\"max\":").append(histogramSnapshot.max()); })); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Test void writeSummary() { DistributionSummary summary = DistributionSummary.builder("summary").register(registry); summary.record(123); summary.record(456); clock.add(config.step()); assertThat(registry.writeSummary(summary)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:01:00.001Z\",\"name\":\"summary\",\"type\":\"distribution_summary\",\"count\":2,\"sum\":579.0,\"mean\":289.5,\"max\":456.0}"); }
CompositeLongTaskTimer extends AbstractCompositeMeter<LongTaskTimer> implements LongTaskTimer { @Override public Sample start() { List<Sample> samples = new ArrayList<>(); forEachChild(ltt -> samples.add(ltt.start())); return new CompositeSample(samples); } CompositeLongTaskTimer(Meter.Id id, DistributionStatisticConfig distributionStatisticConfig); @Override Sample start(); @Override double duration(TimeUnit unit); @Override int activeTasks(); @Override double max(TimeUnit unit); @Override TimeUnit baseTimeUnit(); @Override HistogramSnapshot takeSnapshot(); }
@Test void mapIdsToEachLongTaskTimerInComposite() { MockClock clock = new MockClock(); MeterRegistry s1 = new SimpleMeterRegistry(SimpleConfig.DEFAULT, clock); LongTaskTimer anotherTimer = s1.more().longTaskTimer("long.task"); LongTaskTimer.Sample anotherSample = anotherTimer.start(); clock.add(10, TimeUnit.NANOSECONDS); CompositeMeterRegistry registry = new CompositeMeterRegistry(clock); registry.add(s1); LongTaskTimer longTaskTimer = registry.more().longTaskTimer("long.task"); LongTaskTimer.Sample sample = longTaskTimer.start(); clock.add(100, TimeUnit.NANOSECONDS); assertThat(anotherSample.stop()).isEqualTo(110); assertThat(sample.stop()).isEqualTo(100); }
CommonsObjectPool2Metrics implements MeterBinder, AutoCloseable { @Override public void bindTo(@NonNull MeterRegistry registry) { for (String type : TYPES) { registerMetricsEventually( type, (o, tags) -> { registerGaugeForObject(registry, o, "NumIdle", "num.idle", tags, "The number of instances currently idle in this pool", BaseUnits.OBJECTS); registerGaugeForObject(registry, o, "NumWaiters", "num.waiters", tags, "The estimate of the number of threads currently blocked waiting for an object from the pool", BaseUnits.THREADS); registerFunctionCounterForObject(registry, o, "CreatedCount", "created", tags, "The total number of objects created for this pool over the lifetime of the pool", BaseUnits.OBJECTS); registerFunctionCounterForObject(registry, o, "BorrowedCount", "borrowed", tags, "The total number of objects successfully borrowed from this pool over the lifetime of the pool", BaseUnits.OBJECTS); registerFunctionCounterForObject(registry, o, "ReturnedCount", "returned", tags, "The total number of objects returned to this pool over the lifetime of the pool", BaseUnits.OBJECTS); registerFunctionCounterForObject(registry, o, "DestroyedCount", "destroyed", tags, "The total number of objects destroyed by this pool over the lifetime of the pool", BaseUnits.OBJECTS); registerFunctionCounterForObject(registry, o, "DestroyedByEvictorCount", "destroyed.by.evictor", tags, "The total number of objects destroyed by the evictor associated with this pool over the lifetime of the pool", BaseUnits.OBJECTS); registerFunctionCounterForObject(registry, o, "DestroyedByBorrowValidationCount", "destroyed.by.borrow.validation", tags, "The total number of objects destroyed by this pool as a result of failing validation during borrowObject() over the lifetime of the pool", BaseUnits.OBJECTS); registerTimeGaugeForObject(registry, o, "MaxBorrowWaitTimeMillis", "max.borrow.wait", tags, "The maximum time a thread has waited to borrow objects from the pool"); registerTimeGaugeForObject(registry, o, "MeanActiveTimeMillis", "mean.active", tags, "The mean time objects are active"); registerTimeGaugeForObject(registry, o, "MeanIdleTimeMillis", "mean.idle", tags, "The mean time objects are idle"); registerTimeGaugeForObject(registry, o, "MeanBorrowWaitTimeMillis", "mean.borrow.wait", tags, "The mean time threads wait to borrow an object"); }); } } CommonsObjectPool2Metrics(); CommonsObjectPool2Metrics(Iterable<Tag> tags); CommonsObjectPool2Metrics(MBeanServer mBeanServer, Iterable<Tag> tags); @Override void bindTo(@NonNull MeterRegistry registry); @Override void close(); }
@Test void verifyMetricsWithExpectedTags() { createGenericObjectPool(); MeterRegistry registry = new SimpleMeterRegistry(); commonsObjectPool2Metrics.bindTo(registry); registry.get("commons.pool2.num.idle").tags(tags).gauge(); registry.get("commons.pool2.num.waiters").tags(tags).gauge(); Arrays.asList( "commons.pool2.created", "commons.pool2.borrowed", "commons.pool2.returned", "commons.pool2.destroyed", "commons.pool2.destroyed.by.evictor", "commons.pool2.destroyed.by.borrow.validation" ).forEach(name -> registry.get(name).tags(tags).functionCounter()); Arrays.asList( "commons.pool2.max.borrow.wait", "commons.pool2.mean.active", "commons.pool2.mean.idle", "commons.pool2.mean.borrow.wait" ).forEach(name -> registry.get(name).tags(tags).timeGauge()); } @Test void verifyGenericKeyedObjectPoolMetricsWithExpectedTags() { createGenericKeyedObjectPool(); Tags tagsToMatch = tags.and("type", "GenericKeyedObjectPool"); commonsObjectPool2Metrics.bindTo(registry); Arrays.asList( "commons.pool2.num.idle", "commons.pool2.num.waiters" ).forEach(name -> registry.get(name).tags(tagsToMatch).gauge()); Arrays.asList( "commons.pool2.created", "commons.pool2.borrowed", "commons.pool2.returned", "commons.pool2.destroyed", "commons.pool2.destroyed.by.evictor", "commons.pool2.destroyed.by.borrow.validation" ).forEach(name -> registry.get(name).tags(tagsToMatch).functionCounter()); Arrays.asList( "commons.pool2.max.borrow.wait", "commons.pool2.mean.active", "commons.pool2.mean.idle", "commons.pool2.mean.borrow.wait" ).forEach(name -> registry.get(name).tags(tagsToMatch).timeGauge()); } @Test void metricsReportedPerMultiplePools() { createGenericObjectPool(); createGenericObjectPool(); createGenericObjectPool(); MeterRegistry registry = new SimpleMeterRegistry(); commonsObjectPool2Metrics.bindTo(registry); registry.get("commons.pool2.num.waiters").tag("name", "pool" + genericObjectPoolCount).gauge(); registry.get("commons.pool2.num.waiters").tag("name", "pool" + (genericObjectPoolCount - 1)).gauge(); } @Test void newPoolsAreDiscoveredByListener() throws InterruptedException { MeterRegistry registry = new SimpleMeterRegistry(); commonsObjectPool2Metrics.bindTo(registry); CountDownLatch latch = new CountDownLatch(1); registry.config().onMeterAdded(m -> { if (m.getId().getName().contains("commons.pool2")) latch.countDown(); }); createGenericObjectPool(); latch.await(10, TimeUnit.SECONDS); }
MicrometerMetricsPublisherThreadPool implements HystrixMetricsPublisherThreadPool { private static String metricName(String name) { return String.join(".", NAME_HYSTRIX_THREADPOOL, name); } MicrometerMetricsPublisherThreadPool( final MeterRegistry meterRegistry, final HystrixThreadPoolKey threadPoolKey, final HystrixThreadPoolMetrics metrics, final HystrixThreadPoolProperties properties, final HystrixMetricsPublisherThreadPool metricsPublisherForThreadPool); @Override void initialize(); }
@Test void testMetricIds() { HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance().getMetricsPublisher(); HystrixPlugins.reset(); HystrixPlugins.getInstance().registerMetricsPublisher(new MicrometerMetricsPublisher(registry, metricsPublisher)); HystrixCommandKey key = HystrixCommandKey.Factory.asKey("MicrometerCOMMAND-A"); new SampleCommand(key).execute(); final Tags tags = Tags.of("key", NAME_MICROMETER_GROUP); final Set<MeterId> actualMeterIds = registry.getMeters().stream() .map(meter -> new MeterId(meter.getId().getName(), meter.getId().getType(), Tags.of(meter.getId().getTags()))) .collect(Collectors.toSet()); final Set<MeterId> expectedMeterIds = new HashSet<>(Arrays.asList( new MeterId(metricName("threads.active.current.count"), Type.GAUGE, tags), new MeterId(metricName("threads.cumulative.count"), Type.COUNTER, tags.and(Tags.of("type", "executed"))), new MeterId(metricName("threads.cumulative.count"), Type.COUNTER, tags.and(Tags.of("type", "rejected"))), new MeterId(metricName("threads.pool.current.size"), Type.GAUGE, tags), new MeterId(metricName("threads.largest.pool.current.size"), Type.GAUGE, tags), new MeterId(metricName("threads.max.pool.current.size"), Type.GAUGE, tags), new MeterId(metricName("threads.core.pool.current.size"), Type.GAUGE, tags), new MeterId(metricName("tasks.cumulative.count"), Type.COUNTER, tags.and(Tags.of("type", "scheduled"))), new MeterId(metricName("tasks.cumulative.count"), Type.COUNTER, tags.and(Tags.of("type", "completed"))), new MeterId(metricName("queue.current.size"), Type.GAUGE, tags), new MeterId(metricName("queue.max.size"), Type.GAUGE, tags), new MeterId(metricName("queue.rejection.threshold.size"), Type.GAUGE, tags) )); assertThat(actualMeterIds).containsAll(expectedMeterIds); }
MicrometerHttpRequestExecutor extends HttpRequestExecutor { @Override public HttpResponse execute(HttpRequest request, HttpClientConnection conn, HttpContext context) throws IOException, HttpException { Timer.Sample timerSample = Timer.start(registry); Tag method = Tag.of("method", request.getRequestLine().getMethod()); Tag uri = Tag.of("uri", uriMapper.apply(request)); Tag status = STATUS_UNKNOWN; Tags routeTags = exportTagsForRoute ? HttpContextUtils.generateTagsForRoute(context) : Tags.empty(); try { HttpResponse response = super.execute(request, conn, context); status = response != null ? Tag.of("status", Integer.toString(response.getStatusLine().getStatusCode())) : STATUS_CLIENT_ERROR; return response; } catch (IOException | HttpException | RuntimeException e) { status = STATUS_IO_ERROR; throw e; } finally { Iterable<Tag> tags = Tags.of(extraTags) .and(routeTags) .and(uri, method, status); timerSample.stop(Timer.builder(METER_NAME) .description("Duration of Apache HttpClient request execution") .tags(tags) .register(registry)); } } private MicrometerHttpRequestExecutor(int waitForContinue, MeterRegistry registry, Function<HttpRequest, String> uriMapper, Iterable<Tag> extraTags, boolean exportTagsForRoute); static Builder builder(MeterRegistry registry); @Override HttpResponse execute(HttpRequest request, HttpClientConnection conn, HttpContext context); @Deprecated static final String DEFAULT_URI_PATTERN_HEADER; }
@Test void timeSuccessful(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); HttpClient client = client(executor(false)); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl())).getEntity()); assertThat(registry.get(EXPECTED_METER_NAME) .timer().count()).isEqualTo(1L); } @Test void httpMethodIsTagged(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); HttpClient client = client(executor(false)); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl())).getEntity()); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl())).getEntity()); EntityUtils.consume(client.execute(new HttpPost(server.baseUrl())).getEntity()); assertThat(registry.get(EXPECTED_METER_NAME) .tags("method", "GET") .timer().count()).isEqualTo(2L); assertThat(registry.get(EXPECTED_METER_NAME) .tags("method", "POST") .timer().count()).isEqualTo(1L); } @Test void httpStatusCodeIsTagged(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(urlEqualTo("/ok")).willReturn(aResponse().withStatus(200))); server.stubFor(any(urlEqualTo("/notfound")).willReturn(aResponse().withStatus(404))); server.stubFor(any(urlEqualTo("/error")).willReturn(aResponse().withStatus(500))); HttpClient client = client(executor(false)); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl() + "/ok")).getEntity()); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl() + "/ok")).getEntity()); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl() + "/notfound")).getEntity()); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl() + "/error")).getEntity()); assertThat(registry.get(EXPECTED_METER_NAME) .tags("method", "GET", "status", "200") .timer().count()).isEqualTo(2L); assertThat(registry.get(EXPECTED_METER_NAME) .tags("method", "GET", "status", "404") .timer().count()).isEqualTo(1L); assertThat(registry.get(EXPECTED_METER_NAME) .tags("method", "GET", "status", "500") .timer().count()).isEqualTo(1L); } @Test void uriIsUnknownByDefault(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); HttpClient client = client(executor(false)); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl())).getEntity()); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl() + "/someuri")).getEntity()); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl() + "/otheruri")).getEntity()); assertThat(registry.get(EXPECTED_METER_NAME) .tags("uri", "UNKNOWN") .timer().count()).isEqualTo(3L); } @Test void uriIsReadFromHttpHeader(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); HttpClient client = client(executor(false)); HttpGet getWithHeader = new HttpGet(server.baseUrl()); getWithHeader.addHeader(DefaultUriMapper.URI_PATTERN_HEADER, "/some/pattern"); EntityUtils.consume(client.execute(getWithHeader).getEntity()); assertThat(registry.get(EXPECTED_METER_NAME) .tags("uri", "/some/pattern") .timer().count()).isEqualTo(1L); assertThrows(MeterNotFoundException.class, () -> registry.get(EXPECTED_METER_NAME) .tags("uri", "UNKNOWN") .timer()); } @Test void routeNotTaggedByDefault(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); HttpClient client = client(executor(false)); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl())).getEntity()); List<String> tagKeys = registry.get(EXPECTED_METER_NAME) .timer().getId().getTags().stream() .map(Tag::getKey) .collect(Collectors.toList()); assertThat(tagKeys).doesNotContain("target.scheme", "target.host", "target.port"); assertThat(tagKeys).contains("status", "method"); } @Test void routeTaggedIfEnabled(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); HttpClient client = client(executor(true)); EntityUtils.consume(client.execute(new HttpGet(server.baseUrl())).getEntity()); List<String> tagKeys = registry.get(EXPECTED_METER_NAME) .timer().getId().getTags().stream() .map(Tag::getKey) .collect(Collectors.toList()); assertThat(tagKeys).contains("target.scheme", "target.host", "target.port"); }
ElasticMeterRegistry extends StepMeterRegistry { Optional<String> writeMeter(Meter meter) { Iterable<Measurement> measurements = meter.measure(); List<String> names = new ArrayList<>(); List<Double> values = new ArrayList<>(); for (Measurement measurement : measurements) { double value = measurement.getValue(); if (!Double.isFinite(value)) { continue; } names.add(measurement.getStatistic().getTagValueRepresentation()); values.add(value); } if (names.isEmpty()) { return Optional.empty(); } return Optional.of(writeDocument(meter, builder -> { for (int i = 0; i < names.size(); i++) { builder.append(",\"").append(names.get(i)).append("\":\"").append(values.get(i)).append("\""); } })); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Test void writeMeter() { Timer timer = Timer.builder("myTimer").register(registry); assertThat(registry.writeMeter(timer)) .contains("{ \"index\" : {} }\n{\"@timestamp\":\"1970-01-01T00:00:00.001Z\",\"name\":\"myTimer\",\"type\":\"timer\",\"count\":\"0.0\",\"total\":\"0.0\",\"max\":\"0.0\"}"); }
MicrometerHttpRequestExecutor extends HttpRequestExecutor { public static Builder builder(MeterRegistry registry) { return new Builder(registry); } private MicrometerHttpRequestExecutor(int waitForContinue, MeterRegistry registry, Function<HttpRequest, String> uriMapper, Iterable<Tag> extraTags, boolean exportTagsForRoute); static Builder builder(MeterRegistry registry); @Override HttpResponse execute(HttpRequest request, HttpClientConnection conn, HttpContext context); @Deprecated static final String DEFAULT_URI_PATTERN_HEADER; }
@Test void waitForContinueGetsPassedToSuper() { MicrometerHttpRequestExecutor requestExecutor = MicrometerHttpRequestExecutor.builder(registry) .waitForContinue(1000) .build(); assertThat(requestExecutor).hasFieldOrPropertyWithValue("waitForContinue", 1000); } @Test void settingNullRegistryThrowsException() { assertThrows(IllegalArgumentException.class, () -> MicrometerHttpRequestExecutor.builder(null) .build()); } @Test void overridingUriMapperWithNullThrowsException() { assertThrows(IllegalArgumentException.class, () -> MicrometerHttpRequestExecutor.builder(registry) .uriMapper(null) .build() ); }
KafkaConsumerMetrics implements MeterBinder, AutoCloseable { @Override public void bindTo(MeterRegistry registry) { registerMetricsEventually(registry, "consumer-fetch-manager-metrics", (o, tags) -> { List<Meter> meters = new ArrayList<>(); if (tags.stream().anyMatch(t -> t.getKey().equals("topic")) && tags.stream().anyMatch(t -> t.getKey().equals("partition"))) { meters.add(registerGaugeForObject(registry, o, "records-lag", tags, "The latest lag of the partition", "records")); meters.add(registerGaugeForObject(registry, o, "records-lag-avg", tags, "The average lag of the partition", "records")); meters.add(registerGaugeForObject(registry, o, "records-lag-max", tags, "The maximum lag in terms of number of records for any partition in this window. An increasing value over time is your best indication that the consumer group is not keeping up with the producers.", "records")); if (kafkaMajorVersion(tags) >= 2) { meters.add(registerGaugeForObject(registry, o, "records-lead", tags, "The latest lead of the partition.", "records")); meters.add(registerGaugeForObject(registry, o, "records-lead-min", tags, "The min lead of the partition. The lag between the consumer offset and the start offset of the log. If this gets close to zero, it's an indication that the consumer may lose data soon.", "records")); meters.add(registerGaugeForObject(registry, o, "records-lead-avg", tags, "The average lead of the partition.", "records")); } } else if (tags.stream().anyMatch(t -> t.getKey().equals("topic"))) { meters.add(registerGaugeForObject(registry, o, "fetch-size-avg", tags, "The average number of bytes fetched per request.", BaseUnits.BYTES)); meters.add(registerGaugeForObject(registry, o, "fetch-size-max", tags, "The maximum number of bytes fetched per request.", BaseUnits.BYTES)); meters.add(registerGaugeForObject(registry, o, "records-per-request-avg", tags, "The average number of records in each request.", "records")); meters.add(registerFunctionCounterForObject(registry, o, "bytes-consumed-total", tags, "The total number of bytes consumed.", BaseUnits.BYTES)); meters.add(registerFunctionCounterForObject(registry, o, "records-consumed-total", tags, "The total number of records consumed.", "records")); } else { meters.add(registerFunctionCounterForObject(registry, o, "fetch-total", tags, "The number of fetch requests.", "requests")); meters.add(registerTimeGaugeForObject(registry, o, "fetch-latency-avg", tags, "The average time taken for a fetch request.")); meters.add(registerTimeGaugeForObject(registry, o, "fetch-latency-max", tags, "The max time taken for a fetch request.")); meters.add(registerTimeGaugeForObject(registry, o, "fetch-throttle-time-avg", tags, "The average throttle time. When quotas are enabled, the broker may delay fetch requests in order to throttle a consumer which has exceeded its limit. This metric indicates how throttling time has been added to fetch requests on average.")); meters.add(registerTimeGaugeForObject(registry, o, "fetch-throttle-time-max", tags, "The maximum throttle time.")); } return meters; }); registerMetricsEventually(registry, "consumer-coordinator-metrics", (o, tags) -> { List<Meter> meters = new ArrayList<>(); meters.add(registerGaugeForObject(registry, o, "assigned-partitions", tags, "The number of partitions currently assigned to this consumer.", "partitions")); meters.add(registerGaugeForObject(registry, o, "commit-rate", tags, "The number of commit calls per second.", "commits")); meters.add(registerGaugeForObject(registry, o, "join-rate", tags, "The number of group joins per second. Group joining is the first phase of the rebalance protocol. A large value indicates that the consumer group is unstable and will likely be coupled with increased lag.", "joins")); meters.add(registerGaugeForObject(registry, o, "sync-rate", tags, "The number of group syncs per second. Group synchronization is the second and last phase of the rebalance protocol. A large value indicates group instability.", "syncs")); meters.add(registerGaugeForObject(registry, o, "heartbeat-rate", tags, "The average number of heartbeats per second. After a rebalance, the consumer sends heartbeats to the coordinator to keep itself active in the group. You may see a lower rate than configured if the processing loop is taking more time to handle message batches. Usually this is OK as long as you see no increase in the join rate.", "heartbeats")); meters.add(registerTimeGaugeForObject(registry, o, "commit-latency-avg", tags, "The average time taken for a commit request.")); meters.add(registerTimeGaugeForObject(registry, o, "commit-latency-max", tags, "The max time taken for a commit request.")); meters.add(registerTimeGaugeForObject(registry, o, "join-time-avg", tags, "The average time taken for a group rejoin. This value can get as high as the configured session timeout for the consumer, but should usually be lower.")); meters.add(registerTimeGaugeForObject(registry, o, "join-time-max", tags, "The max time taken for a group rejoin. This value should not get much higher than the configured session timeout for the consumer.")); meters.add(registerTimeGaugeForObject(registry, o, "sync-time-avg", tags, "The average time taken for a group sync.")); meters.add(registerTimeGaugeForObject(registry, o, "sync-time-max", tags, "The max time taken for a group sync.")); meters.add(registerTimeGaugeForObject(registry, o, "heartbeat-response-time-max", tags, "The max time taken to receive a response to a heartbeat request.")); meters.add(registerTimeGaugeForObject(registry, o, "last-heartbeat-seconds-ago", "last-heartbeat", tags, "The time since the last controller heartbeat.", TimeUnit.SECONDS)); return meters; }); registerMetricsEventually(registry, "consumer-metrics", (o, tags) -> { List<Meter> meters = new ArrayList<>(); meters.add(registerGaugeForObject(registry, o, "connection-count", tags, "The current number of active connections.", "connections")); meters.add(registerGaugeForObject(registry, o, "connection-creation-total", tags, "New connections established.", "connections")); meters.add(registerGaugeForObject(registry, o, "connection-close-total", tags, "Connections closed.", "connections")); meters.add(registerGaugeForObject(registry, o, "io-ratio", tags, "The fraction of time the I/O thread spent doing I/O.", null)); meters.add(registerGaugeForObject(registry, o, "io-wait-ratio", tags, "The fraction of time the I/O thread spent waiting.", null)); meters.add(registerGaugeForObject(registry, o, "select-total", tags, "Number of times the I/O layer checked for new I/O to perform.", null)); meters.add(registerTimeGaugeForObject(registry, o, "io-time-ns-avg", "io-time-avg", tags, "The average length of time for I/O per select call.", TimeUnit.NANOSECONDS)); meters.add(registerTimeGaugeForObject(registry, o, "io-wait-time-ns-avg", "io-wait-time-avg", tags, "The average length of time the I/O thread spent waiting for a socket to be ready for reads or writes.", TimeUnit.NANOSECONDS)); if (kafkaMajorVersion(tags) >= 2) { meters.add(registerGaugeForObject(registry, o, "successful-authentication-total", "authentication-attempts", Tags.concat(tags, "result", "successful"), "The number of successful authentication attempts.", null)); meters.add(registerGaugeForObject(registry, o, "failed-authentication-total", "authentication-attempts", Tags.concat(tags, "result", "failed"), "The number of failed authentication attempts.", null)); meters.add(registerGaugeForObject(registry, o, "network-io-total", tags, "", BaseUnits.BYTES)); meters.add(registerGaugeForObject(registry, o, "outgoing-byte-total", tags, "", BaseUnits.BYTES)); meters.add(registerGaugeForObject(registry, o, "request-total", tags, "", "requests")); meters.add(registerGaugeForObject(registry, o, "response-total", tags, "", "responses")); meters.add(registerTimeGaugeForObject(registry, o, "io-waittime-total", "io-wait-time-total", tags, "Time spent on the I/O thread waiting for a socket to be ready for reads or writes.", TimeUnit.NANOSECONDS)); meters.add(registerTimeGaugeForObject(registry, o, "iotime-total", "io-time-total", tags, "Time spent in I/O during select calls.", TimeUnit.NANOSECONDS)); } return meters; }); } KafkaConsumerMetrics(); KafkaConsumerMetrics(Iterable<Tag> tags); KafkaConsumerMetrics(MBeanServer mBeanServer, Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); @Override void close(); }
@Test void verifyConsumerMetricsWithExpectedTags() { try (Consumer<Long, String> consumer = createConsumer()) { MeterRegistry registry = new SimpleMeterRegistry(); kafkaConsumerMetrics.bindTo(registry); Gauge assignedPartitions = registry.get("kafka.consumer.assigned.partitions").tags(tags).gauge(); assertThat(assignedPartitions.getId().getTag("client.id")).isEqualTo("consumer-" + consumerCount); Gauge connectionCount = registry.get("kafka.consumer.connection.count").tags(tags).gauge(); assertThat(connectionCount.getId().getTag("client.id")).startsWith("consumer-" + consumerCount); } } @Test void metricsReportedPerMultipleConsumers() { try (Consumer<Long, String> consumer = createConsumer(); Consumer<Long, String> consumer2 = createConsumer()) { MeterRegistry registry = new SimpleMeterRegistry(); kafkaConsumerMetrics.bindTo(registry); registry.get("kafka.consumer.fetch.total").tag("client.id", "consumer-" + consumerCount).functionCounter(); registry.get("kafka.consumer.fetch.total").tag("client.id", "consumer-" + (consumerCount - 1)).functionCounter(); } } @Test void newConsumersAreDiscoveredByListener() throws InterruptedException { MeterRegistry registry = new SimpleMeterRegistry(); kafkaConsumerMetrics.bindTo(registry); CountDownLatch latch = new CountDownLatch(1); registry.config().onMeterAdded(m -> { if (m.getId().getName().contains("kafka")) latch.countDown(); }); try (Consumer<Long, String> consumer = createConsumer()) { latch.await(10, TimeUnit.SECONDS); } } @Test void consumerBeforeBindingWhenClosedShouldRemoveMeters() { MeterRegistry registry = new SimpleMeterRegistry(); try (Consumer<Long, String> consumer = createConsumer()) { kafkaConsumerMetrics.bindTo(registry); Gauge gauge = registry.get("kafka.consumer.assigned.partitions").gauge(); assertThat(gauge.getId().getTag("client.id")).isEqualTo("consumer-" + consumerCount); } assertThat(registry.find("kafka.consumer.assigned.partitions").gauge()).isNull(); } @Test void consumerAfterBindingWhenClosedShouldRemoveMeters() { MeterRegistry registry = new SimpleMeterRegistry(); kafkaConsumerMetrics.bindTo(registry); try (Consumer<Long, String> consumer = createConsumer()) { Gauge gauge = registry.get("kafka.consumer.assigned.partitions").gauge(); assertThat(gauge.getId().getTag("client.id")).isEqualTo("consumer-" + consumerCount); } assertThat(registry.find("kafka.consumer.assigned.partitions").gauge()).isNull(); }
KafkaConsumerMetrics implements MeterBinder, AutoCloseable { int kafkaMajorVersion(Tags tags) { if (kafkaMajorVersion == null || kafkaMajorVersion == -1) { kafkaMajorVersion = tags.stream().filter(t -> "client.id".equals(t.getKey())).findAny() .map(clientId -> { try { String version = (String) mBeanServer.getAttribute(new ObjectName(JMX_DOMAIN + ":type=app-info,client-id=" + clientId.getValue()), "version"); return Integer.parseInt(version.substring(0, version.indexOf('.'))); } catch (Throwable e) { return -1; } }) .orElse(-1); } return kafkaMajorVersion; } KafkaConsumerMetrics(); KafkaConsumerMetrics(Iterable<Tag> tags); KafkaConsumerMetrics(MBeanServer mBeanServer, Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); @Override void close(); }
@Test void verifyKafkaMajorVersion() { try (Consumer<Long, String> consumer = createConsumer()) { Tags tags = Tags.of("client.id", "consumer-" + consumerCount); assertThat(kafkaConsumerMetrics.kafkaMajorVersion(tags)).isGreaterThanOrEqualTo(2); } } @Test void returnsNegativeKafkaMajorVersionWhenMBeanInstanceNotFound() { try (Consumer<Long, String> consumer = createConsumer()) { Tags tags = Tags.of("client.id", "invalid"); assertThat(kafkaConsumerMetrics.kafkaMajorVersion(tags)).isEqualTo(-1); } } @Test void returnsNegativeKafkaMajorVersionForEmptyTags() { try (Consumer<Long, String> consumer = createConsumer()) { assertThat(kafkaConsumerMetrics.kafkaMajorVersion(Tags.empty())).isEqualTo(-1); } }
ElasticMeterRegistry extends StepMeterRegistry { static int countCreatedItems(String responseBody) { Matcher matcher = STATUS_CREATED_PATTERN.matcher(responseBody); int count = 0; while (matcher.find()) { count++; } return count; } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Test void countCreatedItems() { String responseBody = "{\"took\":254,\"errors\":true,\"items\":[{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"RL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":0,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Rb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":0,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Rr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":0,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"R79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":1,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"SL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":2,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Sb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":0,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Sr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":3,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"S79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":1,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"TL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":4,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Tb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":5,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Tr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":1,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"T79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":6,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"UL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":7,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Ub9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":0,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Ur9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":2,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"U79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":3,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"VL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":4,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Vb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":5,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Vr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":2,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"V79-vGoBVqC16kvPZ54V\",\"status\":400,\"error\":{\"type\":\"illegal_argument_exception\",\"reason\":\"mapper [count] cannot be changed from type [float] to [long]\"}}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"WL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":8,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Wb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":1,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Wr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":1,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"W79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":6,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"XL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":2,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Xb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":9,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Xr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":3,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"X79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":4,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"YL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":5,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Yb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":6,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Yr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":10,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Y79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":2,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"ZL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":7,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Zb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":3,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Zr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":11,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"Z79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":12,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"aL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":3,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"ab9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":4,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"ar9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":7,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"a79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":8,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"bL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":9,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"bb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":5,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"br9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":8,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"b79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":10,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"cL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":11,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"cb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":13,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"cr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":4,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"c79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":6,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"dL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":12,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"db9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":13,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"dr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":7,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"d79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":14,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"eL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":14,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"eb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":9,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"er9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":5,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"e79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":15,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"fL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":15,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"fb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":6,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"fr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":16,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"f79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":16,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"gL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":17,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"gb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":17,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"gr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":10,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"g79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":18,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"hL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":11,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"hb9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":7,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"hr9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":8,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"h79-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":9,\"_primary_term\":1,\"status\":201}},{\"index\":{\"_index\":\"metrics-2019-05\",\"_type\":\"doc\",\"_id\":\"iL9-vGoBVqC16kvPZ54V\",\"_version\":1,\"result\":\"created\",\"_shards\":{\"total\":2,\"successful\":1,\"failed\":0},\"_seq_no\":19,\"_primary_term\":1,\"status\":201}}]}"; assertThat(ElasticMeterRegistry.countCreatedItems(responseBody)).isEqualTo(68); }
KafkaMetrics implements MeterBinder, AutoCloseable { @Override public void bindTo(MeterRegistry registry) { commonTags = getCommonTags(registry); prepareToBindMetrics(registry); checkAndBindMetrics(registry); scheduler.scheduleAtFixedRate(() -> checkAndBindMetrics(registry), getRefreshIntervalInMillis(), getRefreshIntervalInMillis(), TimeUnit.MILLISECONDS); } KafkaMetrics(Supplier<Map<MetricName, ? extends Metric>> metricsSupplier); KafkaMetrics(Supplier<Map<MetricName, ? extends Metric>> metricsSupplier, Iterable<Tag> extraTags); KafkaMetrics(Supplier<Map<MetricName, ? extends Metric>> metricsSupplier, Iterable<Tag> extraTags, Duration refreshInterval); @Override void bindTo(MeterRegistry registry); @Override void close(); }
@Test void shouldRemoveMeterWithLessTags() { Supplier<Map<MetricName, ? extends Metric>> supplier = () -> { MetricName firstName = new MetricName("a", "b", "c", Collections.emptyMap()); KafkaMetric firstMetric = new KafkaMetric(this, firstName, new Value(), new MetricConfig(), Time.SYSTEM); Map<String, String> tags = new LinkedHashMap<>(); tags.put("key0", "value0"); MetricName secondName = new MetricName("a", "b", "c", tags); KafkaMetric secondMetric = new KafkaMetric(this, secondName, new Value(), new MetricConfig(), Time.SYSTEM); Map<MetricName, KafkaMetric> metrics = new LinkedHashMap<>(); metrics.put(firstName, firstMetric); metrics.put(secondName, secondMetric); return metrics; }; kafkaMetrics = new KafkaMetrics(supplier); MeterRegistry registry = new SimpleMeterRegistry(); kafkaMetrics.bindTo(registry); assertThat(registry.getMeters()).hasSize(1); assertThat(registry.getMeters().get(0).getId().getTags()).hasSize(2); } @Test void shouldBindMetersWithSameTags() { Supplier<Map<MetricName, ? extends Metric>> supplier = () -> { Map<String, String> firstTags = new LinkedHashMap<>(); firstTags.put("key0", "value0"); MetricName firstName = new MetricName("a", "b", "c", firstTags); KafkaMetric firstMetric = new KafkaMetric(this, firstName, new Value(), new MetricConfig(), Time.SYSTEM); Map<String, String> secondTags = new LinkedHashMap<>(); secondTags.put("key0", "value1"); MetricName secondName = new MetricName("a", "b", "c", secondTags); KafkaMetric secondMetric = new KafkaMetric(this, secondName, new Value(), new MetricConfig(), Time.SYSTEM); Map<MetricName, KafkaMetric> metrics = new LinkedHashMap<>(); metrics.put(firstName, firstMetric); metrics.put(secondName, secondMetric); return metrics; }; kafkaMetrics = new KafkaMetrics(supplier); MeterRegistry registry = new SimpleMeterRegistry(); kafkaMetrics.bindTo(registry); assertThat(registry.getMeters()).hasSize(2); assertThat(registry.getMeters().get(0).getId().getTags()).hasSize(2); } @Issue("#1968") @Test void shouldBindMetersWithDifferentClientIds() { Supplier<Map<MetricName, ? extends Metric>> supplier = () -> { Map<String, String> firstTags = new LinkedHashMap<>(); firstTags.put("key0", "value0"); firstTags.put("client-id", "client0"); MetricName firstName = new MetricName("a", "b", "c", firstTags); KafkaMetric firstMetric = new KafkaMetric(this, firstName, new Value(), new MetricConfig(), Time.SYSTEM); return Collections.singletonMap(firstName, firstMetric); }; kafkaMetrics = new KafkaMetrics(supplier); MeterRegistry registry = new SimpleMeterRegistry(); registry.counter("kafka.b.a", "client-id", "client1", "key0", "value0"); kafkaMetrics.bindTo(registry); assertThat(registry.getMeters()).hasSize(2); }
DatabaseTableMetrics implements MeterBinder { public static void monitor(MeterRegistry registry, String tableName, String dataSourceName, DataSource dataSource, String... tags) { monitor(registry, dataSource, dataSourceName, tableName, Tags.of(tags)); } DatabaseTableMetrics(DataSource dataSource, String dataSourceName, String tableName, Iterable<Tag> tags); DatabaseTableMetrics(DataSource dataSource, String query, String dataSourceName, String tableName, Iterable<Tag> tags); static void monitor(MeterRegistry registry, String tableName, String dataSourceName, DataSource dataSource, String... tags); static void monitor(MeterRegistry registry, DataSource dataSource, String dataSourceName, String tableName, Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void rowCountGauge() { DatabaseTableMetrics.monitor(registry, "foo", "mydb", ds); assertThat(registry.get("db.table.size") .tag("table", "foo") .tag("db", "mydb") .gauge().value()).isEqualTo(1.0); } @Test void rowCountForNonExistentTable() { DatabaseTableMetrics.monitor(registry, "dne", "mydb", ds); assertThat(registry.get("db.table.size") .tag("table", "dne") .tag("db", "mydb") .gauge().value()).isEqualTo(0.0); }
PostgreSQLDatabaseMetrics implements MeterBinder { @Override public void bindTo(MeterRegistry registry) { Gauge.builder("postgres.size", postgresDataSource, dataSource -> getDatabaseSize()) .tags(tags) .description("The database size") .register(registry); Gauge.builder("postgres.connections", postgresDataSource, dataSource -> getConnectionCount()) .tags(tags) .description("Number of active connections to the given db") .register(registry); FunctionCounter.builder("postgres.blocks.hits", postgresDataSource, dataSource -> resettableFunctionalCounter("postgres.blocks.hits", this::getBlockHits)) .tags(tags) .description("Number of times disk blocks were found already in the buffer cache, so that a read was not necessary") .register(registry); FunctionCounter.builder("postgres.blocks.reads", postgresDataSource, dataSource -> resettableFunctionalCounter("postgres.blocks.reads", this::getBlockReads)) .tags(tags) .description("Number of disk blocks read in this database") .register(registry); FunctionCounter.builder("postgres.transactions", postgresDataSource, dataSource -> resettableFunctionalCounter("postgres.transactions", this::getTransactionCount)) .tags(tags) .description("Total number of transactions executed (commits + rollbacks)") .register(registry); Gauge.builder("postgres.locks", postgresDataSource, dataSource -> getLockCount()) .tags(tags) .description("Number of locks on the given db") .register(registry); FunctionCounter.builder("postgres.temp.writes", postgresDataSource, dataSource -> resettableFunctionalCounter("postgres.temp.writes", this::getTempBytes)) .tags(tags) .description("The total amount of temporary writes to disk to execute queries") .baseUnit(BaseUnits.BYTES) .register(registry); registerRowCountMetrics(registry); registerCheckpointMetrics(registry); } PostgreSQLDatabaseMetrics(DataSource postgresDataSource, String database); PostgreSQLDatabaseMetrics(DataSource postgresDataSource, String database, Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void shouldRegisterPostgreSqlMetrics() { PostgreSQLDatabaseMetrics metrics = new PostgreSQLDatabaseMetrics(dataSource, DATABASE_NAME); metrics.bindTo(registry); registry.get("postgres.size").tag("database", DATABASE_NAME).gauge(); registry.get("postgres.connections").tag("database", DATABASE_NAME).gauge(); registry.get("postgres.rows.fetched").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.rows.inserted").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.rows.updated").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.rows.deleted").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.rows.dead").tag("database", DATABASE_NAME).gauge(); registry.get("postgres.blocks.hits").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.blocks.reads").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.temp.writes").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.locks").tag("database", DATABASE_NAME).gauge(); registry.get("postgres.transactions").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.checkpoints.timed").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.checkpoints.requested").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.buffers.checkpoint").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.buffers.clean").tag("database", DATABASE_NAME).functionCounter(); registry.get("postgres.buffers.backend").tag("database", DATABASE_NAME).functionCounter(); }
ElasticMeterRegistry extends StepMeterRegistry { static int getMajorVersion(String responseBody) { Matcher matcher = MAJOR_VERSION_PATTERN.matcher(responseBody); if (!matcher.find()) { throw new IllegalArgumentException("Unexpected response body: " + responseBody); } return Integer.parseInt(matcher.group(1)); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Test void getVersionWhenVersionIs7() { String responseBody = "{\n" + " \"name\" : \"AL01187277.local\",\n" + " \"cluster_name\" : \"elasticsearch\",\n" + " \"cluster_uuid\" : \"xwKhDd2ITqK4VanwGDmoDQ\",\n" + " \"version\" : {\n" + " \"number\" : \"7.0.1\",\n" + " \"build_flavor\" : \"default\",\n" + " \"build_type\" : \"tar\",\n" + " \"build_hash\" : \"e4efcb5\",\n" + " \"build_date\" : \"2019-04-29T12:56:03.145736Z\",\n" + " \"build_snapshot\" : false,\n" + " \"lucene_version\" : \"8.0.0\",\n" + " \"minimum_wire_compatibility_version\" : \"6.7.0\",\n" + " \"minimum_index_compatibility_version\" : \"6.0.0-beta1\"\n" + " },\n" + " \"tagline\" : \"You Know, for Search\"\n" + "}"; assertThat(ElasticMeterRegistry.getMajorVersion(responseBody)).isEqualTo(7); } @Test void getVersionWhenVersionIs6() { String responseBody = "{\n" + " \"name\" : \"AgISpaH\",\n" + " \"cluster_name\" : \"elasticsearch\",\n" + " \"cluster_uuid\" : \"Pycih38FRn-SJBOeaVniog\",\n" + " \"version\" : {\n" + " \"number\" : \"6.7.2\",\n" + " \"build_flavor\" : \"default\",\n" + " \"build_type\" : \"tar\",\n" + " \"build_hash\" : \"56c6e48\",\n" + " \"build_date\" : \"2019-04-29T09:05:50.290371Z\",\n" + " \"build_snapshot\" : false,\n" + " \"lucene_version\" : \"7.7.0\",\n" + " \"minimum_wire_compatibility_version\" : \"5.6.0\",\n" + " \"minimum_index_compatibility_version\" : \"5.0.0\"\n" + " },\n" + " \"tagline\" : \"You Know, for Search\"\n" + "}"; assertThat(ElasticMeterRegistry.getMajorVersion(responseBody)).isEqualTo(6); } @Test void getVersionWhenVersionIs5() { String responseBody = "{\n" + " \"name\" : \"kDfH9w4\",\n" + " \"cluster_name\" : \"elasticsearch\",\n" + " \"cluster_uuid\" : \"tUrOevi-RcaMGV2250XAnQ\",\n" + " \"version\" : {\n" + " \"number\" : \"5.6.15\",\n" + " \"build_hash\" : \"fe7575a\",\n" + " \"build_date\" : \"2019-02-13T16:21:45.880Z\",\n" + " \"build_snapshot\" : false,\n" + " \"lucene_version\" : \"6.6.1\"\n" + " },\n" + " \"tagline\" : \"You Know, for Search\"\n" + "}"; assertThat(ElasticMeterRegistry.getMajorVersion(responseBody)).isEqualTo(5); } @Issue("#1505") @Test void getVersionWhenVersionIs5AndNotPrettyPrinted() { String responseBody = "{\"status\":200,\"name\":\"Sematext-Logsene\",\"cluster_name\":\"elasticsearch\",\"cluster_uuid\":\"anything\",\"version\":{\"number\":\"5.3.0\",\"build_hash\":\"3adb13b\",\"build_date\":\"2017-03-23T03:31:50.652Z\",\"build_snapshot\":false,\"lucene_version\":\"6.4.1\"},\"tagline\":\"You Know, for Search\"}"; assertThat(ElasticMeterRegistry.getMajorVersion(responseBody)).isEqualTo(5); }
TomcatMetrics implements MeterBinder, AutoCloseable { public static void monitor(MeterRegistry registry, @Nullable Manager manager, String... tags) { monitor(registry, manager, Tags.of(tags)); } TomcatMetrics(@Nullable Manager manager, Iterable<Tag> tags); TomcatMetrics(@Nullable Manager manager, Iterable<Tag> tags, MBeanServer mBeanServer); static void monitor(MeterRegistry registry, @Nullable Manager manager, String... tags); static void monitor(MeterRegistry registry, @Nullable Manager manager, Iterable<Tag> tags); static MBeanServer getMBeanServer(); @Override void bindTo(MeterRegistry registry); void setJmxDomain(String jmxDomain); @Override void close(); }
@Test void managerBasedMetrics() { Context context = new StandardContext(); ManagerBase manager = new ManagerBase() { @Override public void load() { } @Override public void unload() { } @Override public Context getContext() { return context; } }; manager.setMaxActiveSessions(3); manager.createSession("first"); manager.createSession("second"); manager.createSession("third"); try { manager.createSession("fourth"); fail("TooManyActiveSessionsException expected."); } catch (TooManyActiveSessionsException exception) { } StandardSession expiredSession = new StandardSession(manager); expiredSession.setId("third"); expiredSession.setCreationTime(System.currentTimeMillis() - 10_000); manager.remove(expiredSession, true); Iterable<Tag> tags = Tags.of("metricTag", "val1"); TomcatMetrics.monitor(registry, manager, tags); assertThat(registry.get("tomcat.sessions.active.max").tags(tags).gauge().value()).isEqualTo(3.0); assertThat(registry.get("tomcat.sessions.active.current").tags(tags).gauge().value()).isEqualTo(2.0); assertThat(registry.get("tomcat.sessions.expired").tags(tags).functionCounter().count()).isEqualTo(1.0); assertThat(registry.get("tomcat.sessions.rejected").tags(tags).functionCounter().count()).isEqualTo(1.0); assertThat(registry.get("tomcat.sessions.created").tags(tags).functionCounter().count()).isEqualTo(3.0); assertThat(registry.get("tomcat.sessions.alive.max").tags(tags).timeGauge().value()).isGreaterThan(1.0); } @Test void whenTomcatMetricsBoundBeforeTomcatStarted_mbeanMetricsRegisteredEventually() throws Exception { TomcatMetrics.monitor(registry, null); CountDownLatch latch = new CountDownLatch(1); registry.config().onMeterAdded(m -> { if (m.getId().getName().equals("tomcat.global.received")) latch.countDown(); }); HttpServlet servlet = new HttpServlet() { @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException { IOUtils.toString(req.getInputStream()); sleep(); resp.getOutputStream().write("yes".getBytes()); } }; runTomcat(servlet, () -> { assertThat(latch.await(5, TimeUnit.SECONDS)).isTrue(); checkMbeansInitialState(); try (CloseableHttpClient httpClient = HttpClients.createDefault()) { HttpPost post = new HttpPost("http: post.setEntity(new StringEntity("you there?")); CloseableHttpResponse response1 = httpClient.execute(post); CloseableHttpResponse response2 = httpClient.execute( new HttpGet("http: long expectedSentBytes = response1.getEntity().getContentLength() + response2.getEntity().getContentLength(); checkMbeansAfterRequests(expectedSentBytes); } return null; }); } @Test void whenTomcatMetricsBoundAfterTomcatStarted_mbeanMetricsRegisteredImmediately() throws Exception { HttpServlet servlet = new HttpServlet() { @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException { IOUtils.toString(req.getInputStream()); sleep(); resp.getOutputStream().write("yes".getBytes()); } }; runTomcat(servlet, () -> { TomcatMetrics.monitor(registry, null); checkMbeansInitialState(); try (CloseableHttpClient httpClient = HttpClients.createDefault()) { HttpPost post = new HttpPost("http: post.setEntity(new StringEntity("you there?")); CloseableHttpResponse response1 = httpClient.execute(post); CloseableHttpResponse response2 = httpClient.execute( new HttpGet("http: long expectedSentBytes = response1.getEntity().getContentLength() + response2.getEntity().getContentLength(); checkMbeansAfterRequests(expectedSentBytes); } return null; }); } @Test @Issue("#1989") void whenMultipleServlets_thenRegisterMetricsForAllServlets() throws Exception { Collection<Servlet> servlets = Arrays.asList(new HttpServlet() { @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException { IOUtils.toString(req.getInputStream()); sleep(); resp.getOutputStream().write("yes".getBytes()); } }, new HttpServlet() { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { IOUtils.toString(req.getInputStream()); sleep(); resp.getOutputStream().write("hi".getBytes()); } }); runTomcat(servlets, () -> { TomcatMetrics.monitor(registry, null); checkMbeansInitialState(); try (CloseableHttpClient httpClient = HttpClients.createDefault()) { HttpPost post = new HttpPost("http: post.setEntity(new StringEntity("you there?")); CloseableHttpResponse response1 = httpClient.execute(post); CloseableHttpResponse response2 = httpClient.execute( new HttpGet("http: FunctionTimer servlet0 = registry.get("tomcat.servlet.request").tag("name", "servlet0").functionTimer(); FunctionTimer servlet1 = registry.get("tomcat.servlet.request").tag("name", "servlet1").functionTimer(); assertThat(servlet0.count()).isEqualTo(1); assertThat(servlet0.totalTime(TimeUnit.MILLISECONDS)).isGreaterThanOrEqualTo(PROCESSING_TIME_IN_MILLIS); assertThat(servlet1.count()).isEqualTo(1); assertThat(servlet1.totalTime(TimeUnit.MILLISECONDS)).isGreaterThanOrEqualTo(PROCESSING_TIME_IN_MILLIS); } return null; }); } @Test @Issue("#1989") void whenMultipleServletsAndTomcatMetricsBoundBeforeTomcatStarted_thenEventuallyRegisterMetricsForAllServlets() throws Exception { TomcatMetrics.monitor(registry, null); CountDownLatch latch0 = new CountDownLatch(1); CountDownLatch latch1 = new CountDownLatch(1); registry.config().onMeterAdded(m -> { if (m.getId().getName().equals("tomcat.servlet.error")) { if ("servlet0".equals(m.getId().getTag("name"))) { latch0.countDown(); } else if ("servlet1".equals(m.getId().getTag("name"))) { latch1.countDown(); } } }); Collection<Servlet> servlets = Arrays.asList(new HttpServlet() { @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException { IOUtils.toString(req.getInputStream()); sleep(); resp.getOutputStream().write("yes".getBytes()); } }, new HttpServlet() { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { IOUtils.toString(req.getInputStream()); sleep(); resp.getOutputStream().write("hi".getBytes()); } }); runTomcat(servlets, () -> { assertThat(latch0.await(3, TimeUnit.SECONDS)).isTrue(); assertThat(latch1.await(3, TimeUnit.SECONDS)).isTrue(); checkMbeansInitialState(); try (CloseableHttpClient httpClient = HttpClients.createDefault()) { HttpPost post = new HttpPost("http: post.setEntity(new StringEntity("you there?")); CloseableHttpResponse response1 = httpClient.execute(post); CloseableHttpResponse response2 = httpClient.execute( new HttpGet("http: FunctionTimer servlet0 = registry.get("tomcat.servlet.request").tag("name", "servlet0").functionTimer(); FunctionTimer servlet1 = registry.get("tomcat.servlet.request").tag("name", "servlet1").functionTimer(); assertThat(servlet0.count()).isEqualTo(1); assertThat(servlet0.totalTime(TimeUnit.MILLISECONDS)).isGreaterThanOrEqualTo(PROCESSING_TIME_IN_MILLIS); assertThat(servlet1.count()).isEqualTo(1); assertThat(servlet1.totalTime(TimeUnit.MILLISECONDS)).isGreaterThanOrEqualTo(PROCESSING_TIME_IN_MILLIS); } return null; }); }
LogbackMetrics implements MeterBinder, AutoCloseable { @Override public void bindTo(MeterRegistry registry) { MetricsTurboFilter filter = new MetricsTurboFilter(registry, tags); synchronized (metricsTurboFilters) { metricsTurboFilters.put(registry, filter); loggerContext.addTurboFilter(filter); } } LogbackMetrics(); LogbackMetrics(Iterable<Tag> tags); LogbackMetrics(Iterable<Tag> tags, LoggerContext context); @Override void bindTo(MeterRegistry registry); static void ignoreMetrics(Runnable r); @Override void close(); }
@Issue("#411") @Test void ignoringMetricsInsideCounters() { registry = new LoggingCounterMeterRegistry(); try (LogbackMetrics logbackMetrics = new LogbackMetrics()) { logbackMetrics.bindTo(registry); registry.counter("my.counter").increment(); } } @Issue("#2028") @Test void reAddFilterToLoggerContextAfterReset() { LoggerContext loggerContext = new LoggerContext(); assertThat(loggerContext.getTurboFilterList()).isEmpty(); LogbackMetrics logbackMetrics = new LogbackMetrics(emptyList(), loggerContext); logbackMetrics.bindTo(registry); assertThat(loggerContext.getTurboFilterList()).hasSize(1); loggerContext.reset(); assertThat(loggerContext.getTurboFilterList()).hasSize(1); }
LogbackMetrics implements MeterBinder, AutoCloseable { public static void ignoreMetrics(Runnable r) { ignoreMetrics.set(true); try { r.run(); } finally { ignoreMetrics.remove(); } } LogbackMetrics(); LogbackMetrics(Iterable<Tag> tags); LogbackMetrics(Iterable<Tag> tags, LoggerContext context); @Override void bindTo(MeterRegistry registry); static void ignoreMetrics(Runnable r); @Override void close(); }
@Issue("#2270") @Test void resetIgnoreMetricsWhenRunnableThrows() { Counter infoLogCounter = registry.get("logback.events").tag("level", "info").counter(); logger.info("hi"); assertThat(infoLogCounter.count()).isEqualTo(1); try { LogbackMetrics.ignoreMetrics(() -> { throw new RuntimeException(); }); } catch (RuntimeException ignore) { } logger.info("hi"); assertThat(infoLogCounter.count()).isEqualTo(2); }
Log4j2Metrics implements MeterBinder, AutoCloseable { @Override public void bindTo(MeterRegistry registry) { Configuration configuration = loggerContext.getConfiguration(); LoggerConfig rootLoggerConfig = configuration.getRootLogger(); rootLoggerConfig.addFilter(createMetricsFilterAndStart(registry, rootLoggerConfig)); loggerContext.getConfiguration().getLoggers().values().stream() .filter(loggerConfig -> !loggerConfig.isAdditive()) .forEach(loggerConfig -> { if (loggerConfig == rootLoggerConfig) { return; } Filter logFilter = loggerConfig.getFilter(); if ((logFilter instanceof CompositeFilter && Arrays.stream(((CompositeFilter) logFilter).getFiltersArray()) .anyMatch(innerFilter -> innerFilter instanceof MetricsFilter))) { return; } if (logFilter instanceof MetricsFilter) { return; } loggerConfig.addFilter(createMetricsFilterAndStart(registry, loggerConfig)); }); loggerContext.updateLoggers(configuration); } Log4j2Metrics(); Log4j2Metrics(Iterable<Tag> tags); Log4j2Metrics(Iterable<Tag> tags, LoggerContext loggerContext); @Override void bindTo(MeterRegistry registry); @Override void close(); }
@Test void log4j2LevelMetrics() { new Log4j2Metrics().bindTo(registry); assertThat(registry.get("log4j2.events").counter().count()).isEqualTo(0.0); Logger logger = LogManager.getLogger(Log4j2MetricsTest.class); Configurator.setLevel(Log4j2MetricsTest.class.getName(), Level.INFO); logger.info("info"); logger.warn("warn"); logger.fatal("fatal"); logger.error("error"); logger.debug("debug"); logger.trace("trace"); assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(1.0); assertThat(registry.get("log4j2.events").tags("level", "warn").counter().count()).isEqualTo(1.0); assertThat(registry.get("log4j2.events").tags("level", "fatal").counter().count()).isEqualTo(1.0); assertThat(registry.get("log4j2.events").tags("level", "error").counter().count()).isEqualTo(1.0); assertThat(registry.get("log4j2.events").tags("level", "debug").counter().count()).isEqualTo(0.0); assertThat(registry.get("log4j2.events").tags("level", "trace").counter().count()).isEqualTo(0.0); } @Test void filterWhenLoggerAdditivityIsFalseShouldWork() { Logger additivityDisabledLogger = LogManager.getLogger("additivityDisabledLogger"); Configurator.setLevel("additivityDisabledLogger", Level.INFO); LoggerContext loggerContext = (LoggerContext) LogManager.getContext(); Configuration configuration = loggerContext.getConfiguration(); LoggerConfig loggerConfig = configuration.getLoggerConfig("additivityDisabledLogger"); loggerConfig.setAdditive(false); new Log4j2Metrics().bindTo(registry); assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(0); additivityDisabledLogger.info("Hello, world!"); assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(1); } @Issue("#1466") @Test void filterWhenRootLoggerAdditivityIsFalseShouldWork() throws IOException { ConfigurationSource source = new ConfigurationSource(getClass().getResourceAsStream("/binder/logging/log4j2-root-logger-additivity-false.xml")); Configurator.initialize(null, source); Logger logger = LogManager.getLogger(Log4j2MetricsTest.class); new Log4j2Metrics().bindTo(registry); assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(0); logger.info("Hello, world!"); assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(1); } @Test void isLevelEnabledDoesntContributeToCounts() { new Log4j2Metrics().bindTo(registry); Logger logger = LogManager.getLogger(Log4j2MetricsTest.class); logger.isErrorEnabled(); assertThat(registry.get("log4j2.events").tags("level", "error").counter().count()).isEqualTo(0.0); } @Test void noDuplicateLoggingCountWhenMultipleNonAdditiveLoggersShareConfig() { LoggerContext loggerContext = new LoggerContext("test"); LoggerConfig loggerConfig = new LoggerConfig("com.test", Level.INFO, false); Configuration configuration = loggerContext.getConfiguration(); configuration.addLogger("com.test", loggerConfig); loggerContext.setConfiguration(configuration); loggerContext.updateLoggers(); Logger logger1 = loggerContext.getLogger("com.test.log1"); loggerContext.getLogger("com.test.log2"); new Log4j2Metrics(emptyList(), loggerContext).bindTo(registry); assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(0); logger1.info("Hello, world!"); assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(1); } @Issue("#2176") @Test void asyncLogShouldNotBeDuplicated() throws IOException { ConfigurationSource source = new ConfigurationSource(getClass().getResourceAsStream("/binder/logging/log4j2-async-logger.xml")); Configurator.initialize(null, source); Logger logger = LogManager.getLogger(Log4j2MetricsTest.class); new Log4j2Metrics().bindTo(registry); assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(0); logger.info("Hello, world!"); assertThat(registry.get("log4j2.events").tags("level", "info").counter().count()).isEqualTo(1); }
FileDescriptorMetrics implements MeterBinder { @Override public void bindTo(MeterRegistry registry) { if (openFilesMethod != null) { Gauge.builder("process.files.open", osBean, x -> invoke(openFilesMethod)) .tags(tags) .description("The open file descriptor count") .baseUnit(BaseUnits.FILES) .register(registry); } if (maxFilesMethod != null) { Gauge.builder("process.files.max", osBean, x -> invoke(maxFilesMethod)) .tags(tags) .description("The maximum file descriptor count") .baseUnit(BaseUnits.FILES) .register(registry); } } FileDescriptorMetrics(); FileDescriptorMetrics(Iterable<Tag> tags); FileDescriptorMetrics(OperatingSystemMXBean osBean, Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void fileDescriptorMetricsUnsupportedOsBeanMock() { final OperatingSystemMXBean osBean = mock(UnsupportedOperatingSystemMXBean.class); new FileDescriptorMetrics(osBean, Tags.of("some", "tag")).bindTo(registry); assertThat(registry.find("process.files.open").gauge()).isNull(); assertThat(registry.find("process.files.max").gauge()).isNull(); } @Test void unixFileDescriptorMetrics() { assumeFalse(System.getProperty("os.name").toLowerCase().contains("win")); new FileDescriptorMetrics(Tags.of("some", "tag")).bindTo(registry); assertThat(registry.get("process.files.open").tags("some", "tag") .gauge().value()).isGreaterThan(0); assertThat(registry.get("process.files.max").tags("some", "tag") .gauge().value()).isGreaterThan(0); } @Test void windowsFileDescriptorMetrics() { assumeTrue(System.getProperty("os.name").toLowerCase().contains("win")); new FileDescriptorMetrics(Tags.of("some", "tag")).bindTo(registry); assertThat(registry.find("process.files.open").gauge()).isNull(); assertThat(registry.find("process.files.max").gauge()).isNull(); }
UptimeMetrics implements MeterBinder { @Override public void bindTo(MeterRegistry registry) { TimeGauge.builder("process.uptime", runtimeMXBean, TimeUnit.MILLISECONDS, RuntimeMXBean::getUptime) .tags(tags) .description("The uptime of the Java virtual machine") .register(registry); TimeGauge.builder("process.start.time", runtimeMXBean, TimeUnit.MILLISECONDS, RuntimeMXBean::getStartTime) .tags(tags) .description("Start time of the process since unix epoch.") .register(registry); } UptimeMetrics(); UptimeMetrics(Iterable<Tag> tags); UptimeMetrics(RuntimeMXBean runtimeMXBean, Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@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(); } @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); }
OkHttpConnectionPoolMetrics implements MeterBinder { @Override public void bindTo(@NonNull MeterRegistry registry) { String connectionCountName = namePrefix + ".connection.count"; Gauge.builder(connectionCountName, connectionStats, cs -> { if (cs.get() == null) { cs.set(new ConnectionPoolConnectionStats()); } return cs.get().getActiveCount(); }) .baseUnit(BaseUnits.CONNECTIONS) .description("The state of connections in the OkHttp connection pool") .tags(Tags.of(tags).and(TAG_STATE, "active")) .register(registry); Gauge.builder(connectionCountName, connectionStats, cs -> { if (cs.get() == null) { cs.set(new ConnectionPoolConnectionStats()); } return cs.get().getIdleConnectionCount(); }) .baseUnit(BaseUnits.CONNECTIONS) .description("The state of connections in the OkHttp connection pool") .tags(Tags.of(tags).and(TAG_STATE, "idle")) .register(registry); if (this.maxIdleConnectionCount != null) { Gauge.builder(namePrefix + ".connection.limit", () -> this.maxIdleConnectionCount) .baseUnit(BaseUnits.CONNECTIONS) .description("The maximum idle connection count in an OkHttp connection pool.") .tags(Tags.concat(tags)) .register(registry); } } OkHttpConnectionPoolMetrics(ConnectionPool connectionPool); OkHttpConnectionPoolMetrics(ConnectionPool connectionPool, Iterable<Tag> tags); OkHttpConnectionPoolMetrics(ConnectionPool connectionPool, String namePrefix, Iterable<Tag> tags); OkHttpConnectionPoolMetrics(ConnectionPool connectionPool, String namePrefix, Iterable<Tag> tags, Integer maxIdleConnections); @Override void bindTo(@NonNull MeterRegistry registry); }
@Test void instanceUsesDefaultNamePrefix() { OkHttpConnectionPoolMetrics instance = new OkHttpConnectionPoolMetrics(connectionPool); instance.bindTo(registry); registry.get("okhttp.pool.connection.count"); } @Test void instanceUsesDefaultNamePrefixAndGivenTag() { OkHttpConnectionPoolMetrics instance = new OkHttpConnectionPoolMetrics(connectionPool, Tags.of("foo", "bar")); instance.bindTo(registry); registry.get("okhttp.pool.connection.count").tags("foo", "bar"); } @Test void instanceUsesGivenNamePrefix() { OkHttpConnectionPoolMetrics instance = new OkHttpConnectionPoolMetrics(connectionPool, "some.meter", Tags.empty()); instance.bindTo(registry); registry.get("some.meter.connection.count"); } @Test void instanceUsesGivenNamePrefixAndTag() { OkHttpConnectionPoolMetrics instance = new OkHttpConnectionPoolMetrics(connectionPool, "another.meter", Tags.of("bar", "baz")); instance.bindTo(registry); registry.get("another.meter.connection.count").tags("bar", "baz"); } @Test void activeAndIdle() { OkHttpConnectionPoolMetrics instance = new OkHttpConnectionPoolMetrics(connectionPool, Tags.of("foo", "bar")); instance.bindTo(registry); when(connectionPool.connectionCount()).thenReturn(17); when(connectionPool.idleConnectionCount()).thenReturn(10, 9); assertThat(registry.get("okhttp.pool.connection.count") .tags(Tags.of("foo", "bar", "state", "active")) .gauge().value()).isEqualTo(7.0); assertThat(registry.get("okhttp.pool.connection.count") .tags(Tags.of("foo", "bar", "state", "idle")) .gauge().value()).isEqualTo(10.0); assertThat(registry.get("okhttp.pool.connection.count") .tags(Tags.of("foo", "bar", "state", "active")) .gauge().value()).isEqualTo(8.0); assertThat(registry.get("okhttp.pool.connection.count") .tags(Tags.of("foo", "bar", "state", "idle")) .gauge().value()).isEqualTo(9.0); } @Test void maxIfGiven() { OkHttpConnectionPoolMetrics instance = new OkHttpConnectionPoolMetrics(connectionPool, "huge.pool", Tags.of("foo", "bar"), 1234); instance.bindTo(registry); assertThat(registry.get("huge.pool.connection.limit") .tags(Tags.of("foo", "bar")) .gauge().value()).isEqualTo(1234.0); } @Test void maxIfNotGiven() { OkHttpConnectionPoolMetrics instance = new OkHttpConnectionPoolMetrics(connectionPool, "huge.pool", Tags.of("foo", "bar"), null); instance.bindTo(registry); assertThrows(MeterNotFoundException.class, () -> registry.get("huge.pool.connection.limit") .tags(Tags.of("foo", "bar")) .gauge()); }
OkHttpMetricsEventListener extends EventListener { public static Builder builder(MeterRegistry registry, String name) { return new Builder(registry, name); } protected OkHttpMetricsEventListener(MeterRegistry registry, String requestsMetricName, Function<Request, String> urlMapper, Iterable<Tag> extraTags, Iterable<BiFunction<Request, Response, Tag>> contextSpecificTags); OkHttpMetricsEventListener(MeterRegistry registry, String requestsMetricName, Function<Request, String> urlMapper, Iterable<Tag> extraTags, Iterable<BiFunction<Request, Response, Tag>> contextSpecificTags, Iterable<String> requestTagKeys, boolean includeHostTag); static Builder builder(MeterRegistry registry, String name); @Override void callStart(Call call); @Override void callFailed(Call call, IOException e); @Override void callEnd(Call call); @Override void responseHeadersEnd(Call call, Response response); static final String URI_PATTERN; }
@Test void timeFailureDueToTimeout(@WiremockResolver.Wiremock WireMockServer server) { Request request = new Request.Builder() .url(server.baseUrl()) .build(); server.stop(); OkHttpClient client = new OkHttpClient.Builder() .connectTimeout(1, TimeUnit.MILLISECONDS) .eventListener(OkHttpMetricsEventListener.builder(registry, "okhttp.requests") .tags(Tags.of("foo", "bar")) .uriMapper(URI_MAPPER) .build()) .build(); try { client.newCall(request).execute().close(); fail("Expected IOException."); } catch (IOException ignored) { } assertThat(registry.get("okhttp.requests") .tags("foo", "bar", "uri", URI_EXAMPLE_VALUE, "status", "IO_ERROR", "target.host", "localhost") .timer().count()).isEqualTo(1L); } @Test void uriTagWorksWithUriPatternHeader(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); Request request = new Request.Builder() .url(server.baseUrl() + "/helloworld.txt") .header(OkHttpMetricsEventListener.URI_PATTERN, "/") .build(); client = new OkHttpClient.Builder() .eventListener(OkHttpMetricsEventListener.builder(registry, "okhttp.requests") .tags(Tags.of("foo", "bar")) .build()) .build(); client.newCall(request).execute().close(); assertThat(registry.get("okhttp.requests") .tags("foo", "bar", "uri", "/", "status", "200", "target.host", "localhost", "target.port", String.valueOf(server.port()), "target.scheme", "http") .timer().count()).isEqualTo(1L); } @Test void uriTagWorksWithUriMapper(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); OkHttpClient client = new OkHttpClient.Builder() .eventListener(OkHttpMetricsEventListener.builder(registry, "okhttp.requests") .uriMapper(req -> req.url().encodedPath()) .tags(Tags.of("foo", "bar")) .build()) .build(); Request request = new Request.Builder() .url(server.baseUrl() + "/helloworld.txt") .build(); client.newCall(request).execute().close(); assertThat(registry.get("okhttp.requests") .tags("foo", "bar", "uri", "/helloworld.txt", "status", "200", "target.host", "localhost", "target.port", String.valueOf(server.port()), "target.scheme", "http") .timer().count()).isEqualTo(1L); } @Test void contextSpecificTags(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); OkHttpClient client = new OkHttpClient.Builder() .eventListener(OkHttpMetricsEventListener.builder(registry, "okhttp.requests") .tag((req, res) -> Tag.of("another.uri", req.url().encodedPath())) .build()) .build(); Request request = new Request.Builder() .url(server.baseUrl() + "/helloworld.txt") .build(); client.newCall(request).execute().close(); assertThat(registry.get("okhttp.requests") .tags("another.uri", "/helloworld.txt", "status", "200") .timer().count()).isEqualTo(1L); } @Test void cachedResponsesDoNotLeakMemory( @WiremockResolver.Wiremock WireMockServer server, @TempDir Path tempDir) throws IOException { OkHttpMetricsEventListener listener = OkHttpMetricsEventListener.builder(registry, "okhttp.requests").build(); OkHttpClient clientWithCache = new OkHttpClient.Builder() .eventListener(listener) .cache(new Cache(tempDir.toFile(), 55555)) .build(); server.stubFor(any(anyUrl()).willReturn(aResponse().withHeader("Cache-Control", "max-age=9600"))); Request request = new Request.Builder() .url(server.baseUrl()) .build(); clientWithCache.newCall(request).execute().close(); assertThat(listener.callState).isEmpty(); try (Response response = clientWithCache.newCall(request).execute()) { assertThat(response.cacheResponse()).isNotNull(); } assertThat(listener.callState).isEmpty(); } @Test void hostTagCanBeDisabled(@WiremockResolver.Wiremock WireMockServer server) throws IOException { server.stubFor(any(anyUrl())); OkHttpClient client = new OkHttpClient.Builder() .eventListener(OkHttpMetricsEventListener.builder(registry, "okhttp.requests") .includeHostTag(false) .build()) .build(); Request request = new Request.Builder() .url(server.baseUrl()) .build(); client.newCall(request).execute().close(); assertThat(registry.get("okhttp.requests") .tags("status", "200", "target.host", "localhost", "target.port", String.valueOf(server.port()), "target.scheme", "http") .timer().getId().getTags()).doesNotContain(Tag.of("host", "localhost")); }
ElasticMeterRegistry extends StepMeterRegistry { protected String indexName() { ZonedDateTime dt = ZonedDateTime.ofInstant(new Date(config().clock().wallTime()).toInstant(), ZoneOffset.UTC); return config.index() + config.indexDateSeparator() + indexDateFormatter.format(dt); } @SuppressWarnings("deprecation") ElasticMeterRegistry(ElasticConfig config, Clock clock); protected ElasticMeterRegistry(ElasticConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient); static Builder builder(ElasticConfig config); }
@Issue("#987") @Test void indexNameSupportsIndexNameWithoutDateSuffix() { ElasticMeterRegistry registry = new ElasticMeterRegistry(new ElasticConfig() { @Override public String get(String key) { return null; } @Override public String index() { return "my-metrics"; } @Override public String indexDateFormat() { return ""; } @Override public String indexDateSeparator() { return ""; } }, clock); assertThat(registry.indexName()).isEqualTo("my-metrics"); } @Test void canExtendElasticMeterRegistry() { ElasticMeterRegistry registry = new ElasticMeterRegistry(config, clock) { @Override public String indexName() { return "my-metrics"; } }; assertThat(registry.indexName()).isEqualTo("my-metrics"); }
SignalFxNamingConvention implements NamingConvention { @Override public String tagKey(String key) { String conventionKey = delegate.tagKey(key); conventionKey = START_UNDERSCORE_PATTERN.matcher(conventionKey).replaceAll(""); conventionKey = SF_PATTERN.matcher(conventionKey).replaceAll(""); conventionKey = PATTERN_TAG_KEY_BLACKLISTED_CHARS.matcher(conventionKey).replaceAll("_"); if (!START_LETTERS_PATTERN.matcher(conventionKey).matches()) { conventionKey = "a" + conventionKey; } if (PATTERN_TAG_KEY_BLACKLISTED_PREFIX.matcher(conventionKey).matches()) { logger.log("'" + conventionKey + "' (original name: '" + key + "') is not a valid tag key. " + "Must not start with any of these prefixes: aws_, gcp_, or azure_. " + "Please rename it to conform to the constraints. " + "If it comes from a third party, please use MeterFilter to rename it."); } return StringUtils.truncate(conventionKey, KEY_MAX_LENGTH); } SignalFxNamingConvention(); SignalFxNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); @Override String tagValue(String value); }
@Test void tagKey() { assertThat(convention.tagKey("_boo")).isEqualTo("boo"); assertThat(convention.tagKey("sf_boo")).isEqualTo("boo"); assertThat(convention.tagKey("123")).isEqualTo("a123"); } @Test void tagKeyWhenKeyHasBlacklistedCharShouldSanitize() { assertThat(convention.tagKey("a.b")).isEqualTo("a_b"); }
JvmMemory { static Optional<MemoryPoolMXBean> getOldGen() { return ManagementFactory .getPlatformMXBeans(MemoryPoolMXBean.class) .stream() .filter(JvmMemory::isHeap) .filter(mem -> isOldGenPool(mem.getName())) .findAny(); } private JvmMemory(); }
@Test void assertJvmMemoryGetOldGen() { Optional<MemoryPoolMXBean> oldGen = JvmMemory.getOldGen(); assertThat(oldGen).isNotEmpty(); }
JvmThreadMetrics implements MeterBinder { @Override public void bindTo(MeterRegistry registry) { ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); Gauge.builder("jvm.threads.peak", threadBean, ThreadMXBean::getPeakThreadCount) .tags(tags) .description("The peak live thread count since the Java virtual machine started or peak was reset") .baseUnit(BaseUnits.THREADS) .register(registry); Gauge.builder("jvm.threads.daemon", threadBean, ThreadMXBean::getDaemonThreadCount) .tags(tags) .description("The current number of live daemon threads") .baseUnit(BaseUnits.THREADS) .register(registry); Gauge.builder("jvm.threads.live", threadBean, ThreadMXBean::getThreadCount) .tags(tags) .description("The current number of live threads including both daemon and non-daemon threads") .baseUnit(BaseUnits.THREADS) .register(registry); try { threadBean.getAllThreadIds(); for (Thread.State state : Thread.State.values()) { Gauge.builder("jvm.threads.states", threadBean, (bean) -> getThreadStateCount(bean, state)) .tags(Tags.concat(tags, "state", getStateTagValue(state))) .description("The current number of threads having " + state + " state") .baseUnit(BaseUnits.THREADS) .register(registry); } } catch (Error error) { } } JvmThreadMetrics(); JvmThreadMetrics(Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void threadMetrics() { MeterRegistry registry = new SimpleMeterRegistry(); new JvmThreadMetrics().bindTo(registry); assertThat(registry.get("jvm.threads.live").gauge().value()).isGreaterThan(0); assertThat(registry.get("jvm.threads.daemon").gauge().value()).isGreaterThan(0); assertThat(registry.get("jvm.threads.peak").gauge().value()).isGreaterThan(0); assertThat(registry.get("jvm.threads.states").tag("state", "runnable").gauge().value()).isGreaterThan(0); createBlockedThread(); assertThat(registry.get("jvm.threads.states").tag("state", "blocked").gauge().value()).isGreaterThan(0); assertThat(registry.get("jvm.threads.states").tag("state", "waiting").gauge().value()).isGreaterThan(0); createTimedWaitingThread(); assertThat(registry.get("jvm.threads.states").tag("state", "timed-waiting").gauge().value()).isGreaterThan(0); }
JvmThreadMetrics implements MeterBinder { static long getThreadStateCount(ThreadMXBean threadBean, Thread.State state) { return Arrays.stream(threadBean.getThreadInfo(threadBean.getAllThreadIds())) .filter(threadInfo -> threadInfo != null && threadInfo.getThreadState() == state) .count(); } JvmThreadMetrics(); JvmThreadMetrics(Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void getThreadStateCountWhenThreadInfoIsNullShouldWork() { ThreadMXBean threadBean = mock(ThreadMXBean.class); long[] threadIds = {1L, 2L}; when(threadBean.getAllThreadIds()).thenReturn(threadIds); ThreadInfo threadInfo = mock(ThreadInfo.class); when(threadInfo.getThreadState()).thenReturn(Thread.State.RUNNABLE); when(threadBean.getThreadInfo(threadIds)).thenReturn(new ThreadInfo[] { threadInfo, null }); assertThat(JvmThreadMetrics.getThreadStateCount(threadBean, Thread.State.RUNNABLE)).isEqualTo(1); }
ClassLoaderMetrics implements MeterBinder { @Override public void bindTo(MeterRegistry registry) { ClassLoadingMXBean classLoadingBean = ManagementFactory.getClassLoadingMXBean(); Gauge.builder("jvm.classes.loaded", classLoadingBean, ClassLoadingMXBean::getLoadedClassCount) .tags(tags) .description("The number of classes that are currently loaded in the Java virtual machine") .baseUnit(BaseUnits.CLASSES) .register(registry); FunctionCounter.builder("jvm.classes.unloaded", classLoadingBean, ClassLoadingMXBean::getUnloadedClassCount) .tags(tags) .description("The total number of classes unloaded since the Java virtual machine has started execution") .baseUnit(BaseUnits.CLASSES) .register(registry); } ClassLoaderMetrics(); ClassLoaderMetrics(Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void classLoadingMetrics() { MeterRegistry registry = new SimpleMeterRegistry(); new ClassLoaderMetrics().bindTo(registry); assertThat(registry.get("jvm.classes.loaded").gauge().value()).isGreaterThan(0); }
JvmMemoryMetrics implements MeterBinder { @Override public void bindTo(MeterRegistry registry) { for (BufferPoolMXBean bufferPoolBean : ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class)) { Iterable<Tag> tagsWithId = Tags.concat(tags, "id", bufferPoolBean.getName()); Gauge.builder("jvm.buffer.count", bufferPoolBean, BufferPoolMXBean::getCount) .tags(tagsWithId) .description("An estimate of the number of buffers in the pool") .baseUnit(BaseUnits.BUFFERS) .register(registry); Gauge.builder("jvm.buffer.memory.used", bufferPoolBean, BufferPoolMXBean::getMemoryUsed) .tags(tagsWithId) .description("An estimate of the memory that the Java virtual machine is using for this buffer pool") .baseUnit(BaseUnits.BYTES) .register(registry); Gauge.builder("jvm.buffer.total.capacity", bufferPoolBean, BufferPoolMXBean::getTotalCapacity) .tags(tagsWithId) .description("An estimate of the total capacity of the buffers in this pool") .baseUnit(BaseUnits.BYTES) .register(registry); } for (MemoryPoolMXBean memoryPoolBean : ManagementFactory.getPlatformMXBeans(MemoryPoolMXBean.class)) { String area = MemoryType.HEAP.equals(memoryPoolBean.getType()) ? "heap" : "nonheap"; Iterable<Tag> tagsWithId = Tags.concat(tags, "id", memoryPoolBean.getName(), "area", area); Gauge.builder("jvm.memory.used", memoryPoolBean, (mem) -> getUsageValue(mem, MemoryUsage::getUsed)) .tags(tagsWithId) .description("The amount of used memory") .baseUnit(BaseUnits.BYTES) .register(registry); Gauge.builder("jvm.memory.committed", memoryPoolBean, (mem) -> getUsageValue(mem, MemoryUsage::getCommitted)) .tags(tagsWithId) .description("The amount of memory in bytes that is committed for the Java virtual machine to use") .baseUnit(BaseUnits.BYTES) .register(registry); Gauge.builder("jvm.memory.max", memoryPoolBean, (mem) -> getUsageValue(mem, MemoryUsage::getMax)) .tags(tagsWithId) .description("The maximum amount of memory in bytes that can be used for memory management") .baseUnit(BaseUnits.BYTES) .register(registry); } } JvmMemoryMetrics(); JvmMemoryMetrics(Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void memoryMetrics() { MeterRegistry registry = new SimpleMeterRegistry(); new JvmMemoryMetrics().bindTo(registry); assertJvmBufferMetrics(registry, "direct"); assertJvmBufferMetrics(registry, "mapped"); assertJvmMemoryMetrics(registry, "heap"); assertJvmMemoryMetrics(registry, "nonheap"); }
JvmGcMetrics implements MeterBinder, AutoCloseable { @Override public void bindTo(MeterRegistry registry) { if (!this.managementExtensionsPresent) { return; } double maxOldGen = getOldGen().map(mem -> getUsageValue(mem, MemoryUsage::getMax)).orElse(0.0); AtomicLong maxDataSize = new AtomicLong((long) maxOldGen); Gauge.builder("jvm.gc.max.data.size", maxDataSize, AtomicLong::get) .tags(tags) .description("Max size of old generation memory pool") .baseUnit(BaseUnits.BYTES) .register(registry); AtomicLong liveDataSize = new AtomicLong(0L); Gauge.builder("jvm.gc.live.data.size", liveDataSize, AtomicLong::get) .tags(tags) .description("Size of old generation memory pool after a full GC") .baseUnit(BaseUnits.BYTES) .register(registry); Counter promotedBytes = Counter.builder("jvm.gc.memory.promoted").tags(tags) .baseUnit(BaseUnits.BYTES) .description("Count of positive increases in the size of the old generation memory pool before GC to after GC") .register(registry); Counter allocatedBytes = Counter.builder("jvm.gc.memory.allocated").tags(tags) .baseUnit(BaseUnits.BYTES) .description("Incremented for an increase in the size of the young generation memory pool after one GC to before the next") .register(registry); final AtomicLong youngGenSizeAfter = new AtomicLong(0L); for (GarbageCollectorMXBean mbean : ManagementFactory.getGarbageCollectorMXBeans()) { if (!(mbean instanceof NotificationEmitter)) { continue; } NotificationListener notificationListener = (notification, ref) -> { if (!notification.getType().equals(GarbageCollectionNotificationInfo.GARBAGE_COLLECTION_NOTIFICATION)) { return; } CompositeData cd = (CompositeData) notification.getUserData(); GarbageCollectionNotificationInfo notificationInfo = GarbageCollectionNotificationInfo.from(cd); String gcCause = notificationInfo.getGcCause(); String gcAction = notificationInfo.getGcAction(); GcInfo gcInfo = notificationInfo.getGcInfo(); long duration = gcInfo.getDuration(); if (isConcurrentPhase(gcCause)) { Timer.builder("jvm.gc.concurrent.phase.time") .tags(tags) .tags("action", gcAction, "cause", gcCause) .description("Time spent in concurrent phase") .register(registry) .record(duration, TimeUnit.MILLISECONDS); } else { Timer.builder("jvm.gc.pause") .tags(tags) .tags("action", gcAction, "cause", gcCause) .description("Time spent in GC pause") .register(registry) .record(duration, TimeUnit.MILLISECONDS); } final Map<String, MemoryUsage> before = gcInfo.getMemoryUsageBeforeGc(); final Map<String, MemoryUsage> after = gcInfo.getMemoryUsageAfterGc(); if (oldGenPoolName != null) { final long oldBefore = before.get(oldGenPoolName).getUsed(); final long oldAfter = after.get(oldGenPoolName).getUsed(); final long delta = oldAfter - oldBefore; if (delta > 0L) { promotedBytes.increment(delta); } if (oldAfter < oldBefore || GcGenerationAge.fromName(notificationInfo.getGcName()) == GcGenerationAge.OLD) { liveDataSize.set(oldAfter); final long oldMaxAfter = after.get(oldGenPoolName).getMax(); maxDataSize.set(oldMaxAfter); } } if (youngGenPoolName != null) { final long youngBefore = before.get(youngGenPoolName).getUsed(); final long youngAfter = after.get(youngGenPoolName).getUsed(); final long delta = youngBefore - youngGenSizeAfter.get(); youngGenSizeAfter.set(youngAfter); if (delta > 0L) { allocatedBytes.increment(delta); } } }; NotificationEmitter notificationEmitter = (NotificationEmitter) mbean; notificationEmitter.addNotificationListener(notificationListener, null, null); notificationListenerCleanUpRunnables.add(() -> { try { notificationEmitter.removeNotificationListener(notificationListener); } catch (ListenerNotFoundException ignore) { } }); } } JvmGcMetrics(); JvmGcMetrics(Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); @Override void close(); }
@Test void metersAreBound() { SimpleMeterRegistry registry = new SimpleMeterRegistry(); JvmGcMetrics binder = new JvmGcMetrics(); binder.bindTo(registry); assertThat(registry.find("jvm.gc.max.data.size").gauge()).isNotNull(); assertThat(registry.find("jvm.gc.live.data.size").gauge()).isNotNull(); assertThat(registry.find("jvm.gc.memory.promoted").counter()).isNotNull(); assertThat(registry.find("jvm.gc.memory.allocated").counter()).isNotNull(); }
DiskSpaceMetrics implements MeterBinder { public DiskSpaceMetrics(File path) { this(path, emptyList()); } DiskSpaceMetrics(File path); DiskSpaceMetrics(File path, Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void diskSpaceMetrics() { new DiskSpaceMetrics(new File(System.getProperty("user.dir"))).bindTo(registry); assertThat(registry.get("disk.free").gauge().value()).isNotNaN().isGreaterThan(0); assertThat(registry.get("disk.total").gauge().value()).isNotNaN().isGreaterThan(0); }
DiskSpaceMetrics implements MeterBinder { @Override public void bindTo(MeterRegistry registry) { Iterable<Tag> tagsWithPath = Tags.concat(tags, "path", absolutePath); Gauge.builder("disk.free", path, File::getUsableSpace) .tags(tagsWithPath) .description("Usable space for path") .baseUnit(BaseUnits.BYTES) .strongReference(true) .register(registry); Gauge.builder("disk.total", path, File::getTotalSpace) .tags(tagsWithPath) .description("Total space for path") .baseUnit(BaseUnits.BYTES) .strongReference(true) .register(registry); } DiskSpaceMetrics(File path); DiskSpaceMetrics(File path, Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void diskSpaceMetricsWithTags() { new DiskSpaceMetrics(new File(System.getProperty("user.dir")), Tags.of("key1", "value1")).bindTo(registry); assertThat(registry.get("disk.free").tags("key1", "value1").gauge().value()).isNotNaN().isGreaterThan(0); assertThat(registry.get("disk.total").tags("key1", "value1").gauge().value()).isNotNaN().isGreaterThan(0); } @Test void garbageCollectionDoesNotLoseGaugeValue() { new DiskSpaceMetrics(new File(System.getProperty("user.dir"))).bindTo(registry); System.gc(); assertThat(registry.get("disk.free").gauge().value()).isNotNaN().isGreaterThan(0); assertThat(registry.get("disk.total").gauge().value()).isNotNaN().isGreaterThan(0); }
JvmCompilationMetrics implements MeterBinder { @Override public void bindTo(MeterRegistry registry) { CompilationMXBean compilationBean = ManagementFactory.getCompilationMXBean(); if (compilationBean != null && compilationBean.isCompilationTimeMonitoringSupported()) { FunctionCounter.builder("jvm.compilation.time", compilationBean, CompilationMXBean::getTotalCompilationTime) .tags(Tags.concat(tags, "compiler", compilationBean.getName())) .description("The approximate accumulated elapsed time spent in compilation") .baseUnit(BaseUnits.MILLISECONDS) .register(registry); } } JvmCompilationMetrics(); JvmCompilationMetrics(Iterable<Tag> tags); @Override void bindTo(MeterRegistry registry); }
@Test void compilationTimeMetric() { new JvmCompilationMetrics().bindTo(registry); CompilationMXBean compilationMXBean = ManagementFactory.getCompilationMXBean(); assumeTrue(compilationMXBean != null && compilationMXBean.isCompilationTimeMonitoringSupported()); assertThat(registry.get("jvm.compilation.time").functionCounter().count()).isGreaterThan(0); }
EhCache2Metrics extends CacheMeterBinder { public static Ehcache monitor(MeterRegistry registry, Ehcache cache, String... tags) { return monitor(registry, cache, Tags.of(tags)); } EhCache2Metrics(Ehcache cache, Iterable<Tag> tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, String... tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, Iterable<Tag> tags); }
@Test void constructInstanceViaStaticMethodMonitor() { MeterRegistry meterRegistry = new SimpleMeterRegistry(); EhCache2Metrics.monitor(meterRegistry, cache, expectedTag); meterRegistry.get("cache.remoteSize").tags(expectedTag).gauge(); }
EhCache2Metrics extends CacheMeterBinder { @Override protected Long size() { return stats.getSize(); } EhCache2Metrics(Ehcache cache, Iterable<Tag> tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, String... tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, Iterable<Tag> tags); }
@Test void returnCacheSize() { StatisticsGateway stats = cache.getStatistics(); assertThat(metrics.size()).isEqualTo(stats.getSize()); }
EhCache2Metrics extends CacheMeterBinder { @Override protected Long evictionCount() { return stats.cacheEvictedCount(); } EhCache2Metrics(Ehcache cache, Iterable<Tag> tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, String... tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, Iterable<Tag> tags); }
@Test void returnEvictionCount() { StatisticsGateway stats = cache.getStatistics(); assertThat(metrics.evictionCount()).isEqualTo(stats.cacheEvictedCount()); }
EhCache2Metrics extends CacheMeterBinder { @Override protected long hitCount() { return stats.cacheHitCount(); } EhCache2Metrics(Ehcache cache, Iterable<Tag> tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, String... tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, Iterable<Tag> tags); }
@Test void returnHitCount() { StatisticsGateway stats = cache.getStatistics(); assertThat(metrics.hitCount()).isEqualTo(stats.cacheHitCount()); }
EhCache2Metrics extends CacheMeterBinder { @Override protected Long missCount() { return stats.cacheMissCount(); } EhCache2Metrics(Ehcache cache, Iterable<Tag> tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, String... tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, Iterable<Tag> tags); }
@Test void returnMissCount() { StatisticsGateway stats = cache.getStatistics(); assertThat(metrics.missCount()).isEqualTo(stats.cacheMissCount()); }
EhCache2Metrics extends CacheMeterBinder { @Override protected long putCount() { return stats.cachePutCount(); } EhCache2Metrics(Ehcache cache, Iterable<Tag> tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, String... tags); static Ehcache monitor(MeterRegistry registry, Ehcache cache, Iterable<Tag> tags); }
@Test void returnPutCount() { StatisticsGateway stats = cache.getStatistics(); assertThat(metrics.putCount()).isEqualTo(stats.cachePutCount()); }
HazelcastCacheMetrics extends CacheMeterBinder { public static Object monitor(MeterRegistry registry, Object cache, String... tags) { return monitor(registry, cache, Tags.of(tags)); } HazelcastCacheMetrics(Object cache, Iterable<Tag> tags); static Object monitor(MeterRegistry registry, Object cache, String... tags); static Object monitor(MeterRegistry registry, Object cache, Iterable<Tag> tags); }
@Test void constructInstanceViaStaticMethodMonitor() { MeterRegistry meterRegistry = new SimpleMeterRegistry(); HazelcastCacheMetrics.monitor(meterRegistry, cache, expectedTag); meterRegistry.get("cache.partition.gets").tags(expectedTag).functionCounter(); } @Test void doNotReportEvictionCountSinceNotImplemented() { MeterRegistry meterRegistry = new SimpleMeterRegistry(); HazelcastCacheMetrics.monitor(meterRegistry, cache, expectedTag); assertThat(meterRegistry.find("cache.evictions").functionCounter()).isNull(); } @Test void doNotReportMissCountSinceNotImplemented() { MeterRegistry registry = new SimpleMeterRegistry(); HazelcastCacheMetrics.monitor(registry, cache, expectedTag); assertThat(registry.find("cache.gets").tags(Tags.of("result", "miss")).functionCounter()).isNull(); }
HazelcastCacheMetrics extends CacheMeterBinder { @Override protected Long size() { return cache.getLocalMapStats().getOwnedEntryCount(); } HazelcastCacheMetrics(Object cache, Iterable<Tag> tags); static Object monitor(MeterRegistry registry, Object cache, String... tags); static Object monitor(MeterRegistry registry, Object cache, Iterable<Tag> tags); }
@Test void returnCacheSize() { assertThat(metrics.size()).isEqualTo(cache.size()); }
HazelcastCacheMetrics extends CacheMeterBinder { @Override protected Long missCount() { return null; } HazelcastCacheMetrics(Object cache, Iterable<Tag> tags); static Object monitor(MeterRegistry registry, Object cache, String... tags); static Object monitor(MeterRegistry registry, Object cache, Iterable<Tag> tags); }
@Test void returnNullForMissCount() { assertThat(metrics.missCount()).isNull(); }
HazelcastCacheMetrics extends CacheMeterBinder { @Nullable @Override protected Long evictionCount() { return null; } HazelcastCacheMetrics(Object cache, Iterable<Tag> tags); static Object monitor(MeterRegistry registry, Object cache, String... tags); static Object monitor(MeterRegistry registry, Object cache, Iterable<Tag> tags); }
@Test void returnNullForEvictionCount() { assertThat(metrics.evictionCount()).isNull(); }
HazelcastCacheMetrics extends CacheMeterBinder { @Override protected long hitCount() { return cache.getLocalMapStats().getHits(); } HazelcastCacheMetrics(Object cache, Iterable<Tag> tags); static Object monitor(MeterRegistry registry, Object cache, String... tags); static Object monitor(MeterRegistry registry, Object cache, Iterable<Tag> tags); }
@Test void returnHitCount() { assertThat(metrics.hitCount()).isEqualTo(cache.getLocalMapStats().getHits()); }
HazelcastCacheMetrics extends CacheMeterBinder { @Override protected long putCount() { return cache.getLocalMapStats().getPutOperationCount(); } HazelcastCacheMetrics(Object cache, Iterable<Tag> tags); static Object monitor(MeterRegistry registry, Object cache, String... tags); static Object monitor(MeterRegistry registry, Object cache, Iterable<Tag> tags); }
@Test void returnPutCount() { assertThat(metrics.putCount()).isEqualTo(cache.getLocalMapStats().getPutOperationCount()); }
GuavaCacheMetrics extends CacheMeterBinder { public static <C extends Cache<?, ?>> C monitor(MeterRegistry registry, C cache, String cacheName, String... tags) { return monitor(registry, cache, cacheName, Tags.of(tags)); } GuavaCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void constructInstanceViaStaticMethodMonitor() { MeterRegistry meterRegistry = new SimpleMeterRegistry(); GuavaCacheMetrics.monitor(meterRegistry, cache, "testCache", expectedTag); meterRegistry.get("cache.load.duration").tags(expectedTag).timeGauge(); }
GuavaCacheMetrics extends CacheMeterBinder { @Override protected Long size() { return cache.size(); } GuavaCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnCacheSize() { assertThat(metrics.size()).isEqualTo(cache.size()); }
GuavaCacheMetrics extends CacheMeterBinder { @Override protected long hitCount() { return cache.stats().hitCount(); } GuavaCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnHitCount() { assertThat(metrics.hitCount()).isEqualTo(cache.stats().hitCount()); }
GuavaCacheMetrics extends CacheMeterBinder { @Override protected Long missCount() { return cache.stats().missCount(); } GuavaCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnMissCount() { assertThat(metrics.missCount()).isEqualTo(cache.stats().missCount()); }
ElasticNamingConvention implements NamingConvention { @Override public String tagKey(String key) { if (key.equals("name")) { key = "name.tag"; } else if (key.equals("type")) { key = "type.tag"; } else if (key.startsWith("_")) { key = FIRST_UNDERSCORE_PATTERN.matcher(key).replaceFirst(""); } return delegate.tagKey(key); } ElasticNamingConvention(); ElasticNamingConvention(NamingConvention delegate); @Override String name(String name, Meter.Type type, @Nullable String baseUnit); @Override String tagKey(String key); }
@Issue("#506") @Test void replaceNameTag() { assertThat(namingConvention.tagKey("name")).isEqualTo("name_tag"); } @Test void replaceTypeTag() { assertThat(namingConvention.tagKey("type")).isEqualTo("type_tag"); } @Test void replaceLeadingUnderscores() { assertThat(namingConvention.tagKey("__tag")).isEqualTo("tag"); }
GuavaCacheMetrics extends CacheMeterBinder { @Override protected Long evictionCount() { return cache.stats().evictionCount(); } GuavaCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnEvictionCount() { assertThat(metrics.evictionCount()).isEqualTo(cache.stats().evictionCount()); }
GuavaCacheMetrics extends CacheMeterBinder { @Override protected long putCount() { return cache.stats().loadCount(); } GuavaCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnPutCount() { assertThat(metrics.putCount()).isEqualTo(cache.stats().loadCount()); }
CaffeineCacheMetrics extends CacheMeterBinder { public static <C extends Cache<?, ?>> C monitor(MeterRegistry registry, C cache, String cacheName, String... tags) { return monitor(registry, cache, cacheName, Tags.of(tags)); } CaffeineCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void constructInstanceViaStaticMethodMonitor() { MeterRegistry meterRegistry = new SimpleMeterRegistry(); CaffeineCacheMetrics.monitor(meterRegistry, cache, "testCache", expectedTag); meterRegistry.get("cache.eviction.weight").tags(expectedTag).functionCounter(); }
CaffeineCacheMetrics extends CacheMeterBinder { @Override protected Long size() { return cache.estimatedSize(); } CaffeineCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnCacheSize() { assertThat(metrics.size()).isEqualTo(cache.estimatedSize()); }
CaffeineCacheMetrics extends CacheMeterBinder { @Override protected long hitCount() { return cache.stats().hitCount(); } CaffeineCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnHitCount() { assertThat(metrics.hitCount()).isEqualTo(cache.stats().hitCount()); }
CaffeineCacheMetrics extends CacheMeterBinder { @Override protected Long missCount() { return cache.stats().missCount(); } CaffeineCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnMissCount() { assertThat(metrics.missCount()).isEqualTo(cache.stats().missCount()); }
CaffeineCacheMetrics extends CacheMeterBinder { @Override protected Long evictionCount() { return cache.stats().evictionCount(); } CaffeineCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnEvictionCount() { assertThat(metrics.evictionCount()).isEqualTo(cache.stats().evictionCount()); }
CaffeineCacheMetrics extends CacheMeterBinder { @Override protected long putCount() { return cache.stats().loadCount(); } CaffeineCacheMetrics(Cache<?, ?> cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String cacheName, String... tags); static C monitor(MeterRegistry registry, C cache, String cacheName, Iterable<Tag> tags); }
@Test void returnPutCount() { assertThat(metrics.putCount()).isEqualTo(cache.stats().loadCount()); }
JCacheMetrics extends CacheMeterBinder { public static <K, V, C extends Cache<K, V>> C monitor(MeterRegistry registry, C cache, String... tags) { return monitor(registry, cache, Tags.of(tags)); } JCacheMetrics(Cache<?, ?> cache, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String... tags); static C monitor(MeterRegistry registry, C cache, Iterable<Tag> tags); }
@Test void constructInstanceViaStaticMethodMonitor() { MeterRegistry meterRegistry = new SimpleMeterRegistry(); JCacheMetrics.monitor(meterRegistry, cache, expectedTag); meterRegistry.get("cache.removals").tags(expectedTag).gauge(); } @Test void constructInstanceViaStaticMethodMonitorWithVarArgTags() { MeterRegistry meterRegistry = new SimpleMeterRegistry(); JCacheMetrics.monitor(meterRegistry, cache, "version", "1.0"); meterRegistry.get("cache.removals").tags(Tags.of("version", "1.0")).gauge(); }
JCacheMetrics extends CacheMeterBinder { @Override protected Long size() { return null; } JCacheMetrics(Cache<?, ?> cache, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String... tags); static C monitor(MeterRegistry registry, C cache, Iterable<Tag> tags); }
@Test void returnNullForCacheSize() { assertThat(metrics.size()).isNull(); }
JCacheMetrics extends CacheMeterBinder { @Override protected Long missCount() { return lookupStatistic("CacheMisses"); } JCacheMetrics(Cache<?, ?> cache, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String... tags); static C monitor(MeterRegistry registry, C cache, Iterable<Tag> tags); }
@Test void returnMissCount() { assertThat(metrics.missCount()).isEqualTo(expectedAttributeValue); }
JCacheMetrics extends CacheMeterBinder { @Override protected Long evictionCount() { return lookupStatistic("CacheEvictions"); } JCacheMetrics(Cache<?, ?> cache, Iterable<Tag> tags); static C monitor(MeterRegistry registry, C cache, String... tags); static C monitor(MeterRegistry registry, C cache, Iterable<Tag> tags); }
@Test void returnEvictionCount() { assertThat(metrics.evictionCount()).isEqualTo(expectedAttributeValue); }