0.0.4 release

fixes #108 - Implemented the aggregation across time series separate after downsampling

.gitignore

@@ -0,0 +1,9 @@
+.classpath
+.project
+.settings/
+target/
+.idea/
+*.iml
+logs/
+server/pki/
+

CONTRIBUTORS

@@ -0,0 +1,6 @@
+Dave Marion ([email protected])
+Eric Newton ([email protected])
+Jim Klucar ([email protected])
+Charlie Williams ([email protected])
+Drew Farris ([email protected])
+Brian Loss ([email protected])

LICENSE

@@ -0,0 +1,203 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
+

NOTICE

@@ -0,0 +1,2 @@
+This product includes Google Flatbuffers (https://google.github.io/flatbuffers/)
+Copyright 2014 Google Inc. All rights reserved.

README.md

@@ -0,0 +1,8 @@
+![Timely](timely-readme-logo.png)
+
+[![Apache License][li]][ll]
+
+Timely is a time series database application that provides secure access to time series data. Timely is written in Java and designed to work with [Apache Accumulo] (http://accumulo.apache.org/) and [Grafana] (http://www.grafana.org). Documentation is located [here] (https://nationalsecurityagency.github.io/timely/).
+
+[li]: http://img.shields.io/badge/license-ASL-blue.svg
+[ll]: https://www.apache.org/licenses/LICENSE-2.0

analytics/.gitignore

@@ -0,0 +1,2 @@
+/bin/
+/target

analytics/conf/summarization.properties

@@ -0,0 +1,20 @@
+timelyHostname=
+timelyTcpPort=
+timelyHttpsPort=
+timelyWssPort=
+doLogin=
+#timelyUsername=
+#timelyPassword=
+keyStoreFile=
+keyStoreType=
+keyStorePass=
+trustStoreFile=
+trustStoreType=
+trustStorePass=
+hostVerificationEnabled=false
+bufferSize=10485760
+metrics=
+startTime=0
+endTime=0
+interval=1
+intervalUnits=HOURS

analytics/pom.xml

@@ -0,0 +1,336 @@
+<?xml version="1.0"?>
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you 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.
+-->
+<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/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>timely-analytics</artifactId>
+    <parent>
+        <groupId>timely</groupId>
+        <artifactId>timely</artifactId>
+        <version>0.0.4</version>
+    </parent>
+    <properties>
+        <flink.version>1.1.4</flink.version>
+    </properties>
+    <!-- 
+		
+	Execute "mvn clean package -Pbuild-jar"
+	to build a jar file out of this project!
+
+	How to use the Flink Quickstart pom:
+
+	a) Adding new dependencies:
+		You can add dependencies to the list below.
+		Please check if the maven-shade-plugin below is filtering out your dependency
+		and remove the exclude from there.
+
+	b) Build a jar for running on the cluster:
+		There are two options for creating a jar from this project
+
+		b.1) "mvn clean package" -> this will create a fat jar which contains all
+				dependencies necessary for running the jar created by this pom in a cluster.
+				The "maven-shade-plugin" excludes everything that is provided on a running Flink cluster.
+
+		b.2) "mvn clean package -Pbuild-jar" -> This will also create a fat-jar, but with much
+				nicer dependency exclusion handling. This approach is preferred and leads to
+				much cleaner jar files.
+	-->
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.flink</groupId>
+            <artifactId>flink-java</artifactId>
+            <version>${flink.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.flink</groupId>
+            <artifactId>flink-streaming-java_2.11</artifactId>
+            <version>${flink.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.flink</groupId>
+            <artifactId>flink-clients_2.11</artifactId>
+            <version>${flink.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>timely</groupId>
+            <artifactId>timely-client</artifactId>
+            <version>${parent.version}</version>
+            <exclusions>
+            	<exclusion>
+            		<groupId>org.apache.logging.log4j</groupId>
+            		<artifactId>*</artifactId>
+            	</exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>timely</groupId>
+            <artifactId>timely-common</artifactId>
+            <version>${parent.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <profiles>
+        <profile>
+            <!-- Profile for packaging correct JAR files -->
+            <id>build-jar</id>
+            <activation>
+                <activeByDefault>false</activeByDefault>
+            </activation>
+            <dependencies>
+                <dependency>
+                    <groupId>org.apache.flink</groupId>
+                    <artifactId>flink-java</artifactId>
+                    <version>${flink.version}</version>
+                    <scope>provided</scope>
+                </dependency>
+                <dependency>
+                    <groupId>org.apache.flink</groupId>
+                    <artifactId>flink-streaming-java_2.11</artifactId>
+                    <version>${flink.version}</version>
+                    <scope>provided</scope>
+                </dependency>
+                <dependency>
+                    <groupId>org.apache.flink</groupId>
+                    <artifactId>flink-clients_2.11</artifactId>
+                    <version>${flink.version}</version>
+                    <scope>provided</scope>
+                </dependency>
+            </dependencies>
+            <build>
+                <plugins>
+                    <!-- disable the exclusion rules -->
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-shade-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <phase>package</phase>
+                                <goals>
+                                    <goal>shade</goal>
+                                </goals>
+                                <configuration>
+                                    <artifactSet>
+                                        <excludes combine.self="override"/>
+                                    </artifactSet>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>net.revelc.code</groupId>
+                <artifactId>formatter-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+            </plugin>
+            <!-- We use the maven-shade plugin to create a fat jar that contains all dependencies
+			except flink and it's transitive dependencies. The resulting fat-jar can be executed
+			on a cluster. Change the value of Program-Class if your program entry point changes. -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <executions>
+                    <!-- Run shade goal on package phase -->
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <artifactSet>
+                                <excludes>
+                                    <!-- This list contains all dependencies of flink-dist
+										Everything else will be packaged into the fat-jar
+									-->
+                                    <exclude>org.apache.flink:flink-annotations</exclude>
+                                    <exclude>org.apache.flink:flink-shaded-hadoop1_2.11</exclude>
+                                    <exclude>org.apache.flink:flink-shaded-hadoop2</exclude>
+                                    <exclude>org.apache.flink:flink-shaded-curator-recipes</exclude>
+                                    <exclude>org.apache.flink:flink-core</exclude>
+                                    <exclude>org.apache.flink:flink-java</exclude>
+                                    <exclude>org.apache.flink:flink-scala_2.11</exclude>
+                                    <exclude>org.apache.flink:flink-runtime_2.11</exclude>
+                                    <exclude>org.apache.flink:flink-optimizer_2.11</exclude>
+                                    <exclude>org.apache.flink:flink-clients_2.11</exclude>
+                                    <exclude>org.apache.flink:flink-avro_2.11</exclude>
+                                    <exclude>org.apache.flink:flink-examples-batch_2.11</exclude>
+                                    <exclude>org.apache.flink:flink-examples-streaming_2.11</exclude>
+                                    <exclude>org.apache.flink:flink-streaming-java_2.11</exclude>
+                                    <!-- Also exclude very big transitive dependencies of Flink
+										WARNING: You have to remove these excludes if your code relies on other
+										versions of these dependencies.
+ 				    				-->
+                                    <exclude>org.scala-lang:scala-library</exclude>
+                                    <exclude>org.scala-lang:scala-compiler</exclude>
+                                    <exclude>org.scala-lang:scala-reflect</exclude>
+                                    <exclude>com.typesafe.akka:akka-actor_*</exclude>
+                                    <exclude>com.typesafe.akka:akka-remote_*</exclude>
+                                    <exclude>com.typesafe.akka:akka-slf4j_*</exclude>
+                                    <exclude>io.netty:netty-all</exclude>
+                                    <exclude>io.netty:netty</exclude>
+                                    <exclude>commons-fileupload:commons-fileupload</exclude>
+                                    <exclude>org.apache.avro:avro</exclude>
+                                    <exclude>commons-collections:commons-collections</exclude>
+                                    <exclude>org.codehaus.jackson:jackson-core-asl</exclude>
+                                    <exclude>org.codehaus.jackson:jackson-mapper-asl</exclude>
+                                    <exclude>com.thoughtworks.paranamer:paranamer</exclude>
+                                    <exclude>org.xerial.snappy:snappy-java</exclude>
+                                    <exclude>org.apache.commons:commons-compress</exclude>
+                                    <exclude>org.tukaani:xz</exclude>
+                                    <exclude>com.esotericsoftware.kryo:kryo</exclude>
+                                    <exclude>com.esotericsoftware.minlog:minlog</exclude>
+                                    <exclude>org.objenesis:objenesis</exclude>
+                                    <exclude>com.twitter:chill_*</exclude>
+                                    <exclude>com.twitter:chill-java</exclude>
+                                    <exclude>commons-lang:commons-lang</exclude>
+                                    <exclude>junit:junit</exclude>
+                                    <exclude>org.apache.commons:commons-lang3</exclude>
+                                    <exclude>org.slf4j:slf4j-api</exclude>
+                                    <exclude>org.slf4j:slf4j-log4j12</exclude>
+                                    <exclude>log4j:log4j</exclude>
+                                    <exclude>org.apache.commons:commons-math</exclude>
+                                    <exclude>org.apache.sling:org.apache.sling.commons.json</exclude>
+                                    <exclude>commons-logging:commons-logging</exclude>
+                                    <exclude>commons-codec:commons-codec</exclude>
+                                    <exclude>com.fasterxml.jackson.core:jackson-core</exclude>
+                                    <exclude>com.fasterxml.jackson.core:jackson-databind</exclude>
+                                    <exclude>com.fasterxml.jackson.core:jackson-annotations</exclude>
+                                    <exclude>stax:stax-api</exclude>
+                                    <exclude>com.typesafe:config</exclude>
+                                    <exclude>org.uncommons.maths:uncommons-maths</exclude>
+                                    <exclude>com.github.scopt:scopt_*</exclude>
+                                    <exclude>commons-io:commons-io</exclude>
+                                    <exclude>commons-cli:commons-cli</exclude>
+                                </excludes>
+                            </artifactSet>
+                            <filters>
+                                <filter>
+                                    <artifact>org.apache.flink:*</artifact>
+                                    <excludes>
+                                        <!-- exclude shaded google but include shaded curator -->
+                                        <exclude>org/apache/flink/shaded/com/**</exclude>
+                                        <exclude>web-docs/**</exclude>
+                                    </excludes>
+                                </filter>
+                                <filter>
+                                    <!-- Do not copy the signatures in the META-INF folder.
+										Otherwise, this might cause SecurityExceptions when using the JAR.
+									-->
+                                    <artifact>*:*</artifact>
+                                    <excludes>
+                                        <exclude>META-INF/*.SF</exclude>
+                                        <exclude>META-INF/*.DSA</exclude>
+                                        <exclude>META-INF/*.RSA</exclude>
+                                    </excludes>
+                                </filter>
+                            </filters>
+                            <!-- If you want to use ./bin/flink run <quickstart jar> uncomment the following lines.
+							This will add a Main-Class entry to the manifest file -->
+                            <!--
+							<transformers>
+								<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+									<mainClass>jar.StreamingJob</mainClass>
+								</transformer>
+							</transformers>
+			    			-->
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>buildnumber-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <artifactId>maven-compiler-plugin</artifactId>
+                    <configuration>
+                        <source>1.8</source>
+                        <target>1.8</target>
+                        <compilerId>jdt</compilerId>
+                    </configuration>
+                    <dependencies>
+                        <dependency>
+                            <groupId>org.eclipse.tycho</groupId>
+                            <artifactId>tycho-compiler-jdt</artifactId>
+                            <version>0.21.0</version>
+                        </dependency>
+                    </dependencies>
+                </plugin>
+                <plugin>
+                    <groupId>org.eclipse.m2e</groupId>
+                    <artifactId>lifecycle-mapping</artifactId>
+                    <version>1.0.0</version>
+                    <configuration>
+                        <lifecycleMappingMetadata>
+                            <pluginExecutions>
+                                <pluginExecution>
+                                    <pluginExecutionFilter>
+                                        <groupId>org.apache.maven.plugins</groupId>
+                                        <artifactId>maven-assembly-plugin</artifactId>
+                                        <versionRange>[2.4,)</versionRange>
+                                        <goals>
+                                            <goal>single</goal>
+                                        </goals>
+                                    </pluginExecutionFilter>
+                                    <action>
+                                        <ignore/>
+                                    </action>
+                                </pluginExecution>
+                                <pluginExecution>
+                                    <pluginExecutionFilter>
+                                        <groupId>org.apache.maven.plugins</groupId>
+                                        <artifactId>maven-compiler-plugin</artifactId>
+                                        <versionRange>[3.1,)</versionRange>
+                                        <goals>
+                                            <goal>testCompile</goal>
+                                            <goal>compile</goal>
+                                        </goals>
+                                    </pluginExecutionFilter>
+                                    <action>
+                                        <ignore/>
+                                    </action>
+                                </pluginExecution>
+                            </pluginExecutions>
+                        </lifecycleMappingMetadata>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+</project>

analytics/src/main/java/timely/analytics/flink/MetricHistogram.java

@@ -0,0 +1,169 @@
+package timely.analytics.flink;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.apache.flink.streaming.util.serialization.SerializationSchema;
+
+import timely.model.Tag;
+
+public class MetricHistogram implements Serializable, SerializationSchema<MetricHistogram> {
+
+    private static final long serialVersionUID = 1L;
+    private static final String SPACE = " ";
+    private static final String AVG = " sample=avg\n";
+    private static final String COUNT = " sample=count\n";
+    private static final String MAX = " sample=max\n";
+    private static final String MIN = " sample=min\n";
+    private static final String SUM = " sample=sum\n";
+    private static final String p50 = " sample=50p\n";
+    private static final String p75 = " sample=75p\n";
+    private static final String p90 = " sample=90p\n";
+    private static final String p99 = " sample=99p\n";
+
+    private String metric = null;
+    private List<Tag> tags = null;
+    private long timestamp = 0L;
+    private boolean initialized = false;
+    private List<Double> values = new ArrayList<>();
+
+    public void initialize(String metric, List<Tag> tags) {
+        this.metric = metric;
+        this.tags = tags;
+        initialized = true;
+    }
+
+    public boolean isInitialized() {
+        return initialized;
+    }
+
+    public String getMetric() {
+        return metric;
+    }
+
+    public List<Tag> getTags() {
+        return tags;
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public void update(Double d, long timestamp) {
+        values.add(d);
+        this.timestamp = timestamp;
+    }
+
+    public void done() {
+        Collections.sort(values);
+    }
+
+    public Double avg() {
+        if (values.size() == 0) {
+            return 0.0D;
+        }
+        return sum() / count();
+    }
+
+    public Double min() {
+        if (values.size() == 0) {
+            return 0.0D;
+        }
+        return values.get(0);
+    }
+
+    public Double max() {
+        if (values.size() == 0) {
+            return 0.0D;
+        }
+        return values.get(values.size() - 1);
+    }
+
+    public Double getPercentile(int p) {
+        if (values.size() == 0) {
+            return 0.0D;
+        }
+        int position = Math.round((p * 1.0f / 100) * values.size());
+        position = (0 == position) ? 0 : position - 1;
+        return values.get(position);
+    }
+
+    public Double count() {
+        return values.size() * 1.0D;
+    }
+
+    public Double sum() {
+        double sum = 0.0D;
+        for (Double d : values) {
+            sum += d;
+        }
+        return sum;
+    }
+
+    @Override
+    public String toString() {
+        done();
+        StringBuilder buf = new StringBuilder();
+        buf.append("metric: ").append(metric);
+        buf.append(" tags: ").append(tags);
+        buf.append(" timestamp: ").append(timestamp);
+        buf.append(" count: ").append(count());
+        buf.append(" min: ").append(min());
+        buf.append(" max: ").append(max());
+        buf.append(" sum: ").append(sum());
+        buf.append(" 50p: ").append(getPercentile(50));
+        buf.append(" 75p: ").append(getPercentile(75));
+        buf.append(" 99p: ").append(getPercentile(99));
+        return buf.toString();
+    }
+
+    public byte[] serialize(MetricHistogram histo) {
+        StringBuilder buf = new StringBuilder();
+
+        String tags = histo.getTags().stream().map(t -> t.join()).collect(Collectors.joining(" "));
+
+        // @formatter:off
+        buf.append("put ").append(histo.getMetric() + "_summarized")
+            .append(SPACE).append(histo.getTimestamp())
+            .append(SPACE).append(histo.min())
+            .append(SPACE).append(tags).append(MIN);
+        buf.append("put ").append(histo.getMetric() + "_summarized")
+            .append(SPACE).append(histo.getTimestamp())
+            .append(SPACE).append(histo.max())
+            .append(SPACE).append(tags).append(MAX);
+        buf.append("put ").append(histo.getMetric() + "_summarized")
+            .append(SPACE).append(histo.getTimestamp())
+            .append(SPACE).append(histo.count())
+            .append(SPACE).append(tags).append(COUNT);
+        buf.append("put ").append(histo.getMetric() + "_summarized")
+            .append(SPACE).append(histo.getTimestamp())
+            .append(SPACE).append(histo.sum())
+            .append(SPACE).append(tags).append(SUM);
+        buf.append("put ").append(histo.getMetric() + "_summarized")
+            .append(SPACE).append(histo.getTimestamp())
+            .append(SPACE).append(histo.avg())
+            .append(SPACE).append(tags).append(AVG);
+        buf.append("put ").append(histo.getMetric() + "_summarized")
+            .append(SPACE).append(histo.getTimestamp())
+            .append(SPACE).append(histo.getPercentile(50))
+            .append(SPACE).append(tags).append(p50);
+        buf.append("put ").append(histo.getMetric() + "_summarized")
+            .append(SPACE).append(histo.getTimestamp())
+            .append(SPACE).append(histo.getPercentile(75))
+            .append(SPACE).append(tags).append(p75);
+        buf.append("put ").append(histo.getMetric() + "_summarized")
+            .append(SPACE).append(histo.getTimestamp())
+            .append(SPACE).append(histo.getPercentile(90))
+            .append(SPACE).append(tags).append(p90);
+        buf.append("put ").append(histo.getMetric() + "_summarized")
+            .append(SPACE).append(histo.getTimestamp())
+            .append(SPACE).append(histo.getPercentile(99))
+            .append(SPACE).append(tags).append(p99);
+        // @formatter:off
+        return buf.toString().getBytes();
+    }
+
+}

analytics/src/main/java/timely/analytics/flink/MetricKeySelector.java

@@ -0,0 +1,20 @@
+package timely.analytics.flink;
+
+import org.apache.flink.api.java.functions.KeySelector;
+
+import timely.api.response.MetricResponse;
+
+/**
+ * Uniquely defines a time series in a Flink stream. A unique time series is the
+ * metric name and all of its tags, to include visibility if it exists.
+ */
+public class MetricKeySelector implements KeySelector<MetricResponse, String> {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public String getKey(MetricResponse m) throws Exception {
+        return m.getMetric() + m.getTags().toString();
+    }
+
+}

analytics/src/main/java/timely/analytics/flink/SortedStringAccumulator.java

@@ -0,0 +1,55 @@
+package timely.analytics.flink;
+
+import java.util.concurrent.ConcurrentSkipListMap;
+
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.apache.flink.api.common.accumulators.Accumulator;
+
+/**
+ * Custom accumulator that retains a sorted map of strings and their counts
+ *
+ */
+public class SortedStringAccumulator implements Accumulator<String, ConcurrentSkipListMap<String, MutableLong>> {
+
+    private static final long serialVersionUID = 1L;
+
+    private ConcurrentSkipListMap<String, MutableLong> values = new ConcurrentSkipListMap<>();
+
+    @Override
+    public void add(String value) {
+        if (values.containsKey(value)) {
+            values.get(value).increment();
+        } else {
+            values.put(value, new MutableLong(1));
+        }
+    }
+
+    @Override
+    public ConcurrentSkipListMap<String, MutableLong> getLocalValue() {
+        return values;
+    }
+
+    @Override
+    public void resetLocal() {
+        values.clear();
+    }
+
+    @Override
+    public void merge(Accumulator<String, ConcurrentSkipListMap<String, MutableLong>> other) {
+        other.getLocalValue().forEach((k, v) -> {
+            if (values.containsKey(k)) {
+                values.get(k).add(v.longValue());
+            } else {
+                values.put(k, v);
+            }
+        });
+    }
+
+    @Override
+    public Accumulator<String, ConcurrentSkipListMap<String, MutableLong>> clone() {
+        SortedStringAccumulator a = new SortedStringAccumulator();
+        a.getLocalValue().putAll(this.values);
+        return a;
+    }
+
+}

analytics/src/main/java/timely/analytics/flink/SubscriptionSource.java

@@ -0,0 +1,214 @@
+package timely.analytics.flink;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.websocket.CloseReason;
+import javax.websocket.EndpointConfig;
+import javax.websocket.MessageHandler;
+import javax.websocket.Session;
+
+import org.apache.flink.api.common.accumulators.LongCounter;
+import org.apache.flink.api.common.functions.StoppableFunction;
+import org.apache.flink.configuration.Configuration;
+import org.apache.flink.streaming.api.functions.source.RichSourceFunction;
+import org.apache.flink.streaming.api.watermark.Watermark;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import timely.api.response.MetricResponse;
+import timely.api.response.MetricResponses;
+import timely.client.websocket.ClientHandler;
+import timely.client.websocket.subscription.WebSocketSubscriptionClient;
+import timely.serialize.JsonSerializer;
+
+public class SubscriptionSource extends RichSourceFunction<MetricResponse> implements Serializable, StoppableFunction {
+
+    private static class SubscriptionThreadFactory implements ThreadFactory {
+
+        private static final String NAME = "Subscription Source";
+        private AtomicInteger threadNum = new AtomicInteger(1);
+
+        @Override
+        public Thread newThread(Runnable r) {
+            return new Thread(r, NAME + " " + threadNum.getAndIncrement());
+        }
+    }
+
+    private static final Logger LOG = LoggerFactory.getLogger(SubscriptionSource.class);
+    private static final long serialVersionUID = 1L;
+
+    private transient WebSocketSubscriptionClient client = null;
+    private long start = 0L;
+    private long end = 0L;
+    private final String[] metrics;
+    private final SummarizationJobParameters jp;
+    private final long window;
+
+    public SubscriptionSource(SummarizationJobParameters jp) {
+        this.jp = jp;
+        start = jp.getStartTime();
+        end = jp.getEndTime();
+        metrics = jp.getMetrics();
+        window = jp.getSummarizationInterval().toMilliseconds();
+    }
+
+    @Override
+    public void open(Configuration parameters) throws Exception {
+        LOG.info("Opening summarization job.");
+        super.open(parameters);
+        client = new WebSocketSubscriptionClient(jp.getTimelyHostname(), jp.getTimelyHttpsPort(),
+                jp.getTimelyWssPort(), jp.isDoLogin(), jp.getTimelyUsername(), jp.getTimelyPassword(),
+                jp.getKeyStoreFile(), jp.getKeyStoreType(), jp.getKeyStorePass(), jp.getTrustStoreFile(),
+                jp.getTrustStoreType(), jp.getTrustStorePass(), jp.isHostVerificationEnabled(), jp.getBufferSize());
+    }
+
+    @Override
+    public synchronized void close() throws Exception {
+        super.close();
+        if (null != client) {
+            client.close();
+        }
+    }
+
+    @Override
+    public void run(SourceContext<MetricResponse> ctx) throws Exception {
+        LOG.info("Running summarization job");
+        final SortedStringAccumulator dateTimeAccumulator = new SortedStringAccumulator();
+        this.getRuntimeContext().addAccumulator("source hourly count", dateTimeAccumulator);
+        final LongCounter sourceInputs = new LongCounter();
+        this.getRuntimeContext().addAccumulator("source input counter", sourceInputs);
+        final LongCounter inputProcessedInMainThread = new LongCounter();
+        this.getRuntimeContext().addAccumulator("input processed in main thread", inputProcessedInMainThread);
+
+        // Use only one thread to ensure that time is still ordered
+        final ExecutorService svc = Executors.newFixedThreadPool(1, new SubscriptionThreadFactory());
+
+        ClientHandler handler = new ClientHandler() {
+
+            @Override
+            public void onOpen(Session session, EndpointConfig config) {
+                session.addMessageHandler(new MessageHandler.Whole<String>() {
+
+                    private final SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd-HH");
+                    private long lastWatermarkTime = 0L;
+
+                    @Override
+                    public void onMessage(final String message) {
+                        LOG.info("Message received on Websocket session {}: {}", session.getId(), message);
+                        try {
+                            // Deserialize in this thread
+                            final MetricResponses responses = JsonSerializer.getObjectMapper().readValue(message,
+                                    MetricResponses.class);
+                            // Process in the other
+                            final Runnable r = () -> {
+                                responses.getResponses().forEach(response -> {
+                                    if (response.isComplete()) {
+                                        LOG.info("Received last message.");
+                                        ctx.emitWatermark(new Watermark(Long.MAX_VALUE));
+                                        return;
+                                    }
+                                    LOG.trace("Sending metric: {}", response);
+                                    long time = response.getTimestamp();
+                                    ctx.collectWithTimestamp(response, time);
+                                    dateTimeAccumulator.add(formatter.format(new Date(response.getTimestamp())));
+                                    sourceInputs.add(1);
+                                    // Emit a watermark every second of event
+                                    // time
+                                        if (lastWatermarkTime == 0) {
+                                            lastWatermarkTime = time;
+                                        } else if ((time - lastWatermarkTime) > window) {
+                                            lastWatermarkTime = time;
+                                            ctx.emitWatermark(new Watermark(time - 1));
+                                        }
+                                    });
+                            };
+                            try {
+                                svc.execute(r);
+                            } catch (RejectedExecutionException e) {
+                                // Run it in this thread
+                                r.run();
+                                inputProcessedInMainThread.add(1);
+                            }
+                        } catch (IOException e) {
+                            LOG.error("Error deserializing metric response, closing", e);
+                            try {
+                                close();
+                            } catch (Exception e1) {
+                                LOG.error("Error closing client", e1);
+                            }
+                        }
+                    }
+                });
+            }
+
+            @Override
+            public void onClose(Session session, CloseReason reason) {
+                super.onClose(session, reason);
+                try {
+                    close();
+                } catch (Exception e1) {
+                    LOG.error("Error closing client", e1);
+                }
+                // Signal done sending data
+                ctx.emitWatermark(new Watermark(Long.MAX_VALUE));
+            }
+
+            @Override
+            public void onError(Session session, Throwable error) {
+                super.onError(session, error);
+                try {
+                    close();
+                } catch (Exception e1) {
+                    LOG.error("Error closing client", e1);
+                }
+            }
+
+        };
+        try {
+            client.open(handler);
+            for (String m : metrics) {
+                LOG.info("Adding subscription for {}", m);
+                client.addSubscription(m, null, start, end, 5000);
+            }
+            while (!client.isClosed()) {
+                try {
+                    Thread.sleep(5000);
+                } catch (InterruptedException e) {
+                    LOG.error("Sleep interrupted.");
+                }
+            }
+        } finally {
+            svc.shutdown();
+        }
+    }
+
+    @Override
+    public void cancel() {
+        LOG.info("Cancelling subscription source.");
+        try {
+            close();
+        } catch (Exception e) {
+            LOG.error("Error closing web socket client");
+        }
+    }
+
+    @Override
+    public void stop() {
+        LOG.info("Stopping subscription source.");
+        try {
+            close();
+        } catch (Exception e) {
+            LOG.error("Error closing web socket client");
+        }
+
+    }
+
+}

analytics/src/main/java/timely/analytics/flink/SummarizationJob.java

@@ -0,0 +1,109 @@
+package timely.analytics.flink;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.apache.flink.api.common.accumulators.LongCounter;
+import org.apache.flink.api.common.functions.FoldFunction;
+import org.apache.flink.api.java.utils.ParameterTool;
+import org.apache.flink.configuration.Configuration;
+import org.apache.flink.streaming.api.TimeCharacteristic;
+import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
+import org.apache.flink.streaming.api.functions.sink.SocketClientSink;
+import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import timely.api.response.MetricResponse;
+
+public class SummarizationJob {
+
+    private static final Logger LOG = LoggerFactory.getLogger(SummarizationJob.class);
+
+    public static void main(String[] args) throws Exception {
+
+        if (args.length != 1) {
+            System.err.println("Usage: timely.analytics.flink.SummarizationJob <path_to_properties_file>");
+            System.exit(1);
+        }
+
+        LOG.info("Loading properties from: {}", args[0]);
+        ParameterTool params = ParameterTool.fromPropertiesFile(args[0]);
+
+        final SummarizationJobParameters jp = new SummarizationJobParameters(params);
+        LOG.info("Properties: {}", jp);
+
+        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
+        // @formatter:off
+        env.getConfig().setGlobalJobParameters(jp);
+        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
+        env.addSource(new SubscriptionSource(jp), "Timely Metrics Subscription")
+        // partition by unique metric
+        .keyBy(new MetricKeySelector())
+        .window(TumblingEventTimeWindows.of(jp.getSummarizationInterval()))
+        .fold(new MetricHistogram(), new FoldFunction<MetricResponse, MetricHistogram>() {
+
+            private final Logger LOG = LoggerFactory
+                    .getLogger("timely.analytics.SummarizationJob.FoldFunction@");
+            private static final long serialVersionUID = 1L;
+
+            @Override
+            public MetricHistogram fold(MetricHistogram histo, MetricResponse metric) throws Exception {
+                if (!histo.isInitialized()) {
+                    histo.initialize(metric.getMetric(), metric.getTags());
+                } else {
+                    if (!histo.getMetric().equals(metric.getMetric())) {
+                        throw new RuntimeException("Metric name does not match - partitioning problem");
+                    }
+                    if (!histo.getTags().equals(metric.getTags())) {
+                        throw new RuntimeException("Tags don't not match - partitioning problem");
+                    }
+                }
+                LOG.trace("Updating histogram for {} with value {} at {} for metric {}", histo.getMetric()
+                        + histo.getTags(), metric.getValue(), metric.getTimestamp(), metric.getMetric()
+                        + metric.getTags());
+                histo.update(metric.getValue(), metric.getTimestamp());
+                return histo;
+            }
+        })
+        .name("Metric Windows")
+        .addSink(
+    		new SocketClientSink<MetricHistogram>(jp.getTimelyHostname(), jp.getTimelyTcpPort(),
+                    new MetricHistogram(), 2, true) {
+
+                private final Logger LOG = LoggerFactory
+                        .getLogger("timely.analytics.SummarizationJob.SocketClientSink");
+                private static final long serialVersionUID = 1L;
+                private final LongCounter sinkCounter = new LongCounter();
+                private final SortedStringAccumulator dateTimeAccumulator = new SortedStringAccumulator();
+                private final SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd-HH");
+
+                @Override
+                public void open(Configuration parameters) throws Exception {
+                    super.open(parameters);
+                    this.getRuntimeContext().addAccumulator("sink counter", this.sinkCounter);
+                    this.getRuntimeContext().addAccumulator("sink hourly count", dateTimeAccumulator);
+                    LOG.info("Sink opened");
+                }
+
+                @Override
+                public void invoke(MetricHistogram histo) throws Exception {
+                    histo.done();
+                    super.invoke(histo);
+                    this.sinkCounter.add(1);
+                    this.dateTimeAccumulator.add(formatter.format(new Date(histo.getTimestamp())));
+                }
+
+                @Override
+                public void close() throws Exception {
+                    super.close();
+                    LOG.info("Sink closed");
+                }
+
+            }).name("Timely Metric Sink");
+        // @formatter:on
+        env.execute("Metric Summarization");
+        // Looks like there is no way to stop Flink job if underlying web socket
+        // is closed.
+    }
+}

analytics/src/main/java/timely/analytics/flink/SummarizationJobParameters.java

@@ -0,0 +1,208 @@
+package timely.analytics.flink;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.flink.api.common.ExecutionConfig.GlobalJobParameters;
+import org.apache.flink.api.java.utils.ParameterTool;
+import org.apache.flink.configuration.Configuration;
+import org.apache.flink.streaming.api.windowing.time.Time;
+
+public class SummarizationJobParameters extends GlobalJobParameters implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final String timelyHostname;
+    private final int timelyTcpPort;
+    private final int timelyHttpsPort;
+    private final int timelyWssPort;
+    private final boolean doLogin;
+    private final String timelyUsername;
+    private final String timelyPassword;
+    private final String keyStoreFile;
+    private final String keyStoreType;
+    private final String keyStorePass;
+    private final String trustStoreFile;
+    private final String trustStoreType;
+    private final String trustStorePass;
+    private final boolean hostVerificationEnabled;
+    private final int bufferSize;
+    private final String[] metrics;
+    private final long startTime;
+    private final long endTime;
+    private final String interval;
+    private final String intervalUnits;
+
+    public SummarizationJobParameters(ParameterTool params) {
+        timelyHostname = params.getRequired("timelyHostname");
+        timelyTcpPort = params.getInt("timelyTcpPort", 4241);
+        timelyHttpsPort = params.getInt("timelyHttpsPort", 4242);
+        timelyWssPort = params.getInt("timelyWssPort", 4243);
+        doLogin = params.getBoolean("doLogin", false);
+        timelyUsername = params.get("timelyUsername", null);
+        timelyPassword = params.get("timelyPassword", null);
+        keyStoreFile = params.getRequired("keyStoreFile");
+        keyStoreType = params.get("keyStoreType", "JKS");
+        keyStorePass = params.getRequired("keyStorePass");
+        trustStoreFile = params.getRequired("trustStoreFile");
+        trustStoreType = params.get("trustStoreType", "JKS");
+        trustStorePass = params.getRequired("trustStorePass");
+        hostVerificationEnabled = params.getBoolean("hostVerificationEnabled", true);
+        bufferSize = params.getInt("bufferSize", 10485760);
+        String metricNames = params.getRequired("metrics");
+        if (null != metricNames) {
+            metrics = metricNames.split(",");
+        } else {
+            metrics = null;
+        }
+        startTime = params.getLong("startTime", 0L);
+        endTime = params.getLong("endTime", 0L);
+        interval = params.getRequired("interval");
+        intervalUnits = params.getRequired("intervalUnits");
+    }
+
+    public SummarizationJobParameters(Configuration conf) {
+        System.out.println("Creating job parameters from configuration: " + conf);
+        timelyHostname = conf.getString("timelyHostname", null);
+        timelyTcpPort = conf.getInteger("timelyTcpPort", 4241);
+        timelyHttpsPort = conf.getInteger("timelyHttpsPort", 4242);
+        timelyWssPort = conf.getInteger("timelyWssPort", 4243);
+        doLogin = conf.getBoolean("doLogin", false);
+        timelyUsername = conf.getString("timelyUsername", null);
+        timelyPassword = conf.getString("timelyPassword", null);
+        keyStoreFile = conf.getString("keyStoreFile", null);
+        keyStoreType = conf.getString("keyStoreType", "JKS");
+        keyStorePass = conf.getString("keyStorePass", null);
+        trustStoreFile = conf.getString("trustStoreFile", null);
+        trustStoreType = conf.getString("trustStoreType", "JKS");
+        trustStorePass = conf.getString("trustStorePass", null);
+        hostVerificationEnabled = conf.getBoolean("hostVerificationEnabled", true);
+        bufferSize = conf.getInteger("bufferSize", 10485760);
+        String metricNames = conf.getString("metrics", null);
+        if (null != metricNames) {
+            metrics = metricNames.split(",");
+        } else {
+            metrics = null;
+        }
+        startTime = conf.getLong("startTime", 0L);
+        endTime = conf.getLong("endTime", 0L);
+        interval = conf.getString("interval", null);
+        intervalUnits = conf.getString("intervalUnits", null);
+    }
+
+    public Time getSummarizationInterval() {
+        return Time.of(Long.parseLong(interval), TimeUnit.valueOf(intervalUnits));
+    }
+
+    public String getTimelyHostname() {
+        return timelyHostname;
+    }
+
+    public int getTimelyTcpPort() {
+        return timelyTcpPort;
+    }
+
+    public int getTimelyHttpsPort() {
+        return timelyHttpsPort;
+    }
+
+    public int getTimelyWssPort() {
+        return timelyWssPort;
+    }
+
+    public boolean isDoLogin() {
+        return doLogin;
+    }
+
+    public String getTimelyUsername() {
+        return timelyUsername;
+    }
+
+    public String getTimelyPassword() {
+        return timelyPassword;
+    }
+
+    public String getKeyStoreFile() {
+        return keyStoreFile;
+    }
+
+    public String getKeyStoreType() {
+        return keyStoreType;
+    }
+
+    public String getKeyStorePass() {
+        return keyStorePass;
+    }
+
+    public String getTrustStoreFile() {
+        return trustStoreFile;
+    }
+
+    public String getTrustStoreType() {
+        return trustStoreType;
+    }
+
+    public String getTrustStorePass() {
+        return trustStorePass;
+    }
+
+    public boolean isHostVerificationEnabled() {
+        return hostVerificationEnabled;
+    }
+
+    public int getBufferSize() {
+        return bufferSize;
+    }
+
+    public String[] getMetrics() {
+        return metrics;
+    }
+
+    public long getStartTime() {
+        return startTime;
+    }
+
+    public long getEndTime() {
+        return endTime;
+    }
+
+    public String getInterval() {
+        return interval;
+    }
+
+    public String getIntervalUnits() {
+        return intervalUnits;
+    }
+
+    @Override
+    public Map<String, String> toMap() {
+        Map<String, String> m = new HashMap<>();
+        m.put("timelyHostname", this.timelyHostname);
+        m.put("timelyHttpsPort", Integer.toString(this.timelyHttpsPort));
+        m.put("timelyWssPort", Integer.toString(this.timelyWssPort));
+        m.put("doLogin", Boolean.toString(this.doLogin));
+        m.put("timelyUsername", this.timelyUsername);
+        m.put("timelyPassword", this.timelyPassword);
+        m.put("keyStoreFile", this.keyStoreFile);
+        m.put("keyStoreType", this.keyStoreType);
+        m.put("keyStorePass", this.keyStorePass);
+        m.put("trustStoreFile", this.trustStoreFile);
+        m.put("trustStoreType", this.trustStoreType);
+        m.put("trustStorePass", this.trustStorePass);
+        m.put("hostVerificationEnabled", Boolean.toString(this.hostVerificationEnabled));
+        m.put("bufferSize", Integer.toString(this.bufferSize));
+        m.put("metrics", String.join(",", this.metrics));
+        m.put("startTime", Long.toString(this.startTime));
+        m.put("endTime", Long.toString(this.endTime));
+        m.put("interval", this.interval);
+        m.put("intervalUnits", this.intervalUnits);
+        return m;
+    }
+
+    @Override
+    public String toString() {
+        return toMap().toString();
+    }
+}

analytics/src/test/java/timely/analytics/flink/MetricHistogramTest.java

@@ -0,0 +1,108 @@
+package timely.analytics.flink;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import timely.model.Metric;
+import timely.model.Tag;
+import timely.model.parse.MetricParser;
+
+public class MetricHistogramTest {
+
+    private MetricHistogram m = null;
+    private long timestamp = System.currentTimeMillis();
+
+    @Before
+    public void createMetric() throws Exception {
+        m = new MetricHistogram();
+        for (double d = 1.0D; d <= 100.0; d += 1.0) {
+            timestamp += 1000;
+            m.update(d, timestamp);
+        }
+        m.toString();
+        Assert.assertEquals(timestamp, m.getTimestamp());
+    }
+
+    @Test
+    public void testMin() throws Exception {
+        Assert.assertEquals(1.0D, m.min(), 0.0D);
+    }
+
+    @Test
+    public void testMax() throws Exception {
+        Assert.assertEquals(100.0D, m.max(), 0.0D);
+    }
+
+    @Test
+    public void testAvg() throws Exception {
+        int sum = 0;
+        for (int i = 1; i <= 100; i++) {
+            sum += i;
+        }
+        Assert.assertEquals((sum / 100.0D), m.avg(), 0.0D);
+    }
+
+    @Test
+    public void testCount() throws Exception {
+        Assert.assertEquals(100.0D, m.count(), 0.0D);
+    }
+
+    @Test
+    public void test50thPercentile() throws Exception {
+        Assert.assertEquals(50.0D, m.getPercentile(50), 0.0D);
+    }
+
+    @Test
+    public void test75thPercentile() throws Exception {
+        Assert.assertEquals(75.0D, m.getPercentile(75), 0.0D);
+    }
+
+    @Test
+    public void test90thPercentile() throws Exception {
+        Assert.assertEquals(90.0D, m.getPercentile(90), 0.0D);
+    }
+
+    @Test
+    public void test99thPercentile() throws Exception {
+        Assert.assertEquals(99.0D, m.getPercentile(99), 0.0D);
+    }
+
+    @Test
+    public void testSerialization() throws Exception {
+        MetricParser metricParser = new MetricParser();
+        Tag t1 = new Tag("tag1=value1");
+        Tag t2 = new Tag("tag2=value2");
+        Tag avg = new Tag("sample=avg");
+        Tag min = new Tag("sample=min");
+        Tag max = new Tag("sample=max");
+        Tag sum = new Tag("sample=sum");
+        Tag count = new Tag("sample=count");
+        Tag p50 = new Tag("sample=50p");
+        Tag p75 = new Tag("sample=75p");
+        Tag p90 = new Tag("sample=90p");
+        Tag p99 = new Tag("sample=99p");
+
+        List<Tag> tags = new ArrayList<>();
+        tags.add(t1);
+        tags.add(t2);
+        m.initialize("sys.cpu.user", tags);
+
+        byte[] bytes = m.serialize(m);
+        String puts = new String(bytes);
+        for (String put : puts.split("\n")) {
+            Metric metric = metricParser.parse(put);
+            Assert.assertEquals("sys.cpu.user_summarized", metric.getName());
+            metric.getTags().forEach(
+                    t -> {
+                        Assert.assertTrue(t.equals(t1) || t.equals(t2) || t.equals(avg) || t.equals(min)
+                                || t.equals(max) || t.equals(sum) || t.equals(count) || t.equals(p50) || t.equals(p75)
+                                || t.equals(p90) || t.equals(p99));
+                    });
+        }
+    }
+
+}

client/.gitignore

@@ -0,0 +1 @@
+/target/

client/pom.xml

@@ -0,0 +1,142 @@
+<?xml version="1.0"?>
+<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/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>timely-client</artifactId>
+    <parent>
+        <groupId>timely</groupId>
+        <artifactId>timely</artifactId>
+        <version>0.0.4</version>
+    </parent>
+    <dependencies>
+        <dependency>
+            <groupId>timely</groupId>
+            <artifactId>timely-common</artifactId>
+            <version>${parent.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.datatype</groupId>
+            <artifactId>jackson-datatype-jdk8</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-api</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-slf4j-impl</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+        	<groupId>org.glassfish.tyrus</groupId>
+        	<artifactId>tyrus-client</artifactId>
+        	<version>1.13</version>
+        </dependency>
+        <dependency>
+        	<groupId>org.glassfish.tyrus</groupId>
+        	<artifactId>tyrus-container-grizzly-client</artifactId>	
+        	<version>1.13</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>findbugs-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>net.revelc.code</groupId>
+                <artifactId>formatter-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>buildnumber-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+    <reporting>
+        <plugins>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>findbugs-maven-plugin</artifactId>
+                <version>${version.findbugs-maven}</version>
+                <configuration>
+                    <effort>Max</effort>
+                    <threshold>Medium</threshold>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>${version.jacoco}</version>
+                <reportSets>
+                    <reportSet>
+                        <id>JaCoCo Unit Test Coverage</id>
+                        <configuration>
+                            <dataFile>${project.build.directory}/coverage/jacoco-ut.exec</dataFile>
+                        </configuration>
+                        <reports>
+                            <report>report</report>
+                        </reports>
+                    </reportSet>
+                    <reportSet>
+                        <id>JaCoCo Integration Test Coverage</id>
+                        <configuration>
+                            <dataFile>${project.build.directory}/coverage/jacoco-it.exec</dataFile>
+                        </configuration>
+                        <reports>
+                            <report>report-integration</report>
+                        </reports>
+                    </reportSet>
+                </reportSets>
+            </plugin>
+        </plugins>
+    </reporting>
+</project>

client/src/main/java/timely/api/AddSubscription.java

@@ -0,0 +1,82 @@
+package timely.api;
+
+import java.util.Map;
+import java.util.Optional;
+
+public class AddSubscription extends SubscriptionRequest {
+
+    private String operation = "add";
+    private String metric = null;
+    private Optional<Map<String, String>> tags = Optional.empty();
+    private Optional<Long> startTime = Optional.empty();
+    private Optional<Long> endTime = Optional.empty();
+    private Optional<Long> delayTime = Optional.empty();
+
+    public String getOperation() {
+        return operation;
+    }
+
+    public String getMetric() {
+        return metric;
+    }
+
+    public Optional<Map<String, String>> getTags() {
+        return tags;
+    }
+
+    public Optional<Long> getStartTime() {
+        return startTime;
+    }
+
+    public Optional<Long> getDelayTime() {
+        return delayTime;
+    }
+
+    public void setMetric(String metric) {
+        this.metric = metric;
+    }
+
+    public void setTags(Optional<Map<String, String>> tags) {
+        this.tags = tags;
+    }
+
+    public void setStartTime(Optional<Long> startTime) {
+        this.startTime = startTime;
+    }
+
+    public void setDelayTime(Optional<Long> delayTime) {
+        this.delayTime = delayTime;
+    }
+
+    public Optional<Long> getEndTime() {
+        return endTime;
+    }
+
+    public void setEndTime(Optional<Long> endTime) {
+        this.endTime = endTime;
+    }
+
+    @Override
+    public int hashCode() {
+        return (operation + subscriptionId + metric + tags + startTime + endTime + delayTime).hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (null == obj) {
+            return false;
+        }
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof AddSubscription) {
+            AddSubscription other = (AddSubscription) obj;
+            return (this.subscriptionId.equals(other.subscriptionId) && this.metric.equals(other.metric)
+                    && this.tags.equals(other.tags) && this.startTime.equals(other.startTime)
+                    && this.endTime.equals(other.endTime) && this.delayTime.equals(other.delayTime));
+        } else {
+            return false;
+        }
+    }
+
+}

client/src/main/java/timely/api/BasicAuthLogin.java

@@ -0,0 +1,45 @@
+package timely.api;
+
+public class BasicAuthLogin {
+
+    protected String username;
+    protected String password;
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String user) {
+        this.username = user;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    @Override
+    public int hashCode() {
+        return (username + password).hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (null == obj) {
+            return false;
+        }
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof BasicAuthLogin) {
+            BasicAuthLogin other = (BasicAuthLogin) obj;
+            return (this.username.equals(other.username) && this.password.equals(other.password));
+        } else {
+            return false;
+        }
+    }
+
+}

client/src/main/java/timely/api/CloseSubscription.java

@@ -0,0 +1,32 @@
+package timely.api;
+
+public class CloseSubscription extends SubscriptionRequest {
+
+    private String operation = "close";
+
+    public String getOperation() {
+        return operation;
+    }
+
+    @Override
+    public int hashCode() {
+        return (operation + subscriptionId).hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (null == obj) {
+            return false;
+        }
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof CloseSubscription) {
+            CloseSubscription other = (CloseSubscription) obj;
+            return (this.subscriptionId.equals(other.subscriptionId));
+        } else {
+            return false;
+        }
+    }
+
+}

client/src/main/java/timely/api/CreateSubscription.java

@@ -0,0 +1,32 @@
+package timely.api;
+
+public class CreateSubscription extends SubscriptionRequest {
+
+    private String operation = "create";
+
+    public String getOperation() {
+        return operation;
+    }
+
+    @Override
+    public int hashCode() {
+        return (operation + subscriptionId).hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (null == obj) {
+            return false;
+        }
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof CreateSubscription) {
+            CreateSubscription other = (CreateSubscription) obj;
+            return (this.subscriptionId.equals(other.subscriptionId));
+        } else {
+            return false;
+        }
+    }
+
+}

client/src/main/java/timely/api/RemoveSubscription.java

@@ -0,0 +1,41 @@
+package timely.api;
+
+public class RemoveSubscription extends SubscriptionRequest {
+
+    private String operation = "remove";
+    private String metric = null;
+
+    public String getOperation() {
+        return operation;
+    }
+
+    public String getMetric() {
+        return metric;
+    }
+
+    public void setMetric(String metric) {
+        this.metric = metric;
+    }
+
+    @Override
+    public int hashCode() {
+        return (operation + subscriptionId + metric).hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (null == obj) {
+            return false;
+        }
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof RemoveSubscription) {
+            RemoveSubscription other = (RemoveSubscription) obj;
+            return (this.subscriptionId.equals(other.subscriptionId) && this.metric.equals(other.metric));
+        } else {
+            return false;
+        }
+    }
+
+}

client/src/main/java/timely/api/SubscriptionRequest.java

@@ -0,0 +1,15 @@
+package timely.api;
+
+public abstract class SubscriptionRequest {
+
+    protected String subscriptionId = null;
+
+    public final String getSubscriptionId() {
+        return subscriptionId;
+    }
+
+    public final void setSubscriptionId(String subscriptionId) {
+        this.subscriptionId = subscriptionId;
+    }
+
+}

client/src/main/java/timely/api/response/MetricResponse.java

@@ -0,0 +1,126 @@
+package timely.api.response;
+
+import java.util.List;
+
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+import org.apache.commons.lang3.builder.ToStringBuilder;
+
+import timely.model.Metric;
+import timely.model.Tag;
+
+public class MetricResponse {
+
+    private String metric;
+    private long timestamp;
+    private double value;
+    private List<Tag> tags;
+    private String subscriptionId;
+    private boolean complete = false;
+
+    public String getMetric() {
+        return metric;
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public double getValue() {
+        return value;
+    }
+
+    public List<Tag> getTags() {
+        return tags;
+    }
+
+    public boolean isComplete() {
+        return complete;
+    }
+
+    public void setMetric(String metric) {
+        this.metric = metric;
+    }
+
+    public void setTimestamp(long timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    public void setValue(double value) {
+        this.value = value;
+    }
+
+    public void setTags(List<Tag> tags) {
+        this.tags = tags;
+    }
+
+    public String getSubscriptionId() {
+        return subscriptionId;
+    }
+
+    public void setSubscriptionId(String subscriptionId) {
+        this.subscriptionId = subscriptionId;
+    }
+
+    public void setComplete(boolean closed) {
+        this.complete = closed;
+    }
+
+    public static MetricResponse fromMetric(Metric metric, String subscriptionId) {
+        MetricResponse response = new MetricResponse();
+        response.setMetric(metric.getName());
+        response.setTimestamp(metric.getValue().getTimestamp());
+        response.setTags(metric.getTags());
+        response.setValue(metric.getValue().getMeasure());
+        response.setSubscriptionId(subscriptionId);
+        response.setComplete(false);
+        return response;
+    }
+
+    @Override
+    public int hashCode() {
+        HashCodeBuilder hash = new HashCodeBuilder();
+        hash.append(this.metric);
+        hash.append(this.timestamp);
+        hash.append(this.value);
+        hash.append(this.tags);
+        hash.append(this.subscriptionId);
+        hash.append(this.complete);
+        return hash.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (null == obj) {
+            return false;
+        }
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof MetricResponse)) {
+            return false;
+        }
+        MetricResponse other = (MetricResponse) obj;
+        EqualsBuilder equals = new EqualsBuilder();
+        equals.append(this.metric, other.metric);
+        equals.append(this.timestamp, other.timestamp);
+        equals.append(this.value, other.value);
+        equals.append(this.tags, other.tags);
+        equals.append(this.subscriptionId, other.subscriptionId);
+        equals.append(this.complete, other.complete);
+        return equals.isEquals();
+    }
+
+    @Override
+    public String toString() {
+        ToStringBuilder tsb = new ToStringBuilder(this);
+        tsb.append("metric", this.metric);
+        tsb.append("timestamp", this.timestamp);
+        tsb.append("value", this.value);
+        tsb.append("tags", this.tags);
+        tsb.append("subscriptionId", this.subscriptionId);
+        tsb.append("complete", this.complete);
+        return tsb.toString();
+    }
+
+}

client/src/main/java/timely/api/response/MetricResponses.java

@@ -0,0 +1,29 @@
+package timely.api.response;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MetricResponses {
+
+    private List<MetricResponse> responses = new ArrayList<>();
+
+    public synchronized List<MetricResponse> getResponses() {
+        return this.responses;
+    }
+
+    public synchronized void setResponses(List<MetricResponse> responses) {
+        this.responses = responses;
+    }
+
+    public synchronized void addResponse(MetricResponse r) {
+        this.responses.add(r);
+    }
+
+    public int size() {
+        return this.responses.size();
+    }
+
+    public synchronized void clear() {
+        this.responses.clear();
+    }
+}

client/src/main/java/timely/client/http/HttpClient.java

@@ -0,0 +1,55 @@
+package timely.client.http;
+
+import javax.net.ssl.SSLContext;
+
+import org.apache.http.client.CookieStore;
+import org.apache.http.client.config.CookieSpecs;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.conn.ssl.DefaultHostnameVerifier;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.client.HttpClients;
+import org.glassfish.tyrus.client.SslContextConfigurator;
+
+public class HttpClient {
+
+    public static SSLContext getSSLContext(String trustStoreFile, String trustStoreType, String trustStorePass,
+            String keyStoreFile, String keyStoreType, String keyStorePass) {
+        SslContextConfigurator scc = new SslContextConfigurator();
+        scc.setTrustStoreFile(trustStoreFile);
+        scc.setTrustStoreType(trustStoreType);
+        if (null != trustStorePass) {
+            scc.setTrustStorePassword(trustStorePass);
+        }
+        scc.setKeyStoreFile(keyStoreFile);
+        scc.setKeyStoreType(keyStoreType);
+        if (null != keyStorePass) {
+            scc.setKeyStorePassword(keyStorePass);
+        }
+        return scc.createSSLContext();
+    }
+
+    public static CloseableHttpClient get(String trustStoreFile, String trustStoreType, String trustStorePass,
+            String keyStoreFile, String keyStoreType, String keyStorePass, CookieStore cookieStore,
+            boolean hostVerificationEnabled) {
+
+        SSLContext ssl = getSSLContext(trustStoreFile, trustStoreType, trustStorePass, keyStoreFile, keyStoreType,
+                keyStorePass);
+        return get(ssl, cookieStore, hostVerificationEnabled);
+    }
+
+    public static CloseableHttpClient get(SSLContext ssl, CookieStore cookieStore, boolean hostVerificationEnabled) {
+        RequestConfig defaultRequestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD).build();
+
+        HttpClientBuilder builder = HttpClients.custom().setSSLContext(ssl).setDefaultCookieStore(cookieStore)
+                .setDefaultRequestConfig(defaultRequestConfig);
+        if (hostVerificationEnabled) {
+            builder.setSSLHostnameVerifier(new DefaultHostnameVerifier());
+        } else {
+            builder.setSSLHostnameVerifier(new NoopHostnameVerifier());
+        }
+        return builder.build();
+    }
+
+}

