std.log — xyz.zcaudate/std.log 4.0.9

action clj macro

(action body)

(action context body)

(action logger context body)

basic-logger clj

(basic-logger)

(basic-logger m)

constructs a basic logger

(basic-logger) => std.log.core.BasicLogger

block clj macro

(block body)

(block context body)

(block logger context body)

console-logger clj

(console-logger)

(console-logger m)

creates a console logger

(console-logger)

create clj

(create m)

creates a component compatible logger

(log/create {:type :basic})

current-context clj

(current-context)

returns the current context

debug clj macro

(debug data)

(debug context data)

(debug logger context data)

error clj macro

(error exception)

(error context exception)

(error logger context exception)

fatal clj macro

(fatal exception)

(fatal context exception)

(fatal logger context exception)

identity-logger clj

(identity-logger)

(identity-logger m)

creates a identity logger

(identity-logger)

info clj macro

(info data)

(info context data)

(info logger context data)

log clj macro

(log data)

(log context data)

(log level context data)

(log logger level context data)

(log logger level context data exception)

produces a log

log-context clj

(log-context body)

creates a log-context form

(log-context "hello") => seq?

log-meta clj

(log-meta form)

gets the metadata information on macroexpand

log-runtime clj

logger clj

(logger m)

creates an starts a logger

(log/logger {:type :basic})

logger? clj

(logger? m)

checks if the object is a logger

(log/logger? (log/create {:type :basic})) => true

meter clj macro

(meter body)

(meter context body)

(meter logger context body)

multi-logger clj

(multi-logger m)

creates multiple loggers

(multi-logger {:loggers [{:type :console :interval 500 :max-batch 10000} {:type :basic :interval 500 :max-batch 10000}]})

note clj macro

(note body)

(note context body)

(note logger context body)

profile clj macro

(profile body)

(profile context body)

(profile logger context body)

put-logger! clj

(put-logger! {:keys [level context namespace function filter] :as data})

(put-logger! {:keys [instance] :as logger} data)

updates the global logger

section clj macro

(section body)

(section context body)

(section logger context body)

set-context! clj

(set-context! context)

sets the global context

set-level! clj

(set-level! status)

sets the global level variable

set-logger! clj

(set-logger! logger)

(set-logger! logger var)

sets the global logger

set-static! clj

(set-static! bool)

sets the global static variable

show clj macro

(show body)

(show context body)

(show logger context body)

silent clj macro

(silent body)

(silent context body)

(silent logger context body)

spy clj macro

(spy body)

(spy context body)

(spy logger context body)

status clj macro

(status body)

(status context body)

(status logger context body)

step clj macro

(step message & body)

conducts a step that is logged

task clj macro

(task body)

(task context body)

(task logger context body)

todo clj macro

(todo body)

(todo context body)

(todo logger context body)

trace clj macro

(trace body)

(trace context body)

(trace logger context body)

track clj macro

(track body)

(track context body)

(track logger context body)

verbose clj macro

(verbose data)

(verbose context data)

(verbose logger context data)

warn clj macro

(warn data)

(warn context data)

(warn logger context data)

with clj macro

(with opts & body)

enables targeted printing of statements

with-context clj macro

(with-context context & body)

executes code with a given context

with-indent clj macro

(with-indent indent & body)

executes body with a given indent

with-level clj macro

(with-level level & body)

executes body with a given level

with-logger clj macro

(with-logger logger & body)

executes code with a logger

with-logger-basic clj macro

(with-logger-basic & body)

executes code with the basic logger (for debugging the logger)

with-logger-verbose clj macro

(with-logger-verbose & body)

executes code with a verbose logger (for printing out everything)

with-overwrite clj macro

(with-overwrite overwrite & body)

executes code with a given overwrite