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; } } }
@Test public void testClientCustomization() { log.info("--- Starting tests with client customization ---"); final MeterRegistry meterRegistry = new SimpleMeterRegistry(); assertEquals(0, meterRegistry.getMeters().size()); final MetricCollectingClientInterceptor mcci = new MetricCollectingClientInterceptor(meterRegistry, counter -> counter.tag("type", "counter"), timer -> timer.tag("type", "timer").publishPercentiles(0.5, 0.9, 0.99), OK, UNKNOWN); mcci.preregisterService(TestServiceGrpc.getServiceDescriptor()); MetricTestHelper.logMeters(meterRegistry.getMeters()); assertEquals(METHOD_COUNT * 10, meterRegistry.getMeters().size()); final Counter counter = meterRegistry.find(METRIC_NAME_CLIENT_REQUESTS_SENT).counter(); assertNotNull(counter); assertEquals("counter", counter.getId().getTag("type")); final Timer timer = meterRegistry.find(METRIC_NAME_CLIENT_PROCESSING_DURATION).timer(); assertNotNull(timer); assertEquals("timer", timer.getId().getTag("type")); log.info("--- Test completed ---"); }
@Test public void testServerCustomization() { log.info("--- Starting tests with server customization ---"); final MeterRegistry meterRegistry = new SimpleMeterRegistry(); assertEquals(0, meterRegistry.getMeters().size()); final MetricCollectingServerInterceptor mcsi = new MetricCollectingServerInterceptor(meterRegistry, counter -> counter.tag("type", "counter"), timer -> timer.tag("type", "timer").publishPercentiles(0.5, 0.9, 0.99), OK, UNKNOWN); mcsi.preregisterService(new TestServiceImpl()); MetricTestHelper.logMeters(meterRegistry.getMeters()); assertEquals(METHOD_COUNT * 10, meterRegistry.getMeters().size()); final Counter counter = meterRegistry.find(METRIC_NAME_SERVER_REQUESTS_RECEIVED).counter(); assertNotNull(counter); assertEquals("counter", counter.getId().getTag("type")); final Timer timer = meterRegistry.find(METRIC_NAME_SERVER_PROCESSING_DURATION).timer(); assertNotNull(timer); assertEquals("timer", timer.getId().getTag("type")); log.info("--- Test completed ---"); }
@Override public String format(Collection<Gauge> gauges, Collection<Timer> timers) { StringBuilder builder = new StringBuilder("\n########## Metrics Start ##########\n"); gauges.stream().forEach(gauge -> { builder.append("Gauge [" + gauge.getId() + "]: "); builder.append(gauge.value() + "\n"); }); timers.stream().forEach(timer -> { builder.append("Timer [" + timer.getId() + "]: "); builder.append( "totalTime=" + timer.totalTime(timer.baseTimeUnit()) + " " + timer.baseTimeUnit() + "\n"); }); builder.append("########## Metrics End ############"); return builder.toString(); }
@Override public String format(Collection<Gauge> gauges, Collection<Timer> timers) { StringBuilder builder = new StringBuilder("\n########## Metrics Start ##########\n"); gauges.stream().forEach(gauge -> { builder.append("Gauge [" + gauge.getId() + "]: "); builder.append(gauge.value() + "\n"); }); timers.stream().forEach(timer -> { builder.append("Timer [" + timer.getId() + "]: "); builder.append( "totalTime=" + timer.totalTime(timer.baseTimeUnit()) + " " + timer.baseTimeUnit() + "\n"); }); builder.append("########## Metrics End ############"); return builder.toString(); }
private Map<String, Map> serviceMetrics() { Collection<String> crudOperation = Arrays.asList("GET", "POST", "PUT", "DELETE"); Set<String> uris = new HashSet<>(); Collection<Timer> timers = this.meterRegistry.find("http.server.requests").timers(); timers.forEach(timer -> uris.add(timer.getId().getTag("uri"))); Map<String, Map> resultsHttpPerUri = new HashMap<>(); uris.forEach(uri -> { Map<String, Map> resultsPerUri = new HashMap<>(); crudOperation.forEach(operation -> { Map<String, Number> resultsPerUriPerCrudOperation = new HashMap<>(); Collection<Timer> httpTimersStream = this.meterRegistry.find("http.server.requests").tags("uri", uri, "method", operation).timers(); long count = httpTimersStream.stream().map(Timer::count).reduce((x, y) -> x + y).orElse(0L); if (count != 0) { double max = httpTimersStream.stream().map(x -> x.max(TimeUnit.MILLISECONDS)).reduce((x, y) -> x > y ? x : y).orElse((double) 0); double totalTime = httpTimersStream.stream().map(x -> x.totalTime(TimeUnit.MILLISECONDS)).reduce((x, y) -> (x + y)).orElse((double) 0); resultsPerUriPerCrudOperation.put("count", count); resultsPerUriPerCrudOperation.put("max", max); resultsPerUriPerCrudOperation.put("mean", totalTime / count); resultsPerUri.put(operation, resultsPerUriPerCrudOperation); } }); resultsHttpPerUri.put(uri, resultsPerUri); }); return resultsHttpPerUri; }
private Metric<Number> toTimerMetric(Timer timer) { return new Metric<Number>(timer.getId(), timer.takeSnapshot()); }
private Map<String, Map> httpRequestsMetrics() { Set<String> statusCode = new HashSet<>(); Collection<Timer> timers = this.meterRegistry.find("http.server.requests").timers(); timers.forEach(timer -> statusCode.add(timer.getId().getTag("status"))); Map<String, Map> resultsHttp = new HashMap<>(); Map<String, Map<String, Number>> resultsHttpPerCode = new HashMap<>(); statusCode.forEach(code -> { Map<String, Number> resultsPerCode = new HashMap<>(); Collection<Timer> httpTimersStream = this.meterRegistry.find("http.server.requests").tag("status", code).timers(); long count = httpTimersStream.stream().map(Timer::count).reduce((x, y) -> x + y).orElse(0L); double max = httpTimersStream.stream().map(x -> x.max(TimeUnit.MILLISECONDS)).reduce((x, y) -> x > y ? x : y).orElse((double) 0); double totalTime = httpTimersStream.stream().map(x -> x.totalTime(TimeUnit.MILLISECONDS)).reduce((x, y) -> (x + y)).orElse((double) 0); resultsPerCode.put("count", count); resultsPerCode.put("max", max); resultsPerCode.put("mean", count != 0 ? totalTime / count : 0); resultsHttpPerCode.put(code, resultsPerCode); }); resultsHttp.put("percode", resultsHttpPerCode); timers = this.meterRegistry.find("http.server.requests").timers(); long countAllrequests = timers.stream().map(Timer::count).reduce((x, y) -> x + y).orElse(0L); Map<String, Number> resultsHTTPAll = new HashMap<>(); resultsHTTPAll.put("count", countAllrequests); resultsHttp.put("all", resultsHTTPAll); return resultsHttp; }
private Map<String, Map<String, Number>> databaseMetrics() { Map<String, Map<String, Number>> resultsDatabase = new HashMap<>(); Collection<Timer> timers = Search.in(this.meterRegistry).name(s -> s.contains("hikari")).timers(); timers.forEach(timer -> { String key = timer.getId().getName().substring(timer.getId().getName().lastIndexOf('.') + 1); resultsDatabase.putIfAbsent(key, new HashMap<>()); resultsDatabase.get(key).put("count", timer.count()); resultsDatabase.get(key).put("max", timer.max(TimeUnit.MILLISECONDS)); resultsDatabase.get(key).put("totalTime", timer.totalTime(TimeUnit.MILLISECONDS)); resultsDatabase.get(key).put("mean", timer.mean(TimeUnit.MILLISECONDS)); ValueAtPercentile[] percentiles = timer.takeSnapshot().percentileValues(); for (ValueAtPercentile percentile : percentiles) { resultsDatabase.get(key).put(String.valueOf(percentile.percentile()), percentile.value(TimeUnit.MILLISECONDS)); } }); Collection<Gauge> gauges = Search.in(this.meterRegistry).name(s -> s.contains("hikari")).gauges(); gauges.forEach(gauge -> { String key = gauge.getId().getName().substring(gauge.getId().getName().lastIndexOf('.') + 1); resultsDatabase.putIfAbsent(key, new HashMap<>()); resultsDatabase.get(key).put("value", gauge.value()); }); return resultsDatabase; }
Stream<String> writeTimer(Timer timer) { long wallTime = config().clock().wallTime(); return Stream.of( writeMetric(idWithSuffix(timer.getId(), "count"), wallTime, timer.count()), writeMetric(idWithSuffix(timer.getId(), "max"), wallTime, timer.max(getBaseTimeUnit())), writeMetric(idWithSuffix(timer.getId(), "avg"), wallTime, timer.mean(getBaseTimeUnit())), writeMetric(idWithSuffix(timer.getId(), "sum"), wallTime, timer.totalTime(getBaseTimeUnit())) ); }
private Map<String, Object> garbageCollectorMetrics() { Map<String, Object> resultsGarbageCollector = new HashMap<>(); Collection<Timer> timers = Search.in(this.meterRegistry).name(s -> s.contains("jvm.gc.pause")).timers(); timers.forEach(timer -> { String key = timer.getId().getName(); HashMap<String, Number> gcPauseResults = new HashMap<>(); gcPauseResults.put("count", timer.count()); gcPauseResults.put("max", timer.max(TimeUnit.MILLISECONDS)); gcPauseResults.put("totalTime", timer.totalTime(TimeUnit.MILLISECONDS)); gcPauseResults.put("mean", timer.mean(TimeUnit.MILLISECONDS)); ValueAtPercentile[] percentiles = timer.takeSnapshot().percentileValues(); for (ValueAtPercentile percentile : percentiles) { gcPauseResults.put(String.valueOf(percentile.percentile()), percentile.value(TimeUnit.MILLISECONDS)); } resultsGarbageCollector.putIfAbsent(key, gcPauseResults); }); Collection<Gauge> gauges = Search.in(this.meterRegistry).name(s -> s.contains("jvm.gc") && !s.contains("jvm.gc.pause")).gauges(); gauges.forEach(gauge -> resultsGarbageCollector.put(gauge.getId().getName(), gauge.value())); Collection<Counter> counters = Search.in(this.meterRegistry).name(s -> s.contains("jvm.gc") && !s.contains("jvm.gc.pause")).counters(); counters.forEach(counter -> resultsGarbageCollector.put(counter.getId().getName(), counter.count())); gauges = Search.in(this.meterRegistry).name(s -> s.contains("jvm.classes.loaded")).gauges(); Double classesLoaded = gauges.stream().map(Gauge::value).reduce((x, y) -> (x + y)).orElse((double) 0); resultsGarbageCollector.put("classesLoaded", classesLoaded); Collection<FunctionCounter> functionCounters = Search.in(this.meterRegistry).name(s -> s.contains("jvm.classes.unloaded")).functionCounters(); Double classesUnloaded = functionCounters.stream().map(FunctionCounter::count).reduce((x, y) -> (x + y)).orElse((double) 0); resultsGarbageCollector.put("classesUnloaded", classesUnloaded); return resultsGarbageCollector; }
@Override protected void doProcess(Exchange exchange, MicrometerEndpoint endpoint, Timer timer) { String propertyName = getPropertyName(timer.getId().getName()); Timer.Sample sample = getTimerSampleFromExchange(exchange, propertyName); sample.stop(timer); exchange.removeProperty(propertyName); }
@Nullable private Optional<String> writeTimer(Timer timer) { HistogramSnapshot snapshot = timer.takeSnapshot(); long count = snapshot.count(); if (count > 0) { return Optional.of(write(timer.getId(), "timer", Fields.Count.tag(), decimal(count), Fields.Sum.tag(), decimal(snapshot.total(getBaseTimeUnit())), Fields.Max.tag(), decimal(snapshot.max(getBaseTimeUnit())))); } return Optional.empty(); }
private Stream<MetricDatum> timerData(Timer timer) { final Stream.Builder<MetricDatum> metrics = Stream.builder(); metrics.add(metricDatum(timer.getId(), "sum", getBaseTimeUnit().name(), timer.totalTime(getBaseTimeUnit()))); metrics.add(metricDatum(timer.getId(), "count", "count", timer.count())); metrics.add(metricDatum(timer.getId(), "avg", getBaseTimeUnit().name(), timer.mean(getBaseTimeUnit()))); metrics.add(metricDatum(timer.getId(), "max", getBaseTimeUnit().name(), timer.max(getBaseTimeUnit()))); return metrics.build(); }
private Stream<String> writeTimer(Timer timer) { return Stream.of(event(timer.getId(), new Attribute("count", timer.count()), new Attribute("avg", timer.mean(getBaseTimeUnit())), new Attribute("totalTime", timer.totalTime(getBaseTimeUnit())), new Attribute("max", timer.max(getBaseTimeUnit())) )); }
private Stream<String> writeTimer(Timer timer) { final long wallTime = clock.wallTime(); final Stream.Builder<String> metrics = Stream.builder(); Meter.Id id = timer.getId(); addMetric(metrics, id, "sum", wallTime, timer.totalTime(getBaseTimeUnit())); addMetric(metrics, id, "count", wallTime, timer.count()); addMetric(metrics, id, "avg", wallTime, timer.mean(getBaseTimeUnit())); addMetric(metrics, id, "max", wallTime, timer.max(getBaseTimeUnit())); return metrics.build(); }
HistogramSnapshot snapshot = timer.takeSnapshot(); io.micrometer.core.instrument.Meter.Id id = timer.getId(); io.micrometer.core.instrument.Meter.Type type = id.getType();
private Stream<String> writeTimer(Timer timer, Map<String, DatadogMetricMetadata> metadata) { final long wallTime = clock.wallTime(); final Stream.Builder<String> metrics = Stream.builder(); Meter.Id id = timer.getId(); metrics.add(writeMetric(id, "sum", wallTime, timer.totalTime(getBaseTimeUnit()))); metrics.add(writeMetric(id, "count", wallTime, timer.count())); metrics.add(writeMetric(id, "avg", wallTime, timer.mean(getBaseTimeUnit()))); metrics.add(writeMetric(id, "max", wallTime, timer.max(getBaseTimeUnit()))); addToMetadataList(metadata, id, "sum", Statistic.TOTAL_TIME, null); addToMetadataList(metadata, id, "count", Statistic.COUNT, "occurrence"); addToMetadataList(metadata, id, "avg", Statistic.VALUE, null); addToMetadataList(metadata, id, "max", Statistic.MAX, null); return metrics.build(); }