See `example-config` for info.

General-purpose dynamic logging context. Context will be included in
appender data map at logging time.

Core low-level log fn. Implementation detail!

Implementation detail.
Executes body iff given level and ns pass compile-time elision.

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

Controls (:timestamp_ data)

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 _}
    :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
    :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`)
    :profile-stats   ; From `profile` macro

    **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!`.

Sets JVM-global DefaultUncaughtExceptionHandler.

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`.

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

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>}.

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)])
(require '[taoensso.timbre.profiling :as profiling
           :refer (pspy p defnp profile)])

Handy for sampled logging, etc.

Returns a simple `spit` file appender for Clojure.

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