Add streams/fold-interval and test
Add fold-interval-metric convenience fun
Merge pull request #18 from b/fold-interval

Add streams/fold-interval and test
Use a pool of sockets for riemann.graphite.

If the handler returned by riemann.graphite/graphite is used concurrently,
using a single socket will cause nontrivial levels of lock contention.

This socket pool implementation used here could surely be improved, but it
appears to be correct and functional.

Also cleaned up some unnecessary reflection.
Allow custom message-decoding functions for TCP and UDP servers.

Also rework server to use an in-IO-thread message decoder and run `handle`
calls over thread pools for both TCP and UDP.
Merge pull request #22 from banjiewen/update-graphite

Use a pool of sockets for riemann.graphite.
Merge pull request #21 from banjiewen/pluggable-decoders

Allow custom message-decoding functions for TCP and UDP servers.
Minor tuning.
Add a graphite listener.

This will obviously be less efficient than the protobuf tcp-server
or udp-server. But it will allow easy set up with other tools
in the monitoring chain - collectd, statsd for instance -
with very little configuration.

In the configuration, a graphite server is simply started by
issuing `(graphite-server)`. The server will yield events with
only service, metric and timestamp filled. NaN values will be
discarded.

Should you want to do additional handling on the values you
can feed graphite-server a parser-fn yielding a map to
merge onto the event. For instance if you emit data
from collectd using the write_graphite output with the following
configuration:

```
<LoadPlugin write_graphite>
<Plugin write_graphite>
<Carbon>
        Prefix "collectd."
	Host "localhost"
	Port 2003
</Carbon>
</Plugin>
```

You can use the following to have a nicer event, containing hostname
and tags:

```clojure
(graphite-server
 :parser-fn (fn [{:keys [service] :as event}]
              (if-let [[src host service & tags]
                       (clojure.string/split service #"\.")]
                {:host (clojure.string/replace host #"_" ".")
                 :service (clojure.string/join "." (concat [service] tags))
                 :tags (concat tags [src])})))
```
Switch pubsub registry to an atom.

I suppose later on a protocol could be implemented for this,
allowing interfacing with external pubsub systems.
use clojure.set directly
Remove control flow funcs not used anywhere

Past a certain point futures are not as reliable or should
be started within a controlled thread-pool and not clojure's
default thread-pools.
kill tests for funcs that do not exist anymore
kill set functions that are unused
split where into where and where-event, avoiding symbol touching

This saves the guesswork to figure out the current event's symbol
name which is rather risky
Use an atom pointing to a simple list to store events in coalesce.

A possible further optimization would be to store events sorted
by their ttl, and thus dropping every expired events, then
returning the rest of the list.
Ensure only the last event per host/service pair shows up
Merge pull request #24 from pyr/feature-atomize-coalesce

Use an atom pointing to a simple list to store events in coalesce.
Merge pull request #25 from pyr/feature-atomize-pubsub

Switch pubsub registry to an atom.
Readme: obvious link to main site.