@Override public double mean(TimeUnit unit) { return timer.mean(unit); }
private static JsonObject timerToJson(JsonObject obj, Timer timer) { return obj.put("type", "timer") .put("count", timer.count()) .put("totalTimeMs", timer.totalTime(TimeUnit.MILLISECONDS)) .put("meanMs", timer.mean(TimeUnit.MILLISECONDS)) .put("maxMs", timer.max(TimeUnit.MILLISECONDS)); }
Optional<String> writeTimer(Timer timer) { return Optional.of(writeDocument(timer, builder -> { builder.append(",\"count\":").append(timer.count()); builder.append(",\"sum\":").append(timer.totalTime(getBaseTimeUnit())); builder.append(",\"mean\":").append(timer.mean(getBaseTimeUnit())); builder.append(",\"max\":").append(timer.max(getBaseTimeUnit())); })); }
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; }
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; }
private Stream<SignalFxProtocolBuffers.DataPoint.Builder> addTimer(Timer timer) { return Stream.of( addDatapoint(timer, COUNTER, "count", timer.count()), addDatapoint(timer, COUNTER, "totalTime", timer.totalTime(getBaseTimeUnit())), addDatapoint(timer, GAUGE, "avg", timer.mean(getBaseTimeUnit())), addDatapoint(timer, GAUGE, "max", timer.max(getBaseTimeUnit())) ); }
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(); }
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 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(); }
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(); }