Clojurians Log v2

Moin! Im letzten Call hatten wir ja kurz über Möglichkeiten gesprochen, ein Clojure Programm um Auto-Tracing zu erweitern. @ramart hatte alter-var-root ins Spiel gebracht, und ich hatte heute mal ein wenig Zeit und Muße um damit rumzuspielen. Seht ihr hier noch Verbesserungspotenzial?

find-traced-fn gibt alle Funktionen in allen Namespaces zurück, die {:traced true} als Metainformation beinhalten. Mit wrap-fn wird die übergebene Funktion in der Trace-Logik gewrappt, hier könnte man dann z.B. auch Seiteneffekte in Richtung des Tracing-Anbieters auslösen.

Das Hauptproblem was ich damit immer noch nicht gelöst habe: Übergreifende Spans bei verschachtelten Calls

Wie würden die denn erkannt? Vor der Berechnung des Results eine Art „Begin Span Event“ und danach ein End? Jeweils mit ID?

Du gibst den event einen Parent Trace mit, und der identifiziert dann, was hierarchisch zusammengehört.

Habe jetzt noch ein bisschen mit with-meta herumgespielt und mit optionalen Parametern am Ende der Parameterliste. Beide werden nicht 1:1 durchgehoben, da muss dann glaube ich manueller Aufwand hinzukommen.

Es gibt kein Problem. was nicht durch eine weitere Abstraktion gelöst werden kann. „Doppelt wrappen mit UUIDs“ schießt mir spontan durch den Kopf. Bin aber gerade unterwegs…

Ich werd jetzt auch erst mal das Wetter genießen und noch ein bisschen damit rumspielen 😉 Danke schon mal, auch für den ursprünglichen Vorschlag!

Kennt ihr https://github.com/gnl/ghostwheel ? Neben einer schöneren Art Funktionen zu specen kann das auch tracing und side-effect detection.

@mroerni Danke für den Tipp, schaue ich mir mal an! Aber ein bisschen selbst rumschrauben macht ja auch Spaß. 🙃 @javahippie ein kleiner PoC (basierend auf Deiner Vorarbeit):

(def trace-log (partial println "root"))

(defn trace-fn
  [function]
  (alter-var-root
   function
   (fn [f]
     (fn [& n]
       (with-redefs [trace-log (partial println (java.util.UUID/randomUUID))]
         (let [start (System/currentTimeMillis)
               result (apply f n)
               duration (-(System/currentTimeMillis) start)]
           (trace-log (format "This took %s millis" duration))
           result))))))

(defn find-traced-fn []
  (->>
   (all-ns)
   (mapcat ns-publics)
   (vals)
   (filter #(:traced (meta %)))))

(defn innermost {:traced true}
  [a b]
  (trace-log "innermost")
  (+ a b))

(defn inner {:traced true}
  [arg]
  (trace-log "inner")
  (innermost 47 11))

(defn outer {:traced true}
  [arg]
  (trace-log "outer")
  [(inner arg)
   (inner arg)])

;; (map trace-fn (find-traced-fn))

(outer :ignored)

Lustigerweise arbeite ich auch an einer tracing Lösung, mit Fokus auf der Verarbeitung von Traces für "später" (TM).

Traces sind versioniert (auf Wunsch) und lassen sich z.B. in RocksDB speichern und sind vergleichbar usw. Auch laesst sich einstellen wie viel traces man denn gerne im Speicher mitschleppen wuerde. Die Idee ist dass ich etwa alle mein hug-sql Funktionen tracen lassen und mir dann immer mal reinschauen kann. Traces sind navigierbar mit datafy und lassen sich so etwa in Reveal anschauen und navigieren.

Und man kann z.B. einstellen, dass man nach 5 Traces einer fn dieselbe wieder in den Ursprungszustand versetzt

WIP

Interessant! Worauf bezieht sich die Versionierung eines Traces? :thinking_face: