How to use

mean

method

in

io.micrometer.core.instrument.Timer

@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();
}