Initial release

Author: Ruslan Gainutdinov

.gitignore

@@ -0,0 +1,24 @@
+/.vagrant
+/deb
+/docker-compose
+mystem
+bashttpd
+/test/PrettyOutput.html
+/test/*.bin
+/tomita-linux64
+/*.log
+/target/
+/.settings
+/.classpath
+/.project
+.built
+.idea
+*.iml
+/jdk-8u111-linux-x64.tar.gz
+/logs/metabase.log
+/metabase.jar
+/main.html
+/main.md
+/main2.md
+node_modules
+

README.md

@@ -0,0 +1,36 @@
+# Persistent metrics
+
+Drop-in enhancement for [Dropwizard Metrics](http://metrics.dropwizard.io/) which provide metric persistence using Redis DB via [Redisson](https://github.com/redisson/redisson) library.
+
+## Limitations
+
+  1. Gauge is not supported as it implemented as instant Java method call measurement.
+  2. Obvious latency issues. Use only for important selected metrics.
+
+## Usage
+
+Replace your usual
+```java 
+new MetricRegistry();
+```
+
+with improved
+
+```java
+new PersistentMetricRegistry();
+```
+
+## Configuring Redis
+
+By default it uses locally installed Redis (default port, i.e. 6379)
+To configure redis use following environment variables:
+
+  * REDIS_CONF - Redisson JSON [config](https://github.com/redisson/redisson/wiki/2.-Configuration#221-jsonyaml-file-based-configuration) file. Takes precedence.
+  * REDIS_ADDR - host:port for single server.
+
+## Configuring prefix
+
+By default all metrics is put in redis using prefix "metrics.".
+To configure different prefix use METRIC_PREFIX environment variable (dot at the end is added automatically).
+
+

pom.xml

@@ -0,0 +1,47 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>com.wizecore</groupId>
+	<artifactId>persistent-metrics</artifactId>
+	<packaging>jar</packaging>
+	<version>1.0-SNAPSHOT</version>
+	<name>persistent-metrics</name>
+	<url>http://github.com/wizecore/persistent-metrics</url>
+
+	<properties>
+		<maven.compiler.source>1.8</maven.compiler.source>
+		<maven.compiler.target>1.8</maven.compiler.target>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<spring.version>4.3.8.RELEASE</spring.version>
+		<metrics.version>3.2.1</metrics.version>
+	</properties>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.slf4j</groupId>
+			<artifactId>slf4j-jdk14</artifactId>
+			<version>1.7.24</version>
+		</dependency>
+		<dependency>
+			<groupId>org.slf4j</groupId>
+			<artifactId>slf4j-api</artifactId>
+			<version>1.7.24</version>
+		</dependency>
+		<dependency>
+			<groupId>io.dropwizard.metrics</groupId>
+			<artifactId>metrics-core</artifactId>
+			<version>3.2.1</version>
+		</dependency>
+		<dependency>
+			<groupId>org.redisson</groupId>
+			<artifactId>redisson</artifactId>
+			<version>3.3.1</version>
+		</dependency>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.11</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+</project>

src/main/java/com/wizecore/metrics/LongAdderAdapter.java

@@ -0,0 +1,18 @@
+package com.wizecore.metrics;
+
+/**
+ * Interface which exposes the LongAdder functionality. Allows different
+ * LongAdder implementations to coexist together.
+ */
+interface LongAdderAdapter {
+
+    void add(long x);
+
+    long sum();
+
+    void increment();
+
+    void decrement();
+
+    long sumThenReset();
+}

src/main/java/com/wizecore/metrics/PersistenceUtil.java

