[mod] Simplify provided handlers, harmonize output

Author: ptaoussanis

src/taoensso/tufte.cljc

@@ -648,16 +648,19 @@
               (s+spc   hostname)))
 
          (when ns (s+spc (sigs/format-callsite ns (get signal :coords))))
-         (when id (s+spc (sigs/format-id ns id)))
+
+         (do      (enc/sb-append sb " Tufte pstats"))
+         (when id (enc/sb-append sb " " (sigs/format-id ns id)))
+
+         (when-let   [ff format-pstats-fn]
+           (when-let [fs (ff pstats (conj {:incl-newline? false} format-pstats-opts))]
+             (enc/sb-append sb nl fs)))
 
          #?(:clj (when   (enc/and? host   incl-host?)   (enc/sb-append sb nl "   host: " (enc/pr-edn* host))))
          #?(:clj (when   (enc/and? thread incl-thread?) (enc/sb-append sb nl " thread: " (enc/pr-edn* thread))))
          (when-let [data (enc/not-empty-coll data)]     (enc/sb-append sb nl "   data: " (enc/pr-edn* data)))
          (when-let [ctx  (enc/not-empty-coll ctx)]      (enc/sb-append sb nl "    ctx: " (enc/pr-edn* ctx)))
 
-         (enc/when-let [ff format-pstats-fn, formatted (ff pstats format-pstats-opts)]
-           (enc/sb-append sb nl "<<< pstats <<<" nl formatted ">>> pstats >>>"))
-
          (when incl-newline? (enc/sb-append sb nl))
          (str sb))))))
 
@@ -733,7 +736,9 @@
                (let [logger (js-console-logger (get signal :level))]
                  (.call logger logger (str output)))))))))))
 
