@Override public double totalTime(TimeUnit unit) { return delegate.totalTime(unit); }
@Override public long totalTime() { return (long) impl.totalTime(TimeUnit.NANOSECONDS); }
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)); }
@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(); }
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 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())) ); }
@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("record durations") default void recordDuration(MeterRegistry registry) { Timer t = registry.timer("myTimer"); t.record(Duration.ofMillis(42)); clock(registry).add(step()); assertAll(() -> assertEquals(1L, t.count()), () -> assertEquals(42, t.totalTime(TimeUnit.MILLISECONDS), 1.0e-12)); }
@Test @DisplayName("negative times are discarded by the Timer") default void recordNegative(MeterRegistry registry) { Timer t = registry.timer("myTimer"); t.record(-42, TimeUnit.MILLISECONDS); assertAll(() -> assertEquals(0L, t.count()), () -> assertEquals(0, t.totalTime(TimeUnit.NANOSECONDS), 1.0e-12)); }
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())) )); }
@Test @DisplayName("callable task that throws exception is still recorded") default void recordCallableException(MeterRegistry registry) { Timer t = registry.timer("myTimer"); assertThrows(Exception.class, () -> { t.recordCallable(() -> { clock(registry).add(10, TimeUnit.NANOSECONDS); throw new Exception("uh oh"); }); }); clock(registry).add(step()); assertAll(() -> assertEquals(1L, t.count()), () -> assertEquals(10, t.totalTime(TimeUnit.NANOSECONDS), 1.0e-12)); }
@Test @DisplayName("zero times contribute to the count of overall events but do not add to total time") default void recordZero(MeterRegistry registry) { Timer t = registry.timer("myTimer"); t.record(0, TimeUnit.MILLISECONDS); clock(registry).add(step()); assertAll(() -> assertEquals(1L, t.count()), () -> assertEquals(0L, t.totalTime(TimeUnit.NANOSECONDS))); }
@Test @DisplayName("total time and count are preserved for a single timing") default void record(MeterRegistry registry) { Timer t = registry.timer("myTimer"); t.record(42, TimeUnit.MILLISECONDS); clock(registry).add(step()); assertAll(() -> assertEquals(1L, t.count()), () -> assertEquals(42, t.totalTime(TimeUnit.MILLISECONDS), 1.0e-12)); }
@Test @DisplayName("record a runnable task") default void recordWithRunnable(MeterRegistry registry) { Timer t = registry.timer("myTimer"); try { t.record(() -> clock(registry).add(10, TimeUnit.NANOSECONDS)); clock(registry).add(step()); } finally { assertAll(() -> assertEquals(1L, t.count()), () -> assertEquals(10, t.totalTime(TimeUnit.NANOSECONDS), 1.0e-12)); } }
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(); }
@Test @DisplayName("record with stateful Sample instance") default void recordWithSample(MeterRegistry registry) { Timer timer = registry.timer("myTimer"); Timer.Sample sample = Timer.start(registry); clock(registry).add(10, TimeUnit.NANOSECONDS); sample.stop(timer); clock(registry).add(step()); assertAll(() -> assertEquals(1L, timer.count()), () -> assertEquals(10, timer.totalTime(TimeUnit.NANOSECONDS), 1.0e-12)); }
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(); }