private void recordEsMetrics(JestResult jestResult, @Nullable TimeRange range) { esTotalSearchesCounter.inc(); final long tookMs = tookMsFromSearchResult(jestResult); esRequestTimer.update(tookMs, TimeUnit.MILLISECONDS); if (range != null) { esTimeRangeHistogram.update(TimeRanges.toSeconds(range)); } }
public static TimerRateMetricsResponse buildTimerMap(Timer t) { final TimerRateMetricsResponse result = new TimerRateMetricsResponse(); if (t == null) { return result; } final TimerMetricsResponse time = new TimerMetricsResponse(); time.max = TimeUnit.MICROSECONDS.convert(t.getSnapshot().getMax(), TimeUnit.NANOSECONDS); time.min = TimeUnit.MICROSECONDS.convert(t.getSnapshot().getMin(), TimeUnit.NANOSECONDS); time.mean = TimeUnit.MICROSECONDS.convert((long) t.getSnapshot().getMean(), TimeUnit.NANOSECONDS); time.percentile95th = TimeUnit.MICROSECONDS.convert((long) t.getSnapshot().get95thPercentile(), TimeUnit.NANOSECONDS); time.percentile98th = TimeUnit.MICROSECONDS.convert((long) t.getSnapshot().get98thPercentile(), TimeUnit.NANOSECONDS); time.percentile99th = TimeUnit.MICROSECONDS.convert((long) t.getSnapshot().get99thPercentile(), TimeUnit.NANOSECONDS); time.stdDev = TimeUnit.MICROSECONDS.convert((long) t.getSnapshot().getStdDev(), TimeUnit.NANOSECONDS); final RateMetricsResponse rate = new RateMetricsResponse(); rate.oneMinute = t.getOneMinuteRate(); rate.fiveMinute = t.getFiveMinuteRate(); rate.fifteenMinute = t.getFifteenMinuteRate(); rate.total = t.getCount(); rate.mean = t.getMeanRate(); result.time = time; result.rate = rate; result.rateUnit = "events/second"; result.durationUnit = TimeUnit.MICROSECONDS.toString().toLowerCase(Locale.ENGLISH); return result; }
/** * Export dropwizard Timer as a histogram. Use TIME_UNIT as time unit. */ private MetricFamilySamples fromTimer(List<Map.Entry<MetricName, Timer>> histogramsWithSameName) { final SummaryMetricFamily summaryMetricFamily = getSummaryMetricFamily(histogramsWithSameName, "_seconds"); for (Map.Entry<MetricName, Timer> entry : histogramsWithSameName) { addSummaryMetric(summaryMetricFamily, entry.getKey(), entry.getValue().getSnapshot(), SECONDS_IN_NANOS, entry.getValue().getCount()); } return summaryMetricFamily; }
Object secondInitInstance = HelixKafkaMirrorMakerMetricsReporter.get(); Assert.assertTrue(firstInitInstance == secondInitInstance); Counter testCounter0 = new Counter(); Meter testMeter0 = new Meter(); Timer testTimer0 = new Timer(); HelixKafkaMirrorMakerMetricsReporter.get().registerMetric("testCounter0", testCounter0); HelixKafkaMirrorMakerMetricsReporter.get().registerMetric("testMeter0", testMeter0); HelixKafkaMirrorMakerMetricsReporter.get().registerMetric("testTimer0", testTimer0); testCounter0.inc(); testMeter0.mark(); Context context = testTimer0.time(); context.stop(); HelixKafkaMirrorMakerMetricsReporter.get().getRegistry().getCounters().get("testCounter0") .getCount(), 1); Assert.assertEquals( HelixKafkaMirrorMakerMetricsReporter.get().getRegistry().getMeters().get("testMeter0") .getCount(), 1); Assert.assertEquals( HelixKafkaMirrorMakerMetricsReporter.get().getRegistry().getTimers().get("testTimer0") .getCount(), 1);
@Test public void testCompilationQueryMetric() { Timer timer = metricRegistry.getTimers().get(MetricsConstant.HS2_COMPILING_QUERIES); Counter counter = metricRegistry.getCounters() .get(MetricsConstant.ACTIVE_CALLS + MetricsConstant.HS2_COMPILING_QUERIES); assertThat(timer, nullValue()); assertThat(counter, nullValue()); hook.beforeCompile(ctx); timer = metricRegistry.getTimers().get(MetricsConstant.HS2_COMPILING_QUERIES); counter = metricRegistry.getCounters() .get(MetricsConstant.ACTIVE_CALLS + MetricsConstant.HS2_COMPILING_QUERIES); assertThat(timer.getCount(), equalTo(0l)); assertThat(counter.getCount(), equalTo(1l)); hook.afterCompile(ctx, false); timer = metricRegistry.getTimers().get(MetricsConstant.HS2_COMPILING_QUERIES); counter = metricRegistry.getCounters() .get(MetricsConstant.ACTIVE_CALLS + MetricsConstant.HS2_COMPILING_QUERIES); assertThat(timer.getCount(), equalTo(1l)); assertThat(counter.getCount(), equalTo(0l)); }
@Override public void handle(final Request req, final Response rsp) throws Throwable { MetricRegistry registry = req.require(MetricRegistry.class); Counter counter = registry.counter("request.actives"); Timer.Context timer = registry.timer("request").time(); counter.inc(); rsp.complete((ereq, ersp, x) -> { timer.stop(); counter.dec(); Meter meter = registry.meter("responses." + rsp.status().orElse(Status.OK).value()); meter.mark(); }); }
private static List<Metric> allMetrics(MetricsSystem.InstanceType instanceType) { List<Metric> metrics = new ArrayList<>(); for (Entry<String, Gauge> entry : METRIC_REGISTRY.getGauges().entrySet()) { if (entry.getKey().startsWith(instanceType.toString())) { Object value = entry.getValue().getValue(); if (!(value instanceof Number)) { LOG.warn( "The value of metric {} of type {} is not sent to metrics master," + " only metrics value of number can be collected", entry.getKey(), entry.getValue().getClass().getSimpleName()); continue; } metrics.add(Metric.from(entry.getKey(), ((Number) value).longValue())); } } for (Entry<String, Counter> entry : METRIC_REGISTRY.getCounters().entrySet()) { metrics.add(Metric.from(entry.getKey(), entry.getValue().getCount())); } for (Entry<String, Meter> entry : METRIC_REGISTRY.getMeters().entrySet()) { // TODO(yupeng): From Meter's implementation, getOneMinuteRate can only report at rate of at // least seconds. if the client's duration is too short (i.e. < 1s), then getOneMinuteRate // would return 0 metrics.add(Metric.from(entry.getKey(), entry.getValue().getOneMinuteRate())); } for (Entry<String, Timer> entry : METRIC_REGISTRY.getTimers().entrySet()) { metrics.add(Metric.from(entry.getKey(), entry.getValue().getCount())); } return metrics; }
@Subscribe public void jobStarted(JobStartEvent data) { if (this.configuration.isJobsByType()) { registry.meter(prefix + ".job-meter-" + data.getType()) .mark(); jobs.start(data.getCorrelationId(), timer(prefix + ".job-timer-" + data.getType()).time()); registry.counter(prefix + ".jobs-active-" + data.getType() + "-count") .inc(); } }
@Test public void testConcurrency() throws Exception { int threads = 4; ExecutorService executorService = Executors.newFixedThreadPool(threads); for (int i=0; i< threads; i++) { final int n = i; executorService.submit(new Callable<Void>() { @Override public Void call() throws Exception { MetricsFactory.getInstance().startStoredScope("method2"); MetricsFactory.getInstance().endStoredScope("method2"); return null; } }); } executorService.shutdown(); assertTrue(executorService.awaitTermination(10000, TimeUnit.MILLISECONDS)); Timer timer = metricRegistry.getTimers().get("method2"); Assert.assertEquals(4, timer.getCount()); Assert.assertTrue(timer.getMeanRate() > 0); }
@Nullable private Message postProcessMessage(RawMessage raw, Codec codec, String inputIdOnCurrentNode, String baseMetricName, Message message, long decodeTime) { if (message == null) { metricRegistry.meter(name(baseMetricName, "failures")).mark(); return null; metricRegistry.meter(name(baseMetricName, "incomplete")).mark(); if (LOG.isDebugEnabled()) { LOG.debug("Dropping incomplete message {} on input <{}>. Parsed fields: [{}]", metricRegistry.timer(name(baseMetricName, "parseTime")).update(decodeTime, TimeUnit.NANOSECONDS); metricRegistry.meter(name(baseMetricName, "processedMessages")).mark(); decodedTrafficCounter.inc(message.getSize()); return message;
@Override protected void reportInContext(MetricContext context, SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { for (Map.Entry<String, Gauge> entry : gauges.entrySet()) { Gauge gauge = entry.getValue(); if (gauge.getValue() instanceof Long || gauge.getValue() instanceof Integer || gauge.getValue() instanceof Short || gauge.getValue() instanceof Byte) reportValue(context, entry.getKey(), ((Number) gauge.getValue()).longValue()); } for (Map.Entry<String, Counter> entry : counters.entrySet()) { reportCount(context, entry.getKey(), entry.getValue().getCount()); } for (Map.Entry<String, Meter> entry : meters.entrySet()) { reportCount(context, entry.getKey(), entry.getValue().getCount()); } for (Map.Entry<String, Histogram> entry : histograms.entrySet()) { reportCount(context, entry.getKey(), entry.getValue().getCount()); } for (Map.Entry<String, Timer> entry : timers.entrySet()) { reportCount(context, entry.getKey(), entry.getValue().getCount()); } }
@Test public void timer() { MetricRegistry codaRegistry = new MetricRegistry(); MetricsRegistry r = new MetricsRegistry(clock, codaRegistry); r.timer("foo").record(1, TimeUnit.MILLISECONDS); Assertions.assertEquals(1, codaRegistry.getTimers().get("foo").getCount()); }
@Test public void metricsMethodNotCalledYet() { assertThat("Shared metric registry is not created", SharedMetricRegistries.names(), hasItem(REGISTRY_NAME)); MetricRegistry registry = SharedMetricRegistries.getOrCreate(REGISTRY_NAME); assertThat("Metrics are not registered correctly", registry.getMetrics().keySet(), is(equalTo(absoluteMetricNames()))); // Make sure that the metrics haven't been called yet assertThat("Meter count is incorrect", registry.getMeters().get(absoluteMetricName("exception")).getCount(), is(equalTo(0L))); assertThat("Meter count is incorrect", registry.getMeters().get(absoluteMetricName("meter")).getCount(), is(equalTo(0L))); assertThat("Timer count is incorrect", registry.getTimers().get(absoluteMetricName("timer")).getCount(), is(equalTo(0L))); }
public static Map<String, Long> dumpMetrics(MetricContext context) { Map<String, Long> output = new HashMap<>(); for (Map.Entry<String, Meter> entry : context.getMeters().entrySet()) { output.put(entry.getKey(), entry.getValue().getCount()); } for (Map.Entry<String, Timer> entry : context.getTimers().entrySet()) { output.put(entry.getKey(), entry.getValue().getCount()); } return output; }
private <T> T runWithMetrics(String opName, Function<Void,T> impl) { Preconditions.checkNotNull(opName); Preconditions.checkNotNull(impl); final MetricManager mgr = MetricManager.INSTANCE; mgr.getCounter(metricsPrefix, opName, M_CALLS).inc(); final Timer.Context tc = mgr.getTimer(metricsPrefix, opName, M_TIME).time(); try { return impl.apply(null); } catch (RuntimeException e) { mgr.getCounter(metricsPrefix, opName, M_EXCEPTIONS).inc(); throw e; } finally { tc.stop(); } } }
@Override public Status ackMessage(String queueName, UUID queueMessageId ) { if( logger.isTraceEnabled() ){ logger.trace("Acking message for queue {} with id: {}", queueName, queueMessageId); } Timer.Context timer = metricsService.getMetricRegistry().timer( MetricsService.ACK_TIME_TOTAL ).time(); try { QueueAckRequest message = new QueueAckRequest( queueName, queueMessageId ); return sendMessageToLocalRouters( message ); } finally { timer.close(); } }
@Override public Messages process(Messages messages) { for (final MessageFilter filter : filterRegistry) { for (Message msg : messages) { final String timerName = name(filter.getClass(), "executionTime"); final Timer timer = metricRegistry.timer(timerName); final Timer.Context timerContext = timer.time(); try { LOG.debug("Applying filter [{}] on message <{}>.", filter.getName(), msg.getId()); if (filter.filter(msg)) { LOG.debug("Filter [{}] marked message <{}> to be discarded. Dropping message.", filter.getName(), msg.getId()); msg.setFilterOut(true); filteredOutMessages.mark(); journal.markJournalOffsetCommitted(msg.getJournalOffset()); } } catch (Exception e) { LOG.error("Could not apply filter [" + filter.getName() + "] on message <" + msg.getId() + ">: ", e); } finally { final long elapsedNanos = timerContext.stop(); msg.recordTiming(serverStatus, timerName, elapsedNanos); } } } return messages; }