taoensso.timbre — opploans/timbre 4.10.1

Simple, flexible logging for Clojure/Script. No XML.

*config* clj/s

See example-config for info.

*context* clj/s

General-purpose dynamic logging context

-elide? clj

(-elide? level-form ns-str-form)

-levels-map clj/s

-levels-set clj/s

-levels-vec clj/s

-log! clj/s

(-log! config level ?ns-str ?file ?line msg-type ?err vargs_ ?base-data)

(-log! config
       level
       ?ns-str
       ?file
       ?line
       msg-type
       ?err
       vargs_
       ?base-data
       callsite-id)

Core low-level log fn. Implementation detail!

-log-and-rethrow-errors clj/s macro

(-log-and-rethrow-errors ?line & body)

-log-errors clj/s macro

(-log-errors ?line & body)

-logged-future clj/s macro

(-logged-future ?line & body)

-spy clj/s macro

(-spy ?line config level name expr)

color-str clj

(color-str color & xs)

console-?appender cljs

console-appender cljs

debug clj/s macro

(debug & args)

debugf clj/s macro

(debugf & args)

default-err clj/s

default-out clj/s

default-output-fn clj/s

(default-output-fn data)

(default-output-fn opts data)

Default (fn [data]) -> string output fn. Use(partial default-output-fn <opts-map>) to modify default opts.

default-timestamp-opts clj

Controls (:timestamp_ data)

error clj/s macro

(error & args)

errorf clj/s macro

(errorf & args)

example-config clj/s

Example (+default) Timbre v4 config map.

APPENDERS An appender is a map with keys: :min-level ; Level keyword, or nil (=> no minimum level) :enabled? ; :async? ; Dispatch using agent? Useful for slow appenders (clj only) :rate-limit ; [[ncalls-limit window-ms] <...>], or nil :output-fn ; Optional override for inherited (fn [data]) -> string :timestamp-opts ; Optional override for inherited {:pattern _ :locale _ :timezone _} (clj only) :ns-whitelist ; Optional, stacks with active config's whitelist :ns-blacklist ; Optional, stacks with active config's blacklist :fn ; (fn [data]) -> side effects, with keys described below

An appender's fn takes a single data map with keys: :config ; Entire config map (this map, etc.) :appender-id ; Id of appender currently dispatching :appender ; Entire map of appender currently dispatching :instant ; Platform date (java.util.Date or js/Date) :level ; Keyword :error-level? ; Is level e/o #{:error :fatal}? :?ns-str ; String, or nil :?file ; String, or nil :?line ; Integer, or nil ; Waiting on CLJ-865 :?err ; First-arg platform error, or nil :vargs ; Vector of raw args :output_ ; Forceable - final formatted output string created ; by calling (output-fn <this-data-map>) :msg_ ; Forceable - args as a string :timestamp_ ; Forceable - string (clj only) :hostname_ ; Forceable - string (clj only) :output-fn ; (fn [data]) -> formatted output string ; (see default-output-fn for details) :context ; context value at log time (see with-context)

**NB** - any keys not specifically documented here should be
considered private / subject to change without notice.

MIDDLEWARE Middleware are simple (fn [data]) -> ?data fns (applied left->right) that transform the data map dispatched to appender fns. If any middleware returns nil, NO dispatch will occur (i.e. the event will be filtered).

The example-config source code contains further settings and details. See also set-config!, merge-config!, set-level!.

fatal clj/s macro

(fatal & args)

fatalf clj/s macro

(fatalf & args)

get-?hostname clj

(get-?hostname)

Returns live local hostname, or nil.

get-?hostname_ clj

(get-?hostname_)

Returns a new (get-?hostname) promise.

get-env clj/s macro

(get-env)

get-hostname clj/s≠

clj

Returns cached hostname string.

handle-uncaught-jvm-exceptions! clj

(handle-uncaught-jvm-exceptions! & [handler])

Sets JVM-global DefaultUncaughtExceptionHandler.

info clj/s macro

(info & args)

infof clj/s macro

(infof & args)

level>= clj/s

(level>= x y)

log clj/s macro

(log level & args)

log! clj/s macro

(log! level msg-type args & [opts])

Core low-level log macro. Useful for tooling, etc.

• level - must eval to a valid logging level
• msg-type - must eval to e/o #{:p :f nil}
• opts - ks e/o #{:config :?err :?ns-str :?file :?line :?base-data}

Supports compile-time elision when compile-time const vals provided for level and/or ?ns-str.

log* clj/s macro

(log* config level & args)

log-and-rethrow-errors clj/s macro

(log-and-rethrow-errors & body)

log-env clj/s macro

(log-env)

(log-env level)

(log-env level name)

(log-env config level name)

log-errors clj/s macro

(log-errors & body)

log? clj/s

logf clj/s macro

(logf level & args)

logf* clj/s macro

(logf* config level & args)

logged-future clj/s macro

(logged-future & body)

logging-enabled? clj/s

(logging-enabled? level compile-time-ns)

logp clj/s macro

(logp & args)

may-log? clj/s

(may-log? level)

(may-log? level ?ns-str)

(may-log? level ?ns-str ?config)

Runtime check: would Timbre currently log at the given logging level?

• ?ns-str arg required to support ns filtering
• config arg required to support non-global config

merge-config! clj/s

(merge-config! m)

ordered-levels clj/s

println-appender clj/s≠

clj

(println-appender & [{:keys [stream] :or {stream :auto}}])

Returns a simple println appender for Clojure/Script. Use with ClojureScript requires that cljs.core/*print-fn* be set.

:stream (clj only) - e/o #{:auto :out :err :std-err :std-out <io-stream>}.

cljs

refer-timbre clj

(refer-timbre)

Shorthand for: (require '[taoensso.timbre :as timbre :refer (log trace debug info warn error fatal report logf tracef debugf infof warnf errorf fatalf reportf spy get-env log-env)])

report clj/s macro

(report & args)

reportf clj/s macro

(reportf & args)

set-config! clj/s

(set-config! m)

set-level! clj/s

(set-level! level)

sometimes clj/s macro

(sometimes probability & body)

Handy for sampled logging, etc.

spit-appender clj

(spit-appender &
               [{:keys [fname append?]
                 :or {fname "./timbre-spit.log" append? true}}])

Returns a simple spit file appender for Clojure.

spy clj/s macro

(spy expr)

(spy level expr)

(spy level name expr)

(spy config level name expr)

Evaluates named expression and logs its result. Always returns the result. Defaults to :debug logging level and unevaluated expression as name.

stacktrace clj/s

(stacktrace err)

(stacktrace err opts)

str-println clj/s

(str-println & xs)

swap-config! clj/s

(swap-config! f & args)

trace clj/s macro

(trace & args)

tracef clj/s macro

(tracef & args)

valid-level clj/s

(valid-level x)

valid-level? clj/s

(valid-level? x)

warn clj/s macro

(warn & args)

warnf clj/s macro

(warnf & args)

with-config clj/s macro

(with-config config & body)

with-context clj/s macro

(with-context context & body)

Executes body so that given arbitrary data will be included in the data map passed to appenders for any enclosed logging calls.

(with-context {:user-name "Stu"} ; Will be incl. in data dispatched to appenders (info "User request"))

with-default-outs clj/s macro

(with-default-outs & body)

with-level clj/s macro

(with-level level & body)

with-log-level clj/s macro

(with-log-level level & body)

with-logging-config clj/s macro

(with-logging-config config & body)

with-merged-config clj/s macro

(with-merged-config config & body)