net.unit8.metrics.mackerel.MackerelReporter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of metrics-mackerel Show documentation
Show all versions of metrics-mackerel Show documentation
A reporter for Metrics which announces measurements to a Mackerel server.
package net.unit8.metrics.mackerel;
import com.codahale.metrics.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import static com.codahale.metrics.MetricAttribute.*;
/**
* A reporter which publishes metric values to a Mackerel server.
*
* @author kawasima
*/
public class MackerelReporter extends ScheduledReporter {
public static Builder forRegistry(MetricRegistry registry) {
return new Builder(registry);
}
public static class Builder {
private final MetricRegistry registry;
private Clock clock;
private String prefix;
private TimeUnit rateUnit;
private TimeUnit durationUnit;
private MetricFilter filter;
private ScheduledExecutorService executor;
private boolean shutdownExecutorOnStop;
private Set disabledMetricAttributes;
private Builder(MetricRegistry registry) {
this.registry = registry;
this.clock = Clock.defaultClock();
this.prefix = null;
this.rateUnit = TimeUnit.SECONDS;
this.durationUnit = TimeUnit.MILLISECONDS;
this.filter = MetricFilter.ALL;
this.executor = null;
this.shutdownExecutorOnStop = true;
this.disabledMetricAttributes = Collections.emptySet();
}
public Builder shutdownExecutorOnStop(boolean shutdownExecutorOnStop) {
this.shutdownExecutorOnStop = shutdownExecutorOnStop;
return this;
}
public Builder scheduleOn(ScheduledExecutorService executor) {
this.executor = executor;
return this;
}
public Builder withClock(Clock clock) {
this.clock = clock;
return this;
}
public Builder prefixedWith(String prefix) {
this.prefix = prefix;
return this;
}
public Builder convertRatesTo(TimeUnit rateUnit) {
this.rateUnit = rateUnit;
return this;
}
public Builder convertDurationsTo(TimeUnit durationUnit) {
this.durationUnit = durationUnit;
return this;
}
public Builder filter(MetricFilter filter) {
this.filter = filter;
return this;
}
public Builder disabledMetricAttributes(Set disabledMetricAttributes) {
this.disabledMetricAttributes = disabledMetricAttributes;
return this;
}
public MackerelReporter build(MackerelSender mackerel) {
return new MackerelReporter(registry,
mackerel,
clock,
prefix,
rateUnit,
durationUnit,
filter,
executor,
shutdownExecutorOnStop,
disabledMetricAttributes);
}
}
private static final Logger LOGGER = LoggerFactory.getLogger(MackerelReporter.class);
private final MackerelSender mackerel;
private final Clock clock;
private final String prefix;
protected MackerelReporter(MetricRegistry registry,
MackerelSender mackerel,
Clock clock,
String prefix,
TimeUnit rateUnit,
TimeUnit durationUnit,
MetricFilter filter,
ScheduledExecutorService executor,
boolean shutdownExecutorOnStop,
Set disabledMetricAttributes) {
super(registry, "mackerel-reporter", filter, rateUnit, durationUnit, executor, shutdownExecutorOnStop,
disabledMetricAttributes);
this.mackerel = mackerel;
this.clock = clock;
this.prefix = prefix;
}
@Override
public void report(SortedMap gauges,
SortedMap counters,
SortedMap histograms,
SortedMap meters,
SortedMap timers) {
final long timestamp = clock.getTime() / 1000;
try {
for (Map.Entry entry : gauges.entrySet()) {
reportGauge(entry.getKey(), entry.getValue(), timestamp);
}
for (Map.Entry entry : counters.entrySet()) {
reportCounter(entry.getKey(), entry.getValue(), timestamp);
}
for (Map.Entry entry : histograms.entrySet()) {
reportHistogram(entry.getKey(), entry.getValue(), timestamp);
}
for (Map.Entry entry : meters.entrySet()) {
reportMetered(entry.getKey(), entry.getValue(), timestamp);
}
for (Map.Entry entry : timers.entrySet()) {
reportTimer(entry.getKey(), entry.getValue(), timestamp);
}
mackerel.flush();
} catch (IOException e) {
LOGGER.warn("Unable to report to Mackerel", mackerel, e);
}
}
private void reportTimer(String name, Timer timer, long timestamp) throws IOException {
final Snapshot snapshot = timer.getSnapshot();
sendIfEnabled(MAX, name, convertDuration(snapshot.getMax()), timestamp);
sendIfEnabled(MEAN, name, convertDuration(snapshot.getMean()), timestamp);
sendIfEnabled(MIN, name, convertDuration(snapshot.getMin()), timestamp);
sendIfEnabled(STDDEV, name, convertDuration(snapshot.getStdDev()), timestamp);
sendIfEnabled(P50, name, convertDuration(snapshot.getMedian()), timestamp);
sendIfEnabled(P75, name, convertDuration(snapshot.get75thPercentile()), timestamp);
sendIfEnabled(P95, name, convertDuration(snapshot.get95thPercentile()), timestamp);
sendIfEnabled(P98, name, convertDuration(snapshot.get98thPercentile()), timestamp);
sendIfEnabled(P99, name, convertDuration(snapshot.get99thPercentile()), timestamp);
sendIfEnabled(P999, name, convertDuration(snapshot.get999thPercentile()), timestamp);
reportMetered(name, timer, timestamp);
}
private void reportMetered(String name, Metered meter, long timestamp) throws IOException {
sendIfEnabled(COUNT, name, meter.getCount(), timestamp);
sendIfEnabled(M1_RATE, name, convertRate(meter.getOneMinuteRate()), timestamp);
sendIfEnabled(M5_RATE, name, convertRate(meter.getFiveMinuteRate()), timestamp);
sendIfEnabled(M15_RATE, name, convertRate(meter.getFifteenMinuteRate()), timestamp);
sendIfEnabled(MEAN_RATE, name, convertRate(meter.getMeanRate()), timestamp);
}
private void reportHistogram(String name, Histogram histogram, long timestamp) throws IOException {
final Snapshot snapshot = histogram.getSnapshot();
sendIfEnabled(COUNT, name, histogram.getCount(), timestamp);
sendIfEnabled(MAX, name, snapshot.getMax(), timestamp);
sendIfEnabled(MEAN, name, snapshot.getMean(), timestamp);
sendIfEnabled(MIN, name, snapshot.getMin(), timestamp);
sendIfEnabled(STDDEV, name, snapshot.getStdDev(), timestamp);
sendIfEnabled(P50, name, snapshot.getMedian(), timestamp);
sendIfEnabled(P75, name, snapshot.get75thPercentile(), timestamp);
sendIfEnabled(P95, name, snapshot.get95thPercentile(), timestamp);
sendIfEnabled(P98, name, snapshot.get98thPercentile(), timestamp);
sendIfEnabled(P99, name, snapshot.get99thPercentile(), timestamp);
sendIfEnabled(P999, name, snapshot.get999thPercentile(), timestamp);
}
private void sendIfEnabled(MetricAttribute type, String name, double value, long timestamp) throws IOException {
if (getDisabledMetricAttributes().contains(type)){
return;
}
mackerel.send(prefix(name, type.getCode()), format(value), timestamp);
}
private void sendIfEnabled(MetricAttribute type, String name, long value, long timestamp) throws IOException {
if (getDisabledMetricAttributes().contains(type)){
return;
}
mackerel.send(prefix(name, type.getCode()), format(value), timestamp);
}
private void reportCounter(String name, Counter counter, long timestamp) throws IOException {
mackerel.send(prefix(name, COUNT.getCode()), format(counter.getCount()), timestamp);
}
private void reportGauge(String name, Gauge gauge, long timestamp) throws IOException {
final Double value = format(gauge.getValue());
if (value != null) {
mackerel.send(prefix(name), value, timestamp);
}
}
private Double format(Object o) {
if (o instanceof Float) {
return ((Float) o).doubleValue();
} else if (o instanceof Double) {
return (Double) o;
} else if (o instanceof Byte) {
return ((Byte) o).doubleValue();
} else if (o instanceof Short) {
return ((Short) o).doubleValue();
} else if (o instanceof Integer) {
return ((Integer) o).doubleValue();
} else if (o instanceof Long) {
return ((Long) o).doubleValue();
} else if (o instanceof BigInteger) {
return ((BigInteger) o).doubleValue();
} else if (o instanceof BigDecimal) {
return ((BigDecimal) o).doubleValue();
} else if (o instanceof Boolean) {
return ((Boolean) o) ? 1.0 : 0.0;
}
return null;
}
private String prefix(String... components) {
return MetricRegistry.name(prefix, components);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy