Java tutorial
/** * This file is part of Graylog. * * Graylog is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Graylog is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Graylog. If not, see <http://www.gnu.org/licenses/>. */ package org.graylog2.shared.metrics; import com.codahale.metrics.Gauge; import com.codahale.metrics.Histogram; import com.codahale.metrics.Meter; import com.codahale.metrics.Metric; import com.codahale.metrics.MetricFilter; import com.codahale.metrics.MetricRegistry; import com.codahale.metrics.MetricSet; import com.codahale.metrics.Timer; import com.google.common.collect.Maps; import org.graylog2.rest.models.metrics.responses.RateMetricsResponse; import org.graylog2.rest.models.metrics.responses.TimerMetricsResponse; import org.graylog2.rest.models.metrics.responses.TimerRateMetricsResponse; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.Locale; import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; public class MetricUtils { private static final Logger log = LoggerFactory.getLogger(MetricUtils.class); public static Map<String, Object> mapAll(Map<String, Metric> metrics) { return mapAllFiltered(metrics, null); } public static Map<String, Object> mapAllFiltered(Map<String, Metric> metrics, Set<String> blacklist) { Map<String, Object> result = Maps.newHashMap(); if (metrics == null) { return result; } for (Map.Entry<String, Metric> metric : metrics.entrySet()) { boolean filtered = false; if (blacklist != null) { for (String x : blacklist) { if (metric.getKey().startsWith(x)) { filtered = true; break; } } } if (filtered) { continue; } result.put(metric.getKey(), map(metric.getKey(), metric.getValue())); } return result; } public static Map<String, Object> map(String metricName, Metric metric) { String type = metric.getClass().getSimpleName().toLowerCase(Locale.ENGLISH); if (type.isEmpty()) { type = "gauge"; } Map<String, Object> metricMap = Maps.newHashMap(); metricMap.put("full_name", metricName); metricMap.put("name", metricName.substring(metricName.lastIndexOf(".") + 1)); metricMap.put("type", type); if (metric instanceof Timer) { metricMap.put("metric", buildTimerMap((Timer) metric)); } else if (metric instanceof Meter) { metricMap.put("metric", buildMeterMap((Meter) metric)); } else if (metric instanceof Histogram) { metricMap.put("metric", buildHistogramMap((Histogram) metric)); } else { metricMap.put("metric", metric); } return metricMap; } public static TimerRateMetricsResponse buildTimerMap(Timer t) { final TimerRateMetricsResponse result = new TimerRateMetricsResponse(); final TimerMetricsResponse time = new TimerMetricsResponse(); final RateMetricsResponse rate = new RateMetricsResponse(); if (t == null) { return result; } 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); 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; } public static Map<String, Object> buildHistogramMap(Histogram h) { Map<String, Object> metrics = Maps.newHashMap(); if (h == null) { return metrics; } Map<String, Object> time = Maps.newHashMap(); time.put("max", h.getSnapshot().getMax()); time.put("min", h.getSnapshot().getMin()); time.put("mean", (long) h.getSnapshot().getMean()); time.put("95th_percentile", (long) h.getSnapshot().get95thPercentile()); time.put("98th_percentile", (long) h.getSnapshot().get98thPercentile()); time.put("99th_percentile", (long) h.getSnapshot().get99thPercentile()); time.put("std_dev", (long) h.getSnapshot().getStdDev()); metrics.put("time", time); metrics.put("count", h.getCount()); return metrics; } public static Map<String, Object> buildMeterMap(Meter m) { Map<String, Object> metrics = Maps.newHashMap(); if (m == null) { return metrics; } Map<String, Object> rate = Maps.newHashMap(); rate.put("one_minute", m.getOneMinuteRate()); rate.put("five_minute", m.getFiveMinuteRate()); rate.put("fifteen_minute", m.getFifteenMinuteRate()); rate.put("total", m.getCount()); rate.put("mean", m.getMeanRate()); metrics.put("rate_unit", "events/second"); metrics.put("rate", rate); return metrics; } public static MetricFilter filterSingleMetric(String name) { return new SingleMetricFilter(name); } public static <T extends Metric> T safelyRegister(MetricRegistry metricRegistry, String name, T metric) { try { return metricRegistry.register(name, metric); } catch (IllegalArgumentException ignored) { // safely ignore already existing metric, and simply return the one registered previously. // note that we do not guard against differing metric types here, we consider that a programming error for now. //noinspection unchecked return (T) metricRegistry.getMetrics().get(name); } } public static void safelyRegisterAll(MetricRegistry metricRegistry, MetricSet metrics) throws IllegalArgumentException { try { metricRegistry.registerAll(metrics); } catch (IllegalArgumentException e) { log.error("Duplicate metric set registered", e); } } public static Gauge<Long> constantGauge(final long constant) { return new Gauge<Long>() { @Override public Long getValue() { return constant; } }; } public static class SingleMetricFilter implements MetricFilter { private final String allowedName; public SingleMetricFilter(String allowedName) { this.allowedName = allowedName; } @Override public boolean matches(String name, Metric metric) { return allowedName.equals(name); } } }