@@ -0,0 +1,154 @@
+package com.wizecore.metrics;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.SortedSet;
+
+import org.redisson.Redisson;
+import org.redisson.api.RAtomicDouble;
+import org.redisson.api.RAtomicLong;
+import org.redisson.api.RedissonClient;
+import org.redisson.config.Config;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Provides persistance by using Redis instance.
+ * If no REDIS_ADDR or REDIS_CONF enviroment variables specifed, uses local default instance.
+ * 
+ * @see #redisAddr
+ * @
+ * @author Ruslan
+ */
+public class PersistenceUtil {
+	private static Logger log = LoggerFactory.getLogger(PersistenceUtil.class);
+	
+	/**
+	 * Single instance of Redis client
+	 */
+	private static RedissonClient redis;
+	
+	/**
+	 * Optional config file name. Use REDIS_CONF environment variable to set.
+	 * Takes precedence over REDIS_ADDR (@see {@link PersistenceUtil#redisAddr})
+	 */
+	private static String redisConfig = null;
+	
+	/**
+	 * Optional redis address. Use REDIS_ADDR environment variable to set.
+	 */
+	private static String redisAddr = null;
+	
+	/**
+	 * Common prefix for all values stored. By default <code>metrics.</code>
+	 * Can be specified in environment variable METRICS_PREFIX. 
+	 * If not ends with ".", dot will be appended to end of it.
+	 */
+	private static String metricPrefix = null;
+	
+	/**
+	 * Makes lazy initialization of redis client.
+	 */
+	protected static void init() {
+		if (redis == null) {
+			if (redisConfig == null) {
+				redisConfig = System.getenv("REDIS_CONF");
+			}
+			
+			if (redisAddr == null) {
+				redisAddr = System.getenv("REDIS_ADDR");
+			}
+			
+			if (metricPrefix == null) {
+				metricPrefix = System.getenv("METRIC_PREFIX");
+			}
+			
+			if (metricPrefix == null) {
+				metricPrefix = "metrics";
+			}
+			
+			if (!metricPrefix.endsWith(".")) {
+				metricPrefix = metricPrefix + ".";
+			}
+			
+			Config redisConf = null;
+			try {
+				redisConf = redisConfig != null ? Config.fromJSON(new File(redisConfig)) : null;
+				
+				if (redisConf == null && redisAddr != null && !redisAddr.equals("")) {
+					redisConf = new Config();
+					redisConf.useSingleServer().setAddress(redisAddr);
+				}
+				
+				log.info("Initializing persistent metrics via Redis with " + (redisConf != null ? redisConf.toJSON() : "defaults"));
+				redis = redisConf != null ? Redisson.create(redisConf) : Redisson.create();
+			} catch (IOException e) {
+				e.printStackTrace();
+				throw new IllegalStateException("Redis connection failed with " + redisConf);
+			}
+		}
+	}
+	
+	public static <T> SortedSet<T> createSortedSet(String name, Class<T> elements) {
+		return redis.getSortedSet(name);
+	}
+	
+	public static RAtomicLong createAtomicLong(String name, long defaultValue) {
+		init();
+		RAtomicLong v = redis.getAtomicLong(metricPrefix + name);
+		if (!v.isExists()) {
+			v.set(defaultValue);
+		}
+		return v;
+	}
+	
+	public static RAtomicLong createAtomicLong(String name) {
+		init();
+		RAtomicLong v = redis.getAtomicLong(metricPrefix + name);
+		if (!v.isExists()) {
+			v.set(0);
+		}
+		return v;
+	}
+
+	public static LongAdderAdapter createLongAdderAdapter(String name) {
+		final RAtomicLong v = createAtomicLong(name);
+		return new LongAdderAdapter() {
+			@Override
+			public long sumThenReset() {
+				long l = v.get();
+				v.set(0);
+				return l;
+			}
+			
+			@Override
+			public long sum() {
+				return v.get();
+			}
+			
+			@Override
+			public void increment() {
+				v.incrementAndGet();
+			}
+			
+			@Override
+			public void decrement() {
+				v.decrementAndGet();
+			}
+			
+			@Override
+			public void add(long x) {
+				v.addAndGet(x);
+			}
+		};
+	}
+
+	public static RAtomicDouble createAtomicDouble(String name) {
+		init();
+		RAtomicDouble v = redis.getAtomicDouble(metricPrefix + name);
+		if (!v.isExists()) {
+			v.set(0);
+		}
+		return v;
+	}
+}

src/main/java/com/wizecore/metrics/PersistentCounter.java

@@ -0,0 +1,56 @@
+package com.wizecore.metrics;
+
+import com.codahale.metrics.Counter;
+
+/**
+ * An incrementing and decrementing counter metric.
+ */
+public class PersistentCounter extends Counter {
+    private final LongAdderAdapter count;
+
+    public PersistentCounter(String name) {
+        this.count = PersistenceUtil.createLongAdderAdapter(name);
+    }
+
+    /**
+     * Increment the counter by one.
+     */
+    public void inc() {
+        inc(1);
+    }
+
+    /**
+     * Increment the counter by {@code n}.
+     *
+     * @param n the amount by which the counter will be increased
+     */
+    public void inc(long n) {
+        count.add(n);
+    }
+
+    /**
+     * Decrement the counter by one.
+     */
+    public void dec() {
+        dec(1);
+    }
+
+    /**
+     * Decrement the counter by {@code n}.
+     *
+     * @param n the amount by which the counter will be decreased
+     */
+    public void dec(long n) {
+        count.add(-n);
+    }
+
+    /**
+     * Returns the counter's current value.
+     *
+     * @return the counter's current value
+     */
+    @Override
+    public long getCount() {
+        return count.sum();
+    }
+}