-(comment ((handler:console) (assoc (dummy-signal) :data {:k1 :v1})))
+(comment
+  ((handler:console)        (dummy-signal))
+  ((handler:console) (assoc (dummy-signal) :data {:k1 :v1}, :ctx {:k1 :v1})))
 
 (defn handler:accumulating
   "Alpha, subject to change.

src/taoensso/tufte/telemere.cljc

@@ -9,50 +9,39 @@
    [taoensso.telemere       :as tel]))
 
 (defn handler:telemere
-  "Alpha, subject to change.
+  "Alpha, subject to change!
   Returns a signal handler that:
     - Takes a Tufte profiling signal (map).
     - Creates a corresponding Telemere signal for handling by Telemere.
 
-  The Telemere signal will include:
-    As in Tufte signal: #{:inst :ns :coords :id :level :data :host :thread}
-    And:
-    `:kind` --------- `:tufte`
-    `:msg_` --------- Delay of `pstats` formatted as string table
-    `:ctx` ---------- (merge `telemere/*ctx*` `tufte/*ctx*`)
-    `:tufte-signal` - Original Tufte signal (map)
-
   Options:
-    `:telemere-level-fn` -- (fn [tufte-level]) => telemere-level (default to constantly `:info`)
+    `:level-fn` ----------- (fn [tufte-level]) => telemere-level (default to `identity`)
     `:format-pstats-opts` - Opts map provided to `format-pstats` (default nil)"
 
   ([] (handler:telemere nil))
-  ([{:keys [telemere-level-fn format-pstats-opts incl-keys]
-     :or   {telemere-level-fn (fn [tufte-level] tufte-level)}}]
-
-   (let []
-     (fn a-handler:telemere [signal]
-       (when-let [{:keys [inst ns coords, id level, #?@(:clj [host thread]), ctx data,
-                          pstats format-pstats-fn]} signal]
-
-         (taoensso.telemere/signal!
-           {:inst     inst
-            :ns       ns
-            :coords   coords
-            :kind     :tufte
-            :id       id
-            :level    (telemere-level-fn level)
-            :data     data
-            :tufte-signal signal ; Won't be printed by default (good)
-            :msg      (when-let [ff format-pstats-fn] (delay (ff pstats format-pstats-opts)))
-            :ctx+
-            (fn [old]
-              (if (or (nil? old) (map? old))
-                (enc/merge-nx old ctx)
-                (do           old)))
-
-            #?@(:clj
-                [:host   host
-                 :thread thread])}))))))
-
-(comment ((handler:telemere) (#'tufte/dummy-signal)))
+  ([{:keys [level-fn format-pstats-opts]
+     :or   {level-fn identity}}]
+
+   (fn a-handler:telemere [signal]
+     (when-let [{:keys [inst ns coords, id level, #?@(:clj [host thread]), ctx data,
+                        pstats format-pstats-fn]} signal]
+       (tel/signal!
+         {:inst   inst
+          :ns     ns
+          :coords coords
+          :kind   :tufte
+          :id     id
+          :level  (level-fn level)
+          :ctx+   ctx
+          :data   data
+          :tufte/pstats pstats ; -> kvs
+          :msg
+          (when-let   [ff format-pstats-fn]
+            (when-let [fs (ff pstats (conj {:incl-newline? false} format-pstats-opts))]
+              (str enc/newline fs)))
+
+          #?@(:clj [:host host, :thread thread])})))))
+
+(comment
+  ((handler:telemere)        (#'tufte/dummy-signal))
+  ((handler:telemere) (assoc (#'tufte/dummy-signal) :data {:k1 :v1} :ctx {:k1 :v1})))

src/taoensso/tufte/timbre.cljc

@@ -9,62 +9,59 @@
    [taoensso.timbre         :as timbre]))
 
 (defn handler:timbre
-  "Alpha, subject to change.
+  "Alpha, subject to change!
   Returns a signal handler that:
     - Takes a Tufte profiling signal (map).
     - Uses Timbre to log the signal as a human-readable string.
 
   Options:
-    `:timbre-level-fn` ---- (fn [tufte-level]) => timbre-level (default to constantly `:info`)
-    `:format-pstats-opts` - Opts map provided to `format-pstats` (default nil)
-    `:incl-keys` ---------- Subset of profiling signal keys to retain from those
-                            otherwise excluded by default: #{:host :thread}"
+    `:level-fn` ----------- (fn [tufte-level]) => timbre-level (default `identity`).
+    `:format-pstats-opts` - Opts map provided to `format-pstats` (default nil)"
 
   ([] (handler:timbre nil))
-  ([{:keys [timbre-level-fn format-pstats-opts incl-keys]
-     :or   {timbre-level-fn (fn [tufte-level] :info)}}]
+  ([{:keys [level-fn format-pstats-opts]
+     :or   {level-fn identity}}]
 
-   (let [nl enc/newline
-         incl-host?   (contains? incl-keys :host)
-         incl-thread? (contains? incl-keys :thread)]
+   (fn a-handler:timbre [signal]
+     (let [{:keys [inst ns coords, id level, #?@(:clj [host thread]), ctx data,
+                   pstats format-pstats-fn]} signal]
 
-     (fn a-handler:timbre [signal]
-       (let [{:keys [inst ns coords, id level, #?@(:clj [host thread]), ctx data,
-                     pstats format-pstats-fn]} signal]
-         (timbre/log!
-           {:loc      (when ns (let [[line column] coords] {:ns ns, :line line, :column column}))
-            :level    (timbre-level-fn level)
-            :instant  #?(:clj (enc/as-dt inst), :cljs inst)
-            :msg-type :p
-            :vargs
-            (let [sb    (enc/str-builder)
-                  s+spc (enc/sb-appender sb " ")]
+       (timbre/log!
+         {:loc      {:ns ns, :line (get coords 0)}
+          :level    (level-fn level)
+          :instant  #?(:clj (enc/as-dt inst), :cljs inst)
+          :msg-type :p
+          :tufte/pstats pstats ; -> log data map
+          :vargs
+          (let [nl  enc/newline
+                sb (enc/str-builder)]
 
-              (s+spc "Tufte signal")
-              (when id (s+spc (sigs/format-id ns id)))
+            (do      (enc/sb-append sb "Tufte pstats"))
+            (when id (enc/sb-append sb " " (sigs/format-id ns id)))
 
-              #?(:clj (when   (enc/and? host   incl-host?)   (enc/sb-append sb nl "   host: " (enc/pr-edn* host))))
-              #?(:clj (when   (enc/and? thread incl-thread?) (enc/sb-append sb nl " thread: " (enc/pr-edn* thread))))
-              (when-let [data (enc/not-empty-coll data)]     (enc/sb-append sb nl "   data: " (enc/pr-edn* data)))
-              (when-let [ctx  (enc/not-empty-coll ctx)]      (enc/sb-append sb nl "    ctx: " (enc/pr-edn* ctx)))
+            (when-let   [ff  format-pstats-fn]
+              (when-let [fs (ff pstats (conj {:incl-newline? false} format-pstats-opts))]
+                (enc/sb-append sb nl fs)))
 
-              (enc/when-let [ff format-pstats-fn, formatted (ff pstats format-pstats-opts)]
-                (enc/sb-append sb nl "<<< pstats <<<" nl formatted ">>> pstats >>>"))
+            (when-let [data (enc/not-empty-coll data)] (enc/sb-append sb nl " data: " (enc/pr-edn* data)))
+            (when-let [ctx  (enc/not-empty-coll ctx)]  (enc/sb-append sb nl "  ctx: " (enc/pr-edn* ctx)))
 
-              [(str sb)])}))))))
+            [(str sb)])})))))
 
-(comment ((handler:timbre) (assoc (#'tufte/dummy-signal) :data {:k1 :v1})))
+(comment
+  ((handler:timbre)        (#'tufte/dummy-signal))
+  ((handler:timbre) (assoc (#'tufte/dummy-signal) :data {:k1 :v1} :ctx {:k1 :v1})))
 
 (enc/deprecated
   (defn ^:no-doc ^:deprecated add-timbre-logging-handler!
     "Prefer (add-handler! <handler-id> (handler:timbre) <dispatch-opts>)."
     [{:keys [ns-pattern handler-id timbre-level]
-      :or   {ns-pattern "*"
+      :or   {ns-pattern   "*"
              handler-id   :timbre
              timbre-level :info}}]
 
     (let [timbre-level-fn (if (fn? timbre-level) timbre-level (fn [_] timbre-level))
-          handler-fn      (handler:timbre {:timbre-level-fn timbre-level-fn})
+          handler-fn      (handler:timbre {:level-fn timbre-level-fn})
           dispatch-opts
           (when    (and ns-pattern (not= ns-pattern "*"))
             {:ns-filter ns-pattern})]