client/src/main/java/timely/client/tcp/TcpClient.java

@@ -0,0 +1,106 @@
+package timely.client.tcp;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.Socket;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TcpClient implements AutoCloseable {
+
+    private static final Logger LOG = LoggerFactory.getLogger(TcpClient.class);
+
+    private final String host;
+    private final int port;
+    private Socket sock = null;
+    private PrintWriter out = null;
+    private long connectTime = 0L;
+    private long backoff = 2000;
+
+    public TcpClient(String hostname, int port) {
+        this.host = hostname;
+        this.port = port;
+    }
+
+    /**
+     * Opens a TCP connection to the specified host and port
+     * 
+     * @throws IOException
+     *             if an error occurs
+     */
+    public void open() throws IOException {
+        if (connect() != 0) {
+            throw new IOException();
+        }
+    }
+
+    /**
+     * Write a metric to Timely
+     * 
+     * @param metric
+     *            newline terminated string representation of Timely metric
+     * @throws IOException
+     */
+    public synchronized void write(String metric) throws IOException {
+        if (connect() != 0) {
+            throw new IOException();
+        }
+        out.write(metric);
+    }
+
+    public synchronized void flush() {
+        if (null != out) {
+            out.flush();
+        }
+    }
+
+    /**
+     * Closes the tcp connection to Timely
+     * 
+     * @throws IOException
+     *             if an error occurs
+     */
+    @Override
+    public void close() throws IOException {
+        LOG.info("Shutting down connection to Timely at {}:{}", host, port);
+        if (null != sock) {
+            try {
+                if (null != out) {
+                    out.close();
+                }
+                sock.close();
+            } catch (IOException e) {
+                LOG.error("Error closing connection to Timely at " + host + ":" + port + ". Error: " + e.getMessage());
+            } finally {
+                sock = null;
+            }
+        }
+    }
+
+    private synchronized int connect() {
+        if (null == sock || !sock.isConnected() || out.checkError()) {
+            if (System.currentTimeMillis() > (connectTime + backoff)) {
+                try {
+                    connectTime = System.currentTimeMillis();
+                    sock = new Socket(host, port);
+                    out = new PrintWriter(sock.getOutputStream(), false);
+                    backoff = 2000;
+                    LOG.info("Connected to Timely at {}:{}", host, port);
+                } catch (IOException e) {
+                    LOG.error("Error connecting to Timely at {}:" + host + ":" + port + ". Error: " + e.getMessage());
+                    backoff = backoff * 2;
+                    sock = null;
+                    out = null;
+                    LOG.warn("Will retry connection in {} ms.", backoff);
+                    return -1;
+                }
+            } else {
+                LOG.warn("Not writing to Timely, waiting to reconnect");
+                return -1;
+            }
+        }
+        return 0;
+    }
+
+}

client/src/main/java/timely/client/udp/UdpClient.java

@@ -0,0 +1,44 @@
+package timely.client.udp;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetSocketAddress;
+
+public class UdpClient implements AutoCloseable {
+
+    private final InetSocketAddress address;
+    private final DatagramPacket packet;
+    private DatagramSocket sock;
+
+    public UdpClient(String hostname, int port) {
+        this.address = new InetSocketAddress(hostname, port);
+        this.packet = new DatagramPacket("".getBytes(UTF_8), 0, 0, address.getAddress(), port);
+    }
+
+    public void open() throws IOException {
+        if (null == sock) {
+            this.sock = new DatagramSocket();
+        }
+    }
+
+    public void write(String metric) throws IOException {
+        if (null == this.sock) {
+            throw new IllegalStateException("Must call open first");
+        }
+        this.packet.setData(metric.getBytes(UTF_8));
+        this.sock.send(packet);
+    }
+
+    public void flush() throws IOException {
+    }
+
+    public void close() throws IOException {
+        if (null != sock) {
+            sock.close();
+        }
+    }
+
+}

client/src/main/java/timely/client/websocket/ClientHandler.java

@@ -0,0 +1,38 @@
+package timely.client.websocket;
+
+import javax.websocket.CloseReason;
+import javax.websocket.Endpoint;
+import javax.websocket.EndpointConfig;
+import javax.websocket.MessageHandler;
+import javax.websocket.Session;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public abstract class ClientHandler extends Endpoint {
+
+    private final static Logger LOG = LoggerFactory.getLogger(ClientHandler.class);
+
+    @Override
+    public void onOpen(Session session, EndpointConfig config) {
+        LOG.info("Websocket session {} opened.", session.getId());
+        session.addMessageHandler(new MessageHandler.Whole<String>() {
+
+            @Override
+            public void onMessage(String message) {
+                LOG.info("Message received on Websocket session {}: {}", session.getId(), message);
+            }
+        });
+    }
+
+    @Override
+    public void onClose(Session session, CloseReason reason) {
+        LOG.info("Websocket session {} closed.", session.getId());
+    }
+
+    @Override
+    public void onError(Session session, Throwable error) {
+        LOG.error("Error occurred on Websocket session" + session.getId(), error);
+    }
+
+}

client/src/main/java/timely/client/websocket/TimelyEndpointConfig.java

@@ -0,0 +1,65 @@
+package timely.client.websocket;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import javax.websocket.ClientEndpointConfig;
+import javax.websocket.Decoder;
+import javax.websocket.Encoder;
+import javax.websocket.Extension;
+
+import org.apache.http.cookie.Cookie;
+
+public class TimelyEndpointConfig implements ClientEndpointConfig {
+
+    private String sessionCookie = null;
+
+    private static final String FORMAT = "%s=%s;";
+
+    public TimelyEndpointConfig(Cookie sessionCookie) {
+        if (null != sessionCookie) {
+            this.sessionCookie = String.format(FORMAT, sessionCookie.getName(), sessionCookie.getValue());
+        }
+    }
+
+    @Override
+    public List<Class<? extends Encoder>> getEncoders() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<Class<? extends Decoder>> getDecoders() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public Map<String, Object> getUserProperties() {
+        return Collections.emptyMap();
+    }
+
+    @Override
+    public List<String> getPreferredSubprotocols() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<Extension> getExtensions() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public Configurator getConfigurator() {
+        return new Configurator() {
+
+            @Override
+            public void beforeRequest(Map<String, List<String>> headers) {
+                super.beforeRequest(headers);
+                if (null != sessionCookie) {
+                    headers.put("Cookie", Collections.singletonList(sessionCookie));
+                }
+            }
+        };
+    }
+
+}

client/src/main/java/timely/client/websocket/WebSocketClient.java

@@ -0,0 +1,179 @@
+package timely.client.websocket;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.TimeUnit;
+
+import javax.net.ssl.SSLContext;
+import javax.websocket.DeploymentException;
+import javax.websocket.Session;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpStatus;
+import org.apache.http.client.HttpResponseException;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpRequestBase;
+import org.apache.http.client.utils.HttpClientUtils;
+import org.apache.http.cookie.Cookie;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.BasicCookieStore;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.glassfish.tyrus.client.ClientManager;
+import org.glassfish.tyrus.client.ClientProperties;
+import org.glassfish.tyrus.client.SslEngineConfigurator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import timely.api.BasicAuthLogin;
+import timely.client.http.HttpClient;
+import timely.serialize.JsonSerializer;
+
+import com.google.common.base.Preconditions;
+
+public class WebSocketClient implements AutoCloseable {
+
+    private static final Logger LOG = LoggerFactory.getLogger(WebSocketClient.class);
+
+    private final String timelyHostname;
+    private final int timelyHttpsPort;
+    private final int timelyWssPort;
+    private final boolean doLogin;
+    private final String timelyUsername;
+    private final String timelyPassword;
+    private final boolean hostVerificationEnabled;
+    private final int bufferSize;
+    private final SSLContext ssl;
+
+    private ClientManager webSocketClient = null;
+    protected Session session = null;
+    protected volatile boolean closed = true;
+
+    protected WebSocketClient(SSLContext ssl, String timelyHostname, int timelyHttpsPort, int timelyWssPort,
+            boolean doLogin, String timelyUsername, String timelyPassword, boolean hostVerificationEnabled,
+            int bufferSize) {
+        this.ssl = ssl;
+        this.timelyHostname = timelyHostname;
+        this.timelyHttpsPort = timelyHttpsPort;
+        this.timelyWssPort = timelyWssPort;
+        this.doLogin = doLogin;
+        this.timelyUsername = timelyUsername;
+        this.timelyPassword = timelyPassword;
+        this.hostVerificationEnabled = hostVerificationEnabled;
+        this.bufferSize = bufferSize;
+
+        Preconditions.checkNotNull(timelyHostname, "%s must be supplied", "Timely host name");
+        Preconditions.checkNotNull(timelyHttpsPort, "%s must be supplied", "Timely HTTPS port");
+        Preconditions.checkNotNull(timelyWssPort, "%s must be supplied", "Timely WSS port");
+
+        if (doLogin
+                && ((StringUtils.isEmpty(timelyUsername) && !StringUtils.isEmpty(timelyPassword) || (!StringUtils
+                        .isEmpty(timelyUsername) && StringUtils.isEmpty(timelyPassword))))) {
+            throw new IllegalArgumentException("Both Timely username and password must be empty or non-empty");
+        }
+
+    }
+
+    protected WebSocketClient(String timelyHostname, int timelyHttpsPort, int timelyWssPort, boolean doLogin,
+            String timelyUsername, String timelyPassword, String keyStoreFile, String keyStoreType,
+            String keyStorePass, String trustStoreFile, String trustStoreType, String trustStorePass,
+            boolean hostVerificationEnabled, int bufferSize) {
+        this(HttpClient.getSSLContext(trustStoreFile, trustStoreType, trustStorePass, keyStoreFile, keyStoreType,
+                keyStorePass), timelyHostname, timelyHttpsPort, timelyWssPort, doLogin, timelyUsername, timelyPassword,
+                hostVerificationEnabled, bufferSize);
+    }
+
+    public void open(ClientHandler clientEndpoint) throws IOException, DeploymentException, URISyntaxException {
+
+        Cookie sessionCookie = null;
+        if (doLogin) {
+            BasicCookieStore cookieJar = new BasicCookieStore();
+            try (CloseableHttpClient client = HttpClient.get(ssl, cookieJar, hostVerificationEnabled)) {
+
+                String target = "https://" + timelyHostname + ":" + timelyHttpsPort + "/login";
+
+                HttpRequestBase request = null;
+                if (StringUtils.isEmpty(timelyUsername)) {
+                    // HTTP GET to /login to use certificate based login
+                    request = new HttpGet(target);
+                    LOG.trace("Performing client certificate login");
+                } else {
+                    // HTTP POST to /login to use username/password
+                    BasicAuthLogin login = new BasicAuthLogin();
+                    login.setUsername(timelyUsername);
+                    login.setPassword(timelyPassword);
+                    String payload = JsonSerializer.getObjectMapper().writeValueAsString(login);
+                    HttpPost post = new HttpPost(target);
+                    post.setEntity(new StringEntity(payload));
+                    request = post;
+                    LOG.trace("Performing BasicAuth login");
+                }
+
+                HttpResponse response = null;
+                try {
+                    response = client.execute(request);
+                    if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
+                        throw new HttpResponseException(response.getStatusLine().getStatusCode(), response
+                                .getStatusLine().getReasonPhrase());
+                    }
+                    for (Cookie c : cookieJar.getCookies()) {
+                        if (c.getName().equals("TSESSIONID")) {
+                            sessionCookie = c;
+                            break;
+                        }
+                    }
+                    if (null == sessionCookie) {
+                        throw new IllegalStateException(
+                                "Unable to find TSESSIONID cookie header in Timely login response");
+                    }
+                } finally {
+                    HttpClientUtils.closeQuietly(response);
+                }
+            }
+        }
+
+        SslEngineConfigurator sslEngine = new SslEngineConfigurator(ssl);
+        sslEngine.setClientMode(true);
+        sslEngine.setHostVerificationEnabled(hostVerificationEnabled);
+
+        webSocketClient = ClientManager.createClient();
+        webSocketClient.getProperties().put(ClientProperties.SSL_ENGINE_CONFIGURATOR, sslEngine);
+        webSocketClient.getProperties().put(ClientProperties.INCOMING_BUFFER_SIZE, bufferSize);
+        String wssPath = "wss://" + timelyHostname + ":" + timelyWssPort + "/websocket";
+        session = webSocketClient.connectToServer(clientEndpoint, new TimelyEndpointConfig(sessionCookie), new URI(
+                wssPath));
+
+        final ByteBuffer pingData = ByteBuffer.allocate(0);
+        webSocketClient.getScheduledExecutorService().scheduleAtFixedRate(() -> {
+            try {
+                session.getBasicRemote().sendPing(pingData);
+            } catch (Exception e) {
+                LOG.error("Error sending ping", e);
+            }
+        }, 30, 60, TimeUnit.SECONDS);
+        closed = false;
+    }
+
+    public synchronized void close() throws IOException {
+        if (closed) {
+            return;
+        }
+        try {
+            if (null != webSocketClient) {
+                webSocketClient.shutdown();
+            }
+        } finally {
+            session = null;
+            webSocketClient = null;
+            closed = true;
+        }
+    }
+
+    public boolean isClosed() {
+        return closed;
+    }
+
+}

client/src/main/java/timely/client/websocket/subscription/WebSocketSubscriptionClient.java

@@ -0,0 +1,92 @@
+package timely.client.websocket.subscription;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.Future;
+
+import javax.net.ssl.SSLContext;
+import javax.websocket.CloseReason;
+import javax.websocket.DeploymentException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import timely.api.AddSubscription;
+import timely.api.CloseSubscription;
+import timely.api.CreateSubscription;
+import timely.api.RemoveSubscription;
+import timely.client.websocket.ClientHandler;
+import timely.client.websocket.WebSocketClient;
+import timely.serialize.JsonSerializer;
+
+public class WebSocketSubscriptionClient extends WebSocketClient {
+
+    private static final Logger LOG = LoggerFactory.getLogger(WebSocketSubscriptionClient.class);
+    private final String subscriptionId;
+
+    public WebSocketSubscriptionClient(SSLContext ssl, String timelyHostname, int timelyHttpsPort, int timelyWssPort,
+            boolean doLogin, String timelyUsername, String timelyPassword, boolean hostVerificationEnabled,
+            int bufferSize) {
+        super(ssl, timelyHostname, timelyHttpsPort, timelyWssPort, doLogin, timelyUsername, timelyPassword,
+                hostVerificationEnabled, bufferSize);
+        subscriptionId = UUID.randomUUID().toString();
+        LOG.trace("Created WebSocketClient with subscriptionId {}", this.subscriptionId);
+    }
+
+    public WebSocketSubscriptionClient(String timelyHostname, int timelyHttpsPort, int timelyWssPort, boolean doLogin,
+            String timelyUsername, String timelyPassword, String keyStoreFile, String keyStoreType,
+            String keyStorePass, String trustStoreFile, String trustStoreType, String trustStorePass,
+            boolean hostVerificationEnabled, int bufferSize) {
+        super(timelyHostname, timelyHttpsPort, timelyWssPort, doLogin, timelyUsername, timelyPassword, keyStoreFile,
+                keyStoreType, keyStorePass, trustStoreFile, trustStoreType, trustStorePass, hostVerificationEnabled,
+                bufferSize);
+        subscriptionId = UUID.randomUUID().toString();
+        LOG.trace("Created WebSocketClient with subscriptionId {}", this.subscriptionId);
+    }
+
+    @Override
+    public void open(ClientHandler clientEndpoint) throws IOException, DeploymentException, URISyntaxException {
+        super.open(clientEndpoint);
+        CreateSubscription create = new CreateSubscription();
+        create.setSubscriptionId(subscriptionId);
+        session.getBasicRemote().sendText(JsonSerializer.getObjectMapper().writeValueAsString(create));
+    }
+
+    @Override
+    public synchronized void close() throws IOException {
+        if (null != session) {
+            CloseSubscription close = new CloseSubscription();
+            close.setSubscriptionId(subscriptionId);
+            try {
+                session.getBasicRemote().sendText(JsonSerializer.getObjectMapper().writeValueAsString(close));
+                session.close(new CloseReason(CloseReason.CloseCodes.NORMAL_CLOSURE, "Client called close."));
+            } catch (Exception e) {
+                LOG.info("Unable to send close message to server: {}", e.getMessage());
+            }
+        }
+        super.close();
+    }
+
+    public Future<Void> addSubscription(String metric, Map<String, String> tags, long startTime, long endTime,
+            long delayTime) throws IOException {
+        AddSubscription add = new AddSubscription();
+        add.setSubscriptionId(subscriptionId);
+        add.setMetric(metric);
+        add.setTags(Optional.ofNullable(tags));
+        add.setStartTime(Optional.ofNullable(startTime));
+        add.setEndTime(Optional.ofNullable(endTime));
+        add.setDelayTime(Optional.ofNullable(delayTime));
+        return session.getAsyncRemote().sendText(JsonSerializer.getObjectMapper().writeValueAsString(add));
+    }
+
+    public Future<Void> removeSubscription(String metric) throws Exception {
+        RemoveSubscription remove = new RemoveSubscription();
+        remove.setSubscriptionId(subscriptionId);
+        remove.setMetric(metric);
+        return session.getAsyncRemote().sendText(JsonSerializer.getObjectMapper().writeValueAsString(remove));
+    }
+
+}

client/src/main/java/timely/model/Metric.java

@@ -0,0 +1,190 @@
+package timely.model;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import timely.model.parse.TagParser;
+
+import com.fasterxml.jackson.annotation.JsonGetter;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonPropertyOrder;
+import com.fasterxml.jackson.annotation.JsonRootName;
+import com.fasterxml.jackson.annotation.JsonUnwrapped;
+
+/**
+ * A Metric consists of a metric name, tags, and a Value
+ *
+ * Json has been flattened to reduce overhead. Example:
+ * {"name":"m1","timestamp":1,"measure":1.0,"tags":[{"k1":"v1"}]}
+ *
+ */
+@JsonRootName("metric")
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonPropertyOrder({ "name" })
+public class Metric implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String name;
+    private List<Tag> tags;
+    private Value value;
+
+    public Metric() {
+        tags = new ArrayList<>();
+        value = new Value();
+    }
+
+    public Metric(Metric other) {
+        this();
+        this.name = other.getName();
+        this.tags.addAll(other.getTags());
+        this.value = new Value(other.getValue());
+    }
+
+    public Metric(String name, long timestamp, double measure) {
+        this();
+        this.name = name;
+        this.value.setTimestamp(timestamp);
+        this.value.setMeasure(measure);
+    }
+
+    public Metric(String name, long timestamp, double measure, List<Tag> tags) {
+        this(name, timestamp, measure);
+        this.setTags(tags);
+    }
+
+    public Metric(String name, List<Tag> tags) {
+        this();
+        this.name = name;
+        this.setTags(tags);
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    @JsonGetter("name")
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @JsonGetter("tags")
+    public List<Tag> getTags() {
+        return tags;
+    }
+
+    public void setTags(List<Tag> tags) {
+        this.tags.addAll(tags);
+    }
+
+    public void addTag(Tag tag) {
+        tags.add(new Tag(tag));
+    }
+
+    @JsonUnwrapped
+    public Value getValue() {
+        return value;
+    }
+
+    public void setValue(Value value) {
+        this.value = value;
+    }
+
+    @Override
+    public String toString() {
+        Collections.sort(tags);
+        return "Metric{" + "name='" + name + '\'' + ", tags=" + tags + ", value=" + value + '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+
+        Metric metric = (Metric) o;
+
+        if (name != null ? !name.equals(metric.name) : metric.name != null)
+            return false;
+
+        if (tags != null) {
+            if (tags.size() != metric.tags.size()) {
+                return false;
+            } else if (!tags.containsAll(metric.tags)) {
+                return false;
+            }
+        }
+
+        return value != null ? value.equals(metric.value) : metric.value == null;
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = name != null ? name.hashCode() : 0;
+        result = 31 * result + (tags != null ? tags.hashCode() : 0);
+        result = 31 * result + (value != null ? value.hashCode() : 0);
+        return result;
+    }
+
+    /**
+     * Simple Builder for Metric. Note: cannot re-use a builder after build is
+     * called.
+     */
+    public static class Builder {
+
+        Metric metric;
+
+        private Builder() {
+            metric = new Metric();
+        }
+
+        private static TagParser parser = new TagParser();
+
+        public Builder tag(Tag tag) {
+            metric.addTag(tag);
+            return this;
+        }
+
+        public Builder tags(List<Tag> tags) {
+            metric.setTags(tags);
+            return this;
+        }
+
+        public Builder tag(String key, String value) {
+            metric.addTag(new Tag(key, value));
+            return this;
+        }
+
+        public Builder tag(String rawTag) {
+            metric.addTag(parser.parse(rawTag));
+            return this;
+        }
+
+        public Builder name(String name) {
+            metric.setName(name);
+            return this;
+        }
+
+        public Builder value(Value value) {
+            metric.setValue(value);
+            return this;
+        }
+
+        public Builder value(long timestamp, double measure) {
+            metric.setValue(new Value(timestamp, measure));
+            return this;
+        }
+
+        public Metric build() {
+            return this.metric;
+        }
+    }
+}

client/src/main/java/timely/model/Tag.java

@@ -0,0 +1,112 @@
+package timely.model;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonRootName;
+import com.google.common.base.Joiner;
+import com.google.common.base.Preconditions;
+import org.apache.commons.lang3.builder.CompareToBuilder;
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import timely.model.parse.TagParser;
+
+import java.io.Serializable;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Tag consists of key value pair
+ */
+@JsonRootName("tag")
+public class Tag implements Comparable<Tag>, Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final TagParser tagParser = new TagParser();
+
+    private String key;
+    private String value;
+
+    public Tag() {
+    }
+
+    public Tag(Tag other) {
+        this.setKey(other.getKey());
+        this.setValue(other.getValue());
+    }
+
+    public Tag(String tag) {
+        this(tagParser.parse(tag));
+    }
+
+    public Tag(String key, String value) {
+        Preconditions.checkNotNull(key);
+        Preconditions.checkNotNull(value);
+        this.setKey(key);
+        this.setValue(value);
+    }
+
+    @JsonAnyGetter
+    public Map<String, String> get() {
+        return Stream.of(this).collect(Collectors.toMap(Tag::getKey, Tag::getValue));
+    }
+
+    @JsonAnySetter
+    public void set(String key, String value) {
+        this.key = key;
+        this.value = value;
+    }
+
+    @JsonIgnore
+    public String getKey() {
+        return key;
+    }
+
+    public void setKey(String key) {
+        this.key = key;
+    }
+
+    @JsonIgnore
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    /**
+     * Joins key and value into key=value
+     * 
+     * @return
+     */
+    public String join() {
+        return tagParser.combine(this);
+    }
+
+    @Override
+    public String toString() {
+        return "Tag{" + join() + "}";
+    }
+
+    @Override
+    public int hashCode() {
+        return this.toString().hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (null == o || getClass() != o.getClass())
+            return false;
+        Tag other = (Tag) o;
+        return new EqualsBuilder().append(this.key, other.key).append(this.value, other.value).isEquals();
+    }
+
+    @Override
+    public int compareTo(Tag other) {
+        return new CompareToBuilder().append(this.key, other.key).append(this.value, other.value).toComparison();
+    }
+}

client/src/main/java/timely/model/Value.java

@@ -0,0 +1,93 @@
+package timely.model;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.base.Objects;
+
+import java.io.Serializable;
+import java.util.Comparator;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Value consists of a long timestamp and a double measurement
+ */
+public class Value implements Comparator<Value>, Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private Long timestamp;
+    private Double measure;
+
+    public Value() {
+    }
+
+    public Value(Value other) {
+        this.setTimestamp(other.getTimestamp());
+        this.setMeasure(other.getMeasure());
+    }
+
+    @JsonCreator
+    public Value(@JsonProperty("timestamp") Long timestamp, @JsonProperty("measure") Double measure) {
+        this.setTimestamp(timestamp);
+        this.setMeasure(measure);
+    }
+
+    @JsonProperty("timestamp")
+    public Long getTimestamp() {
+        return timestamp;
+    }
+
+    public void setTimestamp(final Long timestamp) {
+        this.setTimestamp(timestamp, TimeUnit.MILLISECONDS);
+    }
+
+    public void setTimestamp(final Long timestamp, TimeUnit timeUnit) {
+        this.timestamp = timeUnit.toMillis(timestamp);
+    }
+
+    @JsonProperty("measure")
+    public Double getMeasure() {
+        return measure;
+    }
+
+    public void setMeasure(final Double measure) {
+        this.measure = measure;
+    }
+
+    @Override
+    /**
+     * Compares timestamps for sorting.
+     *
+     * Note: this comparator imposes orderings that are inconsistent with equals
+     *
+     */
+    public int compare(Value v1, Value v2) {
+        if (v1.getTimestamp().equals(v2.getTimestamp()))
+            return 0;
+        return v1.getTimestamp() > v2.getTimestamp() ? 1 : -1;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (null == o || getClass() != o.getClass())
+            return false;
+
+        if (getTimestamp() != null ? !getTimestamp().equals(((Value) o).getTimestamp())
+                : ((Value) o).getTimestamp() != null)
+            return false;
+        return !(getMeasure() != null ? !getMeasure().equals(((Value) o).getMeasure())
+                : ((Value) o).getMeasure() != null);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(timestamp, measure);
+    }
+
+    @Override
+    public String toString() {
+        return "Value{" + "timestamp=" + timestamp + ", measure=" + measure + "}";
+    }
+}

client/src/main/java/timely/model/parse/Combiner.java

@@ -0,0 +1,6 @@
+package timely.model.parse;
+
+public interface Combiner<T> {
+
+    String combine(T o);
+}

client/src/main/java/timely/model/parse/MetricParser.java

@@ -0,0 +1,30 @@
+package timely.model.parse;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Splitter;
+import timely.model.Metric;
+
+import java.util.List;
+
+public class MetricParser implements Parser<Metric> {
+
+    private static final Splitter spaceSplitter = Splitter.on(" ").omitEmptyStrings().trimResults();
+
+    @Override
+    public Metric parse(String line) {
+
+        // put specification
+        //
+        // put <metricName> <timestamp> <value> <tagK=tagV> <tagK=tagV> ...
+
+        List<String> parts = spaceSplitter.splitToList(line);
+        Preconditions.checkPositionIndex(3, parts.size());
+
+        Metric.Builder builder = Metric.newBuilder();
+        // index 0 is put
+        builder.name(parts.get(1)); // metric name
+        builder.value(Long.parseLong(parts.get(2)), Double.parseDouble(parts.get(3)));
+        parts.stream().skip(4).forEach(builder::tag);
+        return builder.build();
+    }
+}

client/src/main/java/timely/model/parse/Parser.java

