Cross-posted from Zolo Labs.
Logging is an obvious requirement when it comes to being able to debug non-trivial systems. We’ve been thinking a lot about logging, thanks to the large-scale, distributed nature of the Zolodeck architecture. Unfortunately, when logging larger Clojure data-structures, I often find some kinds of log statements a bit hard to decipher. For instance, consider a map m that looked like this:
When you log things like m (shown here with println for simplicity), you may end up needing to understand this:
Aaugh, look at that second line! Where does the data-structure begin and end? What is nested, and what’s top-level? And this problem gets progressively worse as the size and nested-ness of such data-structures grow. I wrote this following function to help alleviate some of the pain:
Remember to include clojure.pprint. And here’s how you use it:
That’s it, really. Not a big deal, not a particularly clever function. But it’s much better to see this structured and formatted log statement when you’re poring over log files in the middle of the night.
Just note that you want to use this sparingly. I first modified things to make ALL log statements automatically wrap everything being logged with pp-str: it immediately halved the performance of everything. pp-str isn’t cheap (actually, pprint isn’t cheap). So use with caution, where you really need it!
Now go sign-up for Zolodeck!
rg.rathore.amit.frumios.core/OBJECT nil {}))
(def this)
(defn new-object [klass]
(let [state (ref {})]
(fn thiz [command & args]
(cond
(= :class command) klass
(= :set! command) (let [[k v] args]
(dosync (alter state assoc k v))
nil)
(= :get command) (let [[key] args]
(state key))
:else (let [method (klass :method command)]
(if method
(binding [this thiz]
(apply method args))))))))
(defn find-method [method-name instance-methods parent-class]
(let [method (instance-methods method-name)]
(or method
(if-not (= #'org.rathore.amit.frumios.core/OBJECT parent-class)
(find-method method-name (parent-class :methods) (parent-class :parent))))))
(defn parent-class-spec [sexprs]
(let [extends-spec (filter #(= :extends (first %)) sexprs)
extends (first extends-spec)]
(if (empty? extends)
'org.rathore.amit.frumios.core/OBJECT
(do
(if-not (= 1 (count extends-spec))
(throw (RuntimeException. "defclass only accepts a single extends clause")))
(if-not (= 2 (count extends))
(throw (RuntimeException. "the extends clause only accepts a single parent class")))
(last extends)))))
(defn method-spec [sexpr]
(let [name (keyword (second sexpr))
remaining (next sexpr)]
{name (conj remaining 'fn)}))
(defn method-specs [sexprs]
(let [method-spec? #(= 'method (first %))
specs (filter method-spec? sexprs)]
(apply merge (map method-spec sexprs))))
(defmacro defclass [class-name & specs]
(let [parent-class-symbol (parent-class-spec specs)
this-class-name (keyword class-name)
fns (method-specs specs)]
`(def ~class-name
(new-class ~this-class-name (var ~parent-class-symbol) ~(or fns {})))))
