                    fn-agg fn-store)
         (swap! (get-cache! rollup)
                (fn [cache]
-                 (assoc cache key (conj (get cache key) data))))
-
-        (println (get-cache! rollup)))
+                 (assoc cache key (conj (get cache key) data)))))
       (flush! [this])
-      (-show-keys [this]
-        (println mkeys))
-      (-show-cache [this]
-        (println caches))
-
-)))
+      (-show-keys [this] (println mkeys))
+      (-show-cache [this] (println caches)))))

  [data]
  (/ (reduce + data) (count data)))

(defn construct-key
  [tenant period rollup time path]
  (str/join "-" [tenant period rollup time path]))

(defn construct-mkey
  [tenant period rollup]
  (str/join "-" [tenant period rollup]))

(defn calc-delay
  [rollup add]

    delayer))

(defn set-pkeys!
  [mkeys tenant period rollup time ttl fn-get fn-agg fn-store]
  (let [mkey (construct-mkey tenant period rollup time)]
    (swap! mkeys
           (fn [mkeys]
             (if (contains? mkeys mkey)
               mkeys
               (let [pkeys (atom [])
                     flusher (create-flusher mkeys mkey pkeys tenant period
                                             rollup time ttl fn-get fn-agg
                                             fn-store)
                     delayer (run-delayer! rollup flusher)]
                 (swap! pkeys
                        (fn [pkeys]
                          (with-meta pkeys {:flusher flusher :delayer delayer})))
                 (assoc mkeys mkey pkeys)))))
    (get @mkeys mkey)))

(defn set-keys!
  [mkeys tenant period rollup time path ttl fn-get fn-agg fn-store]
  (let [pkeys (set-pkeys! mkeys tenant period rollup time ttl fn-get
                          fn-agg fn-store)]
    (swap! pkeys
           (fn [pkeys]