@@ -0,0 +1,7 @@
+package timely.model.parse;
+
+@FunctionalInterface
+public interface Parser<T> {
+
+    T parse(String t);
+}

client/src/main/java/timely/model/parse/TagListParser.java

@@ -0,0 +1,54 @@
+package timely.model.parse;
+
+import com.google.common.base.Splitter;
+import timely.model.Tag;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Parses tag1=val1,tag2=val2,tag3=val3 into a {@code List} of {@code Tag}
+ * Combines {@code List} of {@code Tag} into {@code String} of
+ * tag1=val1,tag2=val2,tag3=val3 NOTE: the tag and the value are both URL
+ * encoded and subsequently URL decoded.
+ */
+public class TagListParser implements Parser<List<Tag>>, Combiner<Collection<Tag>> {
+
+    private static final Splitter commaSplitter = Splitter.on(",").omitEmptyStrings();
+    private static final TagParser tagParser = new TagParser();
+
+    @Override
+    public List<Tag> parse(String t) {
+        ArrayList<Tag> tags = new ArrayList<>();
+        commaSplitter.splitToList(t).forEach(p -> tags.add(tagParser.parse(p)));
+        return tags;
+    }
+
+    @Override
+    public String combine(Collection<Tag> tags) {
+        StringBuilder builder = new StringBuilder();
+        if (!tags.isEmpty()) {
+            tags.forEach(p -> builder.append(tagParser.combine(p)).append(','));
+            builder.setLength(builder.length() - 1);
+        }
+        return builder.toString();
+    }
+
+    /**
+     * An alternative combiner for a map of string to string instead of a list
+     * of tags
+     * 
+     * @param tags
+     * @return string representation
+     */
+    public String combine(Map<String, String> tags) {
+        StringBuilder builder = new StringBuilder();
+        if (!tags.isEmpty()) {
+            tags.forEach((k, v) -> builder.append(tagParser.combine(new Tag(k, v))).append(','));
+            builder.setLength(builder.length() - 1);
+        }
+        return builder.toString();
+    }
+}

client/src/main/java/timely/model/parse/TagParser.java

