fields,
+ final long timestamp) {
+ Preconditions.checkArgument(!name.isEmpty(), "InfluxDbMeasurement must contain a non-empty name");
+ Preconditions.checkArgument(!fields.isEmpty(), "InfluxDbMeasurement must contain at least one field");
+ return new AutoValue_InfluxDbMeasurement(name, tags, fields, timestamp);
+ }
+
+ /**
+ * Returns the measurement in InfluxDB line notation with the provided timestamp precision.
+ *
+ * Does not support sub-millisecond timestamp precision.
+ */
+ public String toLine() {
+ final StringBuilder sb = new StringBuilder();
+ sb.append(name());
+
+ if (!tags().isEmpty()) {
+ sb.append(',');
+ sb.append(joinPairs(tags()));
+ }
+
+ if (!fields().isEmpty()) {
+ sb.append(' ');
+ sb.append(joinPairs(fields()));
+ }
+
+ sb.append(' ');
+ sb.append(TimeUnit.NANOSECONDS.convert(timestamp(), TimeUnit.MILLISECONDS));
+ return sb.toString();
+ }
+
+ @Override
+ public String toString() {
+ return toLine();
+ }
+
+ /**
+ * Returns a comma-separated key-value formatting of {@code pairs}.
+ *
+ *
e.g. "k1=v1,k2=v2,k3=v3"
+ */
+ @VisibleForTesting static String joinPairs(final Map pairs) {
+ final List pairStrs = pairs.entrySet()
+ .parallelStream()
+ .map(e -> String.join("=", e.getKey(), e.getValue()))
+ .collect(toList());
+
+ return String.join(",", pairStrs);
+ }
+
+ // ===================================================================================================================
+ // Builder
+
+ /**
+ * A builder for {@link InfluxDbMeasurement}.
+ */
+ public static class Builder {
+ private final String name;
+ private final long timestamp;
+ private final Map tags = new HashMap<>();
+ private final Map fields = new HashMap<>();
+
+ public Builder(final String name, final long timestamp) {
+ this.name = name;
+ this.timestamp = timestamp;
+ }
+
+ public boolean isValid() {
+ return !name.isEmpty() && !fields.isEmpty();
+ }
+
+ /**
+ * Adds all key-value pairs to the tags map.
+ * @param items
+ * @return
+ */
+ public Builder putTags(final Map items) {
+ tags.putAll(items);
+ return this;
+ }
+
+ /**
+ * Adds the key-value pair to the tags map.
+ */
+ public Builder putTag(final String key, final String value) {
+ tags.put(key, value);
+ return this;
+ }
+
+ /**
+ * Adds all key-value pairs to the fields map.
+ *
+ * @throws IllegalArgumentException if any value is not a String or primitive.
+ */
+ public Builder putFields(final Map fields) {
+ fields.forEach(this::putField);
+ return this;
+ }
+
+ /**
+ * Adds all key-value pairs to the fields map.
+ */
+ public Builder tryPutFields(final Map fields,
+ final Consumer exceptionHandler) {
+ for(final Map.Entry field: fields.entrySet()) {
+ try {
+ putField(field.getKey(), field.getValue());
+ } catch (IllegalArgumentException e) {
+ exceptionHandler.accept(e);
+ }
+ }
+ return this;
+ }
+
+ /**
+ * Adds the given key-value pair to the fields map.
+ *
+ * @throws IllegalArgumentException if any value is not a String or primitive.
+ */
+ public Builder putField(final String key, final T value) {
+ if (value == null) {
+ return this;
+ }
+
+ if (value instanceof Float) {
+ final float f = (Float) value;
+ if (!Float.isNaN(f) && !Float.isInfinite(f)) {
+ fields.put(key, String.valueOf(f));
+ }
+ } else if (value instanceof Double) {
+ final double d = (Double) value;
+ if (!Double.isNaN(d) && !Double.isInfinite(d)) {
+ fields.put(key, String.valueOf(d));
+ }
+ } else if (value instanceof Integer || value instanceof Long) {
+ fields.put(key, String.format("%di", ((Number) value).longValue()));
+ } else if (value instanceof String || value instanceof Boolean) {
+ fields.put(key, value.toString());
+ } else {
+ throw new IllegalArgumentException(
+ String.format("InfluxDbMeasurement field '%s' must be String or primitive: %s", key, value)
+ );
+ }
+
+ return this;
+ }
+
+ public InfluxDbMeasurement build() {
+ return InfluxDbMeasurement.create(name, tags, fields, timestamp);
+ }
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporter.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporter.java
new file mode 100644
index 0000000..c02ff3a
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporter.java
@@ -0,0 +1,77 @@
+package com.kickstarter.dropwizard.metrics.influxdb;
+
+import com.codahale.metrics.Counter;
+import com.codahale.metrics.Gauge;
+import com.codahale.metrics.Histogram;
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricFilter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.ScheduledReporter;
+import com.codahale.metrics.Timer;
+import com.google.common.collect.ImmutableList;
+import com.kickstarter.dropwizard.metrics.influxdb.io.Sender;
+import com.kickstarter.dropwizard.metrics.influxdb.transformer.DropwizardMeasurement;
+import com.kickstarter.dropwizard.metrics.influxdb.transformer.DropwizardTransformer;
+
+import java.time.Clock;
+import java.util.SortedMap;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A Dropwizard {@link ScheduledReporter} for reporting measurements in InfluxDB line format.
+ *
+ *
Supports global tags, tagged templating, counter/gauge grouping,
+ * and per-metric tagging via {@link DropwizardMeasurement#toString}.
+ */
+public class InfluxDbMeasurementReporter extends ScheduledReporter {
+ private final Clock clock;
+ private final Sender sender;
+ private final DropwizardTransformer transformer;
+
+ public InfluxDbMeasurementReporter(final Sender sender,
+ final MetricRegistry registry,
+ final MetricFilter filter,
+ final TimeUnit rateUnit,
+ final TimeUnit durationUnit,
+ final Clock clock,
+ final DropwizardTransformer transformer,
+ final ScheduledExecutorService executor) {
+ super(registry, "influxdb-measurement-reporter", filter, rateUnit, durationUnit, executor);
+ this.clock = clock;
+ this.sender = sender;
+ this.transformer = transformer;
+ }
+
+ public InfluxDbMeasurementReporter(final Sender sender,
+ final MetricRegistry registry,
+ final MetricFilter filter,
+ final TimeUnit rateUnit,
+ final TimeUnit durationUnit,
+ final Clock clock,
+ final DropwizardTransformer transformer) {
+ super(registry, "influxdb-measurement-reporter", filter, rateUnit, durationUnit);
+ this.clock = clock;
+ this.sender = sender;
+ this.transformer = transformer;
+ }
+
+ @Override
+ public void report(final SortedMap gauges,
+ final SortedMap counters,
+ final SortedMap histograms,
+ final SortedMap meters,
+ final SortedMap timers) {
+ final long timestamp = clock.instant().toEpochMilli();
+
+ final ImmutableList influxDbMeasurements = ImmutableList.builder()
+ .addAll(transformer.fromGauges(gauges, timestamp))
+ .addAll(transformer.fromCounters(counters, timestamp))
+ .addAll(transformer.fromHistograms(histograms, timestamp))
+ .addAll(transformer.fromMeters(meters, timestamp))
+ .addAll(transformer.fromTimers(timers, timestamp))
+ .build();
+
+ sender.send(influxDbMeasurements);
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporterFactory.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporterFactory.java
new file mode 100644
index 0000000..ff18ce1
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporterFactory.java
@@ -0,0 +1,117 @@
+package com.kickstarter.dropwizard.metrics.influxdb;
+
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.ScheduledReporter;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import com.google.common.annotations.VisibleForTesting;
+import com.kickstarter.dropwizard.metrics.influxdb.io.InfluxDbHttpWriter;
+import com.kickstarter.dropwizard.metrics.influxdb.io.InfluxDbWriter;
+import com.kickstarter.dropwizard.metrics.influxdb.io.Sender;
+import com.kickstarter.dropwizard.metrics.influxdb.transformer.DropwizardMeasurementParser;
+import com.kickstarter.dropwizard.metrics.influxdb.transformer.DropwizardTransformer;
+import com.kickstarter.dropwizard.metrics.influxdb.transformer.TaggedPattern;
+import io.dropwizard.metrics.BaseReporterFactory;
+import javax.validation.constraints.NotNull;
+
+import java.time.Clock;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A factory for {@link InfluxDbMeasurementReporter} instances.
+ *
+ * Configuration Parameters:
+ *
+ *
+ * | Name |
+ * Default |
+ * Description |
+ *
+ *
+ * | globalTags |
+ * None |
+ * tags for all metrics reported to InfluxDb. |
+ *
+ *
+ * | metricTemplates |
+ * None |
+ * tagged metric templates for converting names passed through MetricRegistry. |
+ *
+ *
+ * | groupGauges |
+ * true |
+ * A boolean to signal whether to group gauges when reporting. |
+ *
+ *
+ * | groupCounters |
+ * true |
+ * A boolean to signal whether to group counters when reporting. |
+ *
+ *
+ * | sender |
+ * http |
+ * The type and configuration for reporting measurements to a receiver. |
+ *
+ *
+ */
+@JsonTypeName("influxdb")
+public class InfluxDbMeasurementReporterFactory extends BaseReporterFactory {
+ @NotNull
+ @JsonProperty
+ private Map globalTags = new HashMap<>();
+ @VisibleForTesting Map globalTags() {
+ return globalTags;
+ }
+
+ @NotNull
+ @JsonProperty
+ private Map metricTemplates = new HashMap<>();
+ @VisibleForTesting Map metricTemplates() {
+ return metricTemplates;
+ }
+
+ @NotNull
+ @JsonProperty
+ private boolean groupGauges = true;
+ @VisibleForTesting boolean groupGauges() {
+ return groupGauges;
+ }
+
+ @NotNull
+ @JsonProperty
+ private boolean groupCounters = true;
+ @VisibleForTesting boolean groupCounters() {
+ return groupCounters;
+ }
+
+ @NotNull
+ @JsonProperty
+ private InfluxDbWriter.Factory sender = new InfluxDbHttpWriter.Factory();
+ @VisibleForTesting InfluxDbWriter.Factory sender() {
+ return sender;
+ }
+
+ @Override
+ public ScheduledReporter build(final MetricRegistry registry) {
+ final Sender builtSender = new Sender(sender.build(registry));
+ final DropwizardTransformer transformer = new DropwizardTransformer(
+ globalTags,
+ DropwizardMeasurementParser.withTemplates(metricTemplates),
+ groupCounters,
+ groupGauges,
+ getRateUnit(),
+ getDurationUnit()
+ );
+
+ return new InfluxDbMeasurementReporter(
+ builtSender,
+ registry,
+ getFilter(),
+ getRateUnit(),
+ getDurationUnit(),
+ Clock.systemUTC(),
+ transformer
+ );
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbHttpWriter.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbHttpWriter.java
new file mode 100644
index 0000000..fbd4e6b
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbHttpWriter.java
@@ -0,0 +1,110 @@
+package com.kickstarter.dropwizard.metrics.influxdb.io;
+
+import com.codahale.metrics.MetricRegistry;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.dropwizard.client.JerseyClientConfiguration;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
+import org.hibernate.validator.constraints.NotBlank;
+import org.hibernate.validator.constraints.Range;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.util.concurrent.Executors;
+
+/**
+ * An {@link InfluxDbWriter} that writes to an HTTP/S server using a {@link Client}.
+ */
+public class InfluxDbHttpWriter implements InfluxDbWriter {
+ private final Client client;
+ private final WebTarget influxLines;
+
+ public InfluxDbHttpWriter(final Client client, final String endpoint) {
+ this.client = client;
+ this.influxLines = client.target(endpoint);
+ }
+
+ @Override
+ public void writeBytes(final byte[] bytes) {
+ influxLines.request().post(Entity.entity(bytes, MediaType.APPLICATION_OCTET_STREAM_TYPE));
+ }
+
+ @Override
+ public void close() throws IOException {
+ client.close();
+ }
+
+ // ===================================================================================================================
+ // Builder
+
+ /**
+ * A factory for {@link InfluxDbHttpWriter}.
+ *
+ * Configuration Parameters:
+ *
+ *
+ * | Name |
+ * Default |
+ * Description |
+ *
+ *
+ * | host |
+ * localhost |
+ * the InfluxDB hostname. |
+ *
+ *
+ * | port |
+ * 8086 |
+ * the InfluxDB port. |
+ *
+ *
+ * | database |
+ * none |
+ * the database to write to. |
+ *
+ *
+ * | jersey |
+ * default |
+ * the jersey client configuration. |
+ *
+ *
+ */
+ public static class Factory implements InfluxDbWriter.Factory {
+ @NotBlank
+ @JsonProperty
+ private String host = "localhost";
+
+ @Range(min = 0, max = 49151)
+ @JsonProperty
+ private int port = 8086;
+
+ @JsonProperty
+ private JerseyClientConfiguration jersey = new JerseyClientConfiguration();
+
+ @NotBlank
+ @JsonProperty
+ private String database;
+
+ public InfluxDbWriter build(final MetricRegistry metrics) {
+ final Client client = new io.dropwizard.client.JerseyClientBuilder(metrics)
+ .using(jersey)
+ .using(new ObjectMapper())
+ .using(Executors.newSingleThreadExecutor())
+ .build("influxdb-http-writer");
+
+ try {
+ final String query = "/write?db=" + URLEncoder.encode(database, "UTF-8");
+ final URL endpoint = new URL("http", host, port, query);
+ return new InfluxDbHttpWriter(client, endpoint.toString());
+ } catch (MalformedURLException | UnsupportedEncodingException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbTcpWriter.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbTcpWriter.java
new file mode 100644
index 0000000..a12e97b
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbTcpWriter.java
@@ -0,0 +1,105 @@
+package com.kickstarter.dropwizard.metrics.influxdb.io;
+
+import com.codahale.metrics.MetricRegistry;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.dropwizard.util.Duration;
+import javax.validation.constraints.NotNull;
+import org.hibernate.validator.constraints.NotBlank;
+import org.hibernate.validator.constraints.Range;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.Socket;
+
+/**
+ * An {@link InfluxDbWriter} that writes bytes to TCP sockets.
+ */
+public class InfluxDbTcpWriter implements InfluxDbWriter {
+ private final String host;
+ private final int port;
+ private final Duration timeout;
+ private Socket tcpSocket;
+
+ public InfluxDbTcpWriter(final String host, final int port, final Duration timeout) {
+ this.host = host;
+ this.port = port;
+ this.timeout = timeout;
+ }
+
+ @Override
+ public void writeBytes(final byte[] bytes) throws IOException {
+ if (tcpSocket == null) {
+ tcpSocket = new Socket(host, port);
+ tcpSocket.setSoTimeout((int) timeout.toMilliseconds());
+ }
+
+ final OutputStream outputStream = tcpSocket.getOutputStream();
+ outputStream.write(bytes);
+ outputStream.flush();
+ }
+
+ @Override
+ public void close() throws IOException {
+ if (tcpSocket != null) {
+ tcpSocket.close();
+ tcpSocket = null;
+ }
+ }
+
+ // ===================================================================================================================
+ // Builder
+
+ /**
+ * A factory for {@link InfluxDbTcpWriter}.
+ *
+ * Configuration Parameters:
+ *
+ *
+ * | Name |
+ * Default |
+ * Description |
+ *
+ *
+ * | host |
+ * localhost |
+ * the consumer hostname. |
+ *
+ *
+ * | port |
+ * 8086 |
+ * the consumer port. |
+ *
+ *
+ * | timeout |
+ * 500 milliseconds/i> |
+ * the socket timeout duration. |
+ *
+ *
+ */
+ public static class Factory implements InfluxDbWriter.Factory {
+ @NotBlank
+ @JsonProperty
+ private String host = "localhost";
+ public String host() {
+ return host;
+ }
+
+ @Range(min = 0, max = 49151)
+ @JsonProperty
+ private int port = 8086;
+ public int port() {
+ return port;
+ }
+
+ @NotNull
+ @JsonProperty
+ private Duration timeout = Duration.milliseconds(500);
+ public Duration timeout() {
+ return timeout;
+ }
+
+ @Override public InfluxDbWriter build(final MetricRegistry __) {
+ return new InfluxDbTcpWriter(host, port, timeout);
+ }
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbWriter.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbWriter.java
new file mode 100644
index 0000000..e153e29
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbWriter.java
@@ -0,0 +1,33 @@
+package com.kickstarter.dropwizard.metrics.influxdb.io;
+
+import com.codahale.metrics.MetricRegistry;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+
+import java.io.IOException;
+
+/**
+ * Writes bytes to an InfluxDB input.
+ */
+public interface InfluxDbWriter {
+ /**
+ * Write the given bytes to the connection.
+ *
+ * @throws Exception if an error occurs while writing.
+ */
+ void writeBytes(final byte[] bytes) throws Exception;
+ /**
+ * Close the writer connection, if it is open.
+ *
+ * @throws IOException if an I/O error occurs when closing the connection.
+ */
+ void close() throws IOException;
+
+ @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
+ @JsonSubTypes({
+ @JsonSubTypes.Type(value = InfluxDbHttpWriter.Factory.class, name = "http"),
+ @JsonSubTypes.Type(value = InfluxDbTcpWriter.Factory.class, name = "tcp")})
+ interface Factory {
+ InfluxDbWriter build(final MetricRegistry metrics);
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/Sender.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/Sender.java
new file mode 100644
index 0000000..2de4831
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/io/Sender.java
@@ -0,0 +1,81 @@
+package com.kickstarter.dropwizard.metrics.influxdb.io;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.EvictingQueue;
+import com.kickstarter.dropwizard.metrics.influxdb.InfluxDbMeasurement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Collection;
+
+import static java.util.stream.Collectors.toList;
+
+/**
+ * Sends measurements to InfluxDB. Uses an {@link EvictingQueue} to store and retry measurements that have
+ * failed to send, and timestamps measurements at the configured {@code precision}, up to millisecond precision.
+ */
+public class Sender {
+ private static final Logger log = LoggerFactory.getLogger(InfluxDbTcpWriter.class);
+
+ public static final int DEFAULT_QUEUE_SIZE = 5000;
+ private static final String SEPARATOR = "\n";
+
+ private final InfluxDbWriter writer;
+ private final EvictingQueue queuedInfluxDbMeasurements;
+
+ public Sender(final InfluxDbWriter writer) {
+ this(writer, DEFAULT_QUEUE_SIZE);
+ }
+
+ public Sender(final InfluxDbWriter writer, final int queueSize) {
+ this.writer = writer;
+ this.queuedInfluxDbMeasurements = EvictingQueue.create(queueSize);
+ }
+
+ @VisibleForTesting int queuedMeasures() {
+ return queuedInfluxDbMeasurements.size();
+ }
+
+ /**
+ * Sends the provided {@link InfluxDbMeasurement measurements} to InfluxDB.
+ *
+ * @return true if the measurements were successfully sent.
+ */
+ public boolean send(final Collection influxDbMeasurements) {
+ queuedInfluxDbMeasurements.addAll(influxDbMeasurements);
+
+ if (queuedInfluxDbMeasurements.isEmpty()) {
+ return true;
+ }
+
+ final String measureLines = String.join(
+ SEPARATOR,
+ queuedInfluxDbMeasurements.stream()
+ .map(InfluxDbMeasurement::toLine)
+ .collect(toList())
+ ) + SEPARATOR;
+
+ try {
+ final byte[] measureBytes = measureLines.getBytes("UTF-8");
+ writer.writeBytes(measureBytes);
+ queuedInfluxDbMeasurements.clear();
+ return true;
+ } catch (final UnsupportedEncodingException e) {
+ log.warn("failed to send metrics", e);
+ } catch (final Exception e) {
+ log.warn("failed to send metrics", e);
+ try {
+ writer.close();
+ } catch (final Exception e2) {
+ log.warn("failed to close metrics connection", e2);
+ }
+ }
+
+ if (queuedInfluxDbMeasurements.remainingCapacity() == 0) {
+ log.warn("Queued measurements at capacity");
+ }
+
+ return false;
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurement.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurement.java
new file mode 100644
index 0000000..63045d3
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurement.java
@@ -0,0 +1,123 @@
+package com.kickstarter.dropwizard.metrics.influxdb.transformer;
+
+import com.codahale.metrics.Counter;
+import com.codahale.metrics.Gauge;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.Timer;
+import com.google.auto.value.AutoValue;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Optional;
+
+import static java.util.stream.Collectors.toMap;
+
+/**
+ * A Dropwizard measurement associated with a {@link MetricRegistry} component
+ * (e.g. {@link Timer timers}, {@link Counter counters}, and {@link Gauge gauges}).
+ *
+ * Serialized in the following format:
+ *
{@code
+ * measurement_name[,tag1=val1,tag2=val2][ field_name]
+ * }
+ */
+@AutoValue
+public abstract class DropwizardMeasurement {
+ // Serializer constants.
+ private static final String FIELD_SEPARATOR = " ";
+ private static final String TAG_SEPARATOR = ",";
+ private static final String VALUE_SEPARATOR = "=";
+ private static final String ESCAPE_CHARS = " |,|=";
+ private static final String SANITIZER = "-";
+
+ // Fields
+ abstract String name();
+ abstract Map tags();
+
+ // Provided field name for gauges; used for gauge grouping.
+ // This field is only set for non-templated measurements;
+ // templates will be parsed for field names.
+ abstract Optional field();
+
+ /**
+ * Sanitizes InfluxDb escape characters.
+ */
+ private static String sanitize(final String s) {
+ return s.replaceAll(ESCAPE_CHARS, SANITIZER);
+ }
+
+ /**
+ * Creates a new {@link DropwizardMeasurement} with sanitized values.
+ */
+ public static DropwizardMeasurement create(final String name, final Map tags, final Optional field) {
+ final Map sanitizedTags = tags.entrySet()
+ .stream()
+ .collect(toMap(
+ e -> DropwizardMeasurement.sanitize(e.getKey()),
+ e -> DropwizardMeasurement.sanitize(e.getValue())
+ ));
+
+ return new AutoValue_DropwizardMeasurement(sanitize(name), sanitizedTags, field.map(DropwizardMeasurement::sanitize));
+ }
+
+ /**
+ * Deserializes a measurement line string in the form:
+ * {@code
+ * measurement_name[,tag1=val1,tag2=val2][ field_name]
+ * }
+ */
+ public static DropwizardMeasurement fromLine(final String line) {
+ // split measurement-name/tags and field name
+ final String[] initialParts = line.split(FIELD_SEPARATOR);
+ if (initialParts.length > 2) {
+ throw new IllegalArgumentException("too many spaces in measurement line");
+ }
+
+ // parse optional field
+ final Optional field;
+ if (initialParts.length == 2) {
+ field = Optional.of(initialParts[1]);
+ } else {
+ field = Optional.empty();
+ }
+
+ // split measurement-name and tags
+ final String[] parts = initialParts[0].split(TAG_SEPARATOR);
+ final String name = parts[0];
+
+ // parse tags as a key-val map
+ final Map tags = Arrays.asList(parts)
+ .subList(1, parts.length)
+ .stream()
+ .map(s -> s.split(VALUE_SEPARATOR))
+ .filter(arr -> arr.length == 2)
+ .collect(toMap(arr -> arr[0], arr -> arr[1]));
+
+ // if the sizes aren't one-to-one, we filtered some tag parts out.
+ if (tags.size() != parts.length - 1) {
+ throw new IllegalArgumentException("tags must contain exactly one '=' character");
+ }
+
+ return DropwizardMeasurement.create(name, tags, field);
+ }
+
+ @Override
+ public String toString() {
+ final StringBuilder builder = new StringBuilder();
+ builder.append(name());
+
+ tags().forEach((k, v) -> {
+ builder.append(TAG_SEPARATOR);
+ builder.append(k);
+ builder.append(VALUE_SEPARATOR);
+ builder.append(v);
+ });
+
+ if (field().isPresent()) {
+ builder.append(FIELD_SEPARATOR);
+ builder.append(field().orElse(""));
+ }
+
+ return builder.toString();
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurementParser.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurementParser.java
new file mode 100644
index 0000000..ca5cd02
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurementParser.java
@@ -0,0 +1,94 @@
+package com.kickstarter.dropwizard.metrics.influxdb.transformer;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * A dropwizard measurement parser that holds metric templates for mapping between
+ * directory-style dot notation and influx-style tags. If no template matches a
+ * given metric name, it will attempt to parse it as a {@link DropwizardMeasurement} line.
+ *
+ * This transformer caches mappings from metric names to {@link DropwizardMeasurement}
+ * objects to avoid extraneous regex matching and string parsing.
+ */
+public class DropwizardMeasurementParser {
+ /**
+ * Templates for provided Dropwizard metrics. I'm so sorry for these regexes.
+ */
+ private static final ImmutableMap DROPWIZARD_METRIC_MAPPINGS = ImmutableMap.builder()
+ .put("health", new TaggedPattern(".*\\.health\\.(?.*)"))
+ .put("resources", new TaggedPattern(".*\\.resources?\\.(?[A-Za-z]+)\\.(?[A-Za-z]+)", "resource", "method"))
+ .put("jvm", new TaggedPattern("^jvm$"))
+ .put("jvm_attribute", new TaggedPattern("jvm\\.attribute.*?"))
+ .put("jvm_buffers", new TaggedPattern("jvm\\.buffers\\.?(?.*)", "type"))
+ .put("jvm_classloader", new TaggedPattern("jvm\\.classloader.*"))
+ .put("jvm_gc", new TaggedPattern("jvm\\.gc\\.?(?.*)", "metric"))
+ .put("jvm_memory", new TaggedPattern("jvm\\.memory\\.?(?.*)", "metric"))
+ .put("jvm_threads", new TaggedPattern("jvm\\.threads\\.?(?.*)", "metric"))
+ .put("logging", new TaggedPattern("ch\\.qos\\.logback\\.core\\.Appender\\.(?.*)", "level"))
+ .put("raw_sql", new TaggedPattern("org\\.skife\\.jdbi\\.v2\\.DBI\\.raw-sql"))
+ .put("clients", new TaggedPattern("org\\.apache\\.http\\.client\\.HttpClient\\.(?.*)\\.(?.*)$", "client", "metric"))
+ .put("client_connections", new TaggedPattern("org\\.apache\\.http\\.conn\\.HttpClientConnectionManager\\.(?.*)", "client"))
+ .put("connections", new TaggedPattern("org\\.eclipse\\.jetty\\.server\\.HttpConnectionFactory\\.(?[0-9]+).*", "port"))
+ .put("thread_pools", new TaggedPattern("org\\.eclipse\\.jetty\\.util\\.thread\\.QueuedThreadPool\\.(?.*)", "pool"))
+ .put("http_server", new TaggedPattern("io\\.dropwizard\\.jetty\\.MutableServletContextHandler\\.?(?.*)", "metric"))
+ .put("data_sources", new TaggedPattern("io\\.dropwizard\\.db\\.ManagedPooledDataSource\\.(?.*)", "metric"))
+ .build();
+
+ private final ImmutableMap metricTemplates;
+ private final Map cache = new HashMap<>();
+
+ @VisibleForTesting DropwizardMeasurementParser(final ImmutableMap metricTemplates) {
+ this.metricTemplates = metricTemplates;
+ }
+
+ /**
+ * Returns a new {@link DropwizardMeasurementParser} with default {@link #DROPWIZARD_METRIC_MAPPINGS}
+ * and the user-provided {@code metricTemplates}.
+ */
+ public static DropwizardMeasurementParser withTemplates(final Map metricTemplates) {
+ return new DropwizardMeasurementParser(
+ new ImmutableMap.Builder()
+ .putAll(metricTemplates)
+ .putAll(DROPWIZARD_METRIC_MAPPINGS)
+ .build()
+ );
+ }
+
+ /**
+ * Returns a {@link DropwizardMeasurement} from a matched template, or parses it as a measurement line.
+ *
+ * @throws IllegalArgumentException if the measurement does not match a template and is not in the
+ * measurement line format.
+ *
+ * @see DropwizardMeasurement#fromLine(String)
+ */
+ /*package*/ DropwizardMeasurement parse(final String metricName) {
+ return cache.computeIfAbsent(metricName, __ ->
+ templatedMeasurement(metricName)
+ .orElseGet(() -> DropwizardMeasurement.fromLine(metricName))
+ );
+ }
+
+ /**
+ * Searches the configured templates for a match to {@code metricName}.
+ *
+ * @return an Optional-wrapped {@link DropwizardMeasurement} with any matched tags, and no field value.
+ */
+ private Optional templatedMeasurement(final String metricName) {
+ for (final Map.Entry entry : metricTemplates.entrySet()) {
+ final Optional measurement = entry.getValue().tags(metricName)
+ .map(tags -> DropwizardMeasurement.create(entry.getKey(), tags, Optional.empty()));
+
+ if (measurement.isPresent()) {
+ return measurement;
+ }
+ }
+
+ return Optional.empty();
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardTransformer.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardTransformer.java
new file mode 100644
index 0000000..50ebd72
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardTransformer.java
@@ -0,0 +1,344 @@
+package com.kickstarter.dropwizard.metrics.influxdb.transformer;
+
+import com.codahale.metrics.Counter;
+import com.codahale.metrics.Gauge;
+import com.codahale.metrics.Histogram;
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.Snapshot;
+import com.codahale.metrics.Timer;
+import com.google.common.annotations.VisibleForTesting;
+import com.kickstarter.dropwizard.metrics.influxdb.InfluxDbMeasurement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+
+import static java.util.stream.Collectors.toList;
+
+/**
+ * A transformer from Dropwizard metric objects to tagged and grouped {@link InfluxDbMeasurement}s.
+ *
+ * Supports global tags, tagged templating, counter/gauge grouping, and per-metric tagging.
+ */
+public class DropwizardTransformer {
+ private static final Logger log = LoggerFactory.getLogger(DropwizardTransformer.class);
+
+ private final Map baseTags;
+ private final DropwizardMeasurementParser parser;
+ private final boolean groupCounters;
+ private final boolean groupGauges;
+
+ private final long rateFactor;
+ private final long durationFactor;
+
+ public DropwizardTransformer(final Map baseTags,
+ final DropwizardMeasurementParser parser,
+ final boolean groupCounters,
+ final boolean groupGauges,
+ final TimeUnit rateUnit,
+ final TimeUnit durationUnit) {
+ this.baseTags = baseTags;
+ this.parser = parser;
+ this.groupCounters = groupCounters;
+ this.groupGauges = groupGauges;
+ this.rateFactor = rateUnit.toSeconds(1);
+ this.durationFactor = durationUnit.toNanos(1);
+ }
+
+ @VisibleForTesting double convertDuration(final double duration) {
+ return duration / durationFactor;
+ }
+
+ @VisibleForTesting double convertRate(final double rate) {
+ return rate * rateFactor;
+ }
+
+ // ===================================================================================================================
+ // timers
+
+ /**
+ * Build a List of {@link InfluxDbMeasurement}s from a timer map.
+ */
+ public List fromTimers(final Map timers, final long timestamp) {
+ return timers.entrySet().stream()
+ .map(e -> fromTimer(e.getKey(), e.getValue(), timestamp))
+ .collect(toList());
+ }
+
+ /**
+ * Build an {@link InfluxDbMeasurement} from a timer.
+ */
+ @VisibleForTesting InfluxDbMeasurement fromTimer(final String metricName, final Timer t, final long timestamp) {
+ final Snapshot snapshot = t.getSnapshot();
+ final DropwizardMeasurement measurement = parser.parse(metricName);
+
+ final Map tags = new HashMap<>(baseTags);
+ tags.putAll(measurement.tags());
+
+ return new InfluxDbMeasurement.Builder(measurement.name(), timestamp)
+ .putTags(tags)
+ .putField("count", snapshot.size())
+ .putField("min", convertDuration(snapshot.getMin()))
+ .putField("max", convertDuration(snapshot.getMax()))
+ .putField("mean", convertDuration(snapshot.getMean()))
+ .putField("std-dev", convertDuration(snapshot.getStdDev()))
+ .putField("50-percentile", convertDuration(snapshot.getMedian()))
+ .putField("75-percentile", convertDuration(snapshot.get75thPercentile()))
+ .putField("95-percentile", convertDuration(snapshot.get95thPercentile()))
+ .putField("99-percentile", convertDuration(snapshot.get99thPercentile()))
+ .putField("999-percentile", convertDuration(snapshot.get999thPercentile()))
+ .putField("one-minute", convertRate(t.getOneMinuteRate()))
+ .putField("five-minute", convertRate(t.getFiveMinuteRate()))
+ .putField("fifteen-minute", convertRate(t.getFifteenMinuteRate()))
+ .putField("mean-minute", convertRate(t.getMeanRate()))
+ .putField("run-count", t.getCount())
+ .build();
+ }
+
+ // ===================================================================================================================
+ // meters
+
+ /**
+ * Build a List of {@link InfluxDbMeasurement}s from a meter map.
+ */
+ public List fromMeters(final Map meters, final long timestamp) {
+ return meters.entrySet().stream()
+ .map(e -> fromMeter(e.getKey(), e.getValue(), timestamp))
+ .collect(toList());
+ }
+
+ /**
+ * Build an {@link InfluxDbMeasurement} from a meter.
+ */
+ @VisibleForTesting InfluxDbMeasurement fromMeter(final String metricName, final Meter mt, final long timestamp) {
+ final DropwizardMeasurement measurement = parser.parse(metricName);
+
+ final Map tags = new HashMap<>(baseTags);
+ tags.putAll(measurement.tags());
+
+ return new InfluxDbMeasurement.Builder(measurement.name(), timestamp)
+ .putTags(tags)
+ .putField("count", mt.getCount())
+ .putField("one-minute", convertRate(mt.getOneMinuteRate()))
+ .putField("five-minute", convertRate(mt.getFiveMinuteRate()))
+ .putField("fifteen-minute", convertRate(mt.getFifteenMinuteRate()))
+ .putField("mean-minute", convertRate(mt.getMeanRate()))
+ .build();
+ }
+
+ // ===================================================================================================================
+ // histograms
+
+ /**
+ * Build a List of {@link InfluxDbMeasurement}s from a histogram map.
+ */
+ public List fromHistograms(final Map histograms, final long timestamp) {
+ return histograms.entrySet().stream()
+ .map(e -> fromHistogram(e.getKey(), e.getValue(), timestamp))
+ .collect(toList());
+ }
+
+ /**
+ * Build an {@link InfluxDbMeasurement} from a histogram.
+ */
+ @VisibleForTesting InfluxDbMeasurement fromHistogram(final String metricName, final Histogram h, final long timestamp) {
+ final Snapshot snapshot = h.getSnapshot();
+ final DropwizardMeasurement measurement = parser.parse(metricName);
+
+ final Map tags = new HashMap<>(baseTags);
+ tags.putAll(measurement.tags());
+
+ return new InfluxDbMeasurement.Builder(measurement.name(), timestamp)
+ .putTags(tags)
+ .putField("count", snapshot.size())
+ .putField("min", snapshot.getMin())
+ .putField("max", snapshot.getMax())
+ .putField("mean", snapshot.getMean())
+ .putField("std-dev", snapshot.getStdDev())
+ .putField("50-percentile", snapshot.getMedian())
+ .putField("75-percentile", snapshot.get75thPercentile())
+ .putField("95-percentile", snapshot.get95thPercentile())
+ .putField("99-percentile", snapshot.get99thPercentile())
+ .putField("999-percentile", snapshot.get999thPercentile())
+ .putField("run-count", h.getCount())
+ .build();
+ }
+
+ // ===================================================================================================================
+ // groupable measurements: counters and gauges
+
+ /**
+ * Build a List of {@link InfluxDbMeasurement}s from a counter map.
+ */
+ public List fromCounters(final Map counters, final long timestamp) {
+ return fromCounterOrGauge(counters, "count", Counter::getCount, timestamp, groupCounters);
+ }
+
+ /**
+ * Build a List of {@link InfluxDbMeasurement}s from a gauge map.
+ */
+ public List fromGauges(final Map gauges, final long timestamp) {
+ return fromCounterOrGauge(gauges, "value", Gauge::getValue, timestamp, groupGauges);
+ }
+
+ private List fromCounterOrGauge(final Map items,
+ final String defaultFieldName,
+ final Function valueExtractor,
+ final long timestamp,
+ final boolean group) {
+ if (group) {
+ final Map> groupedItems = groupValues(items, defaultFieldName, valueExtractor);
+ return groupedItems.entrySet().stream()
+ .map(entry -> fromValueGroup(entry.getKey(), entry.getValue(), timestamp))
+ .filter(Optional::isPresent)
+ .map(Optional::get)
+ .collect(toList());
+ } else {
+ return items.entrySet().stream()
+ .map(entry -> fromKeyValue(entry.getKey(), defaultFieldName, valueExtractor.apply(entry.getValue()), timestamp))
+ .collect(toList());
+ }
+ }
+
+ /**
+ * Build an {@link InfluxDbMeasurement} directly from given values.
+ */
+ @VisibleForTesting InfluxDbMeasurement fromKeyValue(final String metricName,
+ final String defaultFieldName,
+ final T value,
+ final long timestamp) {
+ final DropwizardMeasurement measurement = parser.parse(metricName);
+ final Map tags = new HashMap<>(baseTags);
+ tags.putAll(measurement.tags());
+
+ return new InfluxDbMeasurement.Builder(measurement.name(), timestamp)
+ .putTags(tags)
+ .putField(defaultFieldName, value)
+ .build();
+ }
+
+ /**
+ * Groups {@code items} into a set of measurements marked by the measurement name and tag set.
+ *
+ * This method separates measurement names and fields by the following logic:
+
+ *
For {@link DropwizardMeasurement}-style line notation, we parse measurements and fields
+ * directly via {@link DropwizardMeasurement#fromLine(String)}.
+ *
+ *
+ *
For Dropwizard-style dot notation, we read the last part as a field name. If there is
+ * only one part, we use the provided default field name.
+ *
Metrics that end with `.count` will be parsed with the last two parts as a field name.
+ *
+ *
e.g.
+ *
+ *
+ * | Full Key |
+ * Parsed Group |
+ * Parsed Field |
+ *
+ *
+ * | Measurement,action=restore someField |
+ * Measurement,action=restore |
+ * someField |
+ *
+ *
+ * | Measurement,action=restore |
+ * Measurement,action=restore |
+ * defaultFieldName |
+ *
+ *
+ * | jvm |
+ * jvm |
+ * defaultFieldName |
+ *
+ *
+ * | jvm.threads.deadlock |
+ * jvm.threads |
+ * deadlock |
+ *
+ *
+ * | jvm.threads.deadlock.count |
+ * jvm.threads |
+ * deadlock.count |
+ *
+ *
+ *
+ * @return A map from {@link GroupKey GroupKeys} to the group's field map.
+ */
+ @VisibleForTesting Map> groupValues(final Map items,
+ final String defaultFieldName,
+ final Function valueExtractor) {
+ final Map> groupedValues = new HashMap<>();
+
+ items.forEach((key, item) -> {
+ final String measurementKey;
+ final String field;
+
+ if (key.contains(" ") || key.contains(",")) {
+ // Inlined key with tag or field -- formatted as seen in Measurement.toString().
+ measurementKey = key;
+ field = parser.parse(key).field().orElse(defaultFieldName);
+ } else {
+ // Templated key -- formatted in Dropwizard/Graphite-style directory notation.
+
+ // If the key ends in `.count`, we try to include the previous part in the field name.
+ // This is an odd hack to group Dropwizard jvm.threads gauge measurements.
+ // e.g. for 'jvm.threads.deadlock.count': key=jvm.threads, field=deadlock.count.
+ final boolean hasCountPostfix = key.endsWith(".count");
+ final String mainKey = hasCountPostfix ? key.substring(0, key.length() - 6) : key;
+
+ // Parse the field name from the last key part.
+ // e.g. for `jvm.memory.heap`: key=jvm.memory, field=heap.
+ final int lastDotIndex = mainKey.lastIndexOf(".");
+ if (lastDotIndex == -1) {
+ // only one key part; use the default field name.
+ measurementKey = mainKey;
+ field = hasCountPostfix ? "count" : defaultFieldName;
+ } else {
+ // parse the last part as a field name.
+ measurementKey = mainKey.substring(0, lastDotIndex);
+ // use `key` instead of `mainKey` here
+ // to include `.count` in the field name.
+ field = key.substring(lastDotIndex + 1);
+ }
+ }
+
+ final DropwizardMeasurement measurement = parser.parse(measurementKey);
+ final GroupKey groupKey = GroupKey.create(measurement.name(), measurement.tags());
+
+ final Map fields = groupedValues.getOrDefault(groupKey, new HashMap<>());
+ fields.put(field, valueExtractor.apply(item));
+ groupedValues.put(groupKey, fields);
+ });
+
+ return groupedValues;
+ }
+
+ /**
+ * Build an {@link InfluxDbMeasurement} from a group key and field map.
+ */
+ @VisibleForTesting Optional fromValueGroup(final GroupKey groupKey,
+ final Map fields,
+ final long timestamp) {
+ final Map tags = new HashMap<>(baseTags);
+ tags.putAll(groupKey.tags());
+
+ final InfluxDbMeasurement.Builder builder =
+ new InfluxDbMeasurement.Builder(groupKey.measurement(), timestamp)
+ .putTags(tags)
+ .tryPutFields(fields, e -> log.warn(e.getMessage()));
+
+ if (builder.isValid()) {
+ log.warn("Measurement has no valid fields: {}", groupKey.measurement());
+ return Optional.of(builder.build());
+ }
+
+ return Optional.empty();
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/GroupKey.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/GroupKey.java
new file mode 100644
index 0000000..91b537b
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/GroupKey.java
@@ -0,0 +1,16 @@
+package com.kickstarter.dropwizard.metrics.influxdb.transformer;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+
+import java.util.Map;
+
+@AutoValue
+abstract class GroupKey {
+ abstract String measurement();
+ abstract Map tags();
+
+ @VisibleForTesting static GroupKey create(final String measurement, final Map tags) {
+ return new AutoValue_GroupKey(measurement, tags);
+ }
+}
diff --git a/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/TaggedPattern.java b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/TaggedPattern.java
new file mode 100644
index 0000000..6942203
--- /dev/null
+++ b/src/main/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/TaggedPattern.java
@@ -0,0 +1,67 @@
+package com.kickstarter.dropwizard.metrics.influxdb.transformer;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.annotations.VisibleForTesting;
+import javax.validation.constraints.NotNull;
+import org.hibernate.validator.constraints.NotBlank;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static java.util.stream.Collectors.toMap;
+
+/**
+ * A wrapper for {@link Pattern regex patterns}, used for extracting tags.
+ */
+public class TaggedPattern {
+ @NotBlank
+ @JsonProperty
+ private String pattern;
+ public String pattern() {
+ return pattern;
+ }
+
+ @NotNull
+ @JsonProperty
+ private List tagKeys;
+ public List tagKeys() {
+ return tagKeys;
+ }
+
+ // for internal use.
+ private final Pattern compiledPattern;
+
+ @JsonCreator
+ public TaggedPattern(final String pattern, final List tagKeys) {
+ this.pattern = pattern;
+ this.tagKeys = tagKeys;
+ this.compiledPattern = Pattern.compile(pattern);
+ }
+
+ @VisibleForTesting TaggedPattern(final String pattern, final String... tagKeys) {
+ this(pattern, Arrays.asList(tagKeys));
+ }
+
+ /**
+ * Matches the {@code input} string and returns a map of matched tags.
+ * The tag map will not contain any empty pattern matcher groups.
+ *
+ * @return An Optional-wrapped mapping of tags, or {@link Optional#empty()}
+ * if the input does not match the pattern.
+ */
+ /*package*/ Optional> tags(final CharSequence input) {
+ final Matcher matcher = compiledPattern.matcher(input);
+ if (matcher.matches()) {
+ return Optional.of(tagKeys.stream()
+ .filter(tag -> !matcher.group(tag).isEmpty())
+ .collect(toMap(Function.identity(), matcher::group)));
+ }
+ return Optional.empty();
+ }
+}
diff --git a/src/main/resources/META-INF/services/io.dropwizard.metrics.ReporterFactory b/src/main/resources/META-INF/services/io.dropwizard.metrics.ReporterFactory
new file mode 100644
index 0000000..a3b7ed7
--- /dev/null
+++ b/src/main/resources/META-INF/services/io.dropwizard.metrics.ReporterFactory
@@ -0,0 +1 @@
+com.kickstarter.dropwizard.metrics.influxdb.InfluxDbMeasurementReporterFactory
\ No newline at end of file
diff --git a/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporterFactoryTest.java b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporterFactoryTest.java
new file mode 100644
index 0000000..15da434
--- /dev/null
+++ b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporterFactoryTest.java
@@ -0,0 +1,71 @@
+package com.kickstarter.dropwizard.metrics.influxdb;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.kickstarter.dropwizard.metrics.influxdb.io.InfluxDbTcpWriter;
+import com.kickstarter.dropwizard.metrics.influxdb.transformer.TaggedPattern;
+import io.dropwizard.jackson.Jackson;
+import io.dropwizard.setup.Environment;
+import io.dropwizard.util.Duration;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class InfluxDbMeasurementReporterFactoryTest {
+ @Test
+ public void testSerialization() throws IOException {
+ final String json =
+ "{" +
+ "\"type\": \"influxdb\"," +
+ "\"globalTags\": {\"some\": \"tag\"}," +
+ "\"metricTemplates\": {" +
+ "\"measurement\": {" +
+ "\"pattern\": \".*blah\"," +
+ "\"tagKeys\": [\"blah\"]" +
+ "}" +
+ "}," +
+ "\"groupGauges\": true," +
+ "\"groupCounters\": true," +
+ "\"sender\": {" +
+ "\"type\": \"tcp\"," +
+ "\"host\": \"i am a host\"," +
+ "\"port\": \"12345\"," +
+ "\"timeout\": \"5 minutes\"" +
+ "}" +
+ "}";
+
+ final ObjectMapper mapper = Jackson.newObjectMapper();
+ mapper.registerModule(new ParameterNamesModule(JsonCreator.Mode.PROPERTIES));
+
+ final Environment env = mock(Environment.class);
+ when(env.getObjectMapper()).thenReturn(mapper);
+
+ final InfluxDbMeasurementReporterFactory factory = mapper.readValue(json, InfluxDbMeasurementReporterFactory.class);
+ assertEquals("expected global tags", ImmutableMap.of("some", "tag"), factory.globalTags());
+
+ final Map templates = factory.metricTemplates();
+ assertEquals("expected a single template", 1, templates.size());
+
+ final TaggedPattern template = templates.get("measurement");
+ assertEquals("expected template pattern", ".*blah", template.pattern());
+ assertEquals("expected template tag keys", ImmutableList.of("blah"), template.tagKeys());
+
+
+ assertTrue("expected group_guages", factory.groupGauges());
+ assertTrue("expected group_counters", factory.groupCounters());
+
+ final InfluxDbTcpWriter.Factory tcp = (InfluxDbTcpWriter.Factory) factory.sender();
+ assertEquals("expected TCP host", "i am a host", tcp.host());
+ assertEquals("expected TCP port", 12345, tcp.port());
+ assertEquals("expected TCP timeout", Duration.minutes(5), tcp.timeout());
+ }
+}
diff --git a/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporterTest.java b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporterTest.java
new file mode 100644
index 0000000..e99bc59
--- /dev/null
+++ b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementReporterTest.java
@@ -0,0 +1,86 @@
+package com.kickstarter.dropwizard.metrics.influxdb;
+
+import com.codahale.metrics.Counter;
+import com.codahale.metrics.ExponentiallyDecayingReservoir;
+import com.codahale.metrics.Gauge;
+import com.codahale.metrics.Histogram;
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricFilter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.Timer;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSortedMap;
+import com.kickstarter.dropwizard.metrics.influxdb.io.Sender;
+import com.kickstarter.dropwizard.metrics.influxdb.transformer.DropwizardTransformer;
+import org.junit.Test;
+
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.util.List;
+import java.util.SortedMap;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class InfluxDbMeasurementReporterTest {
+ private final Clock clock = Clock.fixed(Instant.now(), ZoneId.of("UTC"));
+
+ @Test
+ public void testReport() {
+ final Sender sender = mock(Sender.class);
+ final DropwizardTransformer transformer = mock(DropwizardTransformer.class);
+
+ final InfluxDbMeasurementReporter reporter = new InfluxDbMeasurementReporter(
+ sender,
+ new MetricRegistry(),
+ MetricFilter.ALL,
+ TimeUnit.SECONDS,
+ TimeUnit.MILLISECONDS,
+ clock,
+ transformer
+ );
+
+ final long timestamp = clock.instant().toEpochMilli();
+ final SortedMap gauges = ImmutableSortedMap.of("some", () -> 5);
+ final SortedMap counters = ImmutableSortedMap.of("more", new Counter());
+ final SortedMap histograms = ImmutableSortedMap.of("metrics", new Histogram(new ExponentiallyDecayingReservoir()));
+ final SortedMap meters = ImmutableSortedMap.of("for", new Meter());
+ final SortedMap timers = ImmutableSortedMap.of("for", new Timer());
+
+ final List expectedMeasurements =
+ Stream
+ .of("gauge", "counter", "histogram", "meter", "timer")
+ .map(name ->
+ InfluxDbMeasurement.create(
+ "some",
+ ImmutableMap.of(),
+ ImmutableMap.of(name, "stuff"),
+ timestamp
+ )
+ ).collect(toList());
+
+ when(transformer.fromGauges(gauges, timestamp))
+ .thenReturn(ImmutableList.of(expectedMeasurements.get(0)));
+
+ when(transformer.fromCounters(counters, timestamp))
+ .thenReturn(ImmutableList.of(expectedMeasurements.get(1)));
+
+ when(transformer.fromHistograms(histograms, timestamp))
+ .thenReturn(ImmutableList.of(expectedMeasurements.get(2)));
+
+ when(transformer.fromMeters(meters, timestamp))
+ .thenReturn(ImmutableList.of(expectedMeasurements.get(3)));
+
+ when(transformer.fromTimers(timers, timestamp))
+ .thenReturn(ImmutableList.of(expectedMeasurements.get(4)));
+
+ reporter.report(gauges, counters, histograms, meters, timers);
+ verify(sender).send(expectedMeasurements);
+ }
+}
diff --git a/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementTest.java b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementTest.java
new file mode 100644
index 0000000..7d8049a
--- /dev/null
+++ b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/InfluxDbMeasurementTest.java
@@ -0,0 +1,279 @@
+package com.kickstarter.dropwizard.metrics.influxdb;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Map;
+
+import static java.util.stream.Collectors.toList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+public class InfluxDbMeasurementTest {
+ @Test
+ public void testCreate_EmptyName() {
+ try {
+ InfluxDbMeasurement.create("", ImmutableMap.of(), ImmutableMap.of("some", "field"), 123456L);
+ fail("Expected an Exception to be thrown");
+ } catch (final Exception thrown) {
+ assertEquals("Expected an IllegalArgumentException", IllegalArgumentException.class, thrown.getClass());
+ assertEquals("InfluxDbMeasurement must contain a non-empty name", thrown.getMessage());
+ }
+ }
+
+ @Test
+ public void testCreate_EmptyFields() {
+ try {
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of(), 123456L);
+ fail("Expected an Exception to be thrown");
+ } catch (final Exception thrown) {
+ assertEquals("Expected an IllegalArgumentException", IllegalArgumentException.class, thrown.getClass());
+ assertEquals("InfluxDbMeasurement must contain at least one field", thrown.getMessage());
+ }
+ }
+
+ @Test
+ public void testToLine_WithNoTags() {
+ final InfluxDbMeasurement Measurement = InfluxDbMeasurement.create(
+ "Measurement", ImmutableMap.of(), ImmutableMap.of("val", "5i"), 1304695L
+ );
+ assertEquals("Measurement val=5i 1304695000000", Measurement.toLine());
+ }
+
+ @Test
+ public void testToLine_WithSingleTag() {
+ final InfluxDbMeasurement Measurement = InfluxDbMeasurement.create(
+ "Measurement", ImmutableMap.of("action", "restore"), ImmutableMap.of("val", "5i"), 1304695L
+ );
+ assertEquals("Measurement,action=restore val=5i 1304695000000", Measurement.toLine());
+ }
+
+ @Test
+ public void testToLine_WithMultipleTags() {
+ final InfluxDbMeasurement Measurement = InfluxDbMeasurement.create(
+ "Measurement", ImmutableMap.of("action", "restore", "model", "cf-2-005"), ImmutableMap.of("val", "5i"), 1304695L
+ );
+ assertEquals("Measurement,action=restore,model=cf-2-005 val=5i 1304695000000", Measurement.toLine());
+ }
+
+ @Test
+ public void testToLine_WithMultipleFields() {
+ final InfluxDbMeasurement Measurement = InfluxDbMeasurement.create(
+ "Measurement", ImmutableMap.of(), ImmutableMap.of("val", "5i", "other-val", "true"), 1304695L
+ );
+ assertEquals("Measurement val=5i,other-val=true 1304695000000", Measurement.toLine());
+ }
+
+ @Test
+ public void testToLine_WithMultipleTagsAndFields() {
+ final InfluxDbMeasurement Measurement = InfluxDbMeasurement.create(
+ "Measurement",
+ ImmutableMap.of("action", "restore", "model", "cf-2-005"),
+ ImmutableMap.of("val", "5i", "other-val", "true"),
+ 1304695L
+ );
+
+ assertEquals(
+ "Measurement,action=restore,model=cf-2-005 val=5i,other-val=true 1304695000000",
+ Measurement.toLine());
+ }
+
+ @Test
+ public void testJoinPairs_WithNoPairs() {
+ assertTrue("should return an empty string", InfluxDbMeasurement.joinPairs(ImmutableMap.of()).isEmpty());
+ }
+
+ @Test
+ public void testJoinPairs_WithOnePair() {
+ final String joined = InfluxDbMeasurement.joinPairs(ImmutableMap.of("action", "restore"));
+ assertEquals("should join a pair without commas", "action=restore", joined);
+ }
+
+ @Test
+ public void testJoinPairs_WithMultiplePairs() {
+ final String joined = InfluxDbMeasurement.joinPairs(ImmutableMap.of("action", "restore", "greetings", "pleasings"));
+ assertEquals("should join pairs with commas", "action=restore,greetings=pleasings", joined);
+ }
+
+ @Test
+ public void testBuilder_PutTags() {
+ final Map tags = ImmutableMap.of("pleased", "to", "meet", "you");
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putTags(tags)
+ .putField("welcome", "manatee")
+ .build();
+
+ assertEquals("should add all tags to the measurement",
+ InfluxDbMeasurement.create("Measurement", tags, ImmutableMap.of("welcome", "manatee"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_IsInvalidWithEmptyName() {
+ final InfluxDbMeasurement.Builder measurement = new InfluxDbMeasurement.Builder("", 90210L)
+ .putField("some-float", 15321F);
+
+ assertFalse("should be invalid with empty name", measurement.isValid());
+ }
+
+ @Test
+ public void testBuilder_IsInvalidWithEmptyFields() {
+ final InfluxDbMeasurement.Builder measurement = new InfluxDbMeasurement.Builder("hi", 90210L)
+ .tryPutFields(ImmutableMap.of("some-float", Float.NaN), __ -> {});
+
+ assertFalse("should be invalid with empty fields", measurement.isValid());
+ }
+
+ @Test
+ public void testBuilder_PutFloatField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("some-float", 15321F)
+ .build();
+
+ assertEquals("should add double field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("some-float", "15321.0"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutNanFloatField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("some-float", Float.NaN)
+ .putField("need", "val")
+ .build();
+
+ assertEquals("should not add NaN float field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("need", "val"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutInfiniteFloatField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("some-float", Float.POSITIVE_INFINITY)
+ .putField("need", "val")
+ .build();
+
+ assertEquals("should not add infinite float field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("need", "val"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutDoubleField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("some-double", 15321D)
+ .build();
+
+ assertEquals("should add formatted double field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("some-double", "15321.0"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutNanDoubleField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("some-double", Double.NaN)
+ .putField("need", "val")
+ .build();
+
+ assertEquals("should not add NaN double field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("need", "val"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutInfiniteDoubleField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("some-double", Double.POSITIVE_INFINITY)
+ .putField("need", "val")
+ .build();
+
+ assertEquals("should not add infinite double field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("need", "val"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutIntegerField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("some-int", 15321)
+ .build();
+
+ assertEquals("should add integer field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("some-int", "15321i"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutLongField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("some-long", 15321L)
+ .build();
+
+ assertEquals("should add long field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("some-long", "15321i"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutStringField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("some-str", "cookies")
+ .build();
+
+ assertEquals("should add String field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("some-str", "cookies"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutBooleanField() {
+ final InfluxDbMeasurement measurement = new InfluxDbMeasurement.Builder("Measurement", 90210L)
+ .putField("eating", true)
+ .build();
+
+ assertEquals("should add Boolean field to the measurement",
+ InfluxDbMeasurement.create("Measurement", ImmutableMap.of(), ImmutableMap.of("eating", "true"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testBuilder_PutNonStringOrPrimitiveField() {
+ try {
+ new InfluxDbMeasurement.Builder("Measurement", 90210L).putField("val", Arrays.asList(1, 2, 3));
+ fail("Expected an Exception when adding a non-String or -primitive field");
+ } catch (final Exception thrown) {
+ assertEquals("Expected an IllegalArgumentException", IllegalArgumentException.class, thrown.getClass());
+ assertEquals("InfluxDbMeasurement field 'val' must be String or primitive: [1, 2, 3]", thrown.getMessage());
+ }
+ }
+
+ @Test
+ public void testBuilder_TryPutFields() {
+ final ArrayList exceptions = new ArrayList<>();
+
+ new InfluxDbMeasurement.Builder("Measurement", 90210L).tryPutFields(ImmutableMap.of(
+ "a", ImmutableSet.of(),
+ "c", "d",
+ "e", Arrays.asList(1, 2, 3)
+ ), exceptions::add);
+
+ assertEquals("should catch two exceptions", 2, exceptions.size());
+ assertEquals("should catch IllegalArgumentExceptions", IllegalArgumentException.class, exceptions.get(0).getClass());
+ assertEquals("should catch IllegalArgumentExceptions", IllegalArgumentException.class, exceptions.get(1).getClass());
+ assertEquals("should describe the invalid key-value pair",
+ ImmutableList.of(
+ "InfluxDbMeasurement field 'a' must be String or primitive: []",
+ "InfluxDbMeasurement field 'e' must be String or primitive: [1, 2, 3]"
+ ),
+ exceptions.stream().map(Exception::getMessage).collect(toList())
+ );
+ }
+}
diff --git a/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbTcpWriterTest.java b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbTcpWriterTest.java
new file mode 100644
index 0000000..f3ff0b4
--- /dev/null
+++ b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/io/InfluxDbTcpWriterTest.java
@@ -0,0 +1,39 @@
+package com.kickstarter.dropwizard.metrics.influxdb.io;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
+import io.dropwizard.jackson.Jackson;
+import io.dropwizard.setup.Environment;
+import io.dropwizard.util.Duration;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class InfluxDbTcpWriterTest {
+ @Test
+ public void testSerialization() throws IOException {
+ final String json =
+ "{" +
+ "\"type\": \"tcp\"," +
+ "\"host\": \"i am a host\"," +
+ "\"port\": \"12345\"," +
+ "\"timeout\": \"5 minutes\"" +
+ "}";
+
+ final ObjectMapper mapper = Jackson.newObjectMapper();
+ mapper.registerModule(new ParameterNamesModule(JsonCreator.Mode.PROPERTIES));
+
+ final Environment env = mock(Environment.class);
+ when(env.getObjectMapper()).thenReturn(mapper);
+
+ final InfluxDbTcpWriter.Factory factory = mapper.readValue(json, InfluxDbTcpWriter.Factory.class);
+ assertEquals("expected TCP host", "i am a host", factory.host());
+ assertEquals("expected TCP port", 12345, factory.port());
+ assertEquals("expected TCP timeout", Duration.minutes(5), factory.timeout());
+ }
+}
diff --git a/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/io/SenderTest.java b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/io/SenderTest.java
new file mode 100644
index 0000000..f5e1b61
--- /dev/null
+++ b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/io/SenderTest.java
@@ -0,0 +1,73 @@
+package com.kickstarter.dropwizard.metrics.influxdb.io;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.kickstarter.dropwizard.metrics.influxdb.InfluxDbMeasurement;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+public class SenderTest {
+ @Test
+ public void testSend_SendsMeasures() throws Exception {
+ final InfluxDbWriter writer = mock(InfluxDbWriter.class);
+ final Sender sender = new Sender(writer);
+ sender.send(ImmutableList.of(
+ InfluxDbMeasurement.create("hello", ImmutableMap.of("x", "y"), ImmutableMap.of("a", "b"), 90210L),
+ InfluxDbMeasurement.create("hello", ImmutableMap.of("x", "y"), ImmutableMap.of("e", "d"), 90210L)
+ ));
+
+ verify(writer, only()).writeBytes("hello,x=y a=b 90210000000\nhello,x=y e=d 90210000000\n".getBytes());
+ assertEquals("should clear measure queue", 0, sender.queuedMeasures());
+ }
+
+ @Test
+ public void testSend_EmptyMeasures() throws Exception {
+ final InfluxDbWriter writer = mock(InfluxDbWriter.class);
+ final Sender sender = new Sender(writer);
+ sender.send(ImmutableList.of());
+
+ verify(writer, never()).writeBytes(any());
+ verify(writer, never()).close();
+ }
+
+ @Test
+ public void testSend_HandlesExceptions() throws Exception {
+ final InfluxDbWriter writer = mock(InfluxDbWriter.class);
+ final Sender sender = new Sender(writer);
+
+ doThrow(new RuntimeException("what did you do")).when(writer).writeBytes(any());
+ sender.send(ImmutableList.of(
+ InfluxDbMeasurement.create("hello", ImmutableMap.of("x", "y"), ImmutableMap.of("a", "b"), 90210L))
+ );
+
+ verify(writer, times(1)).writeBytes("hello,x=y a=b 90210000000\n".getBytes());
+ verify(writer, times(1)).close();
+ }
+
+ @Test
+ public void testSend_RetriesSend() throws Exception {
+ final InfluxDbWriter writer = mock(InfluxDbWriter.class);
+ final Sender sender = new Sender(writer);
+
+ doThrow(new RuntimeException("what did you do"))
+ .doNothing().when(writer).writeBytes(any());
+
+ sender.send(ImmutableList.of(
+ InfluxDbMeasurement.create("hello", ImmutableMap.of("x", "y"), ImmutableMap.of("a", "b"), 90210L))
+ );
+
+ verify(writer, times(1)).writeBytes("hello,x=y a=b 90210000000\n".getBytes());
+ verify(writer, times(1)).close();
+
+ sender.send(ImmutableList.of());
+ verify(writer, times(2)).writeBytes("hello,x=y a=b 90210000000\n".getBytes());
+ }
+}
diff --git a/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurementParserTest.java b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurementParserTest.java
new file mode 100644
index 0000000..77c4fa1
--- /dev/null
+++ b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurementParserTest.java
@@ -0,0 +1,38 @@
+package com.kickstarter.dropwizard.metrics.influxdb.transformer;
+
+import com.google.common.collect.ImmutableMap;
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+
+public class DropwizardMeasurementParserTest {
+ private static final DropwizardMeasurementParser transformer = new DropwizardMeasurementParser(
+ ImmutableMap.of("custom_metric", new TaggedPattern("\\.holy\\.(?[A-Za-z]+)\\.cow\\.", "adjective"))
+ );
+
+ @Test
+ public void testMeasurement_FromTemplate() {
+ final DropwizardMeasurement measurement = transformer.parse(".holy.jumping.cow.");
+ assertEquals(
+ DropwizardMeasurement.create("custom_metric", ImmutableMap.of("adjective", "jumping"), Optional.empty()),
+ measurement
+ );
+ }
+
+ @Test
+ public void testMeasurement_FromMeasurementLine() {
+ final DropwizardMeasurement expected = DropwizardMeasurement.create(
+ "custom_metric",
+ ImmutableMap.of("adjective", "jumping", "more", "stuff"),
+ Optional.of("im-a-field")
+ );
+
+ final DropwizardMeasurement measurement = transformer.parse(
+ "custom_metric,adjective=jumping,more=stuff im-a-field"
+ );
+
+ assertEquals(expected, measurement);
+ }
+}
diff --git a/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurementTest.java b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurementTest.java
new file mode 100644
index 0000000..240db88
--- /dev/null
+++ b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardMeasurementTest.java
@@ -0,0 +1,218 @@
+package com.kickstarter.dropwizard.metrics.influxdb.transformer;
+
+import com.google.common.collect.ImmutableMap;
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class DropwizardMeasurementTest {
+ @Test
+ public void testCreate_EscapesValues() {
+ final DropwizardMeasurement expected = DropwizardMeasurement.create(
+ "Mode-lS-e-rv-e-r",
+ ImmutableMap.of("k-e-y-", "-v-a-l-u-e-"),
+ Optional.of("f-i-e--ld")
+ );
+
+ final DropwizardMeasurement measurement = DropwizardMeasurement.create(
+ "Mode,lS,e=rv e r",
+ ImmutableMap.of("k,e=y ", " v=a l,u=e "),
+ Optional.of("f i=e,,ld")
+ );
+
+ assertEquals(expected, measurement);
+ }
+
+ @Test
+ public void testFromLine_Deserializes() {
+ final DropwizardMeasurement expected = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of(),
+ Optional.empty()
+ );
+ assertEquals(expected, DropwizardMeasurement.fromLine("Measurement"));
+ }
+
+ @Test
+ public void testFromLine_DeserializesWithTags() {
+ final DropwizardMeasurement expected = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of("action", "restore", "model", "cf-2-005"),
+ Optional.empty()
+ );
+ assertEquals(expected, DropwizardMeasurement.fromLine("Measurement,action=restore,model=cf-2-005"));
+ }
+
+ @Test
+ public void testFromLine_DeserializesWithField() {
+ final DropwizardMeasurement expected = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of(),
+ Optional.of("i-am-a-field")
+ );
+
+ assertEquals(expected, DropwizardMeasurement.fromLine("Measurement i-am-a-field"));
+ }
+
+ @Test
+ public void testFromLine_DeserializesWithTagsAndField() {
+ final DropwizardMeasurement expected = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of("action", "restore", "model", "cf-2-005"),
+ Optional.of("i-am-a-field")
+ );
+
+ assertEquals(expected, DropwizardMeasurement.fromLine("Measurement,action=restore,model=cf-2-005 i-am-a-field"));
+ }
+
+ @Test
+ public void testFromLine_TooManyFieldSeparators() {
+ try {
+ DropwizardMeasurement.fromLine("Measurement,action=restore,model=cf-2-005 one_field too_many_fields");
+ fail("Expected an exception to be thrown");
+ } catch (final Exception thrown) {
+ assertEquals(
+ String.format("Unexpected exception: %s", thrown.getClass()),
+ IllegalArgumentException.class,
+ thrown.getClass()
+ );
+
+ assertEquals("too many spaces in measurement line", thrown.getMessage());
+ }
+ }
+
+ @Test
+ public void testFromLine_TooManyValueSeparators() {
+ try {
+ DropwizardMeasurement.fromLine("Measurement,action=restore=why,model=cf-2-005");
+ fail("Expected an exception to be thrown");
+ } catch (final Exception thrown) {
+ assertEquals(
+ String.format("Unexpected exception: %s", thrown.getClass()),
+ IllegalArgumentException.class,
+ thrown.getClass()
+ );
+
+ assertEquals("tags must contain exactly one '=' character", thrown.getMessage());
+ }
+ }
+
+ @Test
+ public void testFromLine_MissingValueSeparators() {
+ try {
+ DropwizardMeasurement.fromLine("Measurement,actionrestore,model=cf-2-005");
+ fail("Expected an exception to be thrown");
+ } catch (final Exception thrown) {
+ assertEquals(
+ String.format("Unexpected exception: %s", thrown.getClass()),
+ IllegalArgumentException.class,
+ thrown.getClass()
+ );
+
+ assertEquals("tags must contain exactly one '=' character", thrown.getMessage());
+ }
+ }
+
+ @Test
+ public void testToString_Serializes() {
+ final DropwizardMeasurement measurement = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of(),
+ Optional.empty()
+ );
+ assertEquals("Measurement", measurement.toString());
+ }
+
+ @Test
+ public void testToString_SerializesWithTags() {
+ final DropwizardMeasurement measurement = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of("some", "tags", "here", "i-guess"),
+ Optional.empty()
+ );
+ assertEquals("Measurement,here=i-guess,some=tags", measurement.toString());
+ }
+
+ @Test
+ public void testToString_SerializesWithField() {
+ final DropwizardMeasurement measurement = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of(),
+ Optional.of("wow-a-field")
+ );
+ assertEquals("Measurement wow-a-field", measurement.toString());
+ }
+
+ @Test
+ public void testToString_SerializesWithTagsAndField() {
+ final DropwizardMeasurement measurement = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of("some", "tags", "here", "i-guess"),
+ Optional.of("wow-a-field")
+ );
+ assertEquals("Measurement,here=i-guess,some=tags wow-a-field", measurement.toString());
+ }
+
+ @Test
+ public void testIntegrated_Serialization() {
+ final DropwizardMeasurement measurement = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of(),
+ Optional.empty()
+ );
+
+ final String measurementStr = measurement.toString();
+ assertEquals("Measurement", measurementStr);
+
+ final DropwizardMeasurement fromLine = DropwizardMeasurement.fromLine(measurementStr);
+ assertEquals(measurement, fromLine);
+ }
+
+ @Test
+ public void testIntegrated_SerializationWithTags() {
+ final DropwizardMeasurement measurement = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of("action", "restore", "model", "cf-2-005"),
+ Optional.empty()
+ );
+
+ final String measurementStr = measurement.toString();
+ assertEquals("Measurement,action=restore,model=cf-2-005", measurementStr);
+
+ final DropwizardMeasurement fromLine = DropwizardMeasurement.fromLine(measurementStr);
+ assertEquals(measurement, fromLine);
+ }
+
+ @Test
+ public void testIntegrated_SerializationWithField() {
+ final DropwizardMeasurement measurement = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of(),
+ Optional.of("i-like-being-a-field")
+ );
+
+ final String measurementStr = measurement.toString();
+ assertEquals("Measurement i-like-being-a-field", measurementStr);
+
+ final DropwizardMeasurement fromLine = DropwizardMeasurement.fromLine(measurementStr);
+ assertEquals(measurement, fromLine);
+ }
+
+ @Test
+ public void testIntegrated_SerializationWithTagsAndField() {
+ final DropwizardMeasurement measurement = DropwizardMeasurement.create(
+ "Measurement",
+ ImmutableMap.of("action", "restore", "model", "cf-2-005"),
+ Optional.of("i-like-being-a-field")
+ );
+
+ final String measurementStr = measurement.toString();
+ assertEquals("Measurement,action=restore,model=cf-2-005 i-like-being-a-field", measurementStr);
+
+ final DropwizardMeasurement fromLine = DropwizardMeasurement.fromLine(measurementStr);
+ assertEquals(measurement, fromLine);
+ }
+}
diff --git a/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardTransformerTest.java b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardTransformerTest.java
new file mode 100644
index 0000000..d08cdfd
--- /dev/null
+++ b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/DropwizardTransformerTest.java
@@ -0,0 +1,503 @@
+package com.kickstarter.dropwizard.metrics.influxdb.transformer;
+
+import com.codahale.metrics.Counter;
+import com.codahale.metrics.ExponentiallyDecayingReservoir;
+import com.codahale.metrics.Gauge;
+import com.codahale.metrics.Histogram;
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.Timer;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.kickstarter.dropwizard.metrics.influxdb.InfluxDbMeasurement;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+
+public class DropwizardTransformerTest {
+ @Test
+ public void testConvertDuration_Milliseconds() {
+ final DropwizardTransformer transformer = transformerWithUnits(TimeUnit.SECONDS, TimeUnit.MILLISECONDS);
+ assertEquals("Should convert duration to milliseconds precisely", 2.0E-5, transformer.convertDuration(20), 0.0);
+ }
+
+ @Test
+ public void testConvertDuration_Seconds() {
+ final DropwizardTransformer transformer = transformerWithUnits(TimeUnit.SECONDS, TimeUnit.SECONDS);
+ assertEquals("Should convert duration to seconds precisely", 2.0E-8, transformer.convertDuration(20), 0.0);
+ }
+
+ @Test
+ public void testConvertRate_Seconds() {
+ final DropwizardTransformer transformer = transformerWithUnits(TimeUnit.SECONDS, TimeUnit.MILLISECONDS);
+ assertEquals("Should convert rate to seconds precisely", 20.0, transformer.convertRate(20), 0.0);
+ }
+
+ @Test
+ public void testConvertRate_Minutes() {
+ final DropwizardTransformer transformer = transformerWithUnits(TimeUnit.MINUTES, TimeUnit.MILLISECONDS);
+ assertEquals("Should convert rate to minutes precisely", 1200.0, transformer.convertRate(20), 0.0);
+ }
+
+ @Test
+ public void testFromTimer() {
+ final Set fieldKeys = ImmutableSet.of(
+ "count",
+ "min",
+ "max",
+ "mean",
+ "std-dev",
+ "50-percentile",
+ "75-percentile",
+ "95-percentile",
+ "99-percentile",
+ "999-percentile",
+ "one-minute",
+ "five-minute",
+ "fifteen-minute",
+ "mean-minute",
+ "run-count"
+ );
+
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ when(parser.parse("some.metric.name")).thenReturn(
+ DropwizardMeasurement.create("Measurement", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final Timer timer = new Timer();
+ timer.update(50, TimeUnit.MILLISECONDS);
+ timer.update(70, TimeUnit.MILLISECONDS);
+ timer.update(100, TimeUnit.MILLISECONDS);
+
+ final InfluxDbMeasurement measurement = transformer.fromTimer("some.metric.name", timer, 90210L);
+ assertEquals("should parse name from full metric key", "Measurement", measurement.name());
+ assertEquals("should add global and measurement tags", ALL_TAGS, measurement.tags());
+ assertEquals("should timestamp measurement", 90210L, measurement.timestamp());
+ assertEquals("should add all timer fields", fieldKeys, measurement.fields().keySet());
+ }
+
+ @Test
+ public void testFromMeter() {
+ final Set fieldKeys = ImmutableSet.of(
+ "count",
+ "one-minute",
+ "five-minute",
+ "fifteen-minute",
+ "mean-minute"
+ );
+
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ when(parser.parse("some.metric.name")).thenReturn(
+ DropwizardMeasurement.create("Measurement", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final Meter meter = new Meter();
+ meter.mark(50L);
+ meter.mark(64L);
+ meter.mark(80L);
+
+ final InfluxDbMeasurement measurement = transformer.fromMeter("some.metric.name", meter, 90210L);
+ assertEquals("should parse name from full metric key", "Measurement", measurement.name());
+ assertEquals("should add global and measurement tags", ALL_TAGS, measurement.tags());
+ assertEquals("should timestamp measurement", 90210L, measurement.timestamp());
+ assertEquals("should add all meter fields", fieldKeys, measurement.fields().keySet());
+ }
+
+ @Test
+ public void testFromHistogram() {
+ final Set fieldKeys = ImmutableSet.of(
+ "count",
+ "min",
+ "max",
+ "mean",
+ "std-dev",
+ "50-percentile",
+ "75-percentile",
+ "95-percentile",
+ "99-percentile",
+ "999-percentile",
+ "run-count"
+ );
+
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ when(parser.parse("some.metric.name")).thenReturn(
+ DropwizardMeasurement.create("Measurement", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final Histogram histogram = new Histogram(new ExponentiallyDecayingReservoir());
+ histogram.update(15L);
+ histogram.update(70L);
+ histogram.update(100L);
+
+ final InfluxDbMeasurement measurement = transformer.fromHistogram("some.metric.name", histogram, 90210L);
+ assertEquals("should parse name from full metric key", "Measurement", measurement.name());
+ assertEquals("should add global and measurement tags", ALL_TAGS, measurement.tags());
+ assertEquals("should timestamp measurement", 90210L, measurement.timestamp());
+ assertEquals("should add all histogram fields", fieldKeys, measurement.fields().keySet());
+ }
+
+ @Test
+ public void testFromCounters_Ungrouped() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, false);
+
+ final List counters = ImmutableList.of(new Counter(), new Counter());
+ counters.get(0).inc(15L);
+ counters.get(1).inc(6L);
+
+ final Map cMap = ImmutableMap.of(
+ "some.stuff.queued", counters.get(0),
+ "some.stuff.processed", counters.get(1)
+ );
+
+ when(parser.parse("some.stuff.queued")).thenReturn(
+ DropwizardMeasurement.create("some.stuff.queued", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ when(parser.parse("some.stuff.processed")).thenReturn(
+ DropwizardMeasurement.create("some.stuff.processed", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final List expected = ImmutableList.of(
+ InfluxDbMeasurement.create("some.stuff.queued", ALL_TAGS, ImmutableMap.of("count", "15i"), 90210L),
+ InfluxDbMeasurement.create("some.stuff.processed", ALL_TAGS, ImmutableMap.of("count", "6i"), 90210L)
+ );
+
+ final List measurements = transformer.fromCounters(cMap, 90210L);
+ assertEquals("should not group counter measurements", expected, measurements);
+ }
+
+ @Test
+ public void testFromCounters_Grouped() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ final List counters = ImmutableList.of(new Counter(), new Counter());
+ counters.get(0).inc(15L);
+ counters.get(1).inc(6L);
+
+ final Map cMap = ImmutableMap.of(
+ "some.stuff.queued", counters.get(0),
+ "some.stuff.processed", counters.get(1)
+ );
+
+ when(parser.parse("some.stuff")).thenReturn(
+ DropwizardMeasurement.create("some.stuff", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final List expected = ImmutableList.of(
+ InfluxDbMeasurement.create("some.stuff", ALL_TAGS, ImmutableMap.of("queued", "15i", "processed", "6i"), 90210L)
+ );
+
+ final List measurements = transformer.fromCounters(cMap, 90210L);
+ assertEquals("should group counters by tags and prefix", expected, measurements);
+ }
+
+ @Test
+ public void testFromGauges_Ungrouped() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, false);
+
+ final Map gauges = ImmutableMap.of(
+ "some.stuff.queued", () -> 12,
+ "some.stuff.processed", () -> 15
+ );
+
+ when(parser.parse("some.stuff.queued")).thenReturn(
+ DropwizardMeasurement.create("some.stuff.queued", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ when(parser.parse("some.stuff.processed")).thenReturn(
+ DropwizardMeasurement.create("some.stuff.processed", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final List expected = ImmutableList.of(
+ InfluxDbMeasurement.create("some.stuff.queued", ALL_TAGS, ImmutableMap.of("value", "12i"), 90210L),
+ InfluxDbMeasurement.create("some.stuff.processed", ALL_TAGS, ImmutableMap.of("value", "15i"), 90210L)
+ );
+
+ final List measurements = transformer.fromGauges(gauges, 90210L);
+ assertEquals("should not group gauge measurements", expected, measurements);
+ }
+
+ @Test
+ public void testFromGauges_Grouped() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ final Map gauges = ImmutableMap.of(
+ "some.stuff.queued", () -> 12,
+ "some.stuff.processed", () -> 15
+ );
+
+ when(parser.parse("some.stuff")).thenReturn(
+ DropwizardMeasurement.create("some.stuff", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final List expected = ImmutableList.of(
+ InfluxDbMeasurement.create("some.stuff", ALL_TAGS, ImmutableMap.of("queued", "12i", "processed", "15i"), 90210L)
+ );
+
+ final List measurements = transformer.fromGauges(gauges, 90210L);
+ assertEquals("should group gauges by tags and prefix", expected, measurements);
+ }
+
+ @Test
+ public void testFromKeyValue() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, false);
+
+ when(parser.parse("some.stuff.queued")).thenReturn(
+ DropwizardMeasurement.create("some.stuff.queued", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final InfluxDbMeasurement measurement = transformer.fromKeyValue("some.stuff.queued", "some_key", 12L, 90210L);
+
+ assertEquals("should map values directly to measurement",
+ InfluxDbMeasurement.create("some.stuff.queued", ALL_TAGS, ImmutableMap.of("some_key", "12i"), 90210L),
+ measurement);
+ }
+
+ @Test
+ public void testGroupValues_Inline() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ final Map gauges = ImmutableMap.of(
+ "Measurement queued", () -> 12,
+ "Measurement processed", () -> 15
+ );
+
+ when(parser.parse("Measurement queued")).thenReturn(
+ DropwizardMeasurement.create("Measurement", MEASUREMENT_TAGS, Optional.of("queued"))
+ );
+
+ when(parser.parse("Measurement processed")).thenReturn(
+ DropwizardMeasurement.create("Measurement", MEASUREMENT_TAGS, Optional.of("processed"))
+ );
+
+ final Map> expected = ImmutableMap.of(
+ GroupKey.create("Measurement", MEASUREMENT_TAGS), ImmutableMap.of("queued", 12, "processed", 15)
+ );
+
+ final Map> groups = transformer.groupValues(gauges, "unused_default_key", Gauge::getValue);
+ assertEquals("should group values with inlined keys", expected, groups);
+ }
+
+ @Test
+ public void testGroupValues_CountingGauges() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ final Map gauges = ImmutableMap.of(
+ "some.stuff.queued.count", () -> 12,
+ "some.stuff.processed.count", () -> 15
+ );
+
+ when(parser.parse("some.stuff")).thenReturn(
+ DropwizardMeasurement.create("some.stuff", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final Map> expected = ImmutableMap.of(
+ GroupKey.create("some.stuff", MEASUREMENT_TAGS), ImmutableMap.of("queued.count", 12, "processed.count", 15)
+ );
+
+ final Map> groups = transformer.groupValues(gauges, "unused_default_key", Gauge::getValue);
+ assertEquals("should ignore .count postfix when parsing groups", expected, groups);
+ }
+
+ @Test
+ public void testGroupValues_NoDotIndex() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ final Map gauges = ImmutableMap.of(
+ "some_stuff_queued", () -> 12,
+ "some_stuff_processed", () -> 15
+ );
+
+ when(parser.parse("some_stuff_queued")).thenReturn(
+ DropwizardMeasurement.create("some.stuff.queued", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ when(parser.parse("some_stuff_processed")).thenReturn(
+ DropwizardMeasurement.create("some.stuff.processed", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final Map> expected = ImmutableMap.of(
+ GroupKey.create("some.stuff.queued", MEASUREMENT_TAGS), ImmutableMap.of("default_key", 12),
+ GroupKey.create("some.stuff.processed", MEASUREMENT_TAGS), ImmutableMap.of("default_key", 15)
+ );
+
+ final Map> groups = transformer.groupValues(gauges, "default_key", Gauge::getValue);
+ assertEquals("should use fully parsed key and default value", expected, groups);
+ }
+
+ @Test
+ public void testGroupValues_WithDotIndex() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ final Map gauges = ImmutableMap.of(
+ "some.stuff.queued", () -> 12,
+ "some.stuff.processed", () -> 15
+ );
+
+ when(parser.parse("some.stuff")).thenReturn(
+ DropwizardMeasurement.create("some.stuff", MEASUREMENT_TAGS, Optional.empty())
+ );
+
+ final Map> expected = ImmutableMap.of(
+ GroupKey.create("some.stuff", MEASUREMENT_TAGS), ImmutableMap.of("queued", 12, "processed", 15)
+ );
+
+ final Map> groups = transformer.groupValues(gauges, "unused_default_key", Gauge::getValue);
+ assertEquals("should group values by field postfix", expected, groups);
+ }
+
+ @Test
+ public void testGroupValues_WithSeparateTags() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ final Map gauges = ImmutableMap.of(
+ "some.jumping.stuff.queued", () -> 12,
+ "some.leaning.stuff.processed", () -> 15
+ );
+
+ final ImmutableMap jumpingTag = ImmutableMap.of("action", "jumping");
+ final ImmutableMap leaningTag = ImmutableMap.of("action", "leaning");
+
+ when(parser.parse("some.jumping.stuff")).thenReturn(
+ DropwizardMeasurement.create("some.stuff", jumpingTag, Optional.empty())
+ );
+
+ when(parser.parse("some.leaning.stuff")).thenReturn(
+ DropwizardMeasurement.create("some.stuff", leaningTag, Optional.empty())
+ );
+
+ final Map> expected = ImmutableMap.of(
+ GroupKey.create("some.stuff", jumpingTag), ImmutableMap.of("queued", 12),
+ GroupKey.create("some.stuff", leaningTag), ImmutableMap.of("processed", 15)
+ );
+
+ final Map> groups = transformer.groupValues(gauges, "unused_default_key", Gauge::getValue);
+ assertEquals("should separate measurements by tag", expected, groups);
+ }
+
+ @Test
+ public void testFromValueGroup() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+
+ final Map objFields = ImmutableMap.of(
+ "some", true,
+ "fields", 5
+ );
+
+ final Map strFields = ImmutableMap.of(
+ "some", "true",
+ "fields", "5i"
+ );
+
+ assertEquals("should convert value group to influx measurement with global tags and stringy fields",
+ Optional.of(InfluxDbMeasurement.create("Measurement", ALL_TAGS, strFields, 90210L)),
+ transformer.fromValueGroup(GroupKey.create("Measurement", MEASUREMENT_TAGS), objFields, 90210L));
+ }
+
+ @Test
+ public void testFromValueGroup_InvalidField() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+ final GroupKey key = GroupKey.create("Measurement", MEASUREMENT_TAGS);
+
+ final Map objFields = ImmutableMap.of(
+ "some", true,
+ "bad", Arrays.asList(1, 2, 3),
+ "fields", 5
+ );
+
+ final Map strFields = ImmutableMap.of(
+ "some", "true",
+ "fields", "5i"
+ );
+
+ assertEquals("should silently drop invalid values",
+ Optional.of(InfluxDbMeasurement.create("Measurement", ALL_TAGS, strFields, 90210L)),
+ transformer.fromValueGroup(key, objFields, 90210L));
+ }
+
+ @Test
+ public void testFromValueGroup_InvalidMeasurement() {
+ final DropwizardMeasurementParser parser = mock(DropwizardMeasurementParser.class);
+ final DropwizardTransformer transformer = transformerWithParser(parser, true);
+ final GroupKey key = GroupKey.create("Measurement", MEASUREMENT_TAGS);
+
+ final Map objFields = ImmutableMap.of(
+ "all", Float.NaN,
+ "bad", Arrays.asList(1, 2, 3),
+ "fields", Float.NaN
+ );
+
+ assertEquals("should silently drop invalid measurements",
+ Optional.empty(),
+ transformer.fromValueGroup(key, objFields, 90210L));
+ }
+
+ // ===================================================================================================================
+ // Test helpers
+
+ private static final ImmutableMap BASE_TAGS = ImmutableMap.of(
+ "some", "simple",
+ "global", "tags"
+ );
+
+ private static final ImmutableMap MEASUREMENT_TAGS = ImmutableMap.of(
+ "more", "specific",
+ "measurement", "tags"
+ );
+
+ private static final ImmutableMap ALL_TAGS = new ImmutableMap.Builder()
+ .putAll(BASE_TAGS)
+ .putAll(MEASUREMENT_TAGS)
+ .build();
+
+ private static DropwizardTransformer transformerWithParser(final DropwizardMeasurementParser parser, final boolean group) {
+ return new DropwizardTransformer(
+ BASE_TAGS,
+ parser,
+ group,
+ group,
+ // Dropwizard Defaults
+ TimeUnit.SECONDS,
+ TimeUnit.MILLISECONDS
+ );
+ }
+
+ private static DropwizardTransformer transformerWithUnits(final TimeUnit rateUnits, final TimeUnit durationUnits) {
+ return new DropwizardTransformer(
+ ImmutableMap.of(),
+ DropwizardMeasurementParser.withTemplates(ImmutableMap.of()),
+ true,
+ true,
+ rateUnits,
+ durationUnits
+ );
+ }
+}
diff --git a/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/TaggedPatternTest.java b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/TaggedPatternTest.java
new file mode 100644
index 0000000..be1c43b
--- /dev/null
+++ b/src/test/java/com/kickstarter/dropwizard/metrics/influxdb/transformer/TaggedPatternTest.java
@@ -0,0 +1,48 @@
+package com.kickstarter.dropwizard.metrics.influxdb.transformer;
+
+import com.google.common.collect.ImmutableMap;
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+
+public class TaggedPatternTest {
+ private static final TaggedPattern taggedPattern = new TaggedPattern(
+ "\\.hello\\.(?[A-Za-z]+)\\.?(?.*)",
+ "action", "model"
+ );
+
+ @Test
+ public void testTags_noMatch() {
+ assertEquals(
+ Optional.empty(),
+ taggedPattern.tags(".hello.123")
+ );
+ }
+
+ @Test
+ public void testTags_partialMatch() {
+ assertEquals(
+ Optional.of(ImmutableMap.of("action", "restore")),
+ taggedPattern.tags(".hello.restore")
+ );
+ }
+
+ @Test
+ public void testTags_fullMatch() {
+ assertEquals(
+ Optional.of(ImmutableMap.of("action", "restore", "model", "collab-2-005")),
+ taggedPattern.tags(".hello.restore.collab-2-005")
+ );
+ }
+
+ @Test
+ public void testTags_matchWithoutTags() {
+ final TaggedPattern untaggedPattern = new TaggedPattern("\\.hello\\..*\\.whatever");
+ assertEquals(
+ Optional.of(ImmutableMap.of()),
+ untaggedPattern.tags(".hello.anything.whatever")
+ );
+ }
+}
diff --git a/src/test/resources/logback-test.xml b/src/test/resources/logback-test.xml
new file mode 100644
index 0000000..c4f9d84
--- /dev/null
+++ b/src/test/resources/logback-test.xml
@@ -0,0 +1,23 @@
+
+
+
+ %-4relative [%thread] %-5level %logger{35} - %msg%n
+
+
+ OFF
+
+
+
+
+ target/test.log
+ true
+
+ %-4relative [%thread] %-5level %logger{35} - %msg%n
+
+
+
+
+
+
+
+
+
+The jersey client can be customized using all of the options provided by [JerseyClientConfiguration](https://github.com/dropwizard/dropwizard/blob/master/dropwizard-client/src/main/java/io/dropwizard/client/JerseyClientConfiguration.java).
+
+```yml
+metrics:
+ reporters:
+ type: influxdb
+ sender:
+ type: http
+ host: localhost
+ port: 8086
+ database: mydb
+ jersey:
+ connectionTimeout: 500 milliseconds
+```
+
+##### TCP Sender
+
+You may wish to send InfluxDB lines to a collector instance, like Telegraf, instead of using the direct HTTP protocol. You can use the TCP sender to transmit metrics to your collector in InfluxDB line format.
+
+```yml
+metrics:
+ reporters:
+ type: influxdb
+ sender:
+ type: tcp
+ host: localhost
+ port: 8086
+ timeout: 500 milliseconds
+```
+
+##### Exception Handling
+
+A Sender sends a batch of InfluxDbMeasurements to a receiver at the Dropwizard-configured frequency. If the sender catches an exception while writing to the receiver, the exception is logged and the connection is closed. The sender will reconnect to the receiver when the next batch is scheduled to be sent.
+
+The measurements that failed to send are stored in a queue and retried in subsequent batches. When things get **real bad™️** and the queue gets backed up, we'll start dropping old metrics — this logic is all handled by Guava's `EvictingQueue`.
+
+## Contributing
+
+Have questions or feedback? The best way to submit feedback and report bugs is to open a GitHub issue. We'd love to see you contribute — talk to you soon!
+
+## License
+
+```
+Copyright 2017 Kickstarter, PBC.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
diff --git a/bin/checkstyle-6.19-all.jar b/bin/checkstyle-6.19-all.jar
new file mode 100644
index 0000000..690bd2d
Binary files /dev/null and b/bin/checkstyle-6.19-all.jar differ
diff --git a/bin/lint b/bin/lint
new file mode 100755
index 0000000..15f14ce
--- /dev/null
+++ b/bin/lint
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+CHECKSTYLE_JAR_PATH="$DIR/checkstyle-6.19-all.jar"
+CHECKSTYLE_CONFIG_PATH="$DIR/../checkstyle.xml"
+
+find src -name "*.java" | \
+ grep -v generated-sources | grep -v generated-test-sources |
+ xargs java -jar $CHECKSTYLE_JAR_PATH -c $CHECKSTYLE_CONFIG_PATH
diff --git a/checkstyle.xml b/checkstyle.xml
new file mode 100644
index 0000000..bbb92ef
--- /dev/null
+++ b/checkstyle.xml
@@ -0,0 +1,115 @@
+
+
+