private void assertMetricsContainsTag(String tagKey, String tagValue) { List<Meter.Id> meterIds = null; try { meterIds = this.meterRegistry.getMeters().stream() .map(Meter::getId) .collect(Collectors.toList()); Collection<Timer> timers = this.meterRegistry.get(REQUEST_METRICS_NAME).timers(); System.err.println("Looking for gateway.requests: tag: " + tagKey + ", value: "+ tagValue); timers.forEach(timer -> System.err.println(timer.getId()+timer.getClass().getSimpleName())); long count = getCount(tagKey, tagValue); assertThat(count).isEqualTo(1); } catch (MeterNotFoundException e) { System.err.println("\n\n\nError finding gatway.requests meter: tag: " + tagKey + ", value: "+ tagValue); System.err.println("\n\n\nMeter ids prior to search: "+meterIds + "\n\n\n and after:"); this.meterRegistry.forEachMeter(meter -> System.err.println(meter.getId() + meter.getClass().getSimpleName())); // try again? long count = getCount(tagKey, tagValue); if (count != 1) { throw e; } } }
private long getCount(String tagKey, String tagValue) { return this.meterRegistry.get(REQUEST_METRICS_NAME).tag(tagKey, tagValue) .timer().count(); }
this.queue.receive(); MeterRegistry registry = this.meterRegistry; assertThat(registry.get("spring.integration.channels").gauge().value()).isEqualTo(3); assertThat(registry.get("myTimer") .tag("standardTimerName", "spring.integration.send") .tag("name", "queue") .timer().count()).isEqualTo(1); assertThat(registry.get("myCounter") .tag("standardCounterName", "spring.integration.receive") .tag("name", "queue") registry.get("myTimer").timers(); fail("Expected MeterNotFoundException"); registry.get("myCounter").counters(); fail("Expected MeterNotFoundException");
assertThat(registry.get("spring.integration.channels").gauge().value()).isEqualTo(6); assertThat(registry.get("spring.integration.handlers").gauge().value()).isEqualTo(3); assertThat(registry.get("spring.integration.sources").gauge().value()).isEqualTo(1); assertThat(registry.get("spring.integration.receive") .tag("name", "source") .tag("result", "success") .counter().count()).isEqualTo(1); assertThat(registry.get("spring.integration.receive") .tag("name", "badPoll") .tag("result", "failure") .counter().count()).isEqualTo(1); assertThat(registry.get("spring.integration.send") .tag("name", "eipBean.handler") .tag("result", "success") .timer().count()).isEqualTo(1); assertThat(registry.get("spring.integration.send") .tag("name", "eipMethod.handler") .tag("result", "success") .timer().count()).isEqualTo(1); assertThat(registry.get("spring.integration.send") .tag("name", "channel") .tag("result", "success") .timer().count()).isEqualTo(1);
@Test @DisplayName("gauges can be directly associated with collection size") default void collectionSizeGauge(MeterRegistry registry) { List<String> list = registry.gaugeCollectionSize("my.gauge", emptyList(), new ArrayList<>()); list.addAll(Arrays.asList("a", "b")); Gauge g = registry.get("my.gauge").gauge(); assertThat(g.value()).isEqualTo(2); }
@Test @DisplayName("gauges attached to an object are updated when their values are observed") default void objectGauge(MeterRegistry registry) { List<String> list = registry.gauge("my.gauge", emptyList(), new ArrayList<>(), List::size); list.addAll(Arrays.asList("a", "b")); Gauge g = registry.get("my.gauge").gauge(); assertThat(g.value()).isEqualTo(2); }
@Override public Meter get(Id id) { try { return impl.get(id.name()) .tags(convert(id.tags())) .meters() .stream() .filter(m -> id.equals(convert(m.getId()))) .map(this::convert) .filter(Objects::nonNull) .findFirst() .orElse(null); } catch (MeterNotFoundException e) { return null; } }
@Test @DisplayName("gauges can be directly associated with map entry size") default void mapSizeGauge(MeterRegistry registry) { Map<String, Integer> map = registry.gaugeMapSize("my.gauge", emptyList(), new HashMap<>()); map.put("a", 1); Gauge g = registry.get("my.gauge").gauge(); assertThat(g.value()).isEqualTo(1); }
@Test @DisplayName("meters with the same name and tags are registered once") void uniqueMeters(MeterRegistry registry) { registry.counter("foo"); registry.counter("foo"); assertThat(registry.get("foo").meters().size()).isEqualTo(1); }
@Test @DisplayName("gauges that reference an object that is garbage collected report NaN") default void garbageCollectedSourceObject(MeterRegistry registry) { registry.gauge("my.gauge", emptyList(), (Map) null, Map::size); assertThat(registry.get("my.gauge").gauge().value()).matches(val -> val == null || Double.isNaN(val) || val == 0.0); }
@Test @DisplayName("original and convention names are preserved for custom meter types") void aTaleOfTwoNames(MeterRegistry registry) { AtomicInteger n = new AtomicInteger(1); registry.more().counter("my.counter", Collections.emptyList(), n); registry.get("my.counter").functionCounter(); }
@Test @DisplayName("gauges attached to a number are updated when their values are observed") default void numericGauge(MeterRegistry registry) { AtomicInteger n = registry.gauge("my.gauge", new AtomicInteger(0)); n.set(1); Gauge g = registry.get("my.gauge").gauge(); assertThat(g.value()).isEqualTo(1); n.set(2); assertThat(g.value()).isEqualTo(2); }
@Test void puts() { put("k", "v"); assertThat(binder.putCount()).isEqualTo(1); assertThat(registry.get("cache.puts").tag("cache", "mycache") .functionCounter().count()) .isEqualTo(1); }
@Test @DisplayName("find meters by name and class type matching a subset of their tags") void findMeters(MeterRegistry registry) { Counter c1 = registry.counter("foo", "k", "v"); Counter c2 = registry.counter("bar", "k", "v", "k2", "v"); assertThat(registry.get("foo").tags("k", "v").counter()).isSameAs(c1); assertThat(registry.get("bar").tags("k", "v").counter()).isSameAs(c2); }
@Test @DisplayName("find meters by name and value") void findMetersByValue(MeterRegistry registry) { Counter c = registry.counter("counter"); c.increment(); Timer t = registry.timer("timer"); t.record(10, TimeUnit.NANOSECONDS); clock(registry).add(step()); assertThat(registry.get("counter").counter().count()).isEqualTo(1.0); assertThat(registry.get("timer").timer().count()).isEqualTo(1L); assertThat(registry.get("timer").timer().totalTime(TimeUnit.NANOSECONDS)).isEqualTo(10.0); }
@Test @DisplayName("find meters by name and type matching a subset of their tags") void findMetersByType(MeterRegistry registry) { Counter c1 = registry.counter("foo", "k", "v"); Counter c2 = registry.counter("bar", "k", "v", "k2", "v"); assertThat(registry.get("foo").tags("k", "v").counter()).isSameAs(c1); assertThat(registry.get("bar").tags("k", "v").counter()).isSameAs(c2); }
@Test @DisplayName("strong reference gauges") default void strongReferenceGauges(MeterRegistry registry) { Gauge.builder("weak.ref", 1.0, n -> n).register(registry); Gauge.builder("strong.ref", 1.0, n -> n) .strongReference(true) .register(registry); System.gc(); assertThat(registry.get("weak.ref").gauge().value()).isEqualTo(Double.NaN); assertThat(registry.get("strong.ref").gauge().value()).isEqualTo(1.0); } }
@Test @DisplayName("function-tracking counter increments by change in a monotonically increasing function when observed") default void functionTrackingCounter(MeterRegistry registry) { AtomicLong n = new AtomicLong(0); registry.more().counter("tracking", emptyList(), n); n.incrementAndGet(); clock(registry).add(step()); registry.forEachMeter(Meter::measure); assertThat(registry.get("tracking").functionCounter().count()).isEqualTo(1.0); } }
@Test void size() { put("k", "v"); assertThat(binder.size()).isIn(null, 1L); if (binder.size() != null) { assertThat(registry.get("cache.size") .tag("cache", "mycache") .gauge().value()) .isEqualTo(1); } }
@Test @DisplayName("common tags are added to every measurement") void addCommonTags(MeterRegistry registry) { registry.config().commonTags("k", "v"); Counter c = registry.counter("foo"); assertThat(registry.get("foo").tags("k", "v").counter()).isSameAs(c); assertThat(c.getId().getTagsAsIterable()).hasSize(1); }