@@ -0,0 +1,53 @@
+package timely.model.parse;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
+import timely.model.Tag;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Parses tag1=val1 into a {@code Tag} Combines {@code Tag} into {@code String}
+ * of tag1=val1 NOTE: the tag and the value are both URL encoded and
+ * subsequently URL decoded.
+ */
+public class TagParser implements Parser<Tag>, Combiner<Tag> {
+
+    private static final Splitter equalSplitter = Splitter.on("=").trimResults();
+    private static final Joiner equalsJoiner = Joiner.on("=");
+
+    @Override
+    public Tag parse(String t) {
+        List<String> parts = equalSplitter.splitToList(t);
+        if (parts.size() != 2) {
+            throw new IllegalArgumentException("Invalid tag format: " + t);
+        }
+        return new Tag(unescape(parts.get(0)), unescape(parts.get(1)));
+    }
+
+    @Override
+    public String combine(Tag t) {
+        return equalsJoiner.join(escape(t.getKey()), escape(t.getValue()));
+    }
+
+    private String escape(String tag) {
+        try {
+            return URLEncoder.encode(tag, "UTF8");
+        } catch (UnsupportedEncodingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private String unescape(String tag) {
+        try {
+            return URLDecoder.decode(tag, "UTF8");
+        } catch (UnsupportedEncodingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}

client/src/main/java/timely/serialize/JsonSerializer.java

@@ -0,0 +1,22 @@
+package timely.serialize;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
+
+public class JsonSerializer {
+
+    private static ObjectMapper mapper = new ObjectMapper();
+
+    static {
+        mapper.registerModule(new Jdk8Module());
+        mapper.configure(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT, true);
+        mapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
+        mapper.configure(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, true);
+    }
+
+    public static ObjectMapper getObjectMapper() {
+        return mapper;
+    }
+}

client/src/main/python/DataOperations.py

@@ -0,0 +1,128 @@
+import time
+from datetime import datetime
+from TimeDateRange import UTC
+import pandas
+import matplotlib.dates as mdates
+import plotly.graph_objs as go
+import plotly.offline as py
+
+utc = UTC()
+
+def pivot(df, metric, groupByColumn=None):
+
+    dataFrame = pandas.DataFrame(df, copy=True)
+    if dataFrame is not None:
+        if groupByColumn is not None:
+            dataFrame = dataFrame.pivot_table(index="date", columns=groupByColumn, values=metric)
+    return dataFrame
+
+
+def resample(df, sample, how='mean', fill_method='ffill'):
+
+    dataFrame = pandas.DataFrame(df, copy=True)
+    if dataFrame is not None:
+        if sample is not None:
+            dataFrame = dataFrame.resample(sample, how=how, fill_method=fill_method)
+    return dataFrame
+
+
+def unpivot(df, metric, groupByColumn=None):
+    dataFrame = pandas.DataFrame(df, copy=True)
+    if dataFrame is not None:
+        dataFrame['date'] = dataFrame.index.values
+        dataFrame = pandas.melt(dataFrame, id_vars=['date'], value_name=metric, var_name=groupByColumn)
+        dataFrame = dataFrame.set_index(dataFrame['date'])
+    return dataFrame
+
+
+def rolling_average(df, metric, rolling_average=None):
+
+    dataFrame = pandas.DataFrame(df, copy=True)
+    if dataFrame is not None:
+        if rolling_average is not None:
+            dataFrame[metric] = pandas.rolling_mean(dataFrame[metric], rolling_average)
+    return dataFrame
+
+
+def graph(analyticConfig, df, metric, seriesConfig={}, graphConfig={}, notebook=False):
+
+    dataFrame = pandas.DataFrame(df, copy=True)
+    if dataFrame is not None:
+        dataFrame['colFromIndex'] = dataFrame.index
+        if analyticConfig.groupByColumn is not None:
+            # sort on date and the groupByColumn so that the series legend is sorted
+            dataFrame = dataFrame.sort_values(['colFromIndex', analyticConfig.groupByColumn])
+        else:
+            dataFrame = dataFrame.sort_values(['colFromIndex'])
+
+        title = None
+        if analyticConfig.sample is None:
+            title = metric
+        else:
+            title = metric + '\rsample ' + analyticConfig.sample
+
+        dataFrame['date'] = dataFrame.index
+
+        layoutConfig = dict(
+            title=title,
+            autosize=False,
+            width=1000,
+            height=700,
+            showlegend=True,
+            xaxis=dict(
+                autorange=True,
+                tickangle=-45
+            ),
+            yaxis=dict(
+                autorange=True,
+                title=title
+            )
+        )
+
+        layoutConfig.update(graphConfig)
+
+        layout = go.Layout(layoutConfig)
+
+        data = None
+        for col in df[analyticConfig.groupByColumn].unique():
+            tempDataFrame = dataFrame.loc[dataFrame[analyticConfig.groupByColumn] == col]
+
+            addlColConfig = graphConfig.get(col, graphConfig.get('default', dict()))
+
+            config = dict(
+                name=col,
+                x=tempDataFrame.index,
+                y=tempDataFrame[metric],
+                hoverinfo='x+y+text',
+                text=col
+            )
+
+            config.update(addlColConfig)
+
+            s = go.Scatter(config)
+
+            if data is None:
+                data = [s]
+            else:
+                data.append(s)
+
+        now = datetime.now(tz=utc)
+        format = "%Y%m%d%H%M%S"
+        nowStr = time.strftime(format, now.timetuple())
+
+        fileNameBase = analyticConfig.output_dir + "/" + metric
+        if analyticConfig.sample is not None:
+            fileNameBase += "-" + analyticConfig.sample
+        if analyticConfig.how is not None:
+            fileNameBase += "-" + analyticConfig.how
+
+        fig = go.Figure(data=data, layout=layout)
+        if notebook:
+            py.iplot(fig, filename=fileNameBase+'-'+nowStr, show_link=False)
+        else:
+            py.plot(fig, output_type='file', filename=fileNameBase+'-'+nowStr+'.html', auto_open=False, show_link=False)
+
+
+def datetime2graphdays(dt):
+
+    return mdates.epoch2num((time.mktime(dt.timetuple()) / 86400) * mdates.SEC_PER_DAY)

client/src/main/python/TimeDateRange.py

@@ -0,0 +1,124 @@
+import time
+from datetime import datetime
+from datetime import timedelta
+from datetime import tzinfo
+
+class TimeDateError(ValueError):
+
+    def __init__(self, message, *args):
+        self.message = message
+        super(TimeDateError, self).__init__(message, *args)
+
+
+ZERO = timedelta(0)
+
+# A UTC class.
+class UTC(tzinfo):
+    """UTC"""
+
+    def __str__(self):
+        return "UTC"
+
+    def utcoffset(self, dt):
+        return ZERO
+
+    def tzname(self, dt):
+        return "UTC"
+
+    def dst(self, dt):
+        return ZERO
+
+utc = UTC()
+
+class TimeDateRange:
+
+    beginDt = None
+    endDt = None
+    format = "%Y%m%d %H%M%S"
+
+    def getBeginMs(self):
+        if self.beginDt == None:
+            return None
+        return int(time.mktime(self.beginDt.timetuple()) * 1000)
+
+    def getBeginStr(self):
+        if self.beginDt == None:
+            return None
+        return time.strftime(self.format, self.beginDt.timetuple())
+
+    def getEndMs(self):
+        if self.endDt == None:
+            return None
+        return int(time.mktime(self.endDt.timetuple()) * 1000)
+
+    def getEndStr(self):
+        if self.endDt == None:
+            return None
+        return time.strftime(self.format, self.endDt.timetuple())
+
+    def __init__(self, beginStr, endStr, hours, format="%Y%m%d-%H%M%S"):
+
+        now = datetime.now(tz=utc)
+        nowMs = TimeDateRange.unix_time_millis(now)
+
+        if beginStr != None and endStr != None and hours != None:
+            raise TimeDateError("You can not privide a begin, end, and hours")
+        elif (beginStr == None and endStr == None and hours == None) or (hours == None and beginStr == None):
+            raise TimeDateError("You must provide a time range")
+
+        if hours == None:
+            # calculate begin time
+            beginTuple = time.strptime(beginStr, self.format)
+            self.beginDt = datetime(*beginTuple[0:6], tzinfo=utc)
+
+            # calculate end time
+            # end is either specified or now
+            if endStr == None or endStr == 'now':
+                self.endDt = now
+            else:
+
+                self.endDt = datetime(*time.strptime(endStr, self.format)[0:6], tzinfo=utc)
+                if self.endDt > now:
+                    self.endDt = now
+        else:
+            # hours must be specified
+            rangeInSec = hours * 3600
+            if beginStr == None:
+                # calculate begin time from end tme and hours
+
+                # calculate end time
+                # end is either specified or now
+                if endStr == None or endStr == 'now':
+                    self.endDt = now
+                else:
+                    self.endDt = datetime(*time.strptime(endStr, self.format)[0:6], tzinfo=utc)
+                    if self.endDt > now:
+                        self.endDt = now
+
+                # calculate begin time
+                self.beginDt = self.endDt - timedelta(milliseconds=rangeInSec * 1000)
+
+            else:
+                # calculate end time from begin tme and hours
+                # calculate begin time
+                self.beginDt = datetime(*time.strptime(beginStr, self.format)[0:6], tzinfo=utc)
+
+                # calculate end time
+                self.endDt = self.beginDt + timedelta(milliseconds=rangeInSec * 1000)
+
+                if self.endDt > now:
+                    self.endDt = now
+
+        if self.beginDt > now:
+            raise TimeDateError("begin date/time can not be in the future")
+
+        if self.beginDt > self.endDt:
+            raise TimeDateError("begin date/time can not be past end date/time")
+
+    epoch = datetime.utcfromtimestamp(0).replace(tzinfo=utc)
+
+    @classmethod
+    def unix_time_millis(cls, dt):
+        return (dt - TimeDateRange.epoch).total_seconds() * 1000.0
+
+

client/src/main/python/TimelyAlert.py

@@ -0,0 +1,123 @@
+import smtplib
+from os.path import basename
+from email.mime.application import MIMEApplication
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.utils import COMMASPACE, formatdate
+from TimelyMetric import graph
+import syslog
+
+syslog.openlog("TimelyNotifications")
+
+#def __init__(self, file, send_to, subject, text, analyticConfig, notebook):
+
+
+class TimelyAlert():
+
+    def __init__(self, timelyMetric, dataFrame, seriesConfig, analyticConfig, notebook):
+        self.timelyMetric = timelyMetric
+        self.dataFrame = dataFrame
+        self.seriesConfig = seriesConfig
+        self.analyticConfig = analyticConfig
+        self.notebook = notebook
+
+    def createFilename(self, metric, config):
+
+        metricTitle = metric
+        if config.sample is not None:
+            sampleTitle = config.sample + "-" + config.how
+
+        filename = metricTitle
+        if sampleTitle != "":
+            filename += "-" + sampleTitle
+
+        return filename
+
+    def createTitle(self, metric, config):
+
+        if config.orCondition:
+            condition = "OR"
+        else:
+            condition = "AND"
+
+        metricTitle = metric
+        sampleTitle = ""
+        alertTitle = ""
+        if config.sample is not None:
+            sampleTitle = config.sample + " " + config.how + " samples"
+
+        if config.min_threshold is not None:
+            if alertTitle != "":
+                alertTitle += " " + condition + " "
+            alertTitle += "(y < " + str(config.min_threshold) + ")"
+
+        if config.max_threshold is not None:
+            if alertTitle != "":
+                alertTitle += " " + condition + " "
+            alertTitle += "(y > " + str(config.max_threshold) + ")"
+
+        if config.alert_percentage is not None:
+            if alertTitle != "":
+                alertTitle += " " + condition + " "
+            if config.alert_percentage > 0:
+                alertTitle += "(y > " + str(config.alert_percentage) + "% above " + str(config.rolling_average) + " sample average)"
+            else:
+                alertTitle += "(y < " + str(-config.alert_percentage) + "% below " + str(config.rolling_average) + " sample average)"
+
+        title = metricTitle
+        if sampleTitle != "":
+            title += "\n" + sampleTitle
+
+        if alertTitle != "":
+            title += "\n" + alertTitle
+
+        return title
+
+    def notify(self, send_from, send_to, server="127.0.0.1"):
+
+        self.graph()
+
+        return
+
+    def email(self, send_from, send_to, subject, text, files=None, server="127.0.0.1"):
+        assert isinstance(send_to, list)
+
+        msg = MIMEMultipart()
+        msg['From'] = send_from
+        msg['To'] = COMMASPACE.join(send_to)
+        msg['Date'] = formatdate(localtime=True)
+        msg['Subject'] = subject
+
+        msg.attach(MIMEText(text))
+
+        for f in files or []:
+            with open(f, "rb") as fil:
+                part = MIMEApplication(
+                    fil.read(),
+                    Name=basename(f)
+                )
+                part['Content-Disposition'] = 'attachment; filename="%s"' % basename(f)
+                msg.attach(part)
+
+
+        smtp = smtplib.SMTP(server)
+        smtp.sendmail(send_from, send_to, msg.as_string())
+        smtp.close()
+
+    def graph(self):
+
+        graphConfig = {}
+        graphConfig["title"] = self.createTitle(self.timelyMetric.metric, self.analyticConfig)
+        graph(self.analyticConfig, self.dataFrame, self.timelyMetric.metric, seriesConfig=self.seriesConfig, graphConfig=graphConfig, notebook=self.notebook)
+
+
+def main():
+    #syslog.syslog(syslog.LOG_ALERT, "Example message")
+    a = TimelyAlert(None, None, None, None, False)
+
+    a.email_alert("wwoley@localhost", ["wwoley@localhost"], "Test1", "This is a sendmail test")
+
+
+
+if __name__ == '__main__':
+    main()

client/src/main/python/TimelyAnalytic.py

@@ -0,0 +1,105 @@
+import TimelyMetric
+from TimeDateRange import TimeDateRange
+from TimeDateRange import UTC
+from datetime import datetime
+import pandas
+import re
+import plotly
+from TimelyAlert import TimelyAlert
+
+utc = UTC()
+plotly.offline.init_notebook_mode()
+
+def logTiming(timelyMetric, startTime, stopTime):
+    df = timelyMetric.getDataFrame()
+    print("start: " + str(startTime))
+    print("stop: " + str(stopTime))
+    print("num records: " + str(len(df)))
+    elapsedSec = (TimeDateRange.unix_time_millis(stopTime) - TimeDateRange.unix_time_millis(startTime)) / 1000
+    print("elapsed seconds: " + str(elapsedSec))
+    recPerSec = len(df) / elapsedSec
+    print("records per second: " + recPerSec)
+
+def addCondition(orCondition, currResult, condition):
+    if orCondition:
+        currResult = currResult | condition
+    else:
+        currResult = currResult & condition
+    return currResult
+
+def find_alerts(timelyMetric, analyticConfig, notebook=False):
+
+    if analyticConfig.groupByColumn is None:
+        return
+
+    df = timelyMetric.getDataFrame()
+
+    graphDF = TimelyMetric.pivot(df, timelyMetric.metric, groupByColumn=analyticConfig.groupByColumn)
+
+    if analyticConfig.sample is not None:
+        graphDF = TimelyMetric.resample(graphDF, analyticConfig.sample, how=analyticConfig.how)
+
+    if analyticConfig.excludeColRegex is not None:
+        graphDF = graphDF.select(lambda x : not (re.search(analyticConfig.excludeColRegex, x)), axis=1)
+    if analyticConfig.includeColRegex is not None:
+        graphDF = graphDF.select(lambda x : re.search(analyticConfig.includeColRegex, x), axis=1)
+
+    graphDF_avg = pandas.DataFrame(graphDF, copy=True)
+
+    combined = pandas.DataFrame()
+
+    seriesConfig = {}
+    for i in graphDF_avg.columns:
+        col = str(i)
+
+        result = True
+        if analyticConfig.orCondition:
+            result = False
+
+        if analyticConfig.min_threshold is not None:
+            currCondition = graphDF[col].astype(float) < analyticConfig.min_threshold
+            result = addCondition(analyticConfig.orCondition, result, currCondition)
+
+        if analyticConfig.max_threshold is not None:
+            currCondition = graphDF[col].astype(float) > analyticConfig.max_threshold
+            result = addCondition(analyticConfig.orCondition, result, currCondition)
+
+        graphDF_avg = TimelyMetric.rolling_average(graphDF_avg, str(i), rolling_average=analyticConfig.rolling_average)
+        if (analyticConfig.alert_percentage is not None) and (analyticConfig.rolling_average is not None):
+            if analyticConfig.alert_percentage > 0:
+                multiple = 1.0 + (float(abs(analyticConfig.alert_percentage)) / float(100))
+                currCondition = graphDF[col].astype(float) > (graphDF_avg[col].astype(float) * multiple)
+                result = addCondition(analyticConfig.orCondition, result, currCondition)
+            if analyticConfig.alert_percentage < 0:
+                multiple = 1.0 - (float(abs(analyticConfig.alert_percentage)) / float(100))
+                if multiple > 0:
+                    currCondition = graphDF[col].astype(float) < (graphDF_avg[col].astype(float) * multiple)
+                    result = addCondition(analyticConfig.orCondition, result, currCondition)
+
+        exceptional = graphDF.loc[result, col]
+        if (analyticConfig.display.lower() == "all") or (analyticConfig.display.lower() == "alerts" and exceptional.size > 0):
+            combined[col] = graphDF[col]
+
+        if (analyticConfig.display.lower() == "all") or (analyticConfig.display.lower() == "alerts" and exceptional.size > 0 and analyticConfig.alert_percentage is not None and analyticConfig.rolling_average is not None):
+            combined[col+'_avg'] = graphDF_avg[col]
+
+        if (exceptional.size > 0):
+            combined[col+'_warn'] = exceptional.dropna()
+            seriesConfig[col+'_warn'] = {
+                "mode" : "markers",
+                "marker" : {
+                    "symbol" : "hash-open",
+                    "color" : "red"
+                }
+            }
+
+
+
+    timelyAlert = None
+    if not combined.empty:
+        combined = TimelyMetric.unpivot(combined, timelyMetric.metric, groupByColumn=analyticConfig.groupByColumn)
+        combined = combined.sort_index()
+        combined = combined.sort_values(['date', analyticConfig.groupByColumn])
+        timelyAlert = TimelyAlert(timelyMetric, combined, seriesConfig, analyticConfig, notebook)
+
+    return timelyAlert

client/src/main/python/TimelyAnalyticConfiguration.py

@@ -0,0 +1,25 @@
+
+
+
+class TimelyAnalyticConfiguration():
+
+
+    def __init__(self, analyticConfig):
+
+        self.groupByColumn = analyticConfig.get('groupByColumn', None)
+        self.includeColRegex = analyticConfig.get('includeColRegex', None)
+        self.excludeColRegex = analyticConfig.get('excludeColRegex', None)
+        self.sample = analyticConfig.get('sample', None)
+        self.how = analyticConfig.get('how', 'mean')
+        self.rolling_average = analyticConfig.get('rolling_average', None)
+        self.min_threshold = analyticConfig.get('min_threshold', None)
+        self.max_threshold = analyticConfig.get('max_threshold', None)
+        self.alert_percentage = analyticConfig.get('alert_percentage', None)
+        boolean = analyticConfig.get('boolean', 'or')
+        self.orCondition = boolean == 'or' or boolean == 'OR'
+        # alerts or all
+        self.display = analyticConfig.get('display', 'alerts')
+        self.send_alerts_to = analyticConfig.get('send_alerts_to', [])
+        self.output_dir = analyticConfig.get('output_dir', '/tmp')
+
+

client/src/main/python/TimelyMetric.py

@@ -0,0 +1,212 @@
+from TimeDateRange import TimeDateRange
+from TimeDateRange import TimeDateError
+from TimeDateRange import UTC
+from DataOperations import *
+import json
+import pandas
+import getopt
+import sys
+import random
+
+from WebSocketClient import WebSocketClient
+from tornado import ioloop
+
+utc = UTC()
+
+class TimelyWebSocketClient(WebSocketClient):
+
+    def __init__(self, hostport, metric, tags, startTime, endTime, connect_timeout=WebSocketClient.DEFAULT_CONNECT_TIMEOUT,
+                 request_timeout=WebSocketClient.DEFAULT_REQUEST_TIMEOUT):
+
+        self.metric = metric
+        self.tags = tags
+        self.startTime = startTime
+        self.endTime = endTime
+        self.subscriptionId = random.randint(1000000000, 9999999999)
+        WebSocketClient.__init__(self, hostport, connect_timeout, request_timeout)
+
+    def _on_message(self, msg):
+        # implement in subclass
+        pass
+
+    def _on_connection_success(self):
+        print('Connected.')
+
+        create = {
+            "operation": "create",
+            "subscriptionId": self.subscriptionId,
+        }
+        self.send(create)
+        self.send(create)
+
+        m1 = {
+            "operation": "add",
+            "subscriptionId": self.subscriptionId,
+            "metric": self.metric,
+            "startTime": self.startTime,
+            "endTime" : self.endTime
+        }
+
+        if self.tags is not None:
+            t = self.tags.strip().split(',')
+            tagDict = {}
+            for pair in t:
+                k = pair.split('=')[0].strip()
+                v = pair.split('=')[1].strip()
+                tagDict = dict(tagDict.items() + dict({k : v}).items())
+            m1["tags"] = tagDict
+
+        self.send(m1)
+
+    def _on_connection_close(self):
+        print('Connection closed!')
+        exit()
+
+    def _on_connection_error(self, exception):
+        print('Connection error: %s', exception)
+
+
+
+
+class TimelyMetric(TimelyWebSocketClient):
+
+    client = None
+    endtime = None
+
+    def __init__(self, hostport, metric, tags, beginStr, endStr, hours, sample):
+        self.series = pandas.Series()
+        self.metric = metric
+        self.tags = tags
+        self.sample = sample
+        self.debug = False
+        self.dataFrame = None
+        self.data = []
+
+        timeDateRange = TimeDateRange(beginStr, endStr, hours)
+
+        TimelyWebSocketClient.__init__(self, hostport, metric, tags, timeDateRange.getBeginMs(), timeDateRange.getEndMs())
+
+    def debugOn(self):
+        self.debug = True
+
+    def debugOff(self):
+        self.debug = False
+
+    def fetch(self):
+
+        ioloop.IOLoop().make_current()
+        self.connect(ioloop.IOLoop.current(instance=False))
+        ioloop.IOLoop.current(instance=False).start()
+        return self
+
+
+    def _on_message(self, msg):
+
+        global df
+        global endtime
+
+        responsesObj = json.loads(msg)
+        responses = responsesObj.get("responses")
+
+        for obj in responses:
+            complete = bool(obj.get("complete"))
+            if complete:
+                self._on_connection_close()
+                return
+            else:
+                date = int(obj.get("timestamp")/1000)
+                dt = pandas.datetime.utcfromtimestamp(date)
+                metricName = str(obj.get("metric"))
+                metricValue = obj.get("value")
+
+                newData = {}
+                newData["date"] = dt
+                newData[metricName] = metricValue
+
+                tags = obj.get("tags")
+                for d in tags:
+                    for k,v in d.items():
+                        newData[k] = v
+
+                self.data.append(newData)
+
+
+    def _on_connection_close(self):
+        global client
+
+        self.dataFrame = pandas.DataFrame(self.data)
+        self.dataFrame = self.dataFrame.set_index(self.dataFrame['date'].apply(lambda x: pandas.DatetimeIndex([x])))
+
+
+        self.close()
+        ioloop.IOLoop.current(instance=False).stop()
+        print("Exiting.")
+
+    def getDataFrame(self):
+
+        return self.dataFrame;
+
+    def print_debug(self):
+        if self.debug:
+            print(self.dataFrame)
+
+    def graph(self, groupByColumn=None):
+        graph(self.dataFrame, self.metric, sample=self.sample, how=self.how, groupByColumn=groupByColumn)
+
+
+
+def main():
+
+    hours = None
+    beginStr = None
+    endStr = None
+
+    metric = "timely.metrics.received"
+    sample = None
+    how = None
+    tags = None
+    groupByColumn = None
+    try:
+        argv = sys.argv
+        options, remainder = getopt.getopt(argv[1:], 'h', ['metric=', 'tags=', 'hours=', 'groupByColumn=', 'begin=', 'end=', 'sample=', 'how=', 'hostport='])
+    except getopt.GetoptError:
+        print('TimelyMetric.py ---hostport=<host:port> --metric=<metric> --tags=<tag1=val1,tag2=val2> --hours=<hours>, --groupByColumn=<groupByColumn>, --sample=<sample_period> --how=<mean|min|max>')
+        sys.exit(2)
+    for opt, arg in options:
+        if opt == '-h':
+            print('TimelyMetric.py --hostport=<host:port> --metric=<metric> --tags=<tag1=val1,tag2=val2> --hours=<hours>, --groupByColumn=<groupByColumn>, --sample=<sample_period> --how=<mean|min|max>')
+            sys.exit()
+        elif opt in ("--metric"):
+            metric = arg
+        elif opt in ("--hours"):
+            hours = int(arg)
+        elif opt in ("--begin"):
+            beginStr = arg
+        elif opt in ("--end"):
+            endStr = arg
+        elif opt in ("--groupByColumn"):
+            groupByColumn = arg
+        elif opt in ("--sample"):
+            sample = arg
+        elif opt in ("--how"):
+            how = arg
+        elif opt in ("--hostport"):
+            hostport = arg
+    try:
+
+        timelyMetric = TimelyMetric(hostport, metric, tags, beginStr, endStr, hours, sample).fetch()
+        dataFrame = timelyMetric.getDataFrame()
+
+        if dataFrame is not None:
+            dataFrame = resample(dataFrame, metric, sample, how)
+            dataFrame = pivot(dataFrame, metric, groupByColumn=groupByColumn)
+            graph(dataFrame, metric, sample=sample, groupByColumn=groupByColumn, graphConfig={}, notebook=False)
+
+    except TimeDateError as e:
+        print(e.message)
+
+if __name__ == '__main__':
+    main()
+
+
+

client/src/main/python/WebSocketClient.py

@@ -0,0 +1,91 @@
+from tornado import escape
+from tornado import gen
+from tornado import ioloop
+from tornado import websocket
+
+import json
+
+
+class WebSocketClient():
+    """Base for web socket clients.
+    """
+
+    DEFAULT_CONNECT_TIMEOUT = 60
+    DEFAULT_REQUEST_TIMEOUT = 60
+    APPLICATION_JSON = 'application/json'
+
+    def __init__(self, hostport, connect_timeout=DEFAULT_CONNECT_TIMEOUT,
+                 request_timeout=DEFAULT_REQUEST_TIMEOUT):
+
+        self.connect_timeout = connect_timeout
+        self.request_timeout = request_timeout
+        self.url = 'wss://' + hostport + '/websocket'
+
+    def connect(self, ioloop=ioloop.IOLoop.current(instance=False)):
+        """Connect to the server.
+        :param str url: server URL.
+        """
+        request = websocket.httpclient.HTTPRequest(self.url, connect_timeout=self.connect_timeout, request_timeout=self.request_timeout, validate_cert=False)
+        websocket.websocket_connect(request, io_loop=ioloop, callback=self._connect_callback)
+
+    def send(self, data):
+        """Send message to the server
+        :param str data: message.
+        """
+        if not self._ws_connection:
+            raise RuntimeError('Web socket connection is closed.')
+
+        self._ws_connection.write_message(escape.utf8(json.dumps(data)))
+
+    def close(self):
+        """Close connection.
+        """
+        if not self._ws_connection:
+            raise RuntimeError('Web socket connection is already closed.')
+
+        self._ws_connection.close()
+        self._ws_connection = None
+
+    def _connect_callback(self, future):
+        if future.exception() is None:
+            self._ws_connection = future.result()
+            self._on_connection_success()
+            self._read_messages()
+        else:
+            self._on_connection_error(future.exception())
+
+    @gen.coroutine
+    def _read_messages(self):
+        while True and not self._ws_connection is None:
+            msg = yield self._ws_connection.read_message()
+            if msg is None:
+                self._on_connection_close()
+                break
+
+            self._on_message(msg)
+
+    def _on_message(self, msg):
+        """This is called when new message is available from the server.
+        :param str msg: server message.
+        """
+
+        pass
+
+    def _on_connection_success(self):
+        """This is called on successful connection ot the server.
+        """
+
+        pass
+
+    def _on_connection_close(self):
+        """This is called when server closed the connection.
+        """
+        pass
+
+    def _on_connection_error(self, exception):
+        """This is called in case if connection to the server could
+        not established.
+        """
+
+        pass
+

client/src/main/python/sampleAnalytic.py

@@ -0,0 +1,23 @@
+import TimelyMetric
+import TimelyAnalytic
+
+hostport = "127.0.0.1:4244"
+timelyMetric = TimelyMetric.TimelyMetric(hostport, '', None, None, None, 48, None).fetch()
+TimelyAnalytic.find_alerts(timelyMetric, TimelyAnalyticConfiguration({
+    'includeColRegex' : None,
+    'excludeColRegex' : None,
+    'groupByColumn' : 'instance',
+    'sample' : '10min',
+    'how' : 'mean',
+    'rolling_average' : 12,
+    'min_threshold' : None,
+    'max_threshold' : None,
+    'alert_percentage' : 25,
+    'boolean' : 'and'
+    'display' : 'all',
+    'output_dir' : '/path/to/output'
+}))
+
+if alert is not None:
+    alert.graph()
+

client/src/main/resources/findbugs-excludes.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<FindBugsFilter>
+  <Or>
+    <Bug pattern="DM_DEFAULT_ENCODING"/>
+    <Method name="connect" />
+    <Class name="timely.client.tcp.TcpClient"/>
+  </Or>
+</FindBugsFilter>

client/src/test/java/timely/api/SerializationTest.java

@@ -0,0 +1,58 @@
+package timely.api;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import timely.serialize.JsonSerializer;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class SerializationTest {
+
+    private ObjectMapper mapper = JsonSerializer.getObjectMapper();
+
+    @Test
+    public void testBasicAuth() throws Exception {
+        BasicAuthLogin login = new BasicAuthLogin();
+        login.setUsername("test");
+        login.setPassword("pass");
+        testSerialization(login);
+    }
+
+    @Test
+    public void testCreateSubscription() throws Exception {
+        CreateSubscription create = new CreateSubscription();
+        create.setSubscriptionId("1234");
+        testSerialization(create);
+    }
+
+    @Test
+    public void testCloseSubscription() throws Exception {
+        CloseSubscription close = new CloseSubscription();
+        close.setSubscriptionId("1234");
+        testSerialization(close);
+    }
+
+    @Test
+    public void testAddSubscription() throws Exception {
+        AddSubscription add = new AddSubscription();
+        add.setSubscriptionId("1234");
+        add.setMetric("sys.cpu.user");
+        testSerialization(add);
+    }
+
+    @Test
+    public void testRemoveSubscription() throws Exception {
+        RemoveSubscription remove = new RemoveSubscription();
+        remove.setSubscriptionId("1234");
+        remove.setMetric("sys.cpu.user");
+        testSerialization(remove);
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> void testSerialization(T o) throws Exception {
+        String ser = mapper.writeValueAsString(o);
+        T des = mapper.readValue(ser, (Class<T>) o.getClass());
+        Assert.assertEquals(o, des);
+    }
+}

client/src/test/java/timely/model/MetricTest.java

@@ -0,0 +1,63 @@
+package timely.model;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ *
+ *
+ *
+ */
+public class MetricTest {
+
+    @Test
+    public void testEquals() {
+        Metric m1 = Metric.newBuilder().name("m1").tag("t1", "v1").tag("t2", "v2").value(1, 0.0).build();
+        Metric m2 = Metric.newBuilder().name("m1").tag("t2", "v2").tag("t1", "v1").value(1, 0.0).build();
+
+        assertTrue(m1.equals(m2));
+        assertTrue(m2.equals(m1));
+
+        Metric m3 = Metric.newBuilder().name("m1").tag("t1", "v1").value(1, 0.0).build();
+        assertFalse(m1.equals(m3));
+
+        Metric m4 = Metric.newBuilder().name("m4").tag("t2", "v2").tag("t1", "v1").value(1, 0.0).build();
+        assertFalse(m1.equals(m4));
+
+        Metric m5 = Metric.newBuilder().name("m1").tag("t3", "v3").tag("t2", "v2").tag("t1", "v1").value(1, 0.0)
+                .build();
+        assertFalse(m1.equals(m5));
+
+        Metric m6 = Metric.newBuilder().name("m1").tag("t2", "v2").tag("t1", "v1").value(2, 0.0).build();
+        assertFalse(m1.equals(m6));
+
+        Metric m7 = Metric.newBuilder().name("m1").tag("t2", "v2").tag("t1", "v1").value(1, 1.0).build();
+        assertFalse(m1.equals(m7));
+    }
+
+    @Test
+    public void testJson() throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+
+        String expectedJson = "{\"name\":\"m1\",\"timestamp\":1,\"measure\":1.0,\"tags\":[{\"k1\":\"v1\"}]}";
+
+        Metric m1 = Metric.newBuilder().name("m1").tag("k1", "v1").value(1, 1.0).build();
+
+        Metric expectedMetric = mapper.readValue(expectedJson, Metric.class);
+
+        assertTrue(m1.equals(expectedMetric));
+
+        expectedJson = "{\"name\":\"m1\",\"tags\":[{\"k1\":\"v1\"}],\"timestamp\":5,\"measure\":5.0}";
+        expectedMetric = mapper.readValue(expectedJson, Metric.class);
+
+        assertEquals((long) expectedMetric.getValue().getTimestamp(), 5L);
+        assertEquals(expectedMetric.getValue().getMeasure(), 5.0D, 0.0);
+
+    }
+}

client/src/test/java/timely/model/TagListParserTest.java

@@ -0,0 +1,58 @@
+package timely.model;
+
+import org.junit.Assert;
+import org.junit.Test;
+import timely.model.parse.TagListParser;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class TagListParserTest {
+
+    @Test
+    public void testListParse() {
+        String value = "tag1=value1,tag2=value2";
+        List<Tag> tags = new TagListParser().parse(value);
+        Assert.assertEquals(2, tags.size());
+        Assert.assertEquals(new Tag("tag1", "value1"), tags.get(0));
+        Assert.assertEquals(new Tag("tag2", "value2"), tags.get(1));
+    }
+
+    @Test
+    public void testListParseEncoded() {
+        String value = "tag%2C%3D%31=value%2C%3D%31,tag%2C%3D%32=value%2C%3D%32";
+        List<Tag> tags = new TagListParser().parse(value);
+        Assert.assertEquals(2, tags.size());
+        Assert.assertEquals(new Tag("tag,=1", "value,=1"), tags.get(0));
+        Assert.assertEquals(new Tag("tag,=2", "value,=2"), tags.get(1));
+    }
+
+    @Test
+    public void testListCombine() {
+        List<Tag> tags = new ArrayList<>();
+        tags.add(new Tag("tag1", "value1"));
+        tags.add(new Tag("tag2", "value2"));
+        String combined = new TagListParser().combine(tags);
+        Assert.assertEquals("tag1=value1,tag2=value2", combined);
+    }
+
+    @Test
+    public void testListCombineEncoded() {
+        List<Tag> tags = new ArrayList<>();
+        tags.add(new Tag("tag,=1", "value,=1"));
+        tags.add(new Tag("tag,=2", "value,=2"));
+        String combined = new TagListParser().combine(tags);
+        Assert.assertEquals("tag%2C%3D1=value%2C%3D1,tag%2C%3D2=value%2C%3D2", combined);
+    }
+
+    @Test
+    public void testListCombineMap() {
+        Map<String, String> map = new TreeMap<>();
+        map.put("tag1", "value1");
+        map.put("tag2", "value2");
+        String combined = new TagListParser().combine(map);
+        Assert.assertEquals("tag1=value1,tag2=value2", combined);
+    }
+}

collectd-nsq-plugin/pom.xml

@@ -0,0 +1,69 @@
+<?xml version="1.0"?>
+<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/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>timely</groupId>
+        <artifactId>timely</artifactId>
+        <version>0.0.4</version>
+    </parent>
+    <artifactId>collectd-nsq-plugin</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>collectd</groupId>
+            <artifactId>collectd-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>timely</groupId>
+            <artifactId>collectd-plugin-parent</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.7</source>
+                    <target>1.7</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>findbugs-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <configuration>
+                    <artifactSet>
+                        <includes>
+                    </includes>
+                    </artifactSet>
+                    <createDependencyReducedPom>false</createDependencyReducedPom>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>shade</id>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <phase>package</phase>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>net.revelc.code</groupId>
+                <artifactId>formatter-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>buildnumber-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>

collectd-nsq-plugin/src/main/java/timely/collectd/plugin/WriteNSQPlugin.java

@@ -0,0 +1,149 @@
+package timely.collectd.plugin;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.Random;
+
+import org.apache.http.HttpStatus;
+import org.apache.http.client.entity.EntityBuilder;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.util.EntityUtils;
+import org.collectd.api.Collectd;
+import org.collectd.api.CollectdConfigInterface;
+import org.collectd.api.CollectdShutdownInterface;
+import org.collectd.api.CollectdWriteInterface;
+import org.collectd.api.OConfigItem;
+import org.collectd.api.ValueList;
+
+/**
+ *
+ * CollectD plugin that writes metrics collected by the StatsD plugin to NSQ.
+ * NSQ can be configured to write statsd metrics to CollectD. If you do this,
+ * set the statsd prefix in NSQ to 'nsq'.
+ *
+ */
+public class WriteNSQPlugin extends CollectDPluginParent implements CollectdConfigInterface, CollectdShutdownInterface,
+        CollectdWriteInterface {
+
+    private String host = null;
+    private int port = 0;
+    private String topic = "metrics#ephemeral";
+    private String endpoint = null;
+    private ByteArrayOutputStream baos = null;
+    private DataOutputStream out = null;
+
+    private CloseableHttpClient client = HttpClients.createDefault();
+
+    public WriteNSQPlugin() {
+        Collectd.registerConfig(WriteNSQPlugin.class.getName(), this);
+        Collectd.registerShutdown(WriteNSQPlugin.class.getName(), this);
+        Collectd.registerWrite(WriteNSQPlugin.class.getName(), this);
+    }
+
+    public synchronized int write(ValueList vl) {
+        baos = new ByteArrayOutputStream();
+        out = new DataOutputStream(baos);
+        super.process(vl);
+        try {
+            out.flush();
+            HttpPost post = new HttpPost(endpoint);
+            EntityBuilder request = EntityBuilder.create();
+            request.setBinary(baos.toByteArray());
+            post.setEntity(request.build());
+            CloseableHttpResponse response = client.execute(post);
+            try {
+                int code = response.getStatusLine().getStatusCode();
+                String msg = response.getStatusLine().getReasonPhrase();
+                // Consume the entire response so the connection will be reused
+                EntityUtils.consume(response.getEntity());
+                if (code != HttpStatus.SC_OK) {
+                    Collectd.logInfo("Code: " + code + ", msg: " + msg);
+                }
+            } finally {
+                response.close();
+            }
+        } catch (IOException e) {
+            Collectd.logError("Error sending metrics to NSQ: " + e.getMessage());
+        } finally {
+            if (null != out) {
+                try {
+                    out.close();
+                    out = null;
+                } catch (IOException e) {
+                }
+            }
+        }
+        return 0;
+    }
+
+    @Override
+    public synchronized void write(String metric) {
+        try {
+            out.writeBytes(metric);
+        } catch (IOException e) {
+            Collectd.logError("Error writing metric: " + e.getMessage());
+            try {
+                out.close(); // Should cause IOException in write.
+            } catch (IOException e1) {
+            }
+        }
+    }
+
+    public void flush() {
+    }
+
+    public synchronized int shutdown() {
+        Collectd.logInfo("Shutting down connection to NSQ at " + host + ":" + port);
+        try {
+            client.close();
+        } catch (IOException e) {
+            Collectd.logError("Error closing HttpClient: " + e.getMessage());
+        }
+        return 0;
+    }
+
+    public synchronized int config(OConfigItem config) {
+        super.config(config);
+        for (OConfigItem child : config.getChildren()) {
+            switch (child.getKey()) {
+                case "host":
+                case "hostname":
+                case "Host":
+                case "HostName":
+                    String hostString = child.getValues().get(0).getString();
+                    String[] hosts = hostString.split(",");
+                    if (hosts.length == 1) {
+                        host = hosts[0];
+                    } else {
+                        host = hosts[new Random().nextInt(hosts.length)];
+                    }
+                    break;
+                case "Port":
+                case "port":
+                    port = Integer.parseInt(child.getValues().get(0).getString());
+                    break;
+                case "topic":
+                case "Topic":
+                    topic = child.getValues().get(0).getString();
+                    break;
+                default:
+            }
+        }
+        this.endpoint = "http://" + host + ":" + port + "/mpub?topic=" + topic;
+        if (null != host) {
+            return 0;
+        }
+        if (host == null) {
+            Collectd.logError("NSQ host must be configured");
+        }
+        if (port == 0) {
+            Collectd.logError("NSQ port must be configured");
+        }
+        return -1;
+    }
+
+}

collectd-nsq-plugin/src/main/resources/findbugs-excludes.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<FindBugsFilter>
+</FindBugsFilter>

collectd-plugin-parent/pom.xml

@@ -0,0 +1,64 @@
+<?xml version="1.0"?>
+<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/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>timely</groupId>
+        <artifactId>timely</artifactId>
+        <version>0.0.4</version>
+    </parent>
+    <artifactId>collectd-plugin-parent</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>collectd</groupId>
+            <artifactId>collectd-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>net.jcip</groupId>
+            <artifactId>jcip-annotations</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-easymock-release-full</artifactId>
+            <classifier>full</classifier>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.7</source>
+                    <target>1.7</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>findbugs-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>net.revelc.code</groupId>
+                <artifactId>formatter-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>buildnumber-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>

collectd-plugin-parent/src/main/java/timely/collectd/plugin/CollectDPluginParent.java

@@ -0,0 +1,249 @@
+package timely.collectd.plugin;
+
+import java.text.MessageFormat;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.collectd.api.Collectd;
+import org.collectd.api.DataSource;
+import org.collectd.api.OConfigItem;
+import org.collectd.api.ValueList;
+
+public abstract class CollectDPluginParent {
+
+    private static final String PUT = "put {0} {1} {2}{3}\n";
+    private static final Pattern HADOOP_STATSD_PATTERN = Pattern
+            .compile("([\\w-_]+)\\.([\\w-_]+)\\.([\\w-_]+)\\.([\\w-_]+)");
+    private static final String INSTANCE = " instance=";
+    private static final String SAMPLE = " sample=";
+    private static final String CODE = " code=";
+    private static final String PERIOD = ".";
+    private static final String SAMPLE_TYPE = " sampleType=";
+    private static final String COUNTER = "COUNTER";
+    private static final String GAUGE = "GAUGE";
+    private static final String DERIVE = "DERIVE";
+    private static final String ABSOLUTE = "ABSOLUTE";
+    private static final Pattern NSQ_PATTERN1 = Pattern.compile("([\\w-_]+)\\.([\\w-_]+)\\.([\\w-_]+)");
+    private static final Pattern NSQ_PATTERN2 = Pattern.compile("([\\w-_]+)\\.([\\w-_]+)\\.([\\w-_]+)\\.([\\w-_]+)");
+    private static final Pattern NSQ_PATTERN3 = Pattern
+            .compile("([\\w-_]+)\\.([\\w-_]+)\\.([\\w-_]+)\\.([\\w-_]+)\\.([\\w-_#]+)\\.([\\w-_]+)");
+    private static final Pattern ETHSTAT_PATTERN = Pattern.compile("([\\w-_]+)_queue_([\\w-_]+)_([\\w-_]+)");
+    private static final String STATSD_PREFIX = "statsd";
+    private static final String NSQ_PREFIX = STATSD_PREFIX + ".nsq.";
+    private static final Pattern HAPROXY_PATTERN = Pattern.compile("\\[([\\w-_=]+),([\\w-_=]+)\\]");
+
+    private final SMARTCodeMapping smart = new SMARTCodeMapping();
+
+    protected Set<String> addlTags = new HashSet<>();
+
+    public int config(OConfigItem config) {
+        for (OConfigItem child : config.getChildren()) {
+            switch (child.getKey()) {
+                case "Tags":
+                case "tags":
+                    String[] additionalTags = child.getValues().get(0).getString().split(",");
+                    for (String t : additionalTags) {
+                        addlTags.add(" " + t.trim());
+                    }
+                default:
+            }
+        }
+        return 0;
+    }
+
+    public abstract void write(String metric);
+
+    public void process(ValueList vl) {
+        debugValueList(vl);
+
+        StringBuilder metric = new StringBuilder();
+        Long timestamp = vl.getTime();
+        StringBuilder tags = new StringBuilder();
+        String host = vl.getHost();
+        int idx = host.indexOf(PERIOD);
+        if (-1 != idx) {
+            tags.append(" host=").append(host.substring(0, idx));
+        } else {
+            tags.append(" host=").append(host);
+        }
+        int nIdx = host.indexOf('n');
+        if (-1 != nIdx) {
+            tags.append(" rack=").append(host.substring(0, nIdx));
+        }
+        for (String tag : addlTags) {
+            tags.append(tag);
+        }
+        if (vl.getPlugin().equals(STATSD_PREFIX)) {
+            Matcher m = HADOOP_STATSD_PATTERN.matcher(vl.getTypeInstance());
+            Matcher n1 = NSQ_PATTERN1.matcher(vl.getTypeInstance());
+            Matcher n2 = NSQ_PATTERN2.matcher(vl.getTypeInstance());
+            Matcher n3 = NSQ_PATTERN3.matcher(vl.getTypeInstance());
+            String instance = null;
+            if (m.matches() && !vl.getTypeInstance().startsWith("nsq")) {
+                // Here we are processing the statsd metrics coming from the
+                // Hadoop Metrics2 StatsDSink without the host name.
+                // The format of metric is:
+                // serviceName.contextName.recordName.metricName. The recordName
+                // is typically duplicative and is dropped here. The serviceName
+                // is used as the instance.
+                metric.append(STATSD_PREFIX).append(PERIOD).append(m.group(2)).append(PERIOD).append(m.group(4));
+                instance = m.group(1);
+            } else if (n1.matches() && vl.getTypeInstance().startsWith("nsq")) {
+                metric.append(NSQ_PREFIX).append(n1.group(2)).append(PERIOD).append(n1.group(3));
+            } else if (n2.matches() && vl.getTypeInstance().startsWith("nsq")) {
+                metric.append(NSQ_PREFIX).append(n2.group(2)).append(PERIOD).append(n2.group(4));
+                instance = n2.group(3);
+            } else if (n3.matches() && vl.getTypeInstance().startsWith("nsq")) {
+                metric.append(NSQ_PREFIX).append(n3.group(4)).append(PERIOD).append(n3.group(6));
+                instance = n3.group(5);
+            } else {
+                // Handle StatsD metrics of unknown formats. If there is a
+                // period in the metric name, use everything up to that as
+                // the instance.
+                int period = vl.getTypeInstance().indexOf('.');
+                if (-1 == period) {
+                    metric.append(STATSD_PREFIX).append(PERIOD).append(vl.getTypeInstance());
+                } else {
+                    instance = vl.getTypeInstance().substring(0, period);
+                    metric.append(STATSD_PREFIX).append(PERIOD).append(vl.getTypeInstance().substring(period + 1));
+                }
+            }
+            timestamp = vl.getTime();
+            if (null != instance) {
+                tags.append(INSTANCE).append(instance);
+            }
+        } else if (vl.getPlugin().equals("ethstat")) {
+            metric.append("sys.ethstat.");
+            if (vl.getTypeInstance().contains("queue")) {
+                Matcher m = ETHSTAT_PATTERN.matcher(vl.getTypeInstance());
+                if (m.matches()) {
+                    metric.append(m.group(1)).append("_").append(m.group(3));
+                    tags.append(" queue=").append(m.group(2));
+                } else {
+                    metric.append(vl.getTypeInstance());
+                }
+            } else {
+                metric.append(vl.getTypeInstance());
+            }
+            tags.append(INSTANCE).append(vl.getPluginInstance());
+        } else if (vl.getPlugin().equals("hddtemp")) {
+            metric.append("sys.hddtemp.").append(vl.getType());
+            tags.append(INSTANCE).append(vl.getTypeInstance());
+        } else if (vl.getPlugin().equals("smart")) {
+            int code = -1;
+            String name = null;
+            if (vl.getTypeInstance().startsWith("attribute-")) {
+                int hyphen = vl.getTypeInstance().indexOf('-');
+                code = Integer.parseInt(vl.getTypeInstance().substring(hyphen + 1));
+                name = smart.get(code);
+            }
+            if (code == -1) {
+                if (notEmpty(vl.getTypeInstance())) {
+                    metric.append("sys.smart.").append(vl.getTypeInstance());
+                } else {
+                    metric.append("sys.smart.").append(vl.getType());
+                }
+            } else {
+                metric.append("sys.smart.").append(name);
+                tags.append(CODE).append(code);
+            }
+            tags.append(INSTANCE).append(vl.getPluginInstance());
+        } else if (vl.getPlugin().equals("sensors")) {
+            String instance = "";
+            if (vl.getTypeInstance().startsWith("temp")) {
+                instance = vl.getTypeInstance().substring(4);
+            }
+            metric.append("sys.sensors.").append(vl.getType()).append(PERIOD).append(vl.getPluginInstance());
+            tags.append(INSTANCE).append(instance);
+        } else if (vl.getPlugin().equals("haproxy")) {
+            metric.append("sys.haproxy.").append(vl.getTypeInstance());
+            Matcher m = HAPROXY_PATTERN.matcher(vl.getPluginInstance());
+            if (m.matches()) {
+                tags.append(" ").append(m.group(1));
+                tags.append(" ").append(m.group(2));
+            }
+        } else if (vl.getPlugin().equals("ipmi")) {
+            metric.append("sys.ipmi.").append(vl.getType());
+            tags.append(INSTANCE).append(vl.getTypeInstance().replaceAll(" ", "_"));
+        } else if (vl.getPlugin().equals("snmp")) {
+            metric.append("sys.snmp.").append(vl.getType());
+            tags.append(INSTANCE).append(vl.getTypeInstance().replaceAll(" ", "_"));
+        } else if (notEmpty(vl.getTypeInstance()) && notEmpty(vl.getType()) && notEmpty(vl.getPluginInstance())
+                && notEmpty(vl.getPlugin())) {
+            metric.append("sys.").append(vl.getPlugin()).append(PERIOD).append(vl.getType()).append(PERIOD)
+                    .append(vl.getTypeInstance());
+            tags.append(INSTANCE).append(vl.getPluginInstance());
+        } else if (notEmpty(vl.getTypeInstance()) && notEmpty(vl.getType()) && notEmpty(vl.getPlugin())) {
+            metric.append("sys.").append(vl.getPlugin()).append(PERIOD).append(vl.getType()).append(PERIOD)
+                    .append(vl.getTypeInstance());
+        } else if (notEmpty(vl.getType()) && notEmpty(vl.getPluginInstance()) && notEmpty(vl.getPlugin())) {
+            metric.append("sys.").append(vl.getPlugin()).append(PERIOD).append(vl.getType());
+            tags.append(INSTANCE).append(vl.getPluginInstance());
+        } else if (notEmpty(vl.getType()) && notEmpty(vl.getPlugin())) {
+            metric.append("sys.").append(vl.getPlugin()).append(PERIOD).append(vl.getType());
+        } else {
+            Collectd.logWarning("Unhandled metric: " + vl.toString());
+            return;
+        }
+        final String metricName = metric.toString().replaceAll(" ", "_");
+        for (int i = 0; i < vl.getValues().size(); i++) {
+            StringBuilder tagsWithSample = new StringBuilder(tags.toString());
+            String sampleName = vl.getDataSet().getDataSources().get(i).getName();
+            int type = vl.getDataSet().getDataSources().get(i).getType();
+            String sampleType = convertType(type);
+            if (null != sampleName) {
+                tagsWithSample.append(SAMPLE).append(sampleName);
+            }
+            if (null != sampleType) {
+                tagsWithSample.append(SAMPLE_TYPE).append(sampleType);
+            }
+            Double value = vl.getValues().get(i).doubleValue();
+            String datapoint = MessageFormat.format(PUT, metricName, timestamp.toString(), value.toString(),
+                    tagsWithSample.toString());
+            Collectd.logDebug("Writing: " + datapoint);
+            write(datapoint);
+        }
+    }
+
+    private void debugValueList(ValueList vl) {
+        Collectd.logDebug("Input: " + vl.toString());
+        Collectd.logDebug("Plugin: " + vl.getPlugin());
+        Collectd.logDebug("PluginInstance: " + vl.getPluginInstance());
+        Collectd.logDebug("Type: " + vl.getType());
+        Collectd.logDebug("TypeInstance: " + vl.getTypeInstance());
+        for (int i = 0; i < vl.getValues().size(); i++) {
+            Number value = vl.getValues().get(i);
+            DataSource ds = vl.getDataSet().getDataSources().get(i);
+            Collectd.logDebug(convertType(ds.getType()) + " " + ds.getName() + " = " + value);
+        }
+    }
+
+    private String convertType(int type) {
+        String result = null;
+        switch (type) {
+            case 0:
+                result = COUNTER;
+                break;
+            case 1:
+                result = GAUGE;
+                break;
+            case 2:
+                result = DERIVE;
+                break;
+            case 3:
+                result = ABSOLUTE;
+                break;
+            default:
+                result = GAUGE;
+                break;
+        }
+        return result;
+    }
+
+    private boolean notEmpty(String arg) {
+        return (null != arg) && !(arg.equals(""));
+    }
+
+}

collectd-plugin-parent/src/main/java/timely/collectd/plugin/SMARTCodeMapping.java

@@ -0,0 +1,169 @@
+package timely.collectd.plugin;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class SMARTCodeMapping extends HashMap<Integer, String> {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final Map<Integer, String> smart;
+    static {
+        Map<Integer, String> map = new HashMap<>();
+        /**
+         * mapping from https://en.wikipedia.org/wiki/S.M.A.R.T.
+         */
+        map.put(1, "Read_Error_Rate");
+        map.put(2, "Throughput_Performance");
+        map.put(3, "Spin_Up_Time");
+        map.put(4, "Start_Stop_Count");
+        map.put(5, "Reallocated_Sectors_Count");
+        map.put(6, "Read_Channel_Margin");
+        map.put(7, "Seek_Error_Rate");
+        map.put(8, "Seek_Time_Performance");
+        map.put(9, "Power_On_Hours");
+        map.put(10, "Spin_Retry_Count");
+        map.put(11, "Calibration_Retry_Count");
+        map.put(12, "Power_Cycle_Count");
+        map.put(13, "Soft_Read_Error_Rate");
+        map.put(22, "Current_Helium_Level");
+        map.put(170, "Available_Reserved_Space");
+        map.put(171, "SSD_Program_Fail_Count");
+        map.put(172, "SSD_Erase_Fail_Count");
+        map.put(173, "SSD_Wear_Leveling_Count");
+        map.put(174, "Unexpected_power_loss_count");
+        map.put(175, "Power_Loss_Protection_Failure");
+        map.put(176, "Erase_Fail_Count");
+        map.put(177, "Wear_Range_Delta");
+        map.put(179, "Used_Reserved_Block_Count_Total");
+        map.put(180, "Unused_Reserved_Block_Count_Total");
+        map.put(181, "Program_Fail_Count_Total");
+        map.put(182, "Erase_Fail_Count");
+        map.put(183, "SATA_Downshift_Error_Count");
+        map.put(184, "End_to_End_error");
+        map.put(185, "Head_Stability");
+        map.put(186, "Induced_Op_Vibration_Detection");
+        map.put(187, "Reported_Uncorrectable_Errors");
+        map.put(188, "Command_Timeout");
+        map.put(189, "High_Fly_Writes");
+        map.put(190, "Airflow_Temperature_Celsius");
+        map.put(190, "Temperature_Difference_from_100");
+        map.put(191, "G_sense_Error_Rate");
+        map.put(192, "Unsafe_Shutdown_Count");
+        map.put(193, "Load_Unload_Cycle_Count");
+        map.put(194, "Temperature_Celsius");
+        map.put(195, "Hardware_ECC_Recovered");
+        map.put(196, "Reallocation_Event_Count");
+        map.put(197, "Current_Pending_Sector_Count");
+        map.put(198, "Uncorrectable_Sector_Count");
+        map.put(199, "UltraDMA_CRC_Error_Count");
+        // map.put(200,"Multi_Zone_Error_Rate_[41]");
+        map.put(200, "Write_Error_Rate");
+        map.put(201, "Soft_Read_Error_Rate");
+        map.put(202, "Data_Address_Mark_errors");
+        map.put(203, "Run_Out_Cancel");
+        map.put(204, "Soft_ECC_Correction");
+        map.put(205, "Thermal_Asperity_Rate");
+        map.put(206, "Flying_Height");
+        map.put(207, "Spin_High_Current");
+        map.put(208, "Spin_Buzz");
+        map.put(209, "Offline_Seek_Performance");
+        map.put(210, "Vibration_During_Write");
+        map.put(211, "Vibration_During_Write");
+        map.put(212, "Shock_During_Write");
+        map.put(220, "Disk_Shift");
+        map.put(221, "G_Sense_Error_Rate");
+        map.put(222, "Loaded_Hours");
+        map.put(223, "Load_Unload_Retry_Count");
+        map.put(224, "Load_Friction");
+        map.put(225, "Load_Unload_Cycle_Count");
+        map.put(226, "Load_In_time");
+        map.put(227, "Torque_Amplification_Count");
+        map.put(228, "Power_Off_Retract_Cycle");
+        // map.put(230,"GMR_Head_Amplitude");
+        map.put(230, "Drive_Life_Protection_Status");
+        map.put(231, "Temperature");
+        // map.put(231,"SSD_Life_Left");
+        map.put(232, "Endurance_Remaining");
+        // map.put(232,"Available_Reserved_Space");
+        map.put(233, "Power_On_Hours");
+        // map.put(233,"Media_Wearout_Indicator");
+        map.put(234, "Average_erase_count");
+        map.put(235, "Good_Block_Count");
+        map.put(240, "Head_Flying_Hours");
+        // map.put(240,"Transfer_Error_Rate_(Fujitsu)");
+        map.put(241, "Total_LBAs_Written");
+        map.put(242, "Total_LBAs_Read");
+        map.put(243, "Total_LBAs_Written_Expanded");
+        map.put(244, "Total_LBAs_Read_Expanded");
+        map.put(249, "NAND_Writes_1GiB");
+        map.put(250, "Read_Error_Retry_Rate");
+        map.put(251, "Minimum_Spares_Remaining");
+        map.put(252, "Newly_Added_Bad_Flash_Block");
+        map.put(254, "Free_Fall_Protection");
+        smart = Collections.unmodifiableMap(map);
+    }
+
+    protected SMARTCodeMapping() {
+    }
+
+    public int size() {
+        return smart.size();
+    }
+
+    public boolean isEmpty() {
+        return smart.isEmpty();
+    }
+
+    public boolean containsKey(Object key) {
+        return smart.containsKey(key);
+    }
+
+    public boolean containsValue(Object value) {
+        return smart.containsValue(value);
+    }
+
+    public String get(Object key) {
+        return smart.get(key);
+    }
+
+    public String put(Integer key, String value) {
+        return smart.put(key, value);
+    }
+
+    public String remove(Object key) {
+        return smart.remove(key);
+    }
+
+    public void putAll(Map<? extends Integer, ? extends String> m) {
+        smart.putAll(m);
+    }
+
+    public void clear() {
+        smart.clear();
+    }
+
+    public Set<Integer> keySet() {
+        return smart.keySet();
+    }
+
+    public Collection<String> values() {
+        return smart.values();
+    }
+
+    public Set<java.util.Map.Entry<Integer, String>> entrySet() {
+        return smart.entrySet();
+    }
+
+    public boolean equals(Object o) {
+        return smart.equals(o);
+    }
+
+    public int hashCode() {
+        return smart.hashCode();
+    }
+
+}

collectd-plugin-parent/src/main/resources/findbugs-excludes.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<FindBugsFilter>
+</FindBugsFilter>

collectd-plugin-parent/src/test/java/timely/collectd/plugin/PluginParentTest.java

@@ -0,0 +1,337 @@
+package timely.collectd.plugin;
+
+import static org.junit.Assert.*;
+
+import java.util.Collections;
+
+import net.jcip.annotations.NotThreadSafe;
+
+import org.collectd.api.Collectd;
+import org.collectd.api.DataSet;
+import org.collectd.api.DataSource;
+import org.collectd.api.ValueList;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.api.easymock.PowerMock;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ Collectd.class })
+@NotThreadSafe
+public class PluginParentTest {
+
+    public class TestPlugin extends CollectDPluginParent {
+
+        public TestPlugin() {
+            super.addlTags.add(" addl1=foo");
+        }
+
+        @Override
+        public void write(String metric) {
+            result = metric;
+        }
+
+    }
+
+    private static final String HOST = "r01n01.test";
+    private static final Long TIME = 1456156976840L;
+    public String result = null;
+
+    @Before
+    public void setup() throws Exception {
+        PowerMock.suppress(PowerMock.everythingDeclaredIn(Collectd.class));
+    }
+
+    @Test
+    public void testStatsDHadoopFormat() throws Exception {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("statsd");
+        vl.setTime(TIME);
+        vl.setType("derive");
+        vl.setTypeInstance("DataNode.dfs.datanode.BlocksRead");
+        vl.setValues(Collections.singletonList((Number) 1.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put statsd.dfs.BlocksRead 1456156976840 1.0 host=r01n01 rack=r01 addl1=foo instance=DataNode sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testStatsDUnknownFormat() throws Exception {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("statsd");
+        vl.setTime(TIME);
+        vl.setType("derive");
+        vl.setTypeInstance("baz");
+        vl.setValues(Collections.singletonList((Number) 1.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals("put statsd.baz 1456156976840 1.0 host=r01n01 rack=r01 addl1=foo sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testStatsDUnknownFormat2() throws Exception {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("statsd");
+        vl.setTime(TIME);
+        vl.setType("derive");
+        vl.setTypeInstance("bar.baz");
+        vl.setValues(Collections.singletonList((Number) 1.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put statsd.baz 1456156976840 1.0 host=r01n01 rack=r01 addl1=foo instance=bar sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testHddTemp() throws Exception {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("hddtemp");
+        vl.setTime(TIME);
+        vl.setType("temperature");
+        vl.setTypeInstance("sda");
+        vl.setValues(Collections.singletonList((Number) 35.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.hddtemp.temperature 1456156976840 35.0 host=r01n01 rack=r01 addl1=foo instance=sda sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testSmart1() throws Exception {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("smart");
+        vl.setPluginInstance("sda");
+        vl.setTime(TIME);
+        vl.setType("smart_badsectors");
+        vl.setValues(Collections.singletonList((Number) 0.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.smart.smart_badsectors 1456156976840 0.0 host=r01n01 rack=r01 addl1=foo instance=sda sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testSmart2() throws Exception {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("smart");
+        vl.setPluginInstance("sda");
+        vl.setTime(TIME);
+        vl.setType("smart_attribute");
+        vl.setTypeInstance("raw-read-error-rate");
+        vl.setValues(Collections.singletonList((Number) 0.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.smart.raw-read-error-rate 1456156976840 0.0 host=r01n01 rack=r01 addl1=foo instance=sda sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testSmartCode() throws Exception {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("smart");
+        vl.setPluginInstance("sda");
+        vl.setTime(TIME);
+        vl.setType("smart_attribute");
+        vl.setTypeInstance("attribute-242");
+        vl.setValues(Collections.singletonList((Number) 0.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.smart.Total_LBAs_Read 1456156976840 0.0 host=r01n01 rack=r01 addl1=foo code=242 instance=sda sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testSnmp() throws Exception {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("snmp");
+        // vl.setPluginInstance("sda");
+        vl.setTime(TIME);
+        vl.setType("if_octets");
+        vl.setTypeInstance("Ethernet1");
+        vl.setValues(Collections.singletonList((Number) 0.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.snmp.if_octets 1456156976840 0.0 host=r01n01 rack=r01 addl1=foo instance=Ethernet1 sample=value sampleType=GAUGE\n",
+                result);
+
+    }
+
+    @Test
+    public void testSensors() {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("sensors");
+        vl.setPluginInstance("coretemp-isa-0000");
+        vl.setTime(TIME);
+        vl.setType("temperature");
+        vl.setTypeInstance("temp1");
+        vl.setValues(Collections.singletonList((Number) 35.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.sensors.temperature.coretemp-isa-0000 1456156976840 35.0 host=r01n01 rack=r01 addl1=foo instance=1 sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testHAProxy1() {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("haproxy");
+        vl.setTime(TIME);
+        vl.setType("gauge");
+        vl.setTypeInstance("run_queue");
+        vl.setValues(Collections.singletonList((Number) 0.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.haproxy.run_queue 1456156976840 0.0 host=r01n01 rack=r01 addl1=foo sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testHAProxy2() {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("haproxy");
+        vl.setPluginInstance("[proxy_name=proxy1,service_name=server1]");
+        vl.setTime(TIME);
+        vl.setType("gauge");
+        vl.setTypeInstance("queue_current");
+        vl.setValues(Collections.singletonList((Number) 0.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 0.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.haproxy.queue_current 1456156976840 0.0 host=r01n01 rack=r01 addl1=foo proxy_name=proxy1 service_name=server1 sample=value sampleType=GAUGE\n",
+                result);
+    }
+
+    @Test
+    public void testEthStatNoQueue() {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("ethstat");
+        vl.setPluginInstance("eth0");
+        vl.setTime(TIME);
+        vl.setType("derive");
+        vl.setTypeInstance("tx_comp_queue_full");
+        vl.setValues(Collections.singletonList((Number) 6.0D));
+        DataSet ds = new DataSet("DERIVE");
+        ds.addDataSource(new DataSource("value", 1, 6.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.ethstat.tx_comp_queue_full 1456156976840 6.0 host=r01n01 rack=r01 addl1=foo instance=eth0 sample=value sampleType=GAUGE\n",
+                result);
+
+    }
+
+    @Test
+    public void testEthStatWithQueue() {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("ethstat");
+        vl.setPluginInstance("eth0");
+        vl.setTime(TIME);
+        vl.setType("derive");
+        vl.setTypeInstance("rx_queue_1_bytes");
+        vl.setValues(Collections.singletonList((Number) 6.0D));
+        DataSet ds = new DataSet("DERIVE");
+        ds.addDataSource(new DataSource("value", 1, 6.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.ethstat.rx_bytes 1456156976840 6.0 host=r01n01 rack=r01 addl1=foo queue=1 instance=eth0 sample=value sampleType=GAUGE\n",
+                result);
+
+    }
+
+    @Test
+    public void testIpmi() {
+        ValueList vl = new ValueList();
+        vl.setHost(HOST);
+        vl.setPlugin("ipmi");
+        vl.setTime(TIME);
+        vl.setType("temperature");
+        vl.setTypeInstance("LAN NIC Temp system_board (3.2)");
+        vl.setValues(Collections.singletonList((Number) 6.0D));
+        DataSet ds = new DataSet("GAUGE");
+        ds.addDataSource(new DataSource("value", 1, 6.0D, 100.0D));
+        vl.setDataSet(ds);
+
+        TestPlugin test = new TestPlugin();
+        test.process(vl);
+        assertEquals(
+                "put sys.ipmi.temperature 1456156976840 6.0 host=r01n01 rack=r01 addl1=foo instance=LAN_NIC_Temp_system_board_(3.2) sample=value sampleType=GAUGE\n",
+                result);
+
+    }
+
+}

collectd-timely-plugin/pom.xml

@@ -0,0 +1,94 @@
+<?xml version="1.0"?>
+<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/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>timely</groupId>
+        <artifactId>timely</artifactId>
+        <version>0.0.4</version>
+    </parent>
+    <artifactId>collectd-timely-plugin</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>collectd</groupId>
+            <artifactId>collectd-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>net.jcip</groupId>
+            <artifactId>jcip-annotations</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.javassist</groupId>
+            <artifactId>javassist</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-easymock-release-full</artifactId>
+            <classifier>full</classifier>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>timely</groupId>
+            <artifactId>collectd-plugin-parent</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.7</source>
+                    <target>1.7</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>findbugs-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <configuration>
+                    <artifactSet>
+                        <includes>
+                    </includes>
+                    </artifactSet>
+                    <createDependencyReducedPom>false</createDependencyReducedPom>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>shade</id>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <phase>package</phase>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>net.revelc.code</groupId>
+                <artifactId>formatter-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>buildnumber-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>

collectd-timely-plugin/src/main/java/timely/collectd/plugin/WriteTimelyPlugin.java

@@ -0,0 +1,129 @@
+package timely.collectd.plugin;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.Socket;
+
+import org.collectd.api.Collectd;
+import org.collectd.api.CollectdConfigInterface;
+import org.collectd.api.CollectdShutdownInterface;
+import org.collectd.api.CollectdWriteInterface;
+import org.collectd.api.OConfigItem;
+import org.collectd.api.ValueList;
+
+/**
+ *
+ * CollectD plugin that writes metrics collected by the StatsD plugin to Timely.
+ *
+ */
+public class WriteTimelyPlugin extends CollectDPluginParent implements CollectdConfigInterface,
+        CollectdShutdownInterface, CollectdWriteInterface {
+
+    private String host = null;
+    private int port = 0;
+    private Socket sock = null;
+    private PrintWriter out = null;
+    private long connectTime = 0L;
+    private long backoff = 2000;
+
+    public WriteTimelyPlugin() {
+        Collectd.registerConfig(WriteTimelyPlugin.class.getName(), this);
+        Collectd.registerShutdown(WriteTimelyPlugin.class.getName(), this);
+        Collectd.registerWrite(WriteTimelyPlugin.class.getName(), this);
+    }
+
+    private synchronized int connect() {
+        if (null == sock || !sock.isConnected() || out.checkError()) {
+            if (System.currentTimeMillis() > (connectTime + backoff)) {
+                try {
+                    connectTime = System.currentTimeMillis();
+                    sock = new Socket(host, port);
+                    out = new PrintWriter(sock.getOutputStream(), false);
+                    backoff = 2000;
+                    Collectd.logInfo("Connected to Timely at " + host + ":" + port);
+                } catch (IOException e) {
+                    Collectd.logError("Error connecting to Timely at " + host + ":" + port + ". Error: "
+                            + e.getMessage());
+                    backoff = backoff * 2;
+                    sock = null;
+                    out = null;
+                    Collectd.logWarning("Will retry connection in " + backoff + " ms.");
+                    return -1;
+                }
+            } else {
+                Collectd.logWarning("Not writing to Timely, waiting to reconnect");
+                return -1;
+            }
+        }
+        return 0;
+    }
+
+    public synchronized int write(ValueList vl) {
+
+        int c = connect();
+        if (c != 0) {
+            return c;
+        }
+        super.process(vl);
+        return 0;
+    }
+
+    @Override
+    public synchronized void write(String metric) {
+        out.write(metric);
+    }
+
+    public synchronized void flush() {
+        if (null != out) {
+            out.flush();
+        }
+    }
+
+    public synchronized int shutdown() {
+        Collectd.logInfo("Shutting down connection to Timely at " + host + ":" + port);
+        if (null != sock) {
+            try {
+                if (null != out) {
+                    out.close();
+                }
+                sock.close();
+            } catch (IOException e) {
+                Collectd.logError("Error closing connection to Timely at " + host + ":" + port + ". Error: "
+                        + e.getMessage());
+                return -1;
+            }
+        }
+        return 0;
+    }
+
+    public synchronized int config(OConfigItem config) {
+        super.config(config);
+        for (OConfigItem child : config.getChildren()) {
+            switch (child.getKey()) {
+                case "host":
+                case "hostname":
+                case "Host":
+                case "HostName":
+                    host = child.getValues().get(0).getString();
+                    break;
+                case "Port":
+                case "port":
+                    port = Integer.parseInt(child.getValues().get(0).getString());
+                    break;
+                default:
+
+            }
+        }
+        if (null != host) {
+            return 0;
+        }
+        if (host == null) {
+            Collectd.logError("Timely host must be configured");
+        }
+        if (port == 0) {
+            Collectd.logError("Timely port must be configured");
+        }
+        return -1;
+    }
+
+}

collectd-timely-plugin/src/main/resources/findbugs-excludes.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<FindBugsFilter>
+  <Or>
+    <Bug pattern="DM_DEFAULT_ENCODING"/>
+    <Method name="connect" />
+    <Class name="timely.collectd.plugin.WriteTimelyPlugin"/>
+  </Or>
+</FindBugsFilter>

collectd-timely-plugin/src/test/java/timely/collectd/plugin/WriteTimelyPluginTest.java

@@ -0,0 +1,202 @@
+package timely.collectd.plugin;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.Collections;
+
+import net.jcip.annotations.NotThreadSafe;
+
+import org.collectd.api.Collectd;
+import org.collectd.api.DataSet;
+import org.collectd.api.DataSource;
+import org.collectd.api.OConfigItem;
+import org.collectd.api.ValueList;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.api.easymock.PowerMock;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ Collectd.class })
+@NotThreadSafe
+public class WriteTimelyPluginTest {
+
+    private WriteTimelyPlugin plugin = null;
+    private FakeServer server = null;
+
+    @Before
+    public void setup() throws Exception {
+        PowerMock.suppress(PowerMock.everythingDeclaredIn(Collectd.class));
+        server = new FakeServer();
+    }
+
+    private ValueList createMetric() {
+        ValueList val = new ValueList();
+        val.setHost("r001n01.localdomain");
+        val.setTime(System.currentTimeMillis());
+        val.setPlugin("hddtemp");
+        val.setPluginInstance(null);
+        val.setType("temperature");
+        val.setTypeInstance("sda");
+        val.setValues(Collections.singletonList((Number) new Double(2.0)));
+        DataSet ds = new DataSet("test");
+        ds.addDataSource(new DataSource("test", DataSource.TYPE_COUNTER, 0, 100));
+        val.setDataSet(ds);
+        return val;
+    }
+
+    private void setupPlugin() throws Exception {
+        OConfigItem host = new OConfigItem("Host");
+        host.addValue(server.getHost());
+        OConfigItem port = new OConfigItem("Port");
+        port.addValue(Integer.toString(server.getPort()));
+        OConfigItem config = new OConfigItem("");
+        config.addChild(host);
+        config.addChild(port);
+        plugin = new WriteTimelyPlugin();
+        Assert.assertEquals(0, plugin.config(config));
+        // Seed with one metric to create the connection
+        Assert.assertEquals(0, plugin.write(createMetric()));
+        plugin.flush();
+        Thread.sleep(100);
+        Assert.assertTrue(server.messageReceived());
+    }
+
+    @Test
+    public void testWrite() throws Exception {
+        Thread t = new Thread(server);
+        t.start();
+        setupPlugin();
+        while (!server.ready()) {
+            Thread.sleep(1000);
+        }
+        Assert.assertEquals(0, plugin.write(createMetric()));
+        plugin.flush();
+        Thread.sleep(100);
+        Assert.assertTrue(server.messageReceived());
+        plugin.shutdown();
+        server.shutdown();
+        t.join();
+    }
+
+    @Test
+    public void testWriteAfterServerRestart() throws Exception {
+        Thread t = new Thread(server);
+        t.start();
+        setupPlugin();
+        while (!server.ready()) {
+            Thread.sleep(1000);
+        }
+        Assert.assertEquals(0, plugin.write(createMetric()));
+        plugin.flush();
+        Thread.sleep(100);
+        Assert.assertTrue(server.messageReceived());
+        server.shutdown();
+        t.join();
+        Thread.sleep(2000);
+
+        server.create();
+        Thread t2 = new Thread(server);
+        t2.start();
+        while (!server.ready()) {
+            Thread.sleep(1000);
+            // Keep sending metrics to plugin to force reconnect
+            int result = plugin.write(createMetric());
+            System.out.println("Wrote to client, result: " + result);
+            Assert.assertEquals(0, result);
+            plugin.flush();
+        }
+        Assert.assertEquals(0, plugin.write(createMetric()));
+        plugin.flush();
+        Thread.sleep(1000);
+        Assert.assertTrue(server.messageReceived());
+        plugin.shutdown();
+        server.shutdown();
+        t2.join();
+    }
+
+    private static class FakeServer implements Runnable {
+
+        private ServerSocket server = null;
+        private BufferedReader reader = null;
+        private String host = null;
+        private int port = 0;
+        private Socket s = null;
+        private boolean received = false;
+
+        public FakeServer() throws Exception {
+            create();
+        }
+
+        public void create() throws Exception {
+            server = new ServerSocket(port);
+            server.setReceiveBufferSize(8192);
+            host = server.getInetAddress().getHostAddress();
+            port = server.getLocalPort();
+        }
+
+        public String getHost() {
+            return host;
+        }
+
+        public int getPort() {
+            return port;
+        }
+
+        public void shutdown() throws Exception {
+            System.out.println("Closing server.");
+            s.close();
+            s = null;
+            reader.close();
+            reader = null;
+            server.close();
+            server = null;
+        }
+
+        public boolean ready() throws Exception {
+            return (s != null && s.isConnected());
+        }
+
+        public boolean messageReceived() {
+            try {
+                return Boolean.valueOf(this.received);
+            } finally {
+                this.received = false;
+            }
+        }
+
+        @Override
+        public void run() {
+            try {
+                s = server.accept();
+                System.out.println("Client connected.");
+                reader = new BufferedReader(new InputStreamReader(s.getInputStream()));
+                while (server != null && !server.isClosed() && s != null && s.isConnected()) {
+                    String line;
+                    try {
+                        line = reader.readLine();
+                    } catch (Exception e) {
+                        // Might have been closed
+                        System.out.println("Closed by Exception: " + e.getMessage());
+                        return;
+                    }
+                    if (null != line) {
+                        this.received = true;
+                    }
+                    System.out.println(line);
+                }
+            } catch (IOException e) {
+                Assert.fail(e.getMessage());
+            }
+            System.out.println("Exiting run method.");
+        }
+
+    }
+
+}

collectd-timely-plugin/src/test/resources/log4j2.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN">
+  <Appenders>
+    <Console name="CONSOLE" target="SYSTEM_OUT">
+      <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+    </Console>
+  </Appenders>
+  <Loggers>
+    <Root level="TRACE">
+      <AppenderRef ref="CONSOLE"/>
+    </Root>
+  </Loggers>
+</Configuration>

colors.txt

@@ -1,10 +0,0 @@
-Fire Engine Red #CB2129
-Raisin Black #1E1E24
-Arsenic #403F4C
-
-Gainsboro #DADDD8
-
-Gunmetal #2C2B3C
-Dark Gunmetal #1B2432
-
-font-family: "Arial Rounded MT Bold", "Helvetica Rounded", Arial, sans-serif;

common/.gitignore

@@ -0,0 +1 @@
+/target/

common/pom.xml

@@ -0,0 +1,24 @@
+<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/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>timely</groupId>
+    <artifactId>timely</artifactId>
+    <version>0.0.4</version>
+  </parent>
+  <artifactId>timely-common</artifactId>
+  <dependencies>
+	<dependency>
+	    <groupId>junit</groupId>
+	    <artifactId>junit</artifactId>
+	    <scope>test</scope>
+	</dependency>
+  </dependencies>
+  <build>
+        <plugins>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>buildnumber-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+  </build>
+</project>

common/src/main/java/timely/test/IntegrationTest.java

@@ -0,0 +1,4 @@
+package timely.test;
+
+public interface IntegrationTest {
+}

css/bootstrap-theme.css

@@ -1,470 +0,0 @@
-/*!
- * Bootstrap v3.3.1 (http://getbootstrap.com)
- * Copyright 2011-2014 Twitter, Inc.
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
- */
-
-.btn-default,
-.btn-primary,
-.btn-success,
-.btn-info,
-.btn-warning,
-.btn-danger {
-  text-shadow: 0 -1px 0 rgba(0, 0, 0, .2);
-  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 1px rgba(0, 0, 0, .075);
-          box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 1px rgba(0, 0, 0, .075);
-}
-.btn-default:active,
-.btn-primary:active,
-.btn-success:active,
-.btn-info:active,
-.btn-warning:active,
-.btn-danger:active,
-.btn-default.active,
-.btn-primary.active,
-.btn-success.active,
-.btn-info.active,
-.btn-warning.active,
-.btn-danger.active {
-  -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
-          box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
-}
-.btn-default .badge,
-.btn-primary .badge,
-.btn-success .badge,
-.btn-info .badge,
-.btn-warning .badge,
-.btn-danger .badge {
-  text-shadow: none;
-}
-.btn:active,
-.btn.active {
-  background-image: none;
-}
-.btn-default {
-  text-shadow: 0 1px 0 #fff;
-  background-image: -webkit-linear-gradient(top, #fff 0%, #e0e0e0 100%);
-  background-image:      -o-linear-gradient(top, #fff 0%, #e0e0e0 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#fff), to(#e0e0e0));
-  background-image:         linear-gradient(to bottom, #fff 0%, #e0e0e0 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe0e0e0', GradientType=0);
-  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
-  background-repeat: repeat-x;
-  border-color: #dbdbdb;
-  border-color: #ccc;
-}
-.btn-default:hover,
-.btn-default:focus {
-  background-color: #e0e0e0;
-  background-position: 0 -15px;
-}
-.btn-default:active,
-.btn-default.active {
-  background-color: #e0e0e0;
-  border-color: #dbdbdb;
-}
-.btn-default:disabled,
-.btn-default[disabled] {
-  background-color: #e0e0e0;
-  background-image: none;
-}
-.btn-primary {
-  background-image: -webkit-linear-gradient(top, #337ab7 0%, #265a88 100%);
-  background-image:      -o-linear-gradient(top, #337ab7 0%, #265a88 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#265a88));
-  background-image:         linear-gradient(to bottom, #337ab7 0%, #265a88 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff265a88', GradientType=0);
-  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
-  background-repeat: repeat-x;
-  border-color: #245580;
-}
-.btn-primary:hover,
-.btn-primary:focus {
-  background-color: #265a88;
-  background-position: 0 -15px;
-}
-.btn-primary:active,
-.btn-primary.active {
-  background-color: #265a88;
-  border-color: #245580;
-}
-.btn-primary:disabled,
-.btn-primary[disabled] {
-  background-color: #265a88;
-  background-image: none;
-}
-.btn-success {
-  background-image: -webkit-linear-gradient(top, #5cb85c 0%, #419641 100%);
-  background-image:      -o-linear-gradient(top, #5cb85c 0%, #419641 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#5cb85c), to(#419641));
-  background-image:         linear-gradient(to bottom, #5cb85c 0%, #419641 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5cb85c', endColorstr='#ff419641', GradientType=0);
-  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
-  background-repeat: repeat-x;
-  border-color: #3e8f3e;
-}
-.btn-success:hover,
-.btn-success:focus {
-  background-color: #419641;
-  background-position: 0 -15px;
-}
-.btn-success:active,
-.btn-success.active {
-  background-color: #419641;
-  border-color: #3e8f3e;
-}
-.btn-success:disabled,
-.btn-success[disabled] {
-  background-color: #419641;
-  background-image: none;
-}
-.btn-info {
-  background-image: -webkit-linear-gradient(top, #5bc0de 0%, #2aabd2 100%);
-  background-image:      -o-linear-gradient(top, #5bc0de 0%, #2aabd2 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#5bc0de), to(#2aabd2));
-  background-image:         linear-gradient(to bottom, #5bc0de 0%, #2aabd2 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff2aabd2', GradientType=0);
-  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
-  background-repeat: repeat-x;
-  border-color: #28a4c9;
-}
-.btn-info:hover,
-.btn-info:focus {
-  background-color: #2aabd2;
-  background-position: 0 -15px;
-}
-.btn-info:active,
-.btn-info.active {
-  background-color: #2aabd2;
-  border-color: #28a4c9;
-}
-.btn-info:disabled,
-.btn-info[disabled] {
-  background-color: #2aabd2;
-  background-image: none;
-}
-.btn-warning {
-  background-image: -webkit-linear-gradient(top, #f0ad4e 0%, #eb9316 100%);
-  background-image:      -o-linear-gradient(top, #f0ad4e 0%, #eb9316 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#f0ad4e), to(#eb9316));
-  background-image:         linear-gradient(to bottom, #f0ad4e 0%, #eb9316 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff0ad4e', endColorstr='#ffeb9316', GradientType=0);
-  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
-  background-repeat: repeat-x;
-  border-color: #e38d13;
-}
-.btn-warning:hover,
-.btn-warning:focus {
-  background-color: #eb9316;
-  background-position: 0 -15px;
-}
-.btn-warning:active,
-.btn-warning.active {
-  background-color: #eb9316;
-  border-color: #e38d13;
-}
-.btn-warning:disabled,
-.btn-warning[disabled] {
-  background-color: #eb9316;
-  background-image: none;
-}
-.btn-danger {
-  background-image: -webkit-linear-gradient(top, #d9534f 0%, #c12e2a 100%);
-  background-image:      -o-linear-gradient(top, #d9534f 0%, #c12e2a 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#d9534f), to(#c12e2a));
-  background-image:         linear-gradient(to bottom, #d9534f 0%, #c12e2a 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9534f', endColorstr='#ffc12e2a', GradientType=0);
-  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
-  background-repeat: repeat-x;
-  border-color: #b92c28;
-}
-.btn-danger:hover,
-.btn-danger:focus {
-  background-color: #c12e2a;
-  background-position: 0 -15px;
-}
-.btn-danger:active,
-.btn-danger.active {
-  background-color: #c12e2a;
-  border-color: #b92c28;
-}
-.btn-danger:disabled,
-.btn-danger[disabled] {
-  background-color: #c12e2a;
-  background-image: none;
-}
-.thumbnail,
-.img-thumbnail {
-  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
-          box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
-}
-.dropdown-menu > li > a:hover,
-.dropdown-menu > li > a:focus {
-  background-color: #e8e8e8;
-  background-image: -webkit-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
-  background-image:      -o-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#f5f5f5), to(#e8e8e8));
-  background-image:         linear-gradient(to bottom, #f5f5f5 0%, #e8e8e8 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#ffe8e8e8', GradientType=0);
-  background-repeat: repeat-x;
-}
-.dropdown-menu > .active > a,
-.dropdown-menu > .active > a:hover,
-.dropdown-menu > .active > a:focus {
-  background-color: #2e6da4;
-  background-image: -webkit-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
-  background-image:      -o-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#2e6da4));
-  background-image:         linear-gradient(to bottom, #337ab7 0%, #2e6da4 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2e6da4', GradientType=0);
-  background-repeat: repeat-x;
-}
-.navbar-default {
-  background-image: -webkit-linear-gradient(top, #fff 0%, #f8f8f8 100%);
-  background-image:      -o-linear-gradient(top, #fff 0%, #f8f8f8 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#fff), to(#f8f8f8));
-  background-image:         linear-gradient(to bottom, #fff 0%, #f8f8f8 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#fff8f8f8', GradientType=0);
-  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
-  background-repeat: repeat-x;
-  border-radius: 4px;
-  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 5px rgba(0, 0, 0, .075);
-          box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 5px rgba(0, 0, 0, .075);
-}
-.navbar-default .navbar-nav > .open > a,
-.navbar-default .navbar-nav > .active > a {
-  background-image: -webkit-linear-gradient(top, #dbdbdb 0%, #e2e2e2 100%);
-  background-image:      -o-linear-gradient(top, #dbdbdb 0%, #e2e2e2 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#dbdbdb), to(#e2e2e2));
-  background-image:         linear-gradient(to bottom, #dbdbdb 0%, #e2e2e2 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdbdbdb', endColorstr='#ffe2e2e2', GradientType=0);
-  background-repeat: repeat-x;
-  -webkit-box-shadow: inset 0 3px 9px rgba(0, 0, 0, .075);
-          box-shadow: inset 0 3px 9px rgba(0, 0, 0, .075);
-}
-.navbar-brand,
-.navbar-nav > li > a {
-  text-shadow: 0 1px 0 rgba(255, 255, 255, .25);
-}
-.navbar-inverse {
-  background-image: -webkit-linear-gradient(top, #3c3c3c 0%, #222 100%);
-  background-image:      -o-linear-gradient(top, #3c3c3c 0%, #222 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#3c3c3c), to(#222));
-  background-image:         linear-gradient(to bottom, #3c3c3c 0%, #222 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff3c3c3c', endColorstr='#ff222222', GradientType=0);
-  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
-  background-repeat: repeat-x;
-}
-.navbar-inverse .navbar-nav > .open > a,
-.navbar-inverse .navbar-nav > .active > a {
-  background-image: -webkit-linear-gradient(top, #080808 0%, #0f0f0f 100%);
-  background-image:      -o-linear-gradient(top, #080808 0%, #0f0f0f 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#080808), to(#0f0f0f));
-  background-image:         linear-gradient(to bottom, #080808 0%, #0f0f0f 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff080808', endColorstr='#ff0f0f0f', GradientType=0);
-  background-repeat: repeat-x;
-  -webkit-box-shadow: inset 0 3px 9px rgba(0, 0, 0, .25);
-          box-shadow: inset 0 3px 9px rgba(0, 0, 0, .25);
-}
-.navbar-inverse .navbar-brand,
-.navbar-inverse .navbar-nav > li > a {
-  text-shadow: 0 -1px 0 rgba(0, 0, 0, .25);
-}
-.navbar-static-top,
-.navbar-fixed-top,
-.navbar-fixed-bottom {
-  border-radius: 0;
-}
-@media (max-width: 767px) {
-  .navbar .navbar-nav .open .dropdown-menu > .active > a,
-  .navbar .navbar-nav .open .dropdown-menu > .active > a:hover,
-  .navbar .navbar-nav .open .dropdown-menu > .active > a:focus {
-    color: #fff;
-    background-image: -webkit-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
-    background-image:      -o-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
-    background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#2e6da4));
-    background-image:         linear-gradient(to bottom, #337ab7 0%, #2e6da4 100%);
-    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2e6da4', GradientType=0);
-    background-repeat: repeat-x;
-  }
-}
-.alert {
-  text-shadow: 0 1px 0 rgba(255, 255, 255, .2);
-  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .25), 0 1px 2px rgba(0, 0, 0, .05);
-          box-shadow: inset 0 1px 0 rgba(255, 255, 255, .25), 0 1px 2px rgba(0, 0, 0, .05);
-}
-.alert-success {
-  background-image: -webkit-linear-gradient(top, #dff0d8 0%, #c8e5bc 100%);
-  background-image:      -o-linear-gradient(top, #dff0d8 0%, #c8e5bc 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#dff0d8), to(#c8e5bc));
-  background-image:         linear-gradient(to bottom, #dff0d8 0%, #c8e5bc 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdff0d8', endColorstr='#ffc8e5bc', GradientType=0);
-  background-repeat: repeat-x;
-  border-color: #b2dba1;
-}
-.alert-info {
-  background-image: -webkit-linear-gradient(top, #d9edf7 0%, #b9def0 100%);
-  background-image:      -o-linear-gradient(top, #d9edf7 0%, #b9def0 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#d9edf7), to(#b9def0));
-  background-image:         linear-gradient(to bottom, #d9edf7 0%, #b9def0 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9edf7', endColorstr='#ffb9def0', GradientType=0);
-  background-repeat: repeat-x;
-  border-color: #9acfea;
-}
-.alert-warning {
-  background-image: -webkit-linear-gradient(top, #fcf8e3 0%, #f8efc0 100%);
-  background-image:      -o-linear-gradient(top, #fcf8e3 0%, #f8efc0 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#fcf8e3), to(#f8efc0));
-  background-image:         linear-gradient(to bottom, #fcf8e3 0%, #f8efc0 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffcf8e3', endColorstr='#fff8efc0', GradientType=0);
-  background-repeat: repeat-x;
-  border-color: #f5e79e;
-}
-.alert-danger {
-  background-image: -webkit-linear-gradient(top, #f2dede 0%, #e7c3c3 100%);
-  background-image:      -o-linear-gradient(top, #f2dede 0%, #e7c3c3 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#f2dede), to(#e7c3c3));
-  background-image:         linear-gradient(to bottom, #f2dede 0%, #e7c3c3 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2dede', endColorstr='#ffe7c3c3', GradientType=0);
-  background-repeat: repeat-x;
-  border-color: #dca7a7;
-}
-.progress {
-  background-image: -webkit-linear-gradient(top, #ebebeb 0%, #f5f5f5 100%);
-  background-image:      -o-linear-gradient(top, #ebebeb 0%, #f5f5f5 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#ebebeb), to(#f5f5f5));
-  background-image:         linear-gradient(to bottom, #ebebeb 0%, #f5f5f5 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffebebeb', endColorstr='#fff5f5f5', GradientType=0);
-  background-repeat: repeat-x;
-}
-.progress-bar {
-  background-image: -webkit-linear-gradient(top, #337ab7 0%, #286090 100%);
-  background-image:      -o-linear-gradient(top, #337ab7 0%, #286090 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#286090));
-  background-image:         linear-gradient(to bottom, #337ab7 0%, #286090 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff286090', GradientType=0);
-  background-repeat: repeat-x;
-}
-.progress-bar-success {
-  background-image: -webkit-linear-gradient(top, #5cb85c 0%, #449d44 100%);
-  background-image:      -o-linear-gradient(top, #5cb85c 0%, #449d44 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#5cb85c), to(#449d44));
-  background-image:         linear-gradient(to bottom, #5cb85c 0%, #449d44 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5cb85c', endColorstr='#ff449d44', GradientType=0);
-  background-repeat: repeat-x;
-}
-.progress-bar-info {
-  background-image: -webkit-linear-gradient(top, #5bc0de 0%, #31b0d5 100%);
-  background-image:      -o-linear-gradient(top, #5bc0de 0%, #31b0d5 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#5bc0de), to(#31b0d5));
-  background-image:         linear-gradient(to bottom, #5bc0de 0%, #31b0d5 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff31b0d5', GradientType=0);
-  background-repeat: repeat-x;
-}
-.progress-bar-warning {
-  background-image: -webkit-linear-gradient(top, #f0ad4e 0%, #ec971f 100%);
-  background-image:      -o-linear-gradient(top, #f0ad4e 0%, #ec971f 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#f0ad4e), to(#ec971f));
-  background-image:         linear-gradient(to bottom, #f0ad4e 0%, #ec971f 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff0ad4e', endColorstr='#ffec971f', GradientType=0);
-  background-repeat: repeat-x;
-}
-.progress-bar-danger {
-  background-image: -webkit-linear-gradient(top, #d9534f 0%, #c9302c 100%);
-  background-image:      -o-linear-gradient(top, #d9534f 0%, #c9302c 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#d9534f), to(#c9302c));
-  background-image:         linear-gradient(to bottom, #d9534f 0%, #c9302c 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9534f', endColorstr='#ffc9302c', GradientType=0);
-  background-repeat: repeat-x;
-}
-.progress-bar-striped {
-  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
-  background-image:      -o-linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
-  background-image:         linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
-}
-.list-group {
-  border-radius: 4px;
-  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
-          box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
-}
-.list-group-item.active,
-.list-group-item.active:hover,
-.list-group-item.active:focus {
-  text-shadow: 0 -1px 0 #286090;
-  background-image: -webkit-linear-gradient(top, #337ab7 0%, #2b669a 100%);
-  background-image:      -o-linear-gradient(top, #337ab7 0%, #2b669a 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#2b669a));
-  background-image:         linear-gradient(to bottom, #337ab7 0%, #2b669a 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2b669a', GradientType=0);
-  background-repeat: repeat-x;
-  border-color: #2b669a;
-}
-.list-group-item.active .badge,
-.list-group-item.active:hover .badge,
-.list-group-item.active:focus .badge {
-  text-shadow: none;
-}
-.panel {
-  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .05);
-          box-shadow: 0 1px 2px rgba(0, 0, 0, .05);
-}
-.panel-default > .panel-heading {
-  background-image: -webkit-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
-  background-image:      -o-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#f5f5f5), to(#e8e8e8));
-  background-image:         linear-gradient(to bottom, #f5f5f5 0%, #e8e8e8 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#ffe8e8e8', GradientType=0);
-  background-repeat: repeat-x;
-}
-.panel-primary > .panel-heading {
-  background-image: -webkit-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
-  background-image:      -o-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#2e6da4));
-  background-image:         linear-gradient(to bottom, #337ab7 0%, #2e6da4 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2e6da4', GradientType=0);
-  background-repeat: repeat-x;
-}
-.panel-success > .panel-heading {
-  background-image: -webkit-linear-gradient(top, #dff0d8 0%, #d0e9c6 100%);
-  background-image:      -o-linear-gradient(top, #dff0d8 0%, #d0e9c6 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#dff0d8), to(#d0e9c6));
-  background-image:         linear-gradient(to bottom, #dff0d8 0%, #d0e9c6 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdff0d8', endColorstr='#ffd0e9c6', GradientType=0);
-  background-repeat: repeat-x;
-}
-.panel-info > .panel-heading {
-  background-image: -webkit-linear-gradient(top, #d9edf7 0%, #c4e3f3 100%);
-  background-image:      -o-linear-gradient(top, #d9edf7 0%, #c4e3f3 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#d9edf7), to(#c4e3f3));
-  background-image:         linear-gradient(to bottom, #d9edf7 0%, #c4e3f3 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9edf7', endColorstr='#ffc4e3f3', GradientType=0);
-  background-repeat: repeat-x;
-}
-.panel-warning > .panel-heading {
-  background-image: -webkit-linear-gradient(top, #fcf8e3 0%, #faf2cc 100%);
-  background-image:      -o-linear-gradient(top, #fcf8e3 0%, #faf2cc 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#fcf8e3), to(#faf2cc));
-  background-image:         linear-gradient(to bottom, #fcf8e3 0%, #faf2cc 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffcf8e3', endColorstr='#fffaf2cc', GradientType=0);
-  background-repeat: repeat-x;
-}
-.panel-danger > .panel-heading {
-  background-image: -webkit-linear-gradient(top, #f2dede 0%, #ebcccc 100%);
-  background-image:      -o-linear-gradient(top, #f2dede 0%, #ebcccc 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#f2dede), to(#ebcccc));
-  background-image:         linear-gradient(to bottom, #f2dede 0%, #ebcccc 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2dede', endColorstr='#ffebcccc', GradientType=0);
-  background-repeat: repeat-x;
-}
-.well {
-  background-image: -webkit-linear-gradient(top, #e8e8e8 0%, #f5f5f5 100%);
-  background-image:      -o-linear-gradient(top, #e8e8e8 0%, #f5f5f5 100%);
-  background-image: -webkit-gradient(linear, left top, left bottom, from(#e8e8e8), to(#f5f5f5));
-  background-image:         linear-gradient(to bottom, #e8e8e8 0%, #f5f5f5 100%);
-  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffe8e8e8', endColorstr='#fff5f5f5', GradientType=0);
-  background-repeat: repeat-x;
-  border-color: #dcdcdc;
-  -webkit-box-shadow: inset 0 1px 3px rgba(0, 0, 0, .05), 0 1px 0 rgba(255, 255, 255, .1);
-          box-shadow: inset 0 1px 3px rgba(0, 0, 0, .05), 0 1px 0 rgba(255, 255, 255, .1);
-}
-/*# sourceMappingURL=bootstrap-theme.css.map */

css/bootstrap-theme.css.map

@@ -1 +0,0 @@
-{"version":3,"sources":["less/theme.less","less/mixins/vendor-prefixes.less","bootstrap-theme.css","less/mixins/gradients.less","less/mixins/reset-filter.less"],"names":[],"mappings":"AAcA;;;;;;EAME,0CAAA;ECgDA,6FAAA;EACQ,qFAAA;EC5DT;AFgBC;;;;;;;;;;;;EC2CA,0DAAA;EACQ,kDAAA;EC7CT;AFVD;;;;;;EAiBI,mBAAA;EECH;AFgCC;;EAEE,wBAAA;EE9BH;AFmCD;EGlDI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EAEA,wHAAA;ECnBF,qEAAA;EJiCA,6BAAA;EACA,uBAAA;EA+B2C,2BAAA;EAA2B,oBAAA;EExBvE;AFLC;;EAEE,2BAAA;EACA,8BAAA;EEOH;AFJC;;EAEE,2BAAA;EACA,uBAAA;EEMH;AFHC;;EAEE,2BAAA;EACA,wBAAA;EEKH;AFUD;EGnDI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EAEA,wHAAA;ECnBF,qEAAA;EJiCA,6BAAA;EACA,uBAAA;EE+BD;AF7BC;;EAEE,2BAAA;EACA,8BAAA;EE+BH;AF5BC;;EAEE,2BAAA;EACA,uBAAA;EE8BH;AF3BC;;EAEE,2BAAA;EACA,wBAAA;EE6BH;AFbD;EGpDI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EAEA,wHAAA;ECnBF,qEAAA;EJiCA,6BAAA;EACA,uBAAA;EEuDD;AFrDC;;EAEE,2BAAA;EACA,8BAAA;EEuDH;AFpDC;;EAEE,2BAAA;EACA,uBAAA;EEsDH;AFnDC;;EAEE,2BAAA;EACA,wBAAA;EEqDH;AFpCD;EGrDI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EAEA,wHAAA;ECnBF,qEAAA;EJiCA,6BAAA;EACA,uBAAA;EE+ED;AF7EC;;EAEE,2BAAA;EACA,8BAAA;EE+EH;AF5EC;;EAEE,2BAAA;EACA,uBAAA;EE8EH;AF3EC;;EAEE,2BAAA;EACA,wBAAA;EE6EH;AF3DD;EGtDI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EAEA,wHAAA;ECnBF,qEAAA;EJiCA,6BAAA;EACA,uBAAA;EEuGD;AFrGC;;EAEE,2BAAA;EACA,8BAAA;EEuGH;AFpGC;;EAEE,2BAAA;EACA,uBAAA;EEsGH;AFnGC;;EAEE,2BAAA;EACA,wBAAA;EEqGH;AFlFD;EGvDI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EAEA,wHAAA;ECnBF,qEAAA;EJiCA,6BAAA;EACA,uBAAA;EE+HD;AF7HC;;EAEE,2BAAA;EACA,8BAAA;EE+HH;AF5HC;;EAEE,2BAAA;EACA,uBAAA;EE8HH;AF3HC;;EAEE,2BAAA;EACA,wBAAA;EE6HH;AFnGD;;ECfE,oDAAA;EACQ,4CAAA;ECsHT;AF9FD;;EGxEI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EHuEF,2BAAA;EEoGD;AFlGD;;;EG7EI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EH6EF,2BAAA;EEwGD;AF/FD;EG1FI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;ECnBF,qEAAA;EJ4GA,oBAAA;EC9CA,6FAAA;EACQ,qFAAA;ECoJT;AF1GD;;EG1FI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EF2CF,0DAAA;EACQ,kDAAA;EC8JT;AFvGD;;EAEE,gDAAA;EEyGD;AFrGD;EG7GI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;ECnBF,qEAAA;EFyOD;AF7GD;;EG7GI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EF2CF,yDAAA;EACQ,iDAAA;ECoLT;AFvHD;;EAYI,2CAAA;EE+GH;AF1GD;;;EAGE,kBAAA;EE4GD;AF5FD;EAVI;;;IAGE,aAAA;IG1IF,0EAAA;IACA,qEAAA;IACA,+FAAA;IAAA,wEAAA;IACA,6BAAA;IACA,wHAAA;IDoPD;EACF;AFnGD;EACE,+CAAA;ECxGA,4FAAA;EACQ,oFAAA;EC8MT;AF3FD;EGnKI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EH2JF,uBAAA;EEuGD;AFlGD;EGpKI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EH2JF,uBAAA;EE+GD;AFzGD;EGrKI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EH2JF,uBAAA;EEuHD;AFhHD;EGtKI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EH2JF,uBAAA;EE+HD;AFhHD;EG9KI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EDiSH;AF7GD;EGxLI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EDwSH;AFnHD;EGzLI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;ED+SH;AFzHD;EG1LI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EDsTH;AF/HD;EG3LI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;ED6TH;AFrID;EG5LI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EDoUH;AFxID;EG/JI,+MAAA;EACA,0MAAA;EACA,uMAAA;ED0SH;AFpID;EACE,oBAAA;EC3JA,oDAAA;EACQ,4CAAA;ECkST;AFrID;;;EAGE,+BAAA;EGhNE,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EH8MF,uBAAA;EE2ID;AFhJD;;;EAQI,mBAAA;EE6IH;AFnID;EChLE,mDAAA;EACQ,2CAAA;ECsTT;AF7HD;EGzOI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EDyWH;AFnID;EG1OI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EDgXH;AFzID;EG3OI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EDuXH;AF/ID;EG5OI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;ED8XH;AFrJD;EG7OI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EDqYH;AF3JD;EG9OI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;ED4YH;AF3JD;EGrPI,0EAAA;EACA,qEAAA;EACA,+FAAA;EAAA,wEAAA;EACA,6BAAA;EACA,wHAAA;EHmPF,uBAAA;ECxMA,2FAAA;EACQ,mFAAA;EC0WT","file":"bootstrap-theme.css","sourcesContent":["\n//\n// Load core variables and mixins\n// --------------------------------------------------\n\n@import \"variables.less\";\n@import \"mixins.less\";\n\n\n//\n// Buttons\n// --------------------------------------------------\n\n// Common styles\n.btn-default,\n.btn-primary,\n.btn-success,\n.btn-info,\n.btn-warning,\n.btn-danger {\n  text-shadow: 0 -1px 0 rgba(0,0,0,.2);\n  @shadow: inset 0 1px 0 rgba(255,255,255,.15), 0 1px 1px rgba(0,0,0,.075);\n  .box-shadow(@shadow);\n\n  // Reset the shadow\n  &:active,\n  &.active {\n    .box-shadow(inset 0 3px 5px rgba(0,0,0,.125));\n  }\n\n  .badge {\n    text-shadow: none;\n  }\n}\n\n// Mixin for generating new styles\n.btn-styles(@btn-color: #555) {\n  #gradient > .vertical(@start-color: @btn-color; @end-color: darken(@btn-color, 12%));\n  .reset-filterLine truncated

css/bootstrap-theme.min.css

@@ -1,5 +0,0 @@
-/*!
- * Bootstrap v3.3.1 (http://getbootstrap.com)
- * Copyright 2011-2014 Twitter, Inc.
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
- */.btn-default,.btn-primary,.btn-success,.btn-info,.btn-warning,.btn-danger{text-shadow:0 -1px 0 rgba(0,0,0,.2);-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.15),0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 0 rgba(255,255,255,.15),0 1px 1px rgba(0,0,0,.075)}.btn-default:active,.btn-primary:active,.btn-success:active,.btn-info:active,.btn-warning:active,.btn-danger:active,.btn-default.active,.btn-primary.active,.btn-success.active,.btn-info.active,.btn-warning.active,.btn-danger.active{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn-default .badge,.btn-primary .badge,.btn-success .badge,.btn-info .badge,.btn-warning .badge,.btn-danger .badge{text-shadow:none}.btn:active,.btn.active{background-image:none}.btn-default{text-shadow:0 1px 0 #fff;background-image:-webkit-linear-gradient(top,#fff 0,#e0e0e0 100%);background-image:-o-linear-gradient(top,#fff 0,#e0e0e0 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#fff),to(#e0e0e0));background-image:linear-gradient(to bottom,#fff 0,#e0e0e0 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe0e0e0', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#dbdbdb;border-color:#ccc}.btn-default:hover,.btn-default:focus{background-color:#e0e0e0;background-position:0 -15px}.btn-default:active,.btn-default.active{background-color:#e0e0e0;border-color:#dbdbdb}.btn-default:disabled,.btn-default[disabled]{background-color:#e0e0e0;background-image:none}.btn-primary{background-image:-webkit-linear-gradient(top,#337ab7 0,#265a88 100%);background-image:-o-linear-gradient(top,#337ab7 0,#265a88 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#337ab7),to(#265a88));background-image:linear-gradient(to bottom,#337ab7 0,#265a88 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff265a88', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#245580}.btn-primary:hover,.btn-primary:focus{background-color:#265a88;background-position:0 -15px}.btn-primary:active,.btn-primary.active{background-color:#265a88;border-color:#245580}.btn-primary:disabled,.btn-primary[disabled]{background-color:#265a88;background-image:none}.btn-success{background-image:-webkit-linear-gradient(top,#5cb85c 0,#419641 100%);background-image:-o-linear-gradient(top,#5cb85c 0,#419641 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#5cb85c),to(#419641));background-image:linear-gradient(to bottom,#5cb85c 0,#419641 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5cb85c', endColorstr='#ff419641', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#3e8f3e}.btn-success:hover,.btn-success:focus{background-color:#419641;background-position:0 -15px}.btn-success:active,.btn-success.active{background-color:#419641;border-color:#3e8f3e}.btn-success:disabled,.btn-success[disabled]{background-color:#419641;background-image:none}.btn-info{background-image:-webkit-linear-gradient(top,#5bc0de 0,#2aabd2 100%);background-image:-o-linear-gradient(top,#5bc0de 0,#2aabd2 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#5bc0de),to(#2aabd2));background-image:linear-gradient(to bottom,#5bc0de 0,#2aabd2 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff2aabd2', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#28a4c9}.btn-info:hover,.btn-info:focus{background-color:#2aabd2;background-position:0 -15px}.btn-info:active,.btn-info.active{background-color:#2aabd2;border-color:#28a4c9}.btn-info:disabled,.btn-info[disabled]{background-color:#2aabd2;background-image:none}.btn-warning{background-image:-webkit-linear-gradient(top,#f0ad4e 0,#eb9316 100%);background-image:-o-linear-gradient(top,#f0ad4e 0,#eb9316 100%);background-image:-webkit-gradient(linear,left top,left bottom,from(#f0ad4e),to(#eb9316));background-image:linear-gradient(to bottom,#f0ad4e 0,#eb9316 100%);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff0ad4e', endColorstr='#ffeb9316', GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);background-repeat:repeat-x;border-color:#e38d13}.btn-warning:hover,.btn-warning:focus{background-color:#eb9316;background-position:0 -15px}.btn-warning:active,.btn-warning.active{background-color:#eb9316;border-color:#e38d13}.btn-warning:disabled,.btn-warning[disabled]{background-color:#eb9316;background-image:none}.btn-danger{background-image:-webkit-linear-gradient(top,#d9534f 0,#c12e2a 100%);background-image:-o-linear-gradient(top,#d9534f 0,#c12e2a 100%);background-image:-webkit-gradient(linear,left top,left botLine truncated

css/bootstrap.css.map

@@ -1 +0,0 @@
-{"version":3,"sources":["bootstrap.css","less/normalize.less","less/print.less","less/glyphicons.less","less/scaffolding.less","less/mixins/vendor-prefixes.less","less/mixins/tab-focus.less","less/mixins/image.less","less/type.less","less/mixins/text-emphasis.less","less/mixins/background-variant.less","less/mixins/text-overflow.less","less/code.less","less/grid.less","less/mixins/grid.less","less/mixins/grid-framework.less","less/tables.less","less/mixins/table-row.less","less/forms.less","less/mixins/forms.less","less/buttons.less","less/mixins/buttons.less","less/mixins/opacity.less","less/component-animations.less","less/dropdowns.less","less/mixins/nav-divider.less","less/mixins/reset-filter.less","less/button-groups.less","less/mixins/border-radius.less","less/input-groups.less","less/navs.less","less/navbar.less","less/mixins/nav-vertical-align.less","less/utilities.less","less/breadcrumbs.less","less/pagination.less","less/mixins/pagination.less","less/pager.less","less/labels.less","less/mixins/labels.less","less/badges.less","less/jumbotron.less","less/thumbnails.less","less/alerts.less","less/mixins/alerts.less","less/progress-bars.less","less/mixins/gradients.less","less/mixins/progress-bar.less","less/media.less","less/list-group.less","less/mixins/list-group.less","less/panels.less","less/mixins/panels.less","less/responsive-embed.less","less/wells.less","less/close.less","less/modals.less","less/tooltip.less","less/popovers.less","less/carousel.less","less/mixins/clearfix.less","less/mixins/center-block.less","less/mixins/hide-text.less","less/responsive-utilities.less","less/mixins/responsive-visibility.less"],"names":[],"mappings":"AAAA,6DAA4D;ACQ5D;EACE,yBAAA;EACA,4BAAA;EACA,gCAAA;EDND;ACaD;EACE,WAAA;EDXD;ACwBD;;;;;;;;;;;;;EAaE,gBAAA;EDtBD;AC8BD;;;;EAIE,uBAAA;EACA,0BAAA;ED5BD;ACoCD;EACE,eAAA;EACA,WAAA;EDlCD;AC0CD;;EAEE,eAAA;EDxCD;ACkDD;EACE,+BAAA;EDhDD;ACuDD;;EAEE,YAAA;EDrDD;AC+DD;EACE,2BAAA;ED7DD;ACoED;;EAEE,mBAAA;EDlED;ACyED;EACE,oBAAA;EDvED;AC+ED;EACE,gBAAA;EACA,kBAAA;ED7ED;ACoFD;EACE,kBAAA;EACA,aAAA;EDlFD;ACyFD;EACE,gBAAA;EDvFD;AC8FD;;EAEE,gBAAA;EACA,gBAAA;EACA,oBAAA;EACA,0BAAA;ED5FD;AC+FD;EACE,aAAA;ED7FD;ACgGD;EACE,iBAAA;ED9FD;ACwGD;EACE,WAAA;EDtGD;AC6GD;EACE,kBAAA;ED3GD;ACqHD;EACE,kBAAA;EDnHD;AC0HD;EACE,8BAAA;EACA,iCAAA;UAAA,yBAAA;EACA,WAAA;EDxHD;AC+HD;EACE,gBAAA;ED7HD;ACoID;;;;EAIE,mCAAA;EACA,gBAAA;EDlID;ACoJD;;;;;EAKE,gBAAA;EACA,eAAA;EACA,WAAA;EDlJD;ACyJD;EACE,mBAAA;EDvJD;ACiKD;;EAEE,sBAAA;ED/JD;AC0KD;;;;EAIE,4BAAA;EACA,iBAAA;EDxKD;AC+KD;;EAEE,iBAAA;ED7KD;ACoLD;;EAEE,WAAA;EACA,YAAA;EDlLD;AC0LD;EACE,qBAAA;EDxLD;ACmMD;;EAEE,gCAAA;KAAA,6BAAA;UAAA,wBAAA;EACA,YAAA;EDjMD;AC0MD;;EAEE,cAAA;EDxMD;ACiND;EACE,+BAAA;EACA,8BAAA;EACA,iCAAA;EACA,yBAAA;ED/MD;ACwND;;EAEE,0BAAA;EDtND;AC6ND;EACE,2BAAA;EACA,eAAA;EACA,gCAAA;ED3ND;ACmOD;EACE,WAAA;EACA,YAAA;EDjOD;ACwOD;EACE,gBAAA;EDtOD;AC8OD;EACE,mBAAA;ED5OD;ACsPD;EACE,2BAAA;EACA,mBAAA;EDpPD;ACuPD;;EAEE,YAAA;EDrPD;AACD,sFAAqF;AE1ErF;EAnGI;;;IAGI,oCAAA;IACA,wBAAA;IACA,qCAAA;YAAA,6BAAA;IACA,8BAAA;IFgLL;EE7KC;;IAEI,4BAAA;IF+KL;EE5KC;IACI,8BAAA;IF8KL;EE3KC;IACI,+BAAA;IF6KL;EExKC;;IAEI,aAAA;IF0KL;EEvKC;;IAEI,wBAAA;IACA,0BAAA;IFyKL;EEtKC;IACI,6BAAA;IFwKL;EErKC;;IAEI,0BAAA;IFuKL;EEpKC;IACI,4BAAA;IFsKL;EEnKC;;;IAGI,YAAA;IACA,WAAA;IFqKL;EElKC;;IAEI,yBAAA;IFoKL;EE7JC;IACI,6BAAA;IF+JL;EE3JC;IACI,eAAA;IF6JL;EE3JC;;IAGQ,mCAAA;IF4JT;EEzJC;IACI,wBAAA;IF2JL;EExJC;IACI,sCAAA;IF0JL;EE3JC;;IAKQ,mCAAA;IF0JT;EEvJC;;IAGQ,mCAAA;IFwJT;EACF;AGpPD;EACE,qCAAA;EACA,uDAAA;EACA,6TAAA;EHsPD;AG/OD;EACE,oBAAA;EACA,UAAA;EACA,uBAAA;EACA,qCAAA;EACA,oBAAA;EACA,qBAAA;EACA,gBAAA;EACA,qCAAA;EACA,oCAAA;EHiPD;AG7OmC;EAAW,gBAAA;EHgP9C;AG/OmC;EAAW,gBAAA;EHkP9C;AGhPmC;;EAAW,kBAAA;EHoP9C;AGnPmC;EAAW,kBAAA;EHsP9C;AGrPmC;EAAW,kBAAA;EHwP9C;AGvPmC;EAAW,kBAAA;EH0P9C;AGzPmC;EAAW,kBAAA;EH4P9C;AG3PmC;EAAW,kBAAA;EH8P9C;AG7PmC;EAAW,kBAAA;EHgQ9C;AG/PmC;EAAW,kBAAA;EHkQ9C;AGjQmC;EAAW,kBAAA;EHoQ9C;AGnQmC;EAAW,kBAAA;EHsQ9C;AGrQmC;EAAW,kBAAA;EHwQ9C;AGvQmC;EAAW,kBAAA;EH0Q9C;AGzQmC;EAAW,kBAAA;EH4Q9C;AG3QmC;EAAW,kBAAA;EH8Q9C;AG7QmC;EAAW,kBAAA;EHgR9C;AG/QmC;EAAW,kBAAA;EHkR9C;AGjRmC;EAAW,kBAAA;EHoR9C;AGnRmC;EAAW,kBAAA;EHsR9C;AGrRmC;EAAW,kBAAA;EHwR9C;AGvRmC;EAAW,kBAAA;EH0R9C;AGzRmC;EAAW,kBAAA;EH4R9C;AG3RmC;EAAW,kBAAA;EH8R9C;AG7RmC;EAAW,kBAAA;EHgS9C;AG/RmC;EAAW,kBAAA;EHkS9C;AGjSmC;EAAW,kBAAA;EHoS9C;AGnSmC;EAAW,kBAAA;EHsS9C;AGrSmC;EAAW,kBAAA;EHwS9C;AGvSmC;EAAW,kBAAA;EH0S9C;AGzSmC;EAAW,kBAAA;EH4S9C;AG3SmC;EAAW,kBAAA;EH8S9C;AG7SmC;EAAW,kBAAA;EHgT9C;AG/SmC;EAAW,kBAAA;EHkT9C;AGjTmC;EAAW,kBAAA;EHoT9C;AGnTmC;EAAW,kBAAA;EHsT9C;AGrTmC;EAAW,kBAAA;EHwT9C;AGvTmC;EAAW,kBAAA;EH0T9C;AGzTmC;EAAW,kBAAA;EH4T9C;AG3TmC;EAAW,kBAAA;EH8T9C;AG7TmC;EAAW,kBAAA;EHgU9C;AG/TmC;EAAW,kBAAA;EHkU9C;AGjUmC;EAAW,kBAAA;EHoU9C;AGnUmC;EAAW,kBAAA;EHsU9C;AGrUmC;EAAW,kBAAA;EHwU9C;AGvUmC;EAAW,kBAAA;EH0U9C;AGzUmC;EAAW,kBAAA;EH4U9C;AG3UmC;EAAW,kBAAA;EH8U9C;AG7UmC;EAAW,kBAAA;EHgV9C;AG/UmC;EAAW,kBAAA;EHkV9C;AGjVmC;EAAW,kBAAA;EHoV9C;AGnVmC;EAAW,kBAAA;EHsV9C;AGrVmC;EAAW,kBAAA;EHwV9C;AGvVmC;EAAW,kBAAA;EH0V9C;AGzVmC;EAAW,kBAAA;EH4V9C;AG3VmC;EAAW,kBAAA;EH8V9C;AG7VmC;EAAWLine truncated

css/bootstrap.min.css

@@ -1,5 +0,0 @@
-/*!
- * Bootstrap v3.3.1 (http://getbootstrap.com)
- * Copyright 2011-2014 Twitter, Inc.
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
- *//*! normalize.css v3.0.2 | MIT License | git.io/normalize */html{font-family:sans-serif;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,menu,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background-color:transparent}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}dfn{font-style:italic}h1{margin:.67em 0;font-size:2em}mark{color:#000;background:#ff0}small{font-size:80%}sub,sup{position:relative;font-size:75%;line-height:0;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{height:0;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}button,input,optgroup,select,textarea{margin:0;font:inherit;color:inherit}button{overflow:visible}button,select{text-transform:none}button,html input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{padding:0;border:0}input{line-height:normal}input[type=checkbox],input[type=radio]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;padding:0}input[type=number]::-webkit-inner-spin-button,input[type=number]::-webkit-outer-spin-button{height:auto}input[type=search]{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;-webkit-appearance:textfield}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}fieldset{padding:.35em .625em .75em;margin:0 2px;border:1px solid silver}legend{padding:0;border:0}textarea{overflow:auto}optgroup{font-weight:700}table{border-spacing:0;border-collapse:collapse}td,th{padding:0}/*! Source: https://github.com/h5bp/html5-boilerplate/blob/master/src/css/main.css */@media print{*,:before,:after{color:#000!important;text-shadow:none!important;background:transparent!important;-webkit-box-shadow:none!important;box-shadow:none!important}a,a:visited{text-decoration:underline}a[href]:after{content:" (" attr(href) ")"}abbr[title]:after{content:" (" attr(title) ")"}a[href^="#"]:after,a[href^="javascript:"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100%!important}p,h2,h3{orphans:3;widows:3}h2,h3{page-break-after:avoid}select{background:#fff!important}.navbar{display:none}.btn>.caret,.dropup>.btn>.caret{border-top-color:#000!important}.label{border:1px solid #000}.table{border-collapse:collapse!important}.table td,.table th{background-color:#fff!important}.table-bordered th,.table-bordered td{border:1px solid #ddd!important}}@font-face{font-family:'Glyphicons Halflings';src:url(../fonts/glyphicons-halflings-regular.eot);src:url(../fonts/glyphicons-halflings-regular.eot?#iefix) format('embedded-opentype'),url(../fonts/glyphicons-halflings-regular.woff) format('woff'),url(../fonts/glyphicons-halflings-regular.ttf) format('truetype'),url(../fonts/glyphicons-halflings-regular.svg#glyphicons_halflingsregular) format('svg')}.glyphicon{position:relative;top:1px;display:inline-block;font-family:'Glyphicons Halflings';font-style:normal;font-weight:400;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.glyphicon-asterisk:before{content:"\2a"}.glyphicon-plus:before{content:"\2b"}.glyphicon-euro:before,.glyphicon-eur:before{content:"\20ac"}.glyphicon-minus:before{content:"\2212"}.glyphicon-cloud:before{content:"\2601"}.glyphicon-envelope:before{content:"\2709"}.glyphicon-pencil:before{content:"\270f"}.glyphicon-glass:before{content:"\e001"}.glyphicon-music:before{content:"\e002"}.glyphicon-search:before{content:"\e003"}.glyphicon-heart:before{content:"\e005"}.glyphicon-star:before{content:"\e006"}.glyphicon-star-empty:before{content:"\e007"}.glyphicon-user:before{content:"\e008"}.glyphicon-film:before{content:"\e009"}.glyphicon-th-large:before{content:"\e010"}.glyphicon-th:before{content:"\e011"}.glyphicon-th-list:before{content:"\e012"}.glyphicon-ok:before{content:"\e013"}.glyphicon-remove:before{content:"\e014"}.glyphicon-zoom-in:before{content:"\e015"}.glyphicon-zoom-out:before{content:"\e016"}.glyphicon-off:before{content:"\e017"}.glyphicon-signal:before{content:"\e018"}.glyphicon-cog:before{content:"\e019"}.glyphicon-trash:before{content:"\e020"}.glyphicon-home:before{content:"\e021"}.glyphicon-file:before{content:"\e022"}.glyphicon-time:before{content:"\e023"}.glyphicon-road:before{content:"\e024"}.glyphicon-download-alt:before{content:"\e025"}.glyphicon-download:before{content:"\e026"}.glyphicon-upload:before{content:"\e02Line truncated

css/main.css

@@ -1,64 +0,0 @@
-
-body {
-  color: #DADDD8;
-  background-color: #1E1E24;
-  padding-top: 50px;
-  padding-bottom: 20px;
-}
-
-body,html{
- height:100%;
-}
-.container{
- min-height:100%;
-}
-.footer{
- height:40px;
- margin-top:-40px;
- margin-right: 40px;
-}
-
-a {
-  color: #CB2129;
-}
-a:focus {
-  color: #89161c;
-}
-a:hover {
-  color: #89161c;
-}
-
-.navbar-default {
-  background-color: #89161c;
-  border-color: #89161c;
-  background-image: none;
-  color: #DADDD8;
-}
-.navbar .navbar-header {
-  background-color: #89161c;
-}
-
-.nav {
-  background-color: #89161c;
-}
-
-.navbar-default .navbar-brand {
-  font-family: "Arial Rounded MT Bold", "Helvetica Rounded", Arial, sans-serif;
-  color: #DADDD8;
-  text-shadow: none;
-}
-
-.navbar-default .navbar-nav>li>a {
-  text-shadow: none;
-  color: #DADDD8;
-}
-
-
-.btn-default {
-  background-image: none;
-  background-color: #CB2129;
-}
-
-footer {
-  font-size: 10px;
-}

docs/fonts/slate.svg

@@ -1,14 +0,0 @@
-<?xml version="1.0" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
-<svg xmlns="http://www.w3.org/2000/svg">
-<metadata>Generated by IcoMoon</metadata>
-<defs>
-<font id="slate" horiz-adv-x="1024">
-<font-face units-per-em="1024" ascent="960" descent="-64" />
-<missing-glyph horiz-adv-x="1024" />
-<glyph unicode="&#x20;" d="" horiz-adv-x="512" />
-<glyph unicode="&#xe600;" d="M438.857 877.714q119.429 0 220.286-58.857t159.714-159.714 58.857-220.286-58.857-220.286-159.714-159.714-220.286-58.857-220.286 58.857-159.714 159.714-58.857 220.286 58.857 220.286 159.714 159.714 220.286 58.857zM512 165.143v108.571q0 8-5.143 13.429t-12.571 5.429h-109.714q-7.429 0-13.143-5.714t-5.714-13.143v-108.571q0-7.429 5.714-13.143t13.143-5.714h109.714q7.429 0 12.571 5.429t5.143 13.429zM510.857 361.714l10.286 354.857q0 6.857-5.714 10.286-5.714 4.571-13.714 4.571h-125.714q-8 0-13.714-4.571-5.714-3.429-5.714-10.286l9.714-354.857q0-5.714 5.714-10t13.714-4.286h105.714q8 0 13.429 4.286t6 10z" />
-<glyph unicode="&#xe602;" d="M585.143 164.571v91.429q0 8-5.143 13.143t-13.143 5.143h-54.857v292.571q0 8-5.143 13.143t-13.143 5.143h-182.857q-8 0-13.143-5.143t-5.143-13.143v-91.429q0-8 5.143-13.143t13.143-5.143h54.857v-182.857h-54.857q-8 0-13.143-5.143t-5.143-13.143v-91.429q0-8 5.143-13.143t13.143-5.143h256q8 0 13.143 5.143t5.143 13.143zM512 676.571v91.429q0 8-5.143 13.143t-13.143 5.143h-109.714q-8 0-13.143-5.143t-5.143-13.143v-91.429q0-8 5.143-13.143t13.143-5.143h109.714q8 0 13.143 5.143t5.143 13.143zM877.714 438.857q0-119.429-58.857-220.286t-159.714-159.714-220.286-58.857-220.286 58.857-159.714 159.714-58.857 220.286 58.857 220.286 159.714 159.714 220.286 58.857 220.286-58.857 159.714-159.714 58.857-220.286z" />
-<glyph unicode="&#xe606;" d="M733.714 531.428q0 16-10.286 26.286l-52 51.429q-10.857 10.857-25.714 10.857t-25.714-10.857l-233.143-232.571-129.143 129.143q-10.857 10.857-25.714 10.857t-25.714-10.857l-52-51.429q-10.286-10.286-10.286-26.286 0-15.429 10.286-25.714l206.857-206.857q10.857-10.857 25.714-10.857 15.429 0 26.286 10.857l310.286 310.286q10.286 10.286 10.286 25.714zM877.714 438.857q0-119.429-58.857-220.286t-159.714-159.714-220.286-58.857-220.286 58.857-159.714 159.714-58.857 220.286 58.857 220.286 159.714 159.714 220.286 58.857 220.286-58.857 159.714-159.714 58.857-220.286z" />
-<glyph unicode="&#xe607;" d="M658.286 475.428q0 105.714-75.143 180.857t-180.857 75.143-180.857-75.143-75.143-180.857 75.143-180.857 180.857-75.143 180.857 75.143 75.143 180.857zM950.857 0q0-29.714-21.714-51.429t-51.429-21.714q-30.857 0-51.429 21.714l-196 195.429q-102.286-70.857-228-70.857-81.714 0-156.286 31.714t-128.571 85.714-85.714 128.571-31.714 156.286 31.714 156.286 85.714 128.571 128.571 85.714 156.286 31.714 156.286-31.714 128.571-85.714 85.714-128.571 31.714-156.286q0-125.714-70.857-228l196-196q21.143-21.143 21.143-51.429z" horiz-adv-x="951" />
-</font></defs></svg>

docs/index.html.md.orig

@@ -1,170 +0,0 @@
-# Introduction
-
-Welcome to the Kittn API! You can use our API to access Kittn API endpoints, which can get information on various cats, kittens, and breeds in our database.
-
-We have language bindings in Shell, Ruby, and Python! You can view code examples in the dark area to the right, and you can switch the programming language of the examples with the tabs in the top right.
-
-This example API documentation page was created with [Slate](https://github.com/tripit/slate). Feel free to edit it and use it as a base for your own API's documentation.
-
-# Authentication
-
-> To authorize, use this code:
-
-```ruby
-require 'kittn'
-
-api = Kittn::APIClient.authorize!('meowmeowmeow')
-```
-
-```python
-import kittn
-
-api = kittn.authorize('meowmeowmeow')
-```
-
-```shell
-# With shell, you can just pass the correct header with each request
-curl "api_endpoint_here"
-  -H "Authorization: meowmeowmeow"
-```
-
-```javascript
-const kittn = require('kittn');
-
-let api = kittn.authorize('meowmeowmeow');
-```
-
-> Make sure to replace `meowmeowmeow` with your API key.
-
-Kittn uses API keys to allow access to the API. You can register a new Kittn API key at our [developer portal](http://example.com/developers).
-
-Kittn expects for the API key to be included in all API requests to the server in a header that looks like the following:
-
-`Authorization: meowmeowmeow`
-
-<aside class="notice">
-You must replace <code>meowmeowmeow</code> with your personal API key.
-</aside>
-
-# Kittens
-
-## Get All Kittens
-
-```ruby
-require 'kittn'
-
-api = Kittn::APIClient.authorize!('meowmeowmeow')
-api.kittens.get
-```
-
-```python
-import kittn
-
-api = kittn.authorize('meowmeowmeow')
-api.kittens.get()
-```
-
-```shell
-curl "http://example.com/api/kittens"
-  -H "Authorization: meowmeowmeow"
-```
-
-```javascript
-const kittn = require('kittn');
-
-let api = kittn.authorize('meowmeowmeow');
-let kittens = api.kittens.get();
-```
-
-> The above command returns JSON structured like this:
-
-```json
-[
-  {
-    "id": 1,
-    "name": "Fluffums",
-    "breed": "calico",
-    "fluffiness": 6,
-    "cuteness": 7
-  },
-  {
-    "id": 2,
-    "name": "Max",
-    "breed": "unknown",
-    "fluffiness": 5,
-    "cuteness": 10
-  }
-]
-```
-
-This endpoint retrieves all kittens.
-
-### HTTP Request
-
-`GET http://example.com/api/kittens`
-
-### Query Parameters
-
-Parameter | Default | Description
---------- | ------- | -----------
-include_cats | false | If set to true, the result will also include cats.
-available | true | If set to false, the result will include kittens that have already been adopted.
-
-<aside class="success">
-Remember — a happy kitten is an authenticated kitten!
-</aside>
-
-## Get a Specific Kitten
-
-```ruby
-require 'kittn'
-
-api = Kittn::APIClient.authorize!('meowmeowmeow')
-api.kittens.get(2)
-```
-
-```python
-import kittn
-
-api = kittn.authorize('meowmeowmeow')
-api.kittens.get(2)
-```
-
-```shell
-curl "http://example.com/api/kittens/2"
-  -H "Authorization: meowmeowmeow"
-```
-
-```javascript
-const kittn = require('kittn');
-
-let api = kittn.authorize('meowmeowmeow');
-let max = api.kittens.get(2);
-```
-
-> The above command returns JSON structured like this:
-
-```json
-{
-  "id": 2,
-  "name": "Max",
-  "breed": "unknown",
-  "fluffiness": 5,
-  "cuteness": 10
-}
-```
-
-This endpoint retrieves a specific kitten.
-
-<aside class="warning">Inside HTML code blocks like this one, you can't use Markdown, so use <code>&lt;code&gt;</code> blocks to denote code.</aside>
-
-### HTTP Request
-
-`GET http://example.com/kittens/<ID>`
-
-### URL Parameters
-
-Parameter | Description
---------- | -----------
-ID | The ID of the kitten to retrieve
-