 (let [method-calls (atom {})]
   (defn introspect-function
     [caller method args return-value]
-    (let [descriptor          [(.getClass caller) (.getName method)]
+    (let [descriptor          [(-> caller .getClass .getName) (.getName method)]
           current-call-types  (conj (mapv type args) (type return-value))
           previous-call-types (get @method-calls descriptor)]
 

               [descriptor]
               #(conj (or % #{}) current-call-types)))))

  (defn get-method-calls
    []
    @method-calls)

  (defn t
    ([f-name]
       (t (.getClass f-name) "invoke"))
    ([klass method]
       (let [calls (get @method-calls [klass method])]
         (if (not (empty? calls))
           (doseq [call calls]
             (println (format-signature call)))


(defonce introspected-namespaces (atom #{}))
(defn introspect-namespace
  [namespace]
  (when (not (get introspected-namespaces namespace))
    (println (str "Introspecting " namespace))
    (swap! introspected-namespaces conj namespace)

    (IntrospectProfilingAgent/initializeAgent (-> namespace
                                                  name
                                                  (.replace "-" "_")))
    (let [namespace-sym (symbol namespace)]
      (compile namespace-sym)))
  ;; v.ns.name.name.replace('.', '/').replace('-','_') + "$" + munge(v.sym.name);